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['20130614_184135']['title']
 163         );
 164     }
 165
 166     /**
 167      * No link for this hash
 168      */
 169     public function testFilterUnknownSmallHash()
 170     {
 171         $this->assertEquals(
 172             0,
 173             count(self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'Iblaah'))
 174         );
 175     }
 176
 177     /**
 178      * Full-text search - no result found.
 179      */
 180     public function testFilterFullTextNoResult()
 181     {
 182         $this->assertEquals(
 183             0,
 184             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'azertyuiop'))
 185         );
 186     }
 187
 188     /**
 189      * Full-text search - result from a link's URL
 190      */
 191     public function testFilterFullTextURL()
 192     {
 193         $this->assertEquals(
 194             2,
 195             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
 196         );
 197
 198         $this->assertEquals(
 199             2,
 200             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars org'))
 201         );
 202     }
 203
 204     /**
 205      * Full-text search - result from a link's title only
 206      */
 207     public function testFilterFullTextTitle()
 208     {
 209         // use miscellaneous cases
 210         $this->assertEquals(
 211             2,
 212             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'userfriendly -'))
 213         );
 214         $this->assertEquals(
 215             2,
 216             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'UserFriendly -'))
 217         );
 218         $this->assertEquals(
 219             2,
 220             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
 221         );
 222
 223         // use miscellaneous case and offset
 224         $this->assertEquals(
 225             2,
 226             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'RFrIendL'))
 227         );
 228     }
 229
 230     /**
 231      * Full-text search - result from the link's description only
 232      */
 233     public function testFilterFullTextDescription()
 234     {
 235         $this->assertEquals(
 236             1,
 237             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'publishing media'))
 238         );
 239
 240         $this->assertEquals(
 241             1,
 242             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'mercurial w3c'))
 243         );
 244
 245         $this->assertEquals(
 246             3,
 247             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '"free software"'))
 248         );
 249     }
 250
 251     /**
 252      * Full-text search - result from the link's tags only
 253      */
 254     public function testFilterFullTextTags()
 255     {
 256         $this->assertEquals(
 257             2,
 258             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'gnu'))
 259         );
 260
 261         // Private only.
 262         $this->assertEquals(
 263             1,
 264             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, true))
 265         );
 266     }
 267
 268     /**
 269      * Full-text search - result set from mixed sources
 270      */
 271     public function testFilterFullTextMixed()
 272     {
 273         $this->assertEquals(
 274             3,
 275             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free software'))
 276         );
 277     }
 278
 279     /**
 280      * Full-text search - test exclusion with '-'.
 281      */
 282     public function testExcludeSearch()
 283     {
 284         $this->assertEquals(
 285             1,
 286             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free -gnu'))
 287         );
 288
 289         $this->assertEquals(
 290             6,
 291             count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '-revolution'))
 292         );
 293     }
 294
 295     /**
 296      * Full-text search - test AND, exact terms and exclusion combined, across fields.
 297      */
 298     public function testMultiSearch()
 299     {
 300         $this->assertEquals(
 301             2,
 302             count(self::$linkFilter->filter(
 303                 LinkFilter::$FILTER_TEXT,
 304                 '"Free Software " stallman "read this" @website stuff'
 305             ))
 306         );
 307
 308         $this->assertEquals(
 309             1,
 310             count(self::$linkFilter->filter(
 311                 LinkFilter::$FILTER_TEXT,
 312                 '"free software " stallman "read this" -beard @website stuff'
 313             ))
 314         );
 315     }
 316
 317     /**
 318      * Full-text search - make sure that exact search won't work across fields.
 319      */
 320     public function testSearchExactTermMultiFieldsKo()
 321     {
 322         $this->assertEquals(
 323             0,
 324             count(self::$linkFilter->filter(
 325                 LinkFilter::$FILTER_TEXT,
 326                 '"designer naming"'
 327             ))
 328         );
 329
 330         $this->assertEquals(
 331             0,
 332             count(self::$linkFilter->filter(
 333                 LinkFilter::$FILTER_TEXT,
 334                 '"designernaming"'
 335             ))
 336         );
 337     }
 338
 339     /**
 340      * Tag search with exclusion.
 341      */
 342     public function testTagFilterWithExclusion()
 343     {
 344         $this->assertEquals(
 345             1,
 346             count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'gnu -free'))
 347         );
 348
 349         $this->assertEquals(
 350             6,
 351             count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, '-free'))
 352         );
 353     }
 354
 355     /**
 356      * Test crossed search (terms + tags).
 357      */
 358     public function testFilterCrossedSearch()
 359     {
 360         $terms = '"Free Software " stallman "read this" @website stuff';
 361         $tags = 'free';
 362         $this->assertEquals(
 363             1,
 364             count(self::$linkFilter->filter(
 365                 LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
 366                 array($tags, $terms)
 367             ))
 368         );
 369         $this->assertEquals(
 370             2,
 371             count(self::$linkFilter->filter(
 372                 LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
 373                 array('', $terms)
 374             ))
 375         );
 376         $this->assertEquals(
 377             1,
 378             count(self::$linkFilter->filter(
 379                 LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
 380                 array($tags, '')
 381             ))
 382         );
 383         $this->assertEquals(
 384             ReferenceLinkDB::$NB_LINKS_TOTAL,
 385             count(self::$linkFilter->filter(
 386                 LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
 387                 ''
 388             ))
 389         );
 390     }
 391 }