tests/UtilsTest.php

   1 <?php
   2 /**
   3  * Utilities' tests
   4  */
   5
   6 require_once 'application/Utils.php';
   7 require_once 'tests/utils/ReferenceSessionIdHashes.php';
   8
   9 // Initialize reference data before PHPUnit starts a session
  10 ReferenceSessionIdHashes::genAllHashes();
  11
  12
  13 /**
  14  * Unitary tests for Shaarli utilities
  15  */
  16 class UtilsTest extends PHPUnit_Framework_TestCase
  17 {
  18     // Session ID hashes
  19     protected static $sidHashes = null;
  20
  21     /**
  22      * Assign reference data
  23      */
  24     public static function setUpBeforeClass()
  25     {
  26         self::$sidHashes = ReferenceSessionIdHashes::getHashes();
  27     }
  28
  29     /**
  30      * Represent a link by its hash
  31      */
  32     public function testSmallHash()
  33     {
  34         $this->assertEquals('CyAAJw', smallHash('http://test.io'));
  35         $this->assertEquals(6, strlen(smallHash('https://github.com')));
  36     }
  37
  38     /**
  39      * Look for a substring at the beginning of a string
  40      */
  41     public function testStartsWithCaseInsensitive()
  42     {
  43         $this->assertTrue(startsWith('Lorem ipsum', 'lorem', false));
  44         $this->assertTrue(startsWith('Lorem ipsum', 'LoReM i', false));
  45     }
  46
  47     /**
  48      * Look for a substring at the beginning of a string (case-sensitive)
  49      */
  50     public function testStartsWithCaseSensitive()
  51     {
  52         $this->assertTrue(startsWith('Lorem ipsum', 'Lorem', true));
  53         $this->assertFalse(startsWith('Lorem ipsum', 'lorem', true));
  54         $this->assertFalse(startsWith('Lorem ipsum', 'LoReM i', true));
  55     }
  56
  57     /**
  58      * Look for a substring at the beginning of a string (Unicode)
  59      */
  60     public function testStartsWithSpecialChars()
  61     {
  62         $this->assertTrue(startsWith('å!ùµ', 'å!', false));
  63         $this->assertTrue(startsWith('µ$åù', 'µ$', true));
  64     }
  65
  66     /**
  67      * Look for a substring at the end of a string
  68      */
  69     public function testEndsWithCaseInsensitive()
  70     {
  71         $this->assertTrue(endsWith('Lorem ipsum', 'ipsum', false));
  72         $this->assertTrue(endsWith('Lorem ipsum', 'm IpsUM', false));
  73     }
  74
  75     /**
  76      * Look for a substring at the end of a string (case-sensitive)
  77      */
  78     public function testEndsWithCaseSensitive()
  79     {
  80         $this->assertTrue(endsWith('lorem Ipsum', 'Ipsum', true));
  81         $this->assertFalse(endsWith('lorem Ipsum', 'ipsum', true));
  82         $this->assertFalse(endsWith('lorem Ipsum', 'M IPsuM', true));
  83     }
  84
  85     /**
  86      * Look for a substring at the end of a string (Unicode)
  87      */
  88     public function testEndsWithSpecialChars()
  89     {
  90         $this->assertTrue(endsWith('å!ùµ', 'ùµ', false));
  91         $this->assertTrue(endsWith('µ$åù', 'åù', true));
  92     }
  93
  94     /**
  95      * Check valid date strings, according to a DateTime format
  96      */
  97     public function testCheckValidDateFormat()
  98     {
  99         $this->assertTrue(checkDateFormat('Ymd', '20150627'));
 100         $this->assertTrue(checkDateFormat('Y-m-d', '2015-06-27'));
 101     }
 102
 103     /**
 104      * Check erroneous date strings, according to a DateTime format
 105      */
 106     public function testCheckInvalidDateFormat()
 107     {
 108         $this->assertFalse(checkDateFormat('Ymd', '2015'));
 109         $this->assertFalse(checkDateFormat('Y-m-d', '2015-06'));
 110         $this->assertFalse(checkDateFormat('Ymd', 'DeLorean'));
 111     }
 112
 113     /**
 114      * Test generate location with valid data.
 115      */
 116     public function testGenerateLocation() {
 117         $ref = 'http://localhost/?test';
 118         $this->assertEquals($ref, generateLocation($ref, 'localhost'));
 119         $ref = 'http://localhost:8080/?test';
 120         $this->assertEquals($ref, generateLocation($ref, 'localhost:8080'));
 121     }
 122
 123     /**
 124      * Test generate location - anti loop.
 125      */
 126     public function testGenerateLocationLoop() {
 127         $ref = 'http://localhost/?test';
 128         $this->assertEquals('?', generateLocation($ref, 'localhost', array('test')));
 129     }
 130
 131     /**
 132      * Test generate location - from other domain.
 133      */
 134     public function testGenerateLocationOut() {
 135         $ref = 'http://somewebsite.com/?test';
 136         $this->assertEquals('?', generateLocation($ref, 'localhost'));
 137     }
 138
 139     /**
 140      * Check supported PHP versions
 141      */
 142     public function testCheckSupportedPHPVersion()
 143     {
 144         $minVersion = '5.3';
 145         checkPHPVersion($minVersion, '5.4.32');
 146         checkPHPVersion($minVersion, '5.5');
 147         checkPHPVersion($minVersion, '5.6.10');
 148     }
 149
 150     /**
 151      * Check a unsupported PHP version
 152      * @expectedException              Exception
 153      * @expectedExceptionMessageRegExp /Your PHP version is obsolete/
 154      */
 155     public function testCheckSupportedPHPVersion51()
 156     {
 157         checkPHPVersion('5.3', '5.1.0');
 158     }
 159
 160     /**
 161      * Check another unsupported PHP version
 162      * @expectedException              Exception
 163      * @expectedExceptionMessageRegExp /Your PHP version is obsolete/
 164      */
 165     public function testCheckSupportedPHPVersion52()
 166     {
 167         checkPHPVersion('5.3', '5.2');
 168     }
 169
 170     /**
 171      * Test is_session_id_valid with a valid ID - TEST ALL THE HASHES!
 172      *
 173      * This tests extensively covers all hash algorithms / bit representations
 174      */
 175     public function testIsAnyHashSessionIdValid()
 176     {
 177         foreach (self::$sidHashes as $algo => $bpcs) {
 178             foreach ($bpcs as $bpc => $hash) {
 179                 $this->assertTrue(is_session_id_valid($hash));
 180             }
 181         }
 182     }
 183
 184     /**
 185      * Test is_session_id_valid with a valid ID - SHA-1 hashes
 186      */
 187     public function testIsSha1SessionIdValid()
 188     {
 189         $this->assertTrue(is_session_id_valid(sha1('shaarli')));
 190     }
 191
 192     /**
 193      * Test is_session_id_valid with a valid ID - SHA-256 hashes
 194      */
 195     public function testIsSha256SessionIdValid()
 196     {
 197         $this->assertTrue(is_session_id_valid(hash('sha256', 'shaarli')));
 198     }
 199
 200     /**
 201      * Test is_session_id_valid with a valid ID - SHA-512 hashes
 202      */
 203     public function testIsSha512SessionIdValid()
 204     {
 205         $this->assertTrue(is_session_id_valid(hash('sha512', 'shaarli')));
 206     }
 207
 208     /**
 209      * Test is_session_id_valid with invalid IDs.
 210      */
 211     public function testIsSessionIdInvalid()
 212     {
 213         $this->assertFalse(is_session_id_valid(''));
 214         $this->assertFalse(is_session_id_valid(array()));
 215         $this->assertFalse(
 216             is_session_id_valid('c0ZqcWF3VFE2NmJBdm1HMVQ0ZHJ3UmZPbTFsNGhkNHI=')
 217         );
 218     }
 219 }