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 \Shaarli\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(): void
  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      */
 202     public function testFilterInvalidDayWithChars()
 203     {
 204         $this->expectExceptionMessageRegExp('/Invalid date format/');
 205
 206         self::$linkFilter->filter(LegacyLinkFilter::$FILTER_DAY, 'Rainy day, dream away');
 207     }
 208
 209     /**
 210      * Use an invalid date format
 211      * @expectedException              Exception
 212      */
 213     public function testFilterInvalidDayDigits()
 214     {
 215         $this->expectExceptionMessageRegExp('/Invalid date format/');
 216
 217         self::$linkFilter->filter(LegacyLinkFilter::$FILTER_DAY, '20');
 218     }
 219
 220     /**
 221      * Retrieve a link entry with its hash
 222      */
 223     public function testFilterSmallHash()
 224     {
 225         $links = self::$linkFilter->filter(LegacyLinkFilter::$FILTER_HASH, 'IuWvgA');
 226
 227         $this->assertEquals(
 228             1,
 229             count($links)
 230         );
 231
 232         $this->assertEquals(
 233             'MediaGoblin',
 234             $links[7]['title']
 235         );
 236     }
 237
 238     /**
 239      * No link for this hash
 240      */
 241     public function testFilterUnknownSmallHash()
 242     {
 243         $this->expectException(\Shaarli\Bookmark\Exception\BookmarkNotFoundException::class);
 244
 245         self::$linkFilter->filter(LegacyLinkFilter::$FILTER_HASH, 'Iblaah');
 246     }
 247
 248     /**
 249      * Full-text search - no result found.
 250      */
 251     public function testFilterFullTextNoResult()
 252     {
 253         $this->assertEquals(
 254             0,
 255             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'azertyuiop'))
 256         );
 257     }
 258
 259     /**
 260      * Full-text search - result from a link's URL
 261      */
 262     public function testFilterFullTextURL()
 263     {
 264         $this->assertEquals(
 265             2,
 266             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
 267         );
 268
 269         $this->assertEquals(
 270             2,
 271             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'ars org'))
 272         );
 273     }
 274
 275     /**
 276      * Full-text search - result from a link's title only
 277      */
 278     public function testFilterFullTextTitle()
 279     {
 280         // use miscellaneous cases
 281         $this->assertEquals(
 282             2,
 283             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'userfriendly -'))
 284         );
 285         $this->assertEquals(
 286             2,
 287             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'UserFriendly -'))
 288         );
 289         $this->assertEquals(
 290             2,
 291             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
 292         );
 293
 294         // use miscellaneous case and offset
 295         $this->assertEquals(
 296             2,
 297             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'RFrIendL'))
 298         );
 299     }
 300
 301     /**
 302      * Full-text search - result from the link's description only
 303      */
 304     public function testFilterFullTextDescription()
 305     {
 306         $this->assertEquals(
 307             1,
 308             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'publishing media'))
 309         );
 310
 311         $this->assertEquals(
 312             1,
 313             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'mercurial w3c'))
 314         );
 315
 316         $this->assertEquals(
 317             3,
 318             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, '"free software"'))
 319         );
 320     }
 321
 322     /**
 323      * Full-text search - result from the link's tags only
 324      */
 325     public function testFilterFullTextTags()
 326     {
 327         $this->assertEquals(
 328             6,
 329             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web'))
 330         );
 331
 332         $this->assertEquals(
 333             6,
 334             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', 'all'))
 335         );
 336
 337         $this->assertEquals(
 338             6,
 339             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', 'bla'))
 340         );
 341
 342         // Private only.
 343         $this->assertEquals(
 344             1,
 345             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', false, 'private'))
 346         );
 347
 348         // Public only.
 349         $this->assertEquals(
 350             5,
 351             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'web', false, 'public'))
 352         );
 353     }
 354
 355     /**
 356      * Full-text search - result set from mixed sources
 357      */
 358     public function testFilterFullTextMixed()
 359     {
 360         $this->assertEquals(
 361             3,
 362             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'free software'))
 363         );
 364     }
 365
 366     /**
 367      * Full-text search - test exclusion with '-'.
 368      */
 369     public function testExcludeSearch()
 370     {
 371         $this->assertEquals(
 372             1,
 373             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, 'free -gnu'))
 374         );
 375
 376         $this->assertEquals(
 377             ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
 378             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TEXT, '-revolution'))
 379         );
 380     }
 381
 382     /**
 383      * Full-text search - test AND, exact terms and exclusion combined, across fields.
 384      */
 385     public function testMultiSearch()
 386     {
 387         $this->assertEquals(
 388             2,
 389             count(self::$linkFilter->filter(
 390                 LegacyLinkFilter::$FILTER_TEXT,
 391                 '"Free Software " stallman "read this" @website stuff'
 392             ))
 393         );
 394
 395         $this->assertEquals(
 396             1,
 397             count(self::$linkFilter->filter(
 398                 LegacyLinkFilter::$FILTER_TEXT,
 399                 '"free software " stallman "read this" -beard @website stuff'
 400             ))
 401         );
 402     }
 403
 404     /**
 405      * Full-text search - make sure that exact search won't work across fields.
 406      */
 407     public function testSearchExactTermMultiFieldsKo()
 408     {
 409         $this->assertEquals(
 410             0,
 411             count(self::$linkFilter->filter(
 412                 LegacyLinkFilter::$FILTER_TEXT,
 413                 '"designer naming"'
 414             ))
 415         );
 416
 417         $this->assertEquals(
 418             0,
 419             count(self::$linkFilter->filter(
 420                 LegacyLinkFilter::$FILTER_TEXT,
 421                 '"designernaming"'
 422             ))
 423         );
 424     }
 425
 426     /**
 427      * Tag search with exclusion.
 428      */
 429     public function testTagFilterWithExclusion()
 430     {
 431         $this->assertEquals(
 432             1,
 433             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, 'gnu -free'))
 434         );
 435
 436         $this->assertEquals(
 437             ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
 438             count(self::$linkFilter->filter(LegacyLinkFilter::$FILTER_TAG, '-free'))
 439         );
 440     }
 441
 442     /**
 443      * Test crossed search (terms + tags).
 444      */
 445     public function testFilterCrossedSearch()
 446     {
 447         $terms = '"Free Software " stallman "read this" @website stuff';
 448         $tags = 'free';
 449         $this->assertEquals(
 450             1,
 451             count(self::$linkFilter->filter(
 452                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 453                 array($tags, $terms)
 454             ))
 455         );
 456         $this->assertEquals(
 457             2,
 458             count(self::$linkFilter->filter(
 459                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 460                 array('', $terms)
 461             ))
 462         );
 463         $this->assertEquals(
 464             1,
 465             count(self::$linkFilter->filter(
 466                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 467                 array(false, 'PSR-2')
 468             ))
 469         );
 470         $this->assertEquals(
 471             1,
 472             count(self::$linkFilter->filter(
 473                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 474                 array($tags, '')
 475             ))
 476         );
 477         $this->assertEquals(
 478             ReferenceLinkDB::$NB_LINKS_TOTAL,
 479             count(self::$linkFilter->filter(
 480                 LegacyLinkFilter::$FILTER_TAG | LegacyLinkFilter::$FILTER_TEXT,
 481                 ''
 482             ))
 483         );
 484     }
 485
 486     /**
 487      * Filter bookmarks by #hashtag.
 488      */
 489     public function testFilterByHashtag()
 490     {
 491         $hashtag = 'hashtag';
 492         $this->assertEquals(
 493             3,
 494             count(self::$linkFilter->filter(
 495                 LegacyLinkFilter::$FILTER_TAG,
 496                 $hashtag
 497             ))
 498         );
 499
 500         $hashtag = 'private';
 501         $this->assertEquals(
 502             1,
 503             count(self::$linkFilter->filter(
 504                 LegacyLinkFilter::$FILTER_TAG,
 505                 $hashtag,
 506                 false,
 507                 'private'
 508             ))
 509         );
 510     }
 511 }