aboutsummaryrefslogtreecommitdiffhomepage
path: root/tests/LinkDBTest.php
diff options
context:
space:
mode:
authorVirtualTam <virtualtam@flibidi.net>2018-12-03 01:10:39 +0100
committerVirtualTam <virtualtam@flibidi.net>2019-01-12 22:47:48 +0100
commitf24896b237e40718fb6eaa2869592eb0855a47fd (patch)
tree32ca9a3e096981840426a9b762d57ec8db2ecbee /tests/LinkDBTest.php
parenta0c4dbd91c41b9ecdd5176c1ac33b55e240d2392 (diff)
downloadShaarli-f24896b237e40718fb6eaa2869592eb0855a47fd.tar.gz
Shaarli-f24896b237e40718fb6eaa2869592eb0855a47fd.tar.zst
Shaarli-f24896b237e40718fb6eaa2869592eb0855a47fd.zip
namespacing: \Shaarli\Bookmark\LinkDB
Signed-off-by: VirtualTam <virtualtam@flibidi.net>
Diffstat (limited to 'tests/LinkDBTest.php')
-rw-r--r--tests/LinkDBTest.php647
1 files changed, 0 insertions, 647 deletions
diff --git a/tests/LinkDBTest.php b/tests/LinkDBTest.php
deleted file mode 100644
index 737a2247..00000000
--- a/tests/LinkDBTest.php
+++ /dev/null
@@ -1,647 +0,0 @@
1<?php
2/**
3 * Link datastore tests
4 */
5
6require_once 'application/feed/Cache.php';
7require_once 'application/FileUtils.php';
8require_once 'application/LinkDB.php';
9require_once 'application/Utils.php';
10require_once 'tests/utils/ReferenceLinkDB.php';
11
12
13/**
14 * Unitary tests for LinkDB
15 */
16class LinkDBTest extends PHPUnit_Framework_TestCase
17{
18 // datastore to test write operations
19 protected static $testDatastore = 'sandbox/datastore.php';
20
21 /**
22 * @var ReferenceLinkDB instance.
23 */
24 protected static $refDB = null;
25
26 /**
27 * @var LinkDB public LinkDB instance.
28 */
29 protected static $publicLinkDB = null;
30
31 /**
32 * @var LinkDB private LinkDB instance.
33 */
34 protected static $privateLinkDB = null;
35
36 /**
37 * Instantiates public and private LinkDBs with test data
38 *
39 * The reference datastore contains public and private links that
40 * will be used to test LinkDB's methods:
41 * - access filtering (public/private),
42 * - link searches:
43 * - by day,
44 * - by tag,
45 * - by text,
46 * - etc.
47 */
48 public static function setUpBeforeClass()
49 {
50 self::$refDB = new ReferenceLinkDB();
51 self::$refDB->write(self::$testDatastore);
52
53 self::$publicLinkDB = new LinkDB(self::$testDatastore, false, false);
54 self::$privateLinkDB = new LinkDB(self::$testDatastore, true, false);
55 }
56
57 /**
58 * Resets test data for each test
59 */
60 protected function setUp()
61 {
62 if (file_exists(self::$testDatastore)) {
63 unlink(self::$testDatastore);
64 }
65 }
66
67 /**
68 * Allows to test LinkDB's private methods
69 *
70 * @see
71 * https://sebastian-bergmann.de/archives/881-Testing-Your-Privates.html
72 * http://stackoverflow.com/a/2798203
73 */
74 protected static function getMethod($name)
75 {
76 $class = new ReflectionClass('LinkDB');
77 $method = $class->getMethod($name);
78 $method->setAccessible(true);
79 return $method;
80 }
81
82 /**
83 * Instantiate LinkDB objects - logged in user
84 */
85 public function testConstructLoggedIn()
86 {
87 new LinkDB(self::$testDatastore, true, false);
88 $this->assertFileExists(self::$testDatastore);
89 }
90
91 /**
92 * Instantiate LinkDB objects - logged out or public instance
93 */
94 public function testConstructLoggedOut()
95 {
96 new LinkDB(self::$testDatastore, false, false);
97 $this->assertFileExists(self::$testDatastore);
98 }
99
100 /**
101 * Attempt to instantiate a LinkDB whereas the datastore is not writable
102 *
103 * @expectedException Shaarli\Exceptions\IOException
104 * @expectedExceptionMessageRegExp /Error accessing "null"/
105 */
106 public function testConstructDatastoreNotWriteable()
107 {
108 new LinkDB('null/store.db', false, false);
109 }
110
111 /**
112 * The DB doesn't exist, ensure it is created with dummy content
113 */
114 public function testCheckDBNew()
115 {
116 $linkDB = new LinkDB(self::$testDatastore, false, false);
117 unlink(self::$testDatastore);
118 $this->assertFileNotExists(self::$testDatastore);
119
120 $checkDB = self::getMethod('check');
121 $checkDB->invokeArgs($linkDB, array());
122 $this->assertFileExists(self::$testDatastore);
123
124 // ensure the correct data has been written
125 $this->assertGreaterThan(0, filesize(self::$testDatastore));
126 }
127
128 /**
129 * The DB exists, don't do anything
130 */
131 public function testCheckDBLoad()
132 {
133 $linkDB = new LinkDB(self::$testDatastore, false, false);
134 $datastoreSize = filesize(self::$testDatastore);
135 $this->assertGreaterThan(0, $datastoreSize);
136
137 $checkDB = self::getMethod('check');
138 $checkDB->invokeArgs($linkDB, array());
139
140 // ensure the datastore is left unmodified
141 $this->assertEquals(
142 $datastoreSize,
143 filesize(self::$testDatastore)
144 );
145 }
146
147 /**
148 * Load an empty DB
149 */
150 public function testReadEmptyDB()
151 {
152 file_put_contents(self::$testDatastore, '<?php /* S7QysKquBQA= */ ?>');
153 $emptyDB = new LinkDB(self::$testDatastore, false, false);
154 $this->assertEquals(0, sizeof($emptyDB));
155 $this->assertEquals(0, count($emptyDB));
156 }
157
158 /**
159 * Load public links from the DB
160 */
161 public function testReadPublicDB()
162 {
163 $this->assertEquals(
164 self::$refDB->countPublicLinks(),
165 sizeof(self::$publicLinkDB)
166 );
167 }
168
169 /**
170 * Load public and private links from the DB
171 */
172 public function testReadPrivateDB()
173 {
174 $this->assertEquals(
175 self::$refDB->countLinks(),
176 sizeof(self::$privateLinkDB)
177 );
178 }
179
180 /**
181 * Save the links to the DB
182 */
183 public function testSave()
184 {
185 $testDB = new LinkDB(self::$testDatastore, true, false);
186 $dbSize = sizeof($testDB);
187
188 $link = array(
189 'id' => 42,
190 'title'=>'an additional link',
191 'url'=>'http://dum.my',
192 'description'=>'One more',
193 'private'=>0,
194 'created'=> DateTime::createFromFormat(LinkDB::LINK_DATE_FORMAT, '20150518_190000'),
195 'tags'=>'unit test'
196 );
197 $testDB[$link['id']] = $link;
198 $testDB->save('tests');
199
200 $testDB = new LinkDB(self::$testDatastore, true, false);
201 $this->assertEquals($dbSize + 1, sizeof($testDB));
202 }
203
204 /**
205 * Count existing links
206 */
207 public function testCount()
208 {
209 $this->assertEquals(
210 self::$refDB->countPublicLinks(),
211 self::$publicLinkDB->count()
212 );
213 $this->assertEquals(
214 self::$refDB->countLinks(),
215 self::$privateLinkDB->count()
216 );
217 }
218
219 /**
220 * Count existing links - public links hidden
221 */
222 public function testCountHiddenPublic()
223 {
224 $linkDB = new LinkDB(self::$testDatastore, false, true);
225
226 $this->assertEquals(
227 0,
228 $linkDB->count()
229 );
230 $this->assertEquals(
231 0,
232 $linkDB->count()
233 );
234 }
235
236 /**
237 * List the days for which links have been posted
238 */
239 public function testDays()
240 {
241 $this->assertEquals(
242 array('20100309', '20100310', '20121206', '20121207', '20130614', '20150310'),
243 self::$publicLinkDB->days()
244 );
245
246 $this->assertEquals(
247 array('20100309', '20100310', '20121206', '20121207', '20130614', '20141125', '20150310'),
248 self::$privateLinkDB->days()
249 );
250 }
251
252 /**
253 * The URL corresponds to an existing entry in the DB
254 */
255 public function testGetKnownLinkFromURL()
256 {
257 $link = self::$publicLinkDB->getLinkFromUrl('http://mediagoblin.org/');
258
259 $this->assertNotEquals(false, $link);
260 $this->assertContains(
261 'A free software media publishing platform',
262 $link['description']
263 );
264 }
265
266 /**
267 * The URL is not in the DB
268 */
269 public function testGetUnknownLinkFromURL()
270 {
271 $this->assertEquals(
272 false,
273 self::$publicLinkDB->getLinkFromUrl('http://dev.null')
274 );
275 }
276
277 /**
278 * Lists all tags
279 */
280 public function testAllTags()
281 {
282 $this->assertEquals(
283 array(
284 'web' => 3,
285 'cartoon' => 2,
286 'gnu' => 2,
287 'dev' => 1,
288 'samba' => 1,
289 'media' => 1,
290 'software' => 1,
291 'stallman' => 1,
292 'free' => 1,
293 '-exclude' => 1,
294 'hashtag' => 2,
295 // The DB contains a link with `sTuff` and another one with `stuff` tag.
296 // They need to be grouped with the first case found - order by date DESC: `sTuff`.
297 'sTuff' => 2,
298 'ut' => 1,
299 ),
300 self::$publicLinkDB->linksCountPerTag()
301 );
302
303 $this->assertEquals(
304 array(
305 'web' => 4,
306 'cartoon' => 3,
307 'gnu' => 2,
308 'dev' => 2,
309 'samba' => 1,
310 'media' => 1,
311 'software' => 1,
312 'stallman' => 1,
313 'free' => 1,
314 'html' => 1,
315 'w3c' => 1,
316 'css' => 1,
317 'Mercurial' => 1,
318 'sTuff' => 2,
319 '-exclude' => 1,
320 '.hidden' => 1,
321 'hashtag' => 2,
322 'tag1' => 1,
323 'tag2' => 1,
324 'tag3' => 1,
325 'tag4' => 1,
326 'ut' => 1,
327 ),
328 self::$privateLinkDB->linksCountPerTag()
329 );
330 $this->assertEquals(
331 array(
332 'web' => 4,
333 'cartoon' => 2,
334 'gnu' => 1,
335 'dev' => 1,
336 'samba' => 1,
337 'media' => 1,
338 'html' => 1,
339 'w3c' => 1,
340 'css' => 1,
341 'Mercurial' => 1,
342 '.hidden' => 1,
343 'hashtag' => 1,
344 ),
345 self::$privateLinkDB->linksCountPerTag(['web'])
346 );
347 $this->assertEquals(
348 array(
349 'web' => 1,
350 'html' => 1,
351 'w3c' => 1,
352 'css' => 1,
353 'Mercurial' => 1,
354 ),
355 self::$privateLinkDB->linksCountPerTag(['web'], 'private')
356 );
357 }
358
359 /**
360 * Test real_url without redirector.
361 */
362 public function testLinkRealUrlWithoutRedirector()
363 {
364 $db = new LinkDB(self::$testDatastore, false, false);
365 foreach ($db as $link) {
366 $this->assertEquals($link['url'], $link['real_url']);
367 }
368 }
369
370 /**
371 * Test real_url with redirector.
372 */
373 public function testLinkRealUrlWithRedirector()
374 {
375 $redirector = 'http://redirector.to?';
376 $db = new LinkDB(self::$testDatastore, false, false, $redirector);
377 foreach ($db as $link) {
378 $this->assertStringStartsWith($redirector, $link['real_url']);
379 $this->assertNotFalse(strpos($link['real_url'], urlencode('://')));
380 }
381
382 $db = new LinkDB(self::$testDatastore, false, false, $redirector, false);
383 foreach ($db as $link) {
384 $this->assertStringStartsWith($redirector, $link['real_url']);
385 $this->assertFalse(strpos($link['real_url'], urlencode('://')));
386 }
387 }
388
389 /**
390 * Test filter with string.
391 */
392 public function testFilterString()
393 {
394 $tags = 'dev cartoon';
395 $request = array('searchtags' => $tags);
396 $this->assertEquals(
397 2,
398 count(self::$privateLinkDB->filterSearch($request, true, false))
399 );
400 }
401
402 /**
403 * Test filter with string.
404 */
405 public function testFilterArray()
406 {
407 $tags = array('dev', 'cartoon');
408 $request = array('searchtags' => $tags);
409 $this->assertEquals(
410 2,
411 count(self::$privateLinkDB->filterSearch($request, true, false))
412 );
413 }
414
415 /**
416 * Test hidden tags feature:
417 * tags starting with a dot '.' are only visible when logged in.
418 */
419 public function testHiddenTags()
420 {
421 $tags = '.hidden';
422 $request = array('searchtags' => $tags);
423 $this->assertEquals(
424 1,
425 count(self::$privateLinkDB->filterSearch($request, true, false))
426 );
427
428 $this->assertEquals(
429 0,
430 count(self::$publicLinkDB->filterSearch($request, true, false))
431 );
432 }
433
434 /**
435 * Test filterHash() with a valid smallhash.
436 */
437 public function testFilterHashValid()
438 {
439 $request = smallHash('20150310_114651');
440 $this->assertEquals(
441 1,
442 count(self::$publicLinkDB->filterHash($request))
443 );
444 $request = smallHash('20150310_114633' . 8);
445 $this->assertEquals(
446 1,
447 count(self::$publicLinkDB->filterHash($request))
448 );
449 }
450
451 /**
452 * Test filterHash() with an invalid smallhash.
453 *
454 * @expectedException LinkNotFoundException
455 */
456 public function testFilterHashInValid1()
457 {
458 $request = 'blabla';
459 self::$publicLinkDB->filterHash($request);
460 }
461
462 /**
463 * Test filterHash() with an empty smallhash.
464 *
465 * @expectedException LinkNotFoundException
466 */
467 public function testFilterHashInValid()
468 {
469 self::$publicLinkDB->filterHash('');
470 }
471
472 /**
473 * Test reorder with asc/desc parameter.
474 */
475 public function testReorderLinksDesc()
476 {
477 self::$privateLinkDB->reorder('ASC');
478 $stickyIds = [11, 10];
479 $standardIds = [42, 4, 9, 1, 0, 7, 6, 8, 41];
480 $linkIds = array_merge($stickyIds, $standardIds);
481 $cpt = 0;
482 foreach (self::$privateLinkDB as $key => $value) {
483 $this->assertEquals($linkIds[$cpt++], $key);
484 }
485 self::$privateLinkDB->reorder('DESC');
486 $linkIds = array_merge(array_reverse($stickyIds), array_reverse($standardIds));
487 $cpt = 0;
488 foreach (self::$privateLinkDB as $key => $value) {
489 $this->assertEquals($linkIds[$cpt++], $key);
490 }
491 }
492
493 /**
494 * Test rename tag with a valid value present in multiple links
495 */
496 public function testRenameTagMultiple()
497 {
498 self::$refDB->write(self::$testDatastore);
499 $linkDB = new LinkDB(self::$testDatastore, true, false);
500
501 $res = $linkDB->renameTag('cartoon', 'Taz');
502 $this->assertEquals(3, count($res));
503 $this->assertContains(' Taz ', $linkDB[4]['tags']);
504 $this->assertContains(' Taz ', $linkDB[1]['tags']);
505 $this->assertContains(' Taz ', $linkDB[0]['tags']);
506 }
507
508 /**
509 * Test rename tag with a valid value
510 */
511 public function testRenameTagCaseSensitive()
512 {
513 self::$refDB->write(self::$testDatastore);
514 $linkDB = new LinkDB(self::$testDatastore, true, false, '');
515
516 $res = $linkDB->renameTag('sTuff', 'Taz');
517 $this->assertEquals(1, count($res));
518 $this->assertEquals('Taz', $linkDB[41]['tags']);
519 }
520
521 /**
522 * Test rename tag with invalid values
523 */
524 public function testRenameTagInvalid()
525 {
526 $linkDB = new LinkDB(self::$testDatastore, false, false);
527
528 $this->assertFalse($linkDB->renameTag('', 'test'));
529 $this->assertFalse($linkDB->renameTag('', ''));
530 // tag non existent
531 $this->assertEquals([], $linkDB->renameTag('test', ''));
532 $this->assertEquals([], $linkDB->renameTag('test', 'retest'));
533 }
534
535 /**
536 * Test delete tag with a valid value
537 */
538 public function testDeleteTag()
539 {
540 self::$refDB->write(self::$testDatastore);
541 $linkDB = new LinkDB(self::$testDatastore, true, false);
542
543 $res = $linkDB->renameTag('cartoon', null);
544 $this->assertEquals(3, count($res));
545 $this->assertNotContains('cartoon', $linkDB[4]['tags']);
546 }
547
548 /**
549 * Test linksCountPerTag all tags without filter.
550 * Equal occurrences should be sorted alphabetically.
551 */
552 public function testCountLinkPerTagAllNoFilter()
553 {
554 $expected = [
555 'web' => 4,
556 'cartoon' => 3,
557 'dev' => 2,
558 'gnu' => 2,
559 'hashtag' => 2,
560 'sTuff' => 2,
561 '-exclude' => 1,
562 '.hidden' => 1,
563 'Mercurial' => 1,
564 'css' => 1,
565 'free' => 1,
566 'html' => 1,
567 'media' => 1,
568 'samba' => 1,
569 'software' => 1,
570 'stallman' => 1,
571 'tag1' => 1,
572 'tag2' => 1,
573 'tag3' => 1,
574 'tag4' => 1,
575 'ut' => 1,
576 'w3c' => 1,
577 ];
578 $tags = self::$privateLinkDB->linksCountPerTag();
579
580 $this->assertEquals($expected, $tags, var_export($tags, true));
581 }
582
583 /**
584 * Test linksCountPerTag all tags with filter.
585 * Equal occurrences should be sorted alphabetically.
586 */
587 public function testCountLinkPerTagAllWithFilter()
588 {
589 $expected = [
590 'gnu' => 2,
591 'hashtag' => 2,
592 '-exclude' => 1,
593 '.hidden' => 1,
594 'free' => 1,
595 'media' => 1,
596 'software' => 1,
597 'stallman' => 1,
598 'stuff' => 1,
599 'web' => 1,
600 ];
601 $tags = self::$privateLinkDB->linksCountPerTag(['gnu']);
602
603 $this->assertEquals($expected, $tags, var_export($tags, true));
604 }
605
606 /**
607 * Test linksCountPerTag public tags with filter.
608 * Equal occurrences should be sorted alphabetically.
609 */
610 public function testCountLinkPerTagPublicWithFilter()
611 {
612 $expected = [
613 'gnu' => 2,
614 'hashtag' => 2,
615 '-exclude' => 1,
616 '.hidden' => 1,
617 'free' => 1,
618 'media' => 1,
619 'software' => 1,
620 'stallman' => 1,
621 'stuff' => 1,
622 'web' => 1,
623 ];
624 $tags = self::$privateLinkDB->linksCountPerTag(['gnu'], 'public');
625
626 $this->assertEquals($expected, $tags, var_export($tags, true));
627 }
628
629 /**
630 * Test linksCountPerTag public tags with filter.
631 * Equal occurrences should be sorted alphabetically.
632 */
633 public function testCountLinkPerTagPrivateWithFilter()
634 {
635 $expected = [
636 'cartoon' => 1,
637 'dev' => 1,
638 'tag1' => 1,
639 'tag2' => 1,
640 'tag3' => 1,
641 'tag4' => 1,
642 ];
643 $tags = self::$privateLinkDB->linksCountPerTag(['dev'], 'private');
644
645 $this->assertEquals($expected, $tags, var_export($tags, true));
646 }
647}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-24 16:46:35 +0000