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