Changeset 696

Show
Ignore:
Timestamp:
05/30/07 12:13:25 (1 year ago)
Author:
mikey
Message:

removed tabs in unit tests

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/build.xml

    r694 r696  
    5959        <exclude name="**/org/simpletest/**" /> 
    6060      </fileset> 
     61      <fileset dir="${project.basedir}/src/test/php"> 
     62        <include name="**/*.php" /> 
     63      </fileset> 
    6164      <fileset dir="${project.basedir}/examples"> 
    6265        <include name="**/*.php" /> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubIntegerFilterTestCase.php

    r140 r696  
    5252     * assure that values are returned the expected way 
    5353     */ 
    54    public function testValue() 
    55    { 
    56        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
    57        $this->assertEqual($integerFilter->execute(8), 8); 
    58    } 
    59      
     54    public function testValue() 
     55    { 
     56        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
     57        $this->assertEqual($integerFilter->execute(8), 8); 
     58    } 
     59     
    6060    /** 
    6161     * assure that an exceptiom is thrown when a value is 
    6262     * required but not passed 
    6363     */ 
    64    public function testWithUnsetWhenRequired() 
    65    { 
    66        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
    67        $integerFilter->setRequired(true); 
    68        $this->assertEqual($integerFilter->execute(true), 1); 
    69        $this->assertEqual($integerFilter->execute(false), 0); 
    70        $this->expectException('stubFilterException'); 
    71        $value = $integerFilter->execute(null); 
    72    } 
    73      
    74    /** 
     64    public function testWithUnsetWhenRequired() 
     65    { 
     66        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
     67        $integerFilter->setRequired(true); 
     68        $this->assertEqual($integerFilter->execute(true), 1); 
     69        $this->assertEqual($integerFilter->execute(false), 0); 
     70        $this->expectException('stubFilterException'); 
     71        $value = $integerFilter->execute(null); 
     72    } 
     73     
     74    /** 
    7575     * assure that an exceptiom is thrown when a value is 
    7676     * required but not passed 
    7777     */ 
    78    public function testWithUnsetEmptyStringWhenRequired() 
    79    { 
    80        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
    81        $integerFilter->setRequired(true); 
    82        $this->expectException('stubFilterException'); 
    83        $integerFilter->execute(''); 
    84    } 
    85      
     78    public function testWithUnsetEmptyStringWhenRequired() 
     79    { 
     80        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
     81        $integerFilter->setRequired(true); 
     82        $this->expectException('stubFilterException'); 
     83        $integerFilter->execute(''); 
     84    } 
     85     
    8686    /** 
    8787     * assure that 0 or 1 is returned when value not set or empty when no value 
    8888     * is required 
    8989     */ 
    90    public function testUnsetWhenNotRequired() 
    91    { 
    92        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
    93        $integerFilter->setRequired(false); 
    94        $this->assertEqual($integerFilter->execute(null), 0); 
    95        $this->assertEqual($integerFilter->execute(''), 0); 
    96        $this->assertEqual($integerFilter->execute(true), 1); 
    97        $this->assertEqual($integerFilter->execute(false), 0); 
    98    } 
     90    public function testUnsetWhenNotRequired() 
     91    { 
     92        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
     93        $integerFilter->setRequired(false); 
     94        $this->assertEqual($integerFilter->execute(null), 0); 
     95        $this->assertEqual($integerFilter->execute(''), 0); 
     96        $this->assertEqual($integerFilter->execute(true), 1); 
     97        $this->assertEqual($integerFilter->execute(false), 0); 
     98    } 
    9999 
    100100    /** 
    101101     * assure that an FilterException is thrown when value smaller then $min 
    102102     */ 
    103    public function testWithMinValidator() 
    104    { 
    105        $this->mockStubValidatorMin->setReturnValueAt(0, 'validate', true); 
    106        $this->mockStubValidatorMin->setReturnValueAt(1, 'validate', false); 
    107        $this->mockStubValidatorMin->setReturnValue('getCriteria', array()); 
    108         
    109        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory, $this->mockStubValidatorMin); 
    110        $this->assertEqual($integerFilter->execute(-10), -10); 
    111        $this->expectException('stubFilterException'); 
    112        $integerFilter->execute(-11); 
    113    } 
     103    public function testWithMinValidator() 
     104    { 
     105        $this->mockStubValidatorMin->setReturnValueAt(0, 'validate', true); 
     106        $this->mockStubValidatorMin->setReturnValueAt(1, 'validate', false); 
     107        $this->mockStubValidatorMin->setReturnValue('getCriteria', array()); 
     108         
     109        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory, $this->mockStubValidatorMin); 
     110        $this->assertEqual($integerFilter->execute(-10), -10); 
     111        $this->expectException('stubFilterException'); 
     112        $integerFilter->execute(-11); 
     113    } 
    114114 
    115115    /** 
    116116     * assure that an FilterException is thrown when value greater then $max 
    117117     */ 
    118    public function testWithMaxValidator() 
    119    { 
    120        $this->mockStubValidatorMax->setReturnValueAt(0, 'validate', true); 
    121        $this->mockStubValidatorMax->setReturnValueAt(1, 'validate', false); 
    122        $this->mockStubValidatorMax->setReturnValue('getCriteria', array()); 
    123         
    124        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory, null, $this->mockStubValidatorMax); 
    125        $this->assertEqual($integerFilter->execute(10), 10); 
    126        $this->expectException('stubFilterException'); 
    127        $integerFilter->execute(11); 
    128    } 
     118    public function testWithMaxValidator() 
     119    { 
     120        $this->mockStubValidatorMax->setReturnValueAt(0, 'validate', true); 
     121        $this->mockStubValidatorMax->setReturnValueAt(1, 'validate', false); 
     122        $this->mockStubValidatorMax->setReturnValue('getCriteria', array()); 
     123         
     124        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory, null, $this->mockStubValidatorMax); 
     125        $this->assertEqual($integerFilter->execute(10), 10); 
     126        $this->expectException('stubFilterException'); 
     127        $integerFilter->execute(11); 
     128    } 
    129129 
    130130    /** 
    131131     * assure that a given double is returned as integer 
    132132     */ 
    133    public function testFloat() 
    134    { 
    135        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
    136        $this->assertEqual($integerFilter->execute(1.564), 1); 
    137    } 
     133    public function testFloat() 
     134    { 
     135        $integerFilter = new stubIntegerFilter($this->mockStubRequestValueErrorFactory); 
     136        $this->assertEqual($integerFilter->execute(1.564), 1); 
     137    } 
    138138} 
    139139?> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubMD5FilterTestCase.php

    r375 r696  
    2121     * assure that the md5 filter works as expected 
    2222     */ 
    23    public function testWithoutPrefixWithoutPostfix() 
    24    { 
    25        $md5Filter = new stubMD5Filter(); 
    26        $this->assertEqual($md5Filter->execute('hello world'), md5('hello world')); 
    27    } 
    28      
     23    public function testWithoutPrefixWithoutPostfix() 
     24    { 
     25        $md5Filter = new stubMD5Filter(); 
     26        $this->assertEqual($md5Filter->execute('hello world'), md5('hello world')); 
     27    } 
     28 
    2929    /** 
    3030     * assure that the md5 filter works as expected 
    3131     */ 
    32    public function testWithPrefixWithoutPostfix() 
    33    { 
    34        $md5Filter = new stubMD5Filter('foo '); 
    35        $this->assertEqual($md5Filter->execute('hello world'), md5('foo hello world')); 
    36        $md5Filter->setPrefix('bar '); 
    37        $this->assertEqual($md5Filter->execute('hello world'), md5('bar hello world')); 
    38    } 
    39      
    40    /** 
     32    public function testWithPrefixWithoutPostfix() 
     33    { 
     34        $md5Filter = new stubMD5Filter('foo '); 
     35        $this->assertEqual($md5Filter->execute('hello world'), md5('foo hello world')); 
     36        $md5Filter->setPrefix('bar '); 
     37        $this->assertEqual($md5Filter->execute('hello world'), md5('bar hello world')); 
     38    } 
     39 
     40    /** 
    4141     * assure that the md5 filter works as expected 
    4242     */ 
    43    public function testWithoutPrefixWithPostfix() 
    44    { 
    45        $md5Filter = new stubMD5Filter('', ' foo'); 
    46        $this->assertEqual($md5Filter->execute('hello world'), md5('hello world foo')); 
    47        $md5Filter->setPostfix(' bar'); 
    48        $this->assertEqual($md5Filter->execute('hello world'), md5('hello world bar')); 
    49    } 
    50      
    51    /** 
     43    public function testWithoutPrefixWithPostfix() 
     44    { 
     45        $md5Filter = new stubMD5Filter('', ' foo'); 
     46        $this->assertEqual($md5Filter->execute('hello world'), md5('hello world foo')); 
     47        $md5Filter->setPostfix(' bar'); 
     48        $this->assertEqual($md5Filter->execute('hello world'), md5('hello world bar')); 
     49    } 
     50 
     51    /** 
    5252     * assure that the md5 filter works as expected 
    5353     */ 
    54    public function testWithPrefixWithPostfix() 
    55    { 
    56        $md5Filter = new stubMD5Filter('foo ', ' bar'); 
    57        $this->assertEqual($md5Filter->execute('hello world'), md5('foo hello world bar')); 
    58        $md5Filter->setPrefix('baz '); 
    59        $this->assertEqual($md5Filter->execute('hello world'), md5('baz hello world bar')); 
    60        $md5Filter->setPostfix(' foo'); 
    61        $this->assertEqual($md5Filter->execute('hello world'), md5('baz hello world foo')); 
    62    } 
     54    public function testWithPrefixWithPostfix() 
     55    { 
     56        $md5Filter = new stubMD5Filter('foo ', ' bar'); 
     57        $this->assertEqual($md5Filter->execute('hello world'), md5('foo hello world bar')); 
     58        $md5Filter->setPrefix('baz '); 
     59        $this->assertEqual($md5Filter->execute('hello world'), md5('baz hello world bar')); 
     60        $md5Filter->setPostfix(' foo'); 
     61        $this->assertEqual($md5Filter->execute('hello world'), md5('baz hello world foo')); 
     62    } 
    6363} 
    6464?> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubMailFilterTestCase.php

    r337 r696  
    3636     */ 
    3737    protected $mockStubMailValidator; 
    38      
     38 
    3939    /** 
    4040     * create test environment 
    …… 
    4848        $this->mailFilter = new stubMailFilter($this->mockStubRequestValueErrorFactory, $this->mockStubMailValidator); 
    4949    } 
    50      
     50 
    5151    /** 
    5252     * assure that values are returned the expected way 
    5353     */ 
    54    public function testValue() 
    55    { 
    56        $this->mockStubMailValidator->setReturnValue('validate', true); 
    57        $this->assertEqual($this->mailFilter->execute('example@example.org'), 'example@example.org'); 
    58    } 
    59      
     54    public function testValue() 
     55    { 
     56        $this->mockStubMailValidator->setReturnValue('validate', true); 
     57        $this->assertEqual($this->mailFilter->execute('example@example.org'), 'example@example.org'); 
     58    } 
     59 
    6060    /** 
    6161     * assure that an exceptiom is thrown when a wrong value is passed 
    6262     */ 
    63    public function testWrongValue() 
    64    { 
    65        $this->mockStubMailValidator->setReturnValue('validate', false); 
    66        $this->mockStubRequestValueErrorFactory->expect('MAILADDRESS_INCORRECT'); 
    67        $this->expectException('stubFilterException'); 
    68        $this->mailFilter->execute(null); 
    69    } 
     63    public function testWrongValue() 
     64    { 
     65        $this->mockStubMailValidator->setReturnValue('validate', false); 
     66        $this->mockStubRequestValueErrorFactory->expect('MAILADDRESS_INCORRECT'); 
     67        $this->expectException('stubFilterException'); 
     68        $this->mailFilter->execute(null); 
     69    } 
    7070} 
    7171?> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubPassThruFilterTestCase.php

    r410 r696  
    3030     */ 
    3131    protected $mockStubRequestValueErrorFactory; 
    32      
     32 
    3333    /** 
    3434     * set up test environment 
    …… 
    4040        $this->passthruFilter = new stubPassThruFilter($this->mockStubRequestValueErrorFactory); 
    4141    } 
    42      
     42 
    4343    /** 
    4444     * assure that values are returned the expected way 
    4545     */ 
    46    public function testUnrequiredValue() 
    47    { 
    48        $this->passthruFilter->setRequired(false); 
    49        $this->assertEqual($this->passthruFilter->execute(''), ''); 
    50        $this->assertEqual($this->passthruFilter->execute('foo'), 'foo'); 
    51        $this->assertNull($this->passthruFilter->execute(null)); 
    52    } 
    53      
     46    public function testUnrequiredValue() 
     47    { 
     48        $this->passthruFilter->setRequired(false); 
     49        $this->assertEqual($this->passthruFilter->execute(''), ''); 
     50        $this->assertEqual($this->passthruFilter->execute('foo'), 'foo'); 
     51        $this->assertNull($this->passthruFilter->execute(null)); 
     52    } 
     53 
    5454    /** 
    5555     * assure that an exceptiom is thrown when a wrong value is passed 
    5656     */ 
    57    public function testRequiredValue() 
    58    { 
    59        $this->passthruFilter->setRequired(true); 
    60        $this->assertEqual($this->passthruFilter->execute(''), ''); 
    61        $this->assertEqual($this->passthruFilter->execute('foo'), 'foo'); 
    62        $this->expectException('stubFilterException'); 
    63        $this->assertNull($this->passthruFilter->execute(null)); 
    64    } 
     57    public function testRequiredValue() 
     58    { 
     59        $this->passthruFilter->setRequired(true); 
     60        $this->assertEqual($this->passthruFilter->execute(''), ''); 
     61        $this->assertEqual($this->passthruFilter->execute('foo'), 'foo'); 
     62        $this->expectException('stubFilterException'); 
     63        $this->assertNull($this->passthruFilter->execute(null)); 
     64    } 
    6565} 
    6666?> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubPasswordFilterTestCase.php

    r140 r696  
    3636     */ 
    3737    protected $passwordFilter; 
    38      
     38 
    3939    /** 
    4040     * create test environment 
    …… 
    4848        $this->passwordFilter = new stubPasswordFilter($this->mockStubRequestValueErrorFactory, $this->mockMinLengthValidator); 
    4949    } 
    50      
     50 
    5151    /** 
    5252     * assure that values are returned the expected way 
    5353     */ 
    54    public function testValue() 
    55    { 
    56        $this->mockMinLengthValidator->setReturnValueAt(0, 'validate', true); 
    57        $this->mockMinLengthValidator->setReturnValueAt(1, 'validate', true); 
    58        $this->mockMinLengthValidator->setReturnValueAt(2, 'validate', false); 
    59        $this->mockMinLengthValidator->setReturnValue('getCriteria', array('minLength' => 'foo')); 
    60        $this->assertEqual($this->passwordFilter->execute('foo'), md5('foo')); 
    61        $this->assertEqual($this->passwordFilter->execute('425%$%"§$%t 32'), md5('425%$%"§$%t 32')); 
    62        $this->expectException('stubFilterException'); 
    63        $this->passwordFilter->execute('anything'); 
    64    } 
    65      
    66    /** 
     54    public function testValue() 
     55    { 
     56        $this->mockMinLengthValidator->setReturnValueAt(0, 'validate', true); 
     57        $this->mockMinLengthValidator->setReturnValueAt(1, 'validate', true); 
     58        $this->mockMinLengthValidator->setReturnValueAt(2, 'validate', false); 
     59        $this->mockMinLengthValidator->setReturnValue('getCriteria', array('minLength' => 'foo')); 
     60        $this->assertEqual($this->passwordFilter->execute('foo'), md5('foo')); 
     61        $this->assertEqual($this->passwordFilter->execute('425%$%"§$%t 32'), md5('425%$%"§$%t 32')); 
     62        $this->expectException('stubFilterException'); 
     63        $this->passwordFilter->execute('anything'); 
     64    } 
     65 
     66    /** 
    6767     * assure that values are returned the expected way 
    6868     */ 
    69    public function testValueWithoutRequired() 
    70    { 
    71        $this->mockMinLengthValidator->setReturnValue('validate', true); 
    72        $this->passwordFilter->setRequired(false); 
    73        $this->assertNull($this->passwordFilter->execute('')); 
    74        $this->assertNull($this->passwordFilter->execute(null)); 
    75        
    76    } 
    77      
    78    /** 
    79     * assure that array values are returned the expected way 
    80     */ 
    81    public function testArrayValue() 
    82    { 
    83        $this->mockMinLengthValidator->setReturnValue('validate', true); 
    84        $this->assertEqual($this->passwordFilter->execute(array('foo', 'foo')), md5('foo')); 
    85        $this->expectException('stubFilterException'); 
    86        $this->passwordFilter->execute(array('foo', 'bar')); 
    87    } 
     69    public function testValueWithoutRequired() 
     70    { 
     71        $this->mockMinLengthValidator->setReturnValue('validate', true); 
     72        $this->passwordFilter->setRequired(false); 
     73        $this->assertNull($this->passwordFilter->execute('')); 
     74        $this->assertNull($this->passwordFilter->execute(null)); 
     75           
     76    } 
     77 
     78    /** 
     79    * assure that array values are returned the expected way 
     80    */ 
     81    public function testArrayValue() 
     82    { 
     83        $this->mockMinLengthValidator->setReturnValue('validate', true); 
     84        $this->assertEqual($this->passwordFilter->execute(array('foo', 'foo')), md5('foo')); 
     85        $this->expectException('stubFilterException'); 
     86        $this->passwordFilter->execute(array('foo', 'bar')); 
     87    } 
    8888 
    8989    /** 
    9090     * assure that an unexpected value throws a stubFilterException 
    9191     */ 
    92    public function testUnExpectedValue() 
    93    { 
    94        $this->passwordFilter->setNonAllowedValues(array('bar')); 
    95        $this->mockMinLengthValidator->setReturnValue('getCriteria', array('minLength' => 'foo')); 
    96        $this->expectException('stubFilterException'); 
    97        $this->passwordFilter->execute('bar'); 
    98    } 
     92    public function testUnExpectedValue() 
     93    { 
     94        $this->passwordFilter->setNonAllowedValues(array('bar')); 
     95        $this->mockMinLengthValidator->setReturnValue('getCriteria', array('minLength' => 'foo')); 
     96        $this->expectException('stubFilterException'); 
     97        $this->passwordFilter->execute('bar'); 
     98    } 
    9999} 
    100100?> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubStringFilterTestCase.php

    r140 r696  
    3636     */ 
    3737    protected $stringFilter; 
    38      
     38 
    3939    /** 
    4040     * create test environment 
    …… 
    4747        $this->stringFilter = new stubStringFilter($this->mockStubRequestValueErrorFactory, $this->mockRegexValidator); 
    4848    } 
    49      
     49 
    5050    /** 
    5151     * assure that filtering null is ok when no input required and throws an 
    5252     * exception when input required 
    5353     */ 
    54    public function testNull() 
    55    { 
    56        $this->mockRegexValidator->setReturnValue('validate', true); 
    57        $this->stringFilter->setRequired(false); 
    58        $this->assertNull($this->stringFilter->execute(null)); 
    59          
    60        $this->stringFilter->setRequired(true); 
    61        $this->expectException('stubFilterException'); 
    62        $this->stringFilter->execute(null); 
    63    } 
     54    public function testNull() 
     55    { 
     56        $this->mockRegexValidator->setReturnValue('validate', true); 
     57        $this->stringFilter->setRequired(false); 
     58        $this->assertNull($this->stringFilter->execute(null)); 
     59         
     60        $this->stringFilter->setRequired(true); 
     61        $this->expectException('stubFilterException'); 
     62        $this->stringFilter->execute(null); 
     63    } 
    6464 
    6565    /** 
    …… 
    6767     * throws an exception when input required 
    6868     */ 
    69    public function testEmpty() 
    70    { 
    71        $this->mockRegexValidator->setReturnValue('validate', true); 
    72        $this->stringFilter->setRequired(false); 
    73        $this->assertEqual($this->stringFilter->execute(''), ''); 
    74          
    75        $this->stringFilter->setRequired(true); 
    76        $this->expectException('stubFilterException'); 
    77        $this->stringFilter->execute(''); 
    78    } 
    79      
    80    /** 
     69    public function testEmpty() 
     70    { 
     71        $this->mockRegexValidator->setReturnValue('validate', true); 
     72        $this->stringFilter->setRequired(false); 
     73        $this->assertEqual($this->stringFilter->execute(''), ''); 
     74         
     75        $this->stringFilter->setRequired(true); 
     76        $this->expectException('stubFilterException'); 
     77        $this->stringFilter->execute(''); 
     78    } 
     79 
     80    /** 
    8181     * assure that filtering a string with minimum length is ok and a string 
    8282     * with length shorter than minimum length throws an FilterException 
    8383     */ 
    84    public function testMinLength() 
    85    { 
    86        $this->mockRegexValidator->setReturnValue('validate', true); 
    87        $mockMinLengthValidaror = new MockStubValidator(); 
    88        $mockMinLengthValidaror->expect('validate', array('minLengthTest')); 
    89        $mockMinLengthValidaror->setReturnValueAt(0, 'validate', true); 
    90        $mockMinLengthValidaror->setReturnValueAt(1, 'validate', false); 
    91        $mockMinLengthValidaror->setReturnValue('getCriteria', array()); 
    92        $this->stringFilter->setMinLengthValidator($mockMinLengthValidaror); 
    93        $this->assertEqual($this->stringFilter->execute("minLength\nTest"), 'minLengthTest'); 
    94         
    95        $this->expectException('stubFilterException'); 
    96        $this->stringFilter->execute('minLengthTest'); 
    97    } 
     84    public function testMinLength() 
     85    { 
     86        $this->mockRegexValidator->setReturnValue('validate', true); 
     87        $mockMinLengthValidaror = new MockStubValidator(); 
     88        $mockMinLengthValidaror->expect('validate', array('minLengthTest')); 
     89        $mockMinLengthValidaror->setReturnValueAt(0, 'validate', true); 
     90        $mockMinLengthValidaror->setReturnValueAt(1, 'validate', false); 
     91        $mockMinLengthValidaror->setReturnValue('getCriteria', array()); 
     92        $this->stringFilter->setMinLengthValidator($mockMinLengthValidaror); 
     93        $this->assertEqual($this->stringFilter->execute("minLength\nTest"), 'minLengthTest'); 
     94         
     95        $this->expectException('stubFilterException'); 
     96        $this->stringFilter->execute('minLengthTest'); 
     97    } 
    9898 
    9999    /** 
    …… 
    101101     * with length greater than maximum length throws an FilterException 
    102102     */ 
    103    public function testMaxLength() 
    104    { 
    105        $this->mockRegexValidator->setReturnValue('validate', true); 
    106        $mockMaxLengthValidaror = new MockStubValidator(); 
    107        $mockMaxLengthValidaror->expect('validate', array('maxLengthTest')); 
    108        $mockMaxLengthValidaror->setReturnValueAt(0, 'validate', true); 
    109        $mockMaxLengthValidaror->setReturnValueAt(1, 'validate', false); 
    110        $mockMaxLengthValidaror->setReturnValue('getCriteria', array()); 
    111        $this->stringFilter->setMaxLengthValidator($mockMaxLengthValidaror); 
    112        $this->assertEqual($this->stringFilter->execute("max\nLengthTest"), 'maxLengthTest'); 
    113         
    114        $this->expectException('stubFilterException'); 
    115        $this->stringFilter->execute('maxLengthTest'); 
    116    } 
     103    public function testMaxLength() 
     104    { 
     105        $this->mockRegexValidator->setReturnValue('validate', true); 
     106        $mockMaxLengthValidaror = new MockStubValidator(); 
     107        $mockMaxLengthValidaror->expect('validate', array('maxLengthTest')); 
     108        $mockMaxLengthValidaror->setReturnValueAt(0, 'validate', true); 
     109        $mockMaxLengthValidaror->setReturnValueAt(1, 'validate', false); 
     110        $mockMaxLengthValidaror->setReturnValue('getCriteria', array()); 
     111        $this->stringFilter->setMaxLengthValidator($mockMaxLengthValidaror); 
     112        $this->assertEqual($this->stringFilter->execute("max\nLengthTest"), 'maxLengthTest'); 
     113         
     114        $this->expectException('stubFilterException'); 
     115        $this->stringFilter->execute('maxLengthTest'); 
     116    } 
    117117 
    118118    /** 
    …… 
    120120     * without invalid characters 
    121121     */ 
    122    public function testCorrections() 
    123    { 
    124        $this->mockRegexValidator->setReturnValue('validate', true); 
     122    public function testCorrections() 
     123    { 
     124        $this->mockRegexValidator->setReturnValue('validate', true); 
    125125        $this->assertEqual($this->stringFilter->execute("ab\ncde\r\n\'kkk<b>"), "abcde'kkk"); 
    126    } 
     126    } 
    127127 
    128128    /** 
    129129     * assure that filtering a string with regular expressions works correct 
    130130     */ 
    131    public function testRegex() 
    132    { 
    133        $this->mockRegexValidator->setReturnValue('validate', false); 
    134        $this->expectException('stubFilterException'); 
    135        $this->stringFilter->execute('regexTest'); 
    136    } 
     131    public function testRegex() 
     132    { 
     133        $this->mockRegexValidator->setReturnValue('validate', false); 
     134        $this->expectException('stubFilterException'); 
     135        $this->stringFilter->execute('regexTest'); 
     136    } 
    137137} 
    138138?> 

  • trunk/src/test/php/net/stubbles/ipo/request/filters/stubTextFilterTestCase.php

    r140 r696  
    3636     */ 
    3737    protected $textFilter; 
    38      
     38 
    3939    /** 
    4040     * create test environment 
    …… 
    5252     * exception when input required 
    5353     */ 
    54    public function testNull() 
    55    { 
    56        $this->mockRegexValidator->setReturnValue('validate', true); 
    57        $this->textFilter->setRequired(false); 
    58        $this->assertNull($this->textFilter->execute(null)); 
    59          
    60        $this->textFilter->setRequired(true); 
    61        $this->expectException('stubFilterException'); 
    62        $this->textFilter->execute(null); 
    63    } 
     54    public function testNull() 
     55    { 
     56        $this->mockRegexValidator->setReturnValue('validate', true); 
     57        $this->textFilter->setRequired(false); 
     58        $this->assertNull($this->textFilter->execute(null)); 
     59         
     60        $this->textFilter->setRequired(true); 
     61        $this->expectException('stubFilterException'); 
     62        $this->textFilter->execute(null); 
     63    } 
    6464 
    6565    /** 
    …… 
    6767     * throws an exception when input required 
    6868     */ 
    69    public function testEmpty() 
    70    { 
    71        $this->mockRegexValidator->setReturnValue('validate', true); 
    72        $this->textFilter->setRequired(false); 
    73        $this->assertEqual($this->textFilter->execute(''), ''); 
    74          
    75        $this->textFilter->setRequired(true); 
    76        $this->expectException('stubFilterException'); 
    77        $this->textFilter->execute(''); 
    78    } 
     69    public function testEmpty() 
     70    { 
     71        $this->mockRegexValidator->setReturnValue('validate', true); 
     72        $this->textFilter->setRequired(false); 
     73        $this->assertEqual($this->textFilter->execute(''), ''); 
     74         
     75        $this->textFilter->setRequired(true); 
     76        $this->expectException('stubFilterException'); 
     77        $this->textFilter->execute(''); 
     78    } 
    7979 
    8080    /** 
    …… 
    8282     * with length shorter than minimum length throws an FilterException 
    8383     */ 
    84    public function testMinLength() 
    85    { 
    86        $this->mockRegexValidator->setReturnValue('validate', true); 
    87        $mockMinLengthValidaror = new MockStubValidator(); 
    88        $mockMinLengthValidaror->expect('validate', array("minLength\nTest")); 
    89        $mockMinLengthValidaror->setReturnValueAt(0, 'validate', true); 
    90        $mockMinLengthValidaror->setReturnValueAt(1, 'validate', false); 
    91        $mockMinLengthValidaror->setReturnValue('getCriteria', array()); 
    92        $this->textFilter->setMinLengthValidator($mockMinLengthValidaror); 
    93        $this->assertEqual($this->textFilter->execute("minLength\r\nTest"), "minLength\nTest"); 
    94         
    95        $this->expectException('stubFilterException'); 
    96        $this->textFilter->execute("minLength\nTest"); 
    97    } 
     84    public function testMinLength() 
     85    { 
     86        $this->mockRegexValidator->setReturnValue('validate', true); 
     87        $mockMinLengthValidaror = new MockStubValidator(); 
     88        $mockMinLengthValidaror->expect('validate', array("minLength\nTest")); 
     89        $mockMinLengthValidaror->setReturnValueAt(0, 'validate', true); 
     90        $mockMinLengthValidaror->setReturnValueAt(1, 'validate', false); 
     91        $mockMinLengthValidaror->setReturnValue('getCriteria', array()); 
     92        $this->textFilter->setMinLengthValidator($mockMinLengthValidaror); 
     93        $this->assertEqual($this->textFilter->execute("minLength\r\nTest"), "minLength\nTest"); 
     94         
     95        $this->expectException('stubFilterException'); 
     96        $this->textFilter->execute("minLength\nTest"); 
     97    } 
    9898 
    9999    /** 
    …… 
    101101     * with length greater than maximum length throws an FilterException 
    102102     */ 
    103    public function testMaxLength() 
    104    { 
    105        $this->mockRegexValidator->setReturnValue('validate', true); 
    106        $mockMaxLengthValidaror = new MockStubValidator(); 
    107        $mockMaxLengthValidaror->expect('validate', array("max\nLengthTest")); 
    108        $mockMaxLengthValidaror->setReturnValueAt(0, 'validate', true); 
    109        $mockMaxLengthValidaror->setReturnValueAt(1, 'validate', false); 
    110        $mockMaxLengthValidaror->setReturnValue('getCriteria', array()); 
    111        $this->textFilter->setMaxLengthValidator($mockMaxLengthValidaror); 
    112        $this->assertEqual($this->textFilter->execute("max\r\nLengthTest"), "max\nLengthTest"); 
    113         
    114        $this->expectException('stubFilterException'); 
    115        $this->textFilter->execute("max\nLengthTest"); 
    116    } 
     103    public function testMaxLength() 
     104    { 
     105        $this->mockRegexValidator->setReturnValue('validate', true); 
     106        $mockMaxLengthValidaror = new MockStubValidator(); 
     107        $mockMaxLengthValidaror->expect('validate', array("max\nLengthTest")); 
     108        $mockMaxLengthValidaror->setReturnValueAt(0, 'validate', true); 
     109        $mockMaxLengthValidaror->setReturnValueAt(1, 'validate', false); 
     110        $mockMaxLengthValidaror->setReturnValue('getCriteria', array()); 
     111        $this->textFilter->setMaxLengthValidator($mockMaxLengthValidaror); 
     112        $this->assertEqual($this->textFilter->execute("max\r\nLengthTest"), "max\nLengthTest"); 
     113         
     114        $this->expectException('stubFilterException'); 
     115        $this->textFilter->execute("max\nLengthTest"); 
     116    } 
    117117 
    118118    /** 
    …… 
    121121     * removing invalid characters 
    122122     */ 
    123    public function testCorrections() 
    124    { 
    125        $this->mockRegexValidator->setReturnValue('validate', true); 
     123    public function testCorrections() 
     124    { 
     125        $this->mockRegexValidator->setReturnValue('validate', true); 
    126126        $this->assertEqual($this->textFilter->execute("ab\ncde\r\n\'kkk<b>"), "ab\ncde\n'kkk"); 
    127    } 
     127    } 
    128128 
    129129    /** 
    130130     * assure that filtering of HTML works correct 
    131131     */ 
    132    public function testHTML() 
    133    { 
    134        $text = 'this is <b>bold</b> and <i>cursive</i> and <u>underlined</u>'; 
    135        $this->mockRegexValidator->setReturnValue('validate', true); 
    136        $this->assertEqual($this->textFilter->execute($text), 'this is bold and cursive and underlined'); 
    137         
    138        $this->textFilter->setAllowedTags(array('b', 'i')); 
    139        $this->assertEqual($this->textFilter->execute($text), 'this is <b>bold</b> and <i>cursive</i> and underlined'); 
    140          
    141        $this->textFilter->setAllowedTags(array('b', 'i', 'a')); 
    142        $this->assertEqual($this->textFilter->execute($text . ' with a <a href="http://example.org/">link</a>'), 'this is <b>bold</b> and <i>cursive</i> and underlined with a <a href="http://example.org/">link</a>'); 
    143    } 
     132    public function testHTML() 
     133    { 
     134        $text = 'this is <b>bold</b> and <i>cursive</i> and <u>underlined</u>'; 
     135        $this->mockRegexValidator->setReturnValue('validate', true); 
     136        $this->assertEqual($this->textFilter->execute($text), 'this is bold and cursive and underlined'); 
     137         
     138        $this->textFilter->setAllowedTags(array('b', 'i')); 
     139        $this->assertEqual($this->textFilter->execute($text), 'this is <b>bold</b> and <i>cursive</i> and underlined'); 
     140         
     141        $this->textFilter->setAllowedTags(array('b', 'i', 'a')); 
     142        $this->assertEqual($this->textFilter->execute($text . ' with a <a href="http://example.org/">link</a>'), 'this is <b>bold</b> and <i>cursive</i> and underlined with a <a href="http://example.org/">link</a>'); 
     143    } 
    144144} 
    145145?> 

  • trunk/src/test/php/net/stubbles/ipo/request/stubRequestValueErrorTestCase.php

    r98 r696  
    3535     */ 
    3636    protected $withoutValueKeys; 
    37      
     37 
    3838    /** 
    3939     * set up test environment 
    …… 
    4747        $this->withoutValueKeys = new stubRequestValueError('bar', array('en_EN' => 'This is an error message.')); 
    4848    } 
    49      
     49 
    5050    /** 
    5151     * assure that the id is stored and returned correct 
    5252     */ 
    53    public function testID() 
    54    { 
    55        $this->assertEqual($this->withValueKeys->getId(), 'foo'); 
    56        $this->assertEqual($this->withoutValueKeys->getId(), 'bar'); 
    57    } 
     53    public function testID() 
     54    { 
     55        $this->assertEqual($this->withValueKeys->getId(), 'foo'); 
     56        $this->assertEqual($this->withoutValueKeys->getId(), 'bar'); 
     57    } 
    5858 
    59    /** 
    60     * test that checking for existing locale message works correct 
    61     * 
    62     */ 
    63    public function testHasMessages() 
    64    { 
    65        $this->assertTrue($this->withValueKeys->hasMessage('en_EN')); 
    66        $this->assertTrue($this->withValueKeys->hasMessage('de_DE')); 
    67        $this->assertFalse($this->withValueKeys->hasMessage('fr_FR')); 
    68         
    69        $this->assertTrue($this->withoutValueKeys->hasMessage('en_EN')); 
    70        $this->assertFalse($this->withoutValueKeys->hasMessage('de_DE')); 
    71        $this->assertFalse($this->withoutValueKeys->hasMessage('fr_FR')); 
    72    } 
    73      
    74    /** 
    75     * test that getting a specific locale message works correct 
    76     * 
    77     */ 
    78    public function testGetMessage() 
    79    { 
    80        $this->assertEqual($this->withValueKeys->getMessage('en_EN'), 'This is an error with criteria  regarding .'); 
    81        $this->assertEqual($this->withValueKeys->getMessage('de_DE'), 'Dies ist ein Fehler des Kriteriums  betreffend .'); 
    82        $this->assertNull($this->withValueKeys->getMessage('fr_FR')); 
    83         
    84        $this->withValueKeys->setValues(array('foo' => 'dummy1', 'bar' => 'dummy2')); 
    85        $this->assertEqual($this->withValueKeys->getMessage('en_EN'), 'This is an error with criteria dummy1 regarding dummy2.'); 
    86        $this->assertEqual($this->withValueKeys->getMessage('de_DE'), 'Dies ist ein Fehler des Kriteriums dummy1 betreffend dummy2.'); 
    87        $this->assertNull($this->withValueKeys->getMessage('fr_FR')); 
    88         
    89        $this->withValueKeys->setValues(array('foo' => array('dummy3', 'dummy4'), 'bar' => 'dummy2')); 
    90        $this->assertEqual($this->withValueKeys->getMessage('en_EN'), 'This is an error with criteria dummy3, dummy4 regarding dummy2.'); 
    91        $this->assertEqual($this->withValueKeys->getMessage('de_DE'), 'Dies ist ein Fehler des Kriteriums dummy3, dummy4 betreffend dummy2.'); 
    92        $this->assertNull($this->withValueKeys->getMessage('fr_FR')); 
    93         
    94        $this->withValueKeys->setValues(array('foo' => new stdClass(), 'bar' => new TestRequestValueErrorCriteria())); 
    95        $this->assertEqual($this->withValueKeys->getMessage('en_EN'), 'This is an error with criteria stdClass regarding very hypercritical stuff.'); 
    96        $this->assertEqual($this->withValueKeys->getMessage('de_DE'), 'Dies ist ein Fehler des Kriteriums stdClass betreffend very hypercritical stuff.'); 
    97        $this->assertNull($this->withValueKeys->getMessage('fr_FR')); 
    98         
    99        $this->assertEqual($this->withoutValueKeys->getMessage('en_EN'), 'This is an error message.'); 
    100        $this->assertNull($this->withoutValueKeys->getMessage('de_DE')); 
    101        $this->assertNull($this->withoutValueKeys->getMessage('fr_FR')); 
    102    } 
    103      
    104    /** 
    105     * test that getting all message works correct 
    106     * 
    107     */ 
    108    public function testGetMessages() 
    109    { 
    110        $result = $this->withValueKeys->setValues(array('foo' => 'dummy1', 'bar' => 'dummy2')); 
    111        $messages = array('en_EN' => 'This is an error with criteria dummy1 regarding dummy2.', 
     59    /** 
     60    * test that checking for existing locale message wo