diff options
Diffstat (limited to 'tests/LinkFilterTest.php')
-rw-r--r-- | tests/LinkFilterTest.php | 500 |
1 files changed, 0 insertions, 500 deletions
diff --git a/tests/LinkFilterTest.php b/tests/LinkFilterTest.php deleted file mode 100644 index eb54c359..00000000 --- a/tests/LinkFilterTest.php +++ /dev/null | |||
@@ -1,500 +0,0 @@ | |||
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 | } | ||