tests/LinkDBTest.php

   1 <?php
   2 /**
   3  * Link datastore tests
   4  */
   5
   6 require_once 'application/Cache.php';
   7 require_once 'application/FileUtils.php';
   8 require_once 'application/LinkDB.php';
   9 require_once 'application/Utils.php';
  10 require_once 'tests/utils/ReferenceLinkDB.php';
  11
  12
  13 /**
  14  * Unitary tests for LinkDB
  15  */
  16 class LinkDBTest extends PHPUnit_Framework_TestCase
  17 {
  18     // datastore to test write operations
  19     protected static $testDatastore = 'sandbox/datastore.php';
  20
  21     /**
  22      * @var ReferenceLinkDB instance.
  23      */
  24     protected static $refDB = null;
  25
  26     /**
  27      * @var LinkDB public LinkDB instance.
  28      */
  29     protected static $publicLinkDB = null;
  30
  31     /**
  32      * @var LinkDB private LinkDB instance.
  33      */
  34     protected static $privateLinkDB = null;
  35
  36     /**
  37      * Instantiates public and private LinkDBs with test data
  38      *
  39      * The reference datastore contains public and private links that
  40      * will be used to test LinkDB's methods:
  41      *  - access filtering (public/private),
  42      *  - link searches:
  43      *    - by day,
  44      *    - by tag,
  45      *    - by text,
  46      *  - etc.
  47      */
  48     public static function setUpBeforeClass()
  49     {
  50         self::$refDB = new ReferenceLinkDB();
  51         self::$refDB->write(self::$testDatastore);
  52
  53         self::$publicLinkDB = new LinkDB(self::$testDatastore, false, false);
  54         self::$privateLinkDB = new LinkDB(self::$testDatastore, true, false);
  55     }
  56
  57     /**
  58      * Resets test data for each test
  59      */
  60     protected function setUp()
  61     {
  62         if (file_exists(self::$testDatastore)) {
  63             unlink(self::$testDatastore);
  64         }
  65     }
  66
  67     /**
  68      * Allows to test LinkDB's private methods
  69      *
  70      * @see
  71      *  https://sebastian-bergmann.de/archives/881-Testing-Your-Privates.html
  72      *  http://stackoverflow.com/a/2798203
  73      */
  74     protected static function getMethod($name)
  75     {
  76         $class = new ReflectionClass('LinkDB');
  77         $method = $class->getMethod($name);
  78         $method->setAccessible(true);
  79         return $method;
  80     }
  81
  82     /**
  83      * Instantiate LinkDB objects - logged in user
  84      */
  85     public function testConstructLoggedIn()
  86     {
  87         new LinkDB(self::$testDatastore, true, false);
  88         $this->assertFileExists(self::$testDatastore);
  89     }
  90
  91     /**
  92      * Instantiate LinkDB objects - logged out or public instance
  93      */
  94     public function testConstructLoggedOut()
  95     {
  96         new LinkDB(self::$testDatastore, false, false);
  97         $this->assertFileExists(self::$testDatastore);
  98     }
  99
 100     /**
 101      * Attempt to instantiate a LinkDB whereas the datastore is not writable
 102      *
 103      * @expectedException              IOException
 104      * @expectedExceptionMessageRegExp /Error accessing\nnull/
 105      */
 106     public function testConstructDatastoreNotWriteable()
 107     {
 108         new LinkDB('null/store.db', false, false);
 109     }
 110
 111     /**
 112      * The DB doesn't exist, ensure it is created with dummy content
 113      */
 114     public function testCheckDBNew()
 115     {
 116         $linkDB = new LinkDB(self::$testDatastore, false, false);
 117         unlink(self::$testDatastore);
 118         $this->assertFileNotExists(self::$testDatastore);
 119
 120         $checkDB = self::getMethod('check');
 121         $checkDB->invokeArgs($linkDB, array());
 122         $this->assertFileExists(self::$testDatastore);
 123
 124         // ensure the correct data has been written
 125         $this->assertGreaterThan(0, filesize(self::$testDatastore));
 126     }
 127
 128     /**
 129      * The DB exists, don't do anything
 130      */
 131     public function testCheckDBLoad()
 132     {
 133         $linkDB = new LinkDB(self::$testDatastore, false, false);
 134         $datastoreSize = filesize(self::$testDatastore);
 135         $this->assertGreaterThan(0, $datastoreSize);
 136
 137         $checkDB = self::getMethod('check');
 138         $checkDB->invokeArgs($linkDB, array());
 139
 140         // ensure the datastore is left unmodified
 141         $this->assertEquals(
 142             $datastoreSize,
 143             filesize(self::$testDatastore)
 144         );
 145     }
 146
 147     /**
 148      * Load an empty DB
 149      */
 150     public function testReadEmptyDB()
 151     {
 152         file_put_contents(self::$testDatastore, '<?php /* S7QysKquBQA= */ ?>');
 153         $emptyDB = new LinkDB(self::$testDatastore, false, false);
 154         $this->assertEquals(0, sizeof($emptyDB));
 155         $this->assertEquals(0, count($emptyDB));
 156     }
 157
 158     /**
 159      * Load public links from the DB
 160      */
 161     public function testReadPublicDB()
 162     {
 163         $this->assertEquals(
 164             self::$refDB->countPublicLinks(),
 165             sizeof(self::$publicLinkDB)
 166         );
 167     }
 168
 169     /**
 170      * Load public and private links from the DB
 171      */
 172     public function testReadPrivateDB()
 173     {
 174         $this->assertEquals(
 175             self::$refDB->countLinks(),
 176             sizeof(self::$privateLinkDB)
 177         );
 178     }
 179
 180     /**
 181      * Save the links to the DB
 182      */
 183     public function testSave()
 184     {
 185         $testDB = new LinkDB(self::$testDatastore, true, false);
 186         $dbSize = sizeof($testDB);
 187
 188         $link = array(
 189             'title'=>'an additional link',
 190             'url'=>'http://dum.my',
 191             'description'=>'One more',
 192             'private'=>0,
 193             'linkdate'=>'20150518_190000',
 194             'tags'=>'unit test'
 195         );
 196         $testDB[$link['linkdate']] = $link;
 197         $testDB->save('tests');
 198
 199         $testDB = new LinkDB(self::$testDatastore, true, false);
 200         $this->assertEquals($dbSize + 1, sizeof($testDB));
 201     }
 202
 203     /**
 204      * Count existing links
 205      */
 206     public function testCount()
 207     {
 208         $this->assertEquals(
 209             self::$refDB->countPublicLinks(),
 210             self::$publicLinkDB->count()
 211         );
 212         $this->assertEquals(
 213             self::$refDB->countLinks(),
 214             self::$privateLinkDB->count()
 215         );
 216     }
 217
 218     /**
 219      * Count existing links - public links hidden
 220      */
 221     public function testCountHiddenPublic()
 222     {
 223         $linkDB = new LinkDB(self::$testDatastore, false, true);
 224
 225         $this->assertEquals(
 226             0,
 227             $linkDB->count()
 228         );
 229         $this->assertEquals(
 230             0,
 231             $linkDB->count()
 232         );
 233     }
 234
 235     /**
 236      * List the days for which links have been posted
 237      */
 238     public function testDays()
 239     {
 240         $this->assertEquals(
 241             array('20121206', '20130614', '20150310'),
 242             self::$publicLinkDB->days()
 243         );
 244
 245         $this->assertEquals(
 246             array('20121206', '20130614', '20141125', '20150310'),
 247             self::$privateLinkDB->days()
 248         );
 249     }
 250
 251     /**
 252      * The URL corresponds to an existing entry in the DB
 253      */
 254     public function testGetKnownLinkFromURL()
 255     {
 256         $link = self::$publicLinkDB->getLinkFromUrl('http://mediagoblin.org/');
 257
 258         $this->assertNotEquals(false, $link);
 259         $this->assertContains(
 260             'A free software media publishing platform',
 261             $link['description']
 262         );
 263     }
 264
 265     /**
 266      * The URL is not in the DB
 267      */
 268     public function testGetUnknownLinkFromURL()
 269     {
 270         $this->assertEquals(
 271             false,
 272             self::$publicLinkDB->getLinkFromUrl('http://dev.null')
 273         );
 274     }
 275
 276     /**
 277      * Lists all tags
 278      */
 279     public function testAllTags()
 280     {
 281         $this->assertEquals(
 282             array(
 283                 'web' => 3,
 284                 'cartoon' => 2,
 285                 'gnu' => 2,
 286                 'dev' => 1,
 287                 'samba' => 1,
 288                 'media' => 1,
 289                 'software' => 1,
 290                 'stallman' => 1,
 291                 'free' => 1,
 292                 '-exclude' => 1,
 293                 // The DB contains a link with `sTuff` and another one with `stuff` tag.
 294                 // They need to be grouped with the first case found (`sTuff`).
 295                 'sTuff' => 2,
 296                 'hashtag' => 2,
 297             ),
 298             self::$publicLinkDB->allTags()
 299         );
 300
 301         $this->assertEquals(
 302             array(
 303                 'web' => 4,
 304                 'cartoon' => 3,
 305                 'gnu' => 2,
 306                 'dev' => 2,
 307                 'samba' => 1,
 308                 'media' => 1,
 309                 'software' => 1,
 310                 'stallman' => 1,
 311                 'free' => 1,
 312                 'html' => 1,
 313                 'w3c' => 1,
 314                 'css' => 1,
 315                 'Mercurial' => 1,
 316                 'sTuff' => 2,
 317                 '-exclude' => 1,
 318                 '.hidden' => 1,
 319                 'hashtag' => 2,
 320                 'tag1' => 1,
 321                 'tag2' => 1,
 322                 'tag3' => 1,
 323                 'tag4' => 1,
 324             ),
 325             self::$privateLinkDB->allTags()
 326         );
 327     }
 328
 329     /**
 330      * Test real_url without redirector.
 331      */
 332     public function testLinkRealUrlWithoutRedirector()
 333     {
 334         $db = new LinkDB(self::$testDatastore, false, false);
 335         foreach($db as $link) {
 336             $this->assertEquals($link['url'], $link['real_url']);
 337         }
 338     }
 339
 340     /**
 341      * Test real_url with redirector.
 342      */
 343     public function testLinkRealUrlWithRedirector()
 344     {
 345         $redirector = 'http://redirector.to?';
 346         $db = new LinkDB(self::$testDatastore, false, false, $redirector);
 347         foreach($db as $link) {
 348             $this->assertStringStartsWith($redirector, $link['real_url']);
 349             $this->assertNotFalse(strpos($link['real_url'], urlencode('://')));
 350         }
 351
 352         $db = new LinkDB(self::$testDatastore, false, false, $redirector, false);
 353         foreach($db as $link) {
 354             $this->assertStringStartsWith($redirector, $link['real_url']);
 355             $this->assertFalse(strpos($link['real_url'], urlencode('://')));
 356         }
 357     }
 358
 359     /**
 360      * Test filter with string.
 361      */
 362     public function testFilterString()
 363     {
 364         $tags = 'dev cartoon';
 365         $request = array('searchtags' => $tags);
 366         $this->assertEquals(
 367             2,
 368             count(self::$privateLinkDB->filterSearch($request, true, false))
 369         );
 370     }
 371
 372     /**
 373      * Test filter with string.
 374      */
 375     public function testFilterArray()
 376     {
 377         $tags = array('dev', 'cartoon');
 378         $request = array('searchtags' => $tags);
 379         $this->assertEquals(
 380             2,
 381             count(self::$privateLinkDB->filterSearch($request, true, false))
 382         );
 383     }
 384
 385     /**
 386      * Test hidden tags feature:
 387      *  tags starting with a dot '.' are only visible when logged in.
 388      */
 389     public function testHiddenTags()
 390     {
 391         $tags = '.hidden';
 392         $request = array('searchtags' => $tags);
 393         $this->assertEquals(
 394             1,
 395             count(self::$privateLinkDB->filterSearch($request, true, false))
 396         );
 397
 398         $this->assertEquals(
 399             0,
 400             count(self::$publicLinkDB->filterSearch($request, true, false))
 401         );
 402     }
 403
 404     /**
 405      * Test filterHash() with a valid smallhash.
 406      */
 407     public function testFilterHashValid()
 408     {
 409         $request = smallHash('20150310_114651');
 410         $this->assertEquals(
 411             1,
 412             count(self::$publicLinkDB->filterHash($request))
 413         );
 414     }
 415
 416     /**
 417      * Test filterHash() with an invalid smallhash.
 418      *
 419      * @expectedException LinkNotFoundException
 420      */
 421     public function testFilterHashInValid1()
 422     {
 423         $request = 'blabla';
 424         self::$publicLinkDB->filterHash($request);
 425     }
 426
 427     /**
 428      * Test filterHash() with an empty smallhash.
 429      *
 430      * @expectedException LinkNotFoundException
 431      */
 432     public function testFilterHashInValid()
 433     {
 434         self::$publicLinkDB->filterHash('');
 435     }
 436 }