tests/legacy/LegacyLinkFilterTest.php

   1 <?php
   2
   3 namespace Shaarli\Bookmark;
   4
   5 use Exception;
   6 use ReferenceLinkDB;
   7 use Shaarli\Legacy\LegacyLinkDB;
   8 use Shaarli\Legacy\LegacyLinkFilter;
   9
  10 /**
  11  * Class LegacyLinkFilterTest.
  12  */
  13 class LegacyLinkFilterTest extends \PHPUnit\Framework\TestCase
  14 {
  15     /**
  16      * @var string Test datastore path.
  17      */
  18     protected static $testDatastore = 'sandbox/datastore.php';
  19     /**
  20      * @var BookmarkFilter instance.
  21      */
  22     protected static $linkFilter;
  23
  24     /**
  25      * @var ReferenceLinkDB instance
  26      */
  27     protected static $refDB;
  28
  29     /**
  30      * @var LegacyLinkDB instance
  31      */
  32     protected static $linkDB;
  33
  34     /**
  35      * Instantiate linkFilter with ReferenceLinkDB data.
  36      */
  37     public static function setUpBeforeClass()
  38     {
  39         self::$refDB = new ReferenceLinkDB(true);
  40         self::$refDB->write(self::$testDatastore);
  41         self::$linkDB = new LegacyLinkDB(self::$testDatastore, true, false);
  42         self::$linkFilter = new LegacyLinkFilter(self::$linkDB);
  43     }
  44
  45     /**
  46      * Blank filter.
  47      */
  48     public function testFilter()
  49     {
  50         $this->assertEquals(
  51             self::$refDB->countLinks(),
  52             count(self::$linkFilter->filter('', ''))
  53         );
  54
  55         $this->assertEquals(
  56             self::$refDB->countLinks(),
  57             count(self::$linkFilter->filter('', '', 'all'))
  58         );
  59
  60         $this->assertEquals(
  61             self::$refDB->countLinks(),
  62             count(self::$linkFilter->filter('', '', 'randomstr'))
  63         );
  64
  65         // Private only.
  66         $this->assertEquals(
  67             self::$refDB->countPrivateLinks(),
  68             count(self::$linkFilter->filter('', '', false, 'private'))
  69         );
  70
  71         // Public only.
  72         $this->assertEquals(
  73             self::$refDB->countPublicLinks(),
  74             count(self::$linkFilter->filter('', '', false, 'public'))
  75         );
  76
  77         $this->assertEquals(
  78             ReferenceLinkDB::$NB_LINKS_TOTAL,
  79             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, ''))
  80         );
  81
  82         $this->assertEquals(
  83             self::$refDB->countUntaggedLinks(),
  84             count(
  85                 self::$linkFilter->filter(
  86                     LegacyLinkFilter::$FILTER_TAG,
  87                     /*$request=*/
  88                     '',
  89                     /*$casesensitive=*/
  90                     false,
  91                     /*$visibility=*/
  92                     'all',
  93                     /*$untaggedonly=*/
  94                     true
  95                 )
  96             )
  97         );
  98
  99         $this->assertEquals(
 100             ReferenceLinkDB::$NB_LINKS_TOTAL,
 101             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, ''))
 102         );
 103     }
 104
 105     /**
 106      * Filter bookmarks using a tag
 107      */
 108     public function testFilterOneTag()
 109     {
 110         $this->assertEquals(
 111             4,
 112             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'web', false))
 113         );
 114
 115         $this->assertEquals(
 116             4,
 117             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'web', false, 'all'))
 118         );
 119
 120         $this->assertEquals(
 121             4,
 122             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'web', false, 'default-blabla'))
 123         );
 124
 125         // Private only.
 126         $this->assertEquals(
 127             1,
 128             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'web', false, 'private'))
 129         );
 130
 131         // Public only.
 132         $this->assertEquals(
 133             3,
 134             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'web', false, 'public'))
 135         );
 136     }
 137
 138     /**
 139      * Filter bookmarks using a tag - case-sensitive
 140      */
 141     public function testFilterCaseSensitiveTag()
 142     {
 143         $this->assertEquals(
 144             0,
 145             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'mercurial', true))
 146         );
 147
 148         $this->assertEquals(
 149             1,
 150             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'Mercurial', true))
 151         );
 152     }
 153
 154     /**
 155      * Filter bookmarks using a tag combination
 156      */
 157     public function testFilterMultipleTags()
 158     {
 159         $this->assertEquals(
 160             2,
 161             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'dev cartoon', false))
 162         );
 163     }
 164
 165     /**
 166      * Filter bookmarks using a non-existent tag
 167      */
 168     public function testFilterUnknownTag()
 169     {
 170         $this->assertEquals(
 171             0,
 172             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'null', false))
 173         );
 174     }
 175
 176     /**
 177      * Return bookmarks for a given day
 178      */
 179     public function testFilterDay()
 180     {
 181         $this->assertEquals(
 182             4,
 183             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_DAY, '20121206'))
 184         );
 185     }
 186
 187     /**
 188      * 404 - day not found
 189      */
 190     public function testFilterUnknownDay()
 191     {
 192         $this->assertEquals(
 193             0,
 194             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_DAY, '19700101'))
 195         );
 196     }
 197
 198     /**
 199      * Use an invalid date format
 200      * @expectedException              Exception
 201      * @expectedExceptionMessageRegExp /Invalid date format/
 202      */
 203     public function testFilterInvalidDayWithChars()
 204     {
 205         self::$linkFilter->filter(LegacyLinkFilter::$FILTER_DAY, 'Rainy day, dream away');
 206     }
 207
 208     /**
 209      * Use an invalid date format
 210      * @expectedException              Exception
 211      * @expectedExceptionMessageRegExp /Invalid date format/
 212      */
 213     public function testFilterInvalidDayDigits()
 214     {
 215         self::$linkFilter->filter(LegacyLinkFilter::$FILTER_DAY, '20');
 216     }
 217
 218     /**
 219      * Retrieve a link entry with its hash
 220      */
 221     public function testFilterSmallHash()
 222     {
 223         $links = self::$linkFilter->filter(LegacyLinkFilter::$FILTER_HASH, 'IuWvgA');
 224
 225         $this->assertEquals(
 226             1,
 227             count($links)
 228         );
 229
 230         $this->assertEquals(
 231             'MediaGoblin',
 232             $links[7]['title']
 233         );
 234     }
 235
 236     /**
 237      * No link for this hash
 238      *
 239      * @expectedException \Shaarli\Bookmark\Exception\BookmarkNotFoundException
 240      */
 241     public function testFilterUnknownSmallHash()
 242     {
 243         self::$linkFilter->filter(LegacyLinkFilter::$FILTER_HASH, 'Iblaah');
 244     }
 245
 246     /**
 247      * Full-text search - no result found.
 248      */
 249     public function testFilterFullTextNoResult()
 250     {
 251         $this->assertEquals(
 252             0,
 253             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'azertyuiop'))
 254         );
 255     }
 256
 257     /**
 258      * Full-text search - result from a link's URL
 259      */
 260     public function testFilterFullTextURL()
 261     {
 262         $this->assertEquals(
 263             2,
 264             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
 265         );
 266
 267         $this->assertEquals(
 268             2,
 269             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'ars org'))
 270         );
 271     }
 272
 273     /**
 274      * Full-text search - result from a link's title only
 275      */
 276     public function testFilterFullTextTitle()
 277     {
 278         // use miscellaneous cases
 279         $this->assertEquals(
 280             2,
 281             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'userfriendly -'))
 282         );
 283         $this->assertEquals(
 284             2,
 285             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'UserFriendly -'))
 286         );
 287         $this->assertEquals(
 288             2,
 289             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
 290         );
 291
 292         // use miscellaneous case and offset
 293         $this->assertEquals(
 294             2,
 295             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'RFrIendL'))
 296         );
 297     }
 298
 299     /**
 300      * Full-text search - result from the link's description only
 301      */
 302     public function testFilterFullTextDescription()
 303     {
 304         $this->assertEquals(
 305             1,
 306             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'publishing media'))
 307         );
 308
 309         $this->assertEquals(
 310             1,
 311             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'mercurial w3c'))
 312         );
 313
 314         $this->assertEquals(
 315             3,
 316             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, '"free software"'))
 317         );
 318     }
 319
 320     /**
 321      * Full-text search - result from the link's tags only
 322      */
 323     public function testFilterFullTextTags()
 324     {
 325         $this->assertEquals(
 326             6,
 327             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web'))
 328         );
 329
 330         $this->assertEquals(
 331             6,
 332             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', 'all'))
 333         );
 334
 335         $this->assertEquals(
 336             6,
 337             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', 'bla'))
 338         );
 339
 340         // Private only.
 341         $this->assertEquals(
 342             1,
 343             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', false, 'private'))
 344         );
 345
 346         // Public only.
 347         $this->assertEquals(
 348             5,
 349             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', false, 'public'))
 350         );
 351     }
 352
 353     /**
 354      * Full-text search - result set from mixed sources
 355      */
 356     public function testFilterFullTextMixed()
 357     {
 358         $this->assertEquals(
 359             3,
 360             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'free software'))
 361         );
 362     }
 363
 364     /**
 365      * Full-text search - test exclusion with '-'.
 366      */
 367     public function testExcludeSearch()
 368     {
 369         $this->assertEquals(
 370             1,
 371             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'free -gnu'))
 372         );
 373
 374         $this->assertEquals(
 375             ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
 376             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, '-revolution'))
 377         );
 378     }
 379
 380     /**
 381      * Full-text search - test AND, exact terms and exclusion combined, across fields.
 382      */
 383     public function testMultiSearch()
 384     {
 385         $this->assertEquals(
 386             2,
 387             count(self::$linkFilter->filter(
 388                 LegacyLinkFilter::$FILTER_TEXT,
 389                 '"Free Software " stallman "read this" @website stuff'
 390             ))
 391         );
 392
 393         $this->assertEquals(
 394             1,
 395             count(self::$linkFilter->filter(
 396                 LegacyLinkFilter::$FILTER_TEXT,
 397                 '"free software " stallman "read this" -beard @website stuff'
 398             ))
 399         );
 400     }
 401
 402     /**
 403      * Full-text search - make sure that exact search won't work across fields.
 404      */
 405     public function testSearchExactTermMultiFieldsKo()
 406     {
 407         $this->assertEquals(
 408             0,
 409             count(self::$linkFilter->filter(
 410                 LegacyLinkFilter::$FILTER_TEXT,
 411                 '"designer naming"'
 412             ))
 413         );
 414
 415         $this->assertEquals(
 416             0,
 417             count(self::$linkFilter->filter(
 418                 LegacyLinkFilter::$FILTER_TEXT,
 419                 '"designernaming"'
 420             ))
 421         );
 422     }
 423
 424     /**
 425      * Tag search with exclusion.
 426      */
 427     public function testTagFilterWithExclusion()
 428     {
 429         $this->assertEquals(
 430             1,
 431             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'gnu -free'))
 432         );
 433
 434         $this->assertEquals(
 435             ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
 436             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, '-free'))
 437         );
 438     }
 439
 440     /**
 441      * Test crossed search (terms + tags).
 442      */
 443     public function testFilterCrossedSearch()
 444     {
 445         $terms = '"Free Software " stallman "read this" @website stuff';
 446         $tags = 'free';
 447         $this->assertEquals(
 448             1,
 449             count(self::$linkFilter->filter(
 450                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 451                 array($tags, $terms)
 452             ))
 453         );
 454         $this->assertEquals(
 455             2,
 456             count(self::$linkFilter->filter(
 457                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 458                 array('', $terms)
 459             ))
 460         );
 461         $this->assertEquals(
 462             1,
 463             count(self::$linkFilter->filter(
 464                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 465                 array(false, 'PSR-2')
 466             ))
 467         );
 468         $this->assertEquals(
 469             1,
 470             count(self::$linkFilter->filter(
 471                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 472                 array($tags, '')
 473             ))
 474         );
 475         $this->assertEquals(
 476             ReferenceLinkDB::$NB_LINKS_TOTAL,
 477             count(self::$linkFilter->filter(
 478                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 479                 ''
 480             ))
 481         );
 482     }
 483
 484     /**
 485      * Filter bookmarks by #hashtag.
 486      */
 487     public function testFilterByHashtag()
 488     {
 489         $hashtag = 'hashtag';
 490         $this->assertEquals(
 491             3,
 492             count(self::$linkFilter->filter(
 493                 LegacyLinkFilter::$FILTER_TAG,
 494                 $hashtag
 495             ))
 496         );
 497
 498         $hashtag = 'private';
 499         $this->assertEquals(
 500             1,
 501             count(self::$linkFilter->filter(
 502                 LegacyLinkFilter::$FILTER_TAG,
 503                 $hashtag,
 504                 false,
 505                 'private'
 506             ))
 507         );
 508     }
 509 }