tests/bookmark/BookmarkFilterTest.php

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