tests/LinkFilterTest.php

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