tests/LinkDBTest.php

   1 <?php
   2 /**
   3  * Link datastore tests
   4  */
   5
   6 require_once 'application/feed/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              Shaarli\Exceptions\IOException
 104      * @expectedExceptionMessageRegExp /Error accessing "null"/
 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             'id' => 42,
 190             'title'=>'an additional link',
 191             'url'=>'http://dum.my',
 192             'description'=>'One more',
 193             'private'=>0,
 194             'created'=> DateTime::createFromFormat(LinkDB::LINK_DATE_FORMAT, '20150518_190000'),
 195             'tags'=>'unit test'
 196         );
 197         $testDB[$link['id']] = $link;
 198         $testDB->save('tests');
 199
 200         $testDB = new LinkDB(self::$testDatastore, true, false);
 201         $this->assertEquals($dbSize + 1, sizeof($testDB));
 202     }
 203
 204     /**
 205      * Count existing links
 206      */
 207     public function testCount()
 208     {
 209         $this->assertEquals(
 210             self::$refDB->countPublicLinks(),
 211             self::$publicLinkDB->count()
 212         );
 213         $this->assertEquals(
 214             self::$refDB->countLinks(),
 215             self::$privateLinkDB->count()
 216         );
 217     }
 218
 219     /**
 220      * Count existing links - public links hidden
 221      */
 222     public function testCountHiddenPublic()
 223     {
 224         $linkDB = new LinkDB(self::$testDatastore, false, true);
 225
 226         $this->assertEquals(
 227             0,
 228             $linkDB->count()
 229         );
 230         $this->assertEquals(
 231             0,
 232             $linkDB->count()
 233         );
 234     }
 235
 236     /**
 237      * List the days for which links have been posted
 238      */
 239     public function testDays()
 240     {
 241         $this->assertEquals(
 242             array('20100309', '20100310', '20121206', '20121207', '20130614', '20150310'),
 243             self::$publicLinkDB->days()
 244         );
 245
 246         $this->assertEquals(
 247             array('20100309', '20100310', '20121206', '20121207', '20130614', '20141125', '20150310'),
 248             self::$privateLinkDB->days()
 249         );
 250     }
 251
 252     /**
 253      * The URL corresponds to an existing entry in the DB
 254      */
 255     public function testGetKnownLinkFromURL()
 256     {
 257         $link = self::$publicLinkDB->getLinkFromUrl('http://mediagoblin.org/');
 258
 259         $this->assertNotEquals(false, $link);
 260         $this->assertContains(
 261             'A free software media publishing platform',
 262             $link['description']
 263         );
 264     }
 265
 266     /**
 267      * The URL is not in the DB
 268      */
 269     public function testGetUnknownLinkFromURL()
 270     {
 271         $this->assertEquals(
 272             false,
 273             self::$publicLinkDB->getLinkFromUrl('http://dev.null')
 274         );
 275     }
 276
 277     /**
 278      * Lists all tags
 279      */
 280     public function testAllTags()
 281     {
 282         $this->assertEquals(
 283             array(
 284                 'web' => 3,
 285                 'cartoon' => 2,
 286                 'gnu' => 2,
 287                 'dev' => 1,
 288                 'samba' => 1,
 289                 'media' => 1,
 290                 'software' => 1,
 291                 'stallman' => 1,
 292                 'free' => 1,
 293                 '-exclude' => 1,
 294                 'hashtag' => 2,
 295                 // The DB contains a link with `sTuff` and another one with `stuff` tag.
 296                 // They need to be grouped with the first case found - order by date DESC: `sTuff`.
 297                 'sTuff' => 2,
 298                 'ut' => 1,
 299             ),
 300             self::$publicLinkDB->linksCountPerTag()
 301         );
 302
 303         $this->assertEquals(
 304             array(
 305                 'web' => 4,
 306                 'cartoon' => 3,
 307                 'gnu' => 2,
 308                 'dev' => 2,
 309                 'samba' => 1,
 310                 'media' => 1,
 311                 'software' => 1,
 312                 'stallman' => 1,
 313                 'free' => 1,
 314                 'html' => 1,
 315                 'w3c' => 1,
 316                 'css' => 1,
 317                 'Mercurial' => 1,
 318                 'sTuff' => 2,
 319                 '-exclude' => 1,
 320                 '.hidden' => 1,
 321                 'hashtag' => 2,
 322                 'tag1' => 1,
 323                 'tag2' => 1,
 324                 'tag3' => 1,
 325                 'tag4' => 1,
 326                 'ut' => 1,
 327             ),
 328             self::$privateLinkDB->linksCountPerTag()
 329         );
 330         $this->assertEquals(
 331             array(
 332                 'web' => 4,
 333                 'cartoon' => 2,
 334                 'gnu' => 1,
 335                 'dev' => 1,
 336                 'samba' => 1,
 337                 'media' => 1,
 338                 'html' => 1,
 339                 'w3c' => 1,
 340                 'css' => 1,
 341                 'Mercurial' => 1,
 342                 '.hidden' => 1,
 343                 'hashtag' => 1,
 344             ),
 345             self::$privateLinkDB->linksCountPerTag(['web'])
 346         );
 347         $this->assertEquals(
 348             array(
 349                 'web' => 1,
 350                 'html' => 1,
 351                 'w3c' => 1,
 352                 'css' => 1,
 353                 'Mercurial' => 1,
 354             ),
 355             self::$privateLinkDB->linksCountPerTag(['web'], 'private')
 356         );
 357     }
 358
 359     /**
 360      * Test real_url without redirector.
 361      */
 362     public function testLinkRealUrlWithoutRedirector()
 363     {
 364         $db = new LinkDB(self::$testDatastore, false, false);
 365         foreach ($db as $link) {
 366             $this->assertEquals($link['url'], $link['real_url']);
 367         }
 368     }
 369
 370     /**
 371      * Test real_url with redirector.
 372      */
 373     public function testLinkRealUrlWithRedirector()
 374     {
 375         $redirector = 'http://redirector.to?';
 376         $db = new LinkDB(self::$testDatastore, false, false, $redirector);
 377         foreach ($db as $link) {
 378             $this->assertStringStartsWith($redirector, $link['real_url']);
 379             $this->assertNotFalse(strpos($link['real_url'], urlencode('://')));
 380         }
 381
 382         $db = new LinkDB(self::$testDatastore, false, false, $redirector, false);
 383         foreach ($db as $link) {
 384             $this->assertStringStartsWith($redirector, $link['real_url']);
 385             $this->assertFalse(strpos($link['real_url'], urlencode('://')));
 386         }
 387     }
 388
 389     /**
 390      * Test filter with string.
 391      */
 392     public function testFilterString()
 393     {
 394         $tags = 'dev cartoon';
 395         $request = array('searchtags' => $tags);
 396         $this->assertEquals(
 397             2,
 398             count(self::$privateLinkDB->filterSearch($request, true, false))
 399         );
 400     }
 401
 402     /**
 403      * Test filter with string.
 404      */
 405     public function testFilterArray()
 406     {
 407         $tags = array('dev', 'cartoon');
 408         $request = array('searchtags' => $tags);
 409         $this->assertEquals(
 410             2,
 411             count(self::$privateLinkDB->filterSearch($request, true, false))
 412         );
 413     }
 414
 415     /**
 416      * Test hidden tags feature:
 417      *  tags starting with a dot '.' are only visible when logged in.
 418      */
 419     public function testHiddenTags()
 420     {
 421         $tags = '.hidden';
 422         $request = array('searchtags' => $tags);
 423         $this->assertEquals(
 424             1,
 425             count(self::$privateLinkDB->filterSearch($request, true, false))
 426         );
 427
 428         $this->assertEquals(
 429             0,
 430             count(self::$publicLinkDB->filterSearch($request, true, false))
 431         );
 432     }
 433
 434     /**
 435      * Test filterHash() with a valid smallhash.
 436      */
 437     public function testFilterHashValid()
 438     {
 439         $request = smallHash('20150310_114651');
 440         $this->assertEquals(
 441             1,
 442             count(self::$publicLinkDB->filterHash($request))
 443         );
 444         $request = smallHash('20150310_114633' . 8);
 445         $this->assertEquals(
 446             1,
 447             count(self::$publicLinkDB->filterHash($request))
 448         );
 449     }
 450
 451     /**
 452      * Test filterHash() with an invalid smallhash.
 453      *
 454      * @expectedException LinkNotFoundException
 455      */
 456     public function testFilterHashInValid1()
 457     {
 458         $request = 'blabla';
 459         self::$publicLinkDB->filterHash($request);
 460     }
 461
 462     /**
 463      * Test filterHash() with an empty smallhash.
 464      *
 465      * @expectedException LinkNotFoundException
 466      */
 467     public function testFilterHashInValid()
 468     {
 469         self::$publicLinkDB->filterHash('');
 470     }
 471
 472     /**
 473      * Test reorder with asc/desc parameter.
 474      */
 475     public function testReorderLinksDesc()
 476     {
 477         self::$privateLinkDB->reorder('ASC');
 478         $stickyIds = [11, 10];
 479         $standardIds = [42, 4, 9, 1, 0, 7, 6, 8, 41];
 480         $linkIds = array_merge($stickyIds, $standardIds);
 481         $cpt = 0;
 482         foreach (self::$privateLinkDB as $key => $value) {
 483             $this->assertEquals($linkIds[$cpt++], $key);
 484         }
 485         self::$privateLinkDB->reorder('DESC');
 486         $linkIds = array_merge(array_reverse($stickyIds), array_reverse($standardIds));
 487         $cpt = 0;
 488         foreach (self::$privateLinkDB as $key => $value) {
 489             $this->assertEquals($linkIds[$cpt++], $key);
 490         }
 491     }
 492
 493     /**
 494      * Test rename tag with a valid value present in multiple links
 495      */
 496     public function testRenameTagMultiple()
 497     {
 498         self::$refDB->write(self::$testDatastore);
 499         $linkDB = new LinkDB(self::$testDatastore, true, false);
 500
 501         $res = $linkDB->renameTag('cartoon', 'Taz');
 502         $this->assertEquals(3, count($res));
 503         $this->assertContains(' Taz ', $linkDB[4]['tags']);
 504         $this->assertContains(' Taz ', $linkDB[1]['tags']);
 505         $this->assertContains(' Taz ', $linkDB[0]['tags']);
 506     }
 507
 508     /**
 509      * Test rename tag with a valid value
 510      */
 511     public function testRenameTagCaseSensitive()
 512     {
 513         self::$refDB->write(self::$testDatastore);
 514         $linkDB = new LinkDB(self::$testDatastore, true, false, '');
 515
 516         $res = $linkDB->renameTag('sTuff', 'Taz');
 517         $this->assertEquals(1, count($res));
 518         $this->assertEquals('Taz', $linkDB[41]['tags']);
 519     }
 520
 521     /**
 522      * Test rename tag with invalid values
 523      */
 524     public function testRenameTagInvalid()
 525     {
 526         $linkDB = new LinkDB(self::$testDatastore, false, false);
 527
 528         $this->assertFalse($linkDB->renameTag('', 'test'));
 529         $this->assertFalse($linkDB->renameTag('', ''));
 530         // tag non existent
 531         $this->assertEquals([], $linkDB->renameTag('test', ''));
 532         $this->assertEquals([], $linkDB->renameTag('test', 'retest'));
 533     }
 534
 535     /**
 536      * Test delete tag with a valid value
 537      */
 538     public function testDeleteTag()
 539     {
 540         self::$refDB->write(self::$testDatastore);
 541         $linkDB = new LinkDB(self::$testDatastore, true, false);
 542
 543         $res = $linkDB->renameTag('cartoon', null);
 544         $this->assertEquals(3, count($res));
 545         $this->assertNotContains('cartoon', $linkDB[4]['tags']);
 546     }
 547
 548     /**
 549      * Test linksCountPerTag all tags without filter.
 550      * Equal occurrences should be sorted alphabetically.
 551      */
 552     public function testCountLinkPerTagAllNoFilter()
 553     {
 554         $expected = [
 555             'web' => 4,
 556             'cartoon' => 3,
 557             'dev' => 2,
 558             'gnu' => 2,
 559             'hashtag' => 2,
 560             'sTuff' => 2,
 561             '-exclude' => 1,
 562             '.hidden' => 1,
 563             'Mercurial' => 1,
 564             'css' => 1,
 565             'free' => 1,
 566             'html' => 1,
 567             'media' => 1,
 568             'samba' => 1,
 569             'software' => 1,
 570             'stallman' => 1,
 571             'tag1' => 1,
 572             'tag2' => 1,
 573             'tag3' => 1,
 574             'tag4' => 1,
 575             'ut' => 1,
 576             'w3c' => 1,
 577         ];
 578         $tags = self::$privateLinkDB->linksCountPerTag();
 579
 580         $this->assertEquals($expected, $tags, var_export($tags, true));
 581     }
 582
 583     /**
 584      * Test linksCountPerTag all tags with filter.
 585      * Equal occurrences should be sorted alphabetically.
 586      */
 587     public function testCountLinkPerTagAllWithFilter()
 588     {
 589         $expected = [
 590             'gnu' => 2,
 591             'hashtag' => 2,
 592             '-exclude' => 1,
 593             '.hidden' => 1,
 594             'free' => 1,
 595             'media' => 1,
 596             'software' => 1,
 597             'stallman' => 1,
 598             'stuff' => 1,
 599             'web' => 1,
 600         ];
 601         $tags = self::$privateLinkDB->linksCountPerTag(['gnu']);
 602
 603         $this->assertEquals($expected, $tags, var_export($tags, true));
 604     }
 605
 606     /**
 607      * Test linksCountPerTag public tags with filter.
 608      * Equal occurrences should be sorted alphabetically.
 609      */
 610     public function testCountLinkPerTagPublicWithFilter()
 611     {
 612         $expected = [
 613             'gnu' => 2,
 614             'hashtag' => 2,
 615             '-exclude' => 1,
 616             '.hidden' => 1,
 617             'free' => 1,
 618             'media' => 1,
 619             'software' => 1,
 620             'stallman' => 1,
 621             'stuff' => 1,
 622             'web' => 1,
 623         ];
 624         $tags = self::$privateLinkDB->linksCountPerTag(['gnu'], 'public');
 625
 626         $this->assertEquals($expected, $tags, var_export($tags, true));
 627     }
 628
 629     /**
 630      * Test linksCountPerTag public tags with filter.
 631      * Equal occurrences should be sorted alphabetically.
 632      */
 633     public function testCountLinkPerTagPrivateWithFilter()
 634     {
 635         $expected = [
 636             'cartoon' => 1,
 637             'dev' => 1,
 638             'tag1' => 1,
 639             'tag2' => 1,
 640             'tag3' => 1,
 641             'tag4' => 1,
 642         ];
 643         $tags = self::$privateLinkDB->linksCountPerTag(['dev'], 'private');
 644
 645         $this->assertEquals($expected, $tags, var_export($tags, true));
 646     }
 647 }