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