X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=tests%2FLinkDBTest.php;h=3b9808782fba646c9ec1440b844d46310b05cbcd;hb=c2c2338f9adecf971d01d7abcd09bab6275a9706;hp=bbe4e026963785c75193fd5287b838cbdfd4d491;hpb=adb1d6c213e64f7a6f4559adbc4d1f69f5a74e62;p=github%2Fshaarli%2FShaarli.git

diff --git a/tests/LinkDBTest.php b/tests/LinkDBTest.php
index bbe4e026..3b980878 100644
--- a/tests/LinkDBTest.php
+++ b/tests/LinkDBTest.php
@@ -3,13 +3,12 @@
  * Link datastore tests
  */
 
+require_once 'application/Cache.php';
+require_once 'application/FileUtils.php';
 require_once 'application/LinkDB.php';
 require_once 'application/Utils.php';
 require_once 'tests/utils/ReferenceLinkDB.php';
 
-define('PHPPREFIX', '<?php /* ');
-define('PHPSUFFIX', ' */ ?>');
-
 
 /**
  * Unitary tests for LinkDB
@@ -17,10 +16,21 @@ define('PHPSUFFIX', ' */ ?>');
 class LinkDBTest extends PHPUnit_Framework_TestCase
 {
     // datastore to test write operations
-    protected static $testDatastore = 'tests/datastore.php';
-    protected static $dummyDatastoreSHA1 = 'e3edea8ea7bb50be4bcb404df53fbb4546a7156e';
+    protected static $testDatastore = 'sandbox/datastore.php';
+
+    /**
+     * @var ReferenceLinkDB instance.
+     */
     protected static $refDB = null;
+
+    /**
+     * @var LinkDB public LinkDB instance.
+     */
     protected static $publicLinkDB = null;
+
+    /**
+     * @var LinkDB private LinkDB instance.
+     */
     protected static $privateLinkDB = null;
 
     /**
@@ -38,11 +48,10 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
     public static function setUpBeforeClass()
     {
         self::$refDB = new ReferenceLinkDB();
-        self::$refDB->write(self::$testDatastore, PHPPREFIX, PHPSUFFIX);
+        self::$refDB->write(self::$testDatastore);
 
-        $GLOBALS['config']['DATASTORE'] = self::$testDatastore;
-        self::$publicLinkDB = new LinkDB(false);
-        self::$privateLinkDB = new LinkDB(true);
+        self::$publicLinkDB = new LinkDB(self::$testDatastore, false, false);
+        self::$privateLinkDB = new LinkDB(self::$testDatastore, true, false);
     }
 
     /**
@@ -50,7 +59,6 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
      */
     protected function setUp()
     {
-        $GLOBALS['config']['DATASTORE'] = self::$testDatastore;
         if (file_exists(self::$testDatastore)) {
             unlink(self::$testDatastore);
         }
@@ -76,7 +84,7 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
      */
     public function testConstructLoggedIn()
     {
-        new LinkDB(true);
+        new LinkDB(self::$testDatastore, true, false);
         $this->assertFileExists(self::$testDatastore);
     }
 
@@ -85,20 +93,19 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
      */
     public function testConstructLoggedOut()
     {
-        new LinkDB(false);
+        new LinkDB(self::$testDatastore, false, false);
         $this->assertFileExists(self::$testDatastore);
     }
 
     /**
      * Attempt to instantiate a LinkDB whereas the datastore is not writable
      *
-     * @expectedException              PHPUnit_Framework_Error_Warning
-     * @expectedExceptionMessageRegExp /failed to open stream: No such file or directory/
+     * @expectedException              IOException
+     * @expectedExceptionMessageRegExp /Error accessing "null"/
      */
     public function testConstructDatastoreNotWriteable()
     {
-        $GLOBALS['config']['DATASTORE'] = 'null/store.db';
-        new LinkDB(false);
+        new LinkDB('null/store.db', false, false);
     }
 
     /**
@@ -106,19 +113,16 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
      */
     public function testCheckDBNew()
     {
-        $linkDB = new LinkDB(false);
+        $linkDB = new LinkDB(self::$testDatastore, false, false);
         unlink(self::$testDatastore);
         $this->assertFileNotExists(self::$testDatastore);
 
-        $checkDB = self::getMethod('checkDB');
+        $checkDB = self::getMethod('check');
         $checkDB->invokeArgs($linkDB, array());
         $this->assertFileExists(self::$testDatastore);
 
         // ensure the correct data has been written
-        $this->assertEquals(
-            self::$dummyDatastoreSHA1,
-            sha1_file(self::$testDatastore)
-        );
+        $this->assertGreaterThan(0, filesize(self::$testDatastore));
     }
 
     /**
@@ -126,19 +130,17 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
      */
     public function testCheckDBLoad()
     {
-        $linkDB = new LinkDB(false);
-        $this->assertEquals(
-            self::$dummyDatastoreSHA1,
-            sha1_file(self::$testDatastore)
-        );
+        $linkDB = new LinkDB(self::$testDatastore, false, false);
+        $datastoreSize = filesize(self::$testDatastore);
+        $this->assertGreaterThan(0, $datastoreSize);
 
-        $checkDB = self::getMethod('checkDB');
+        $checkDB = self::getMethod('check');
         $checkDB->invokeArgs($linkDB, array());
 
         // ensure the datastore is left unmodified
         $this->assertEquals(
-            self::$dummyDatastoreSHA1,
-            sha1_file(self::$testDatastore)
+            $datastoreSize,
+            filesize(self::$testDatastore)
         );
     }
 
@@ -147,8 +149,8 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
      */
     public function testReadEmptyDB()
     {
-        file_put_contents(self::$testDatastore, PHPPREFIX.'S7QysKquBQA='.PHPSUFFIX);
-        $emptyDB = new LinkDB(false);
+        file_put_contents(self::$testDatastore, '<?php /* S7QysKquBQA= */ ?>');
+        $emptyDB = new LinkDB(self::$testDatastore, false, false);
         $this->assertEquals(0, sizeof($emptyDB));
         $this->assertEquals(0, count($emptyDB));
     }
@@ -178,27 +180,24 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
     /**
      * Save the links to the DB
      */
-    public function testSaveDB()
+    public function testSave()
     {
-        $testDB = new LinkDB(true);
+        $testDB = new LinkDB(self::$testDatastore, true, false);
         $dbSize = sizeof($testDB);
 
         $link = array(
+            'id' => 42,
             'title'=>'an additional link',
             'url'=>'http://dum.my',
             'description'=>'One more',
             'private'=>0,
-            'linkdate'=>'20150518_190000',
+            'created'=> DateTime::createFromFormat(LinkDB::LINK_DATE_FORMAT, '20150518_190000'),
             'tags'=>'unit test'
         );
-        $testDB[$link['linkdate']] = $link;
-
-        // TODO: move PageCache to a proper class/file
-        function invalidateCaches() {}
-
-        $testDB->savedb();
+        $testDB[$link['id']] = $link;
+        $testDB->save('tests');
 
-        $testDB = new LinkDB(true);
+        $testDB = new LinkDB(self::$testDatastore, true, false);
         $this->assertEquals($dbSize + 1, sizeof($testDB));
     }
 
@@ -217,18 +216,35 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
         );
     }
 
+    /**
+     * Count existing links - public links hidden
+     */
+    public function testCountHiddenPublic()
+    {
+        $linkDB = new LinkDB(self::$testDatastore, false, true);
+
+        $this->assertEquals(
+            0,
+            $linkDB->count()
+        );
+        $this->assertEquals(
+            0,
+            $linkDB->count()
+        );
+    }
+
     /**
      * List the days for which links have been posted
      */
     public function testDays()
     {
         $this->assertEquals(
-            ['20121206', '20130614', '20150310'],
+            array('20100310', '20121206', '20130614', '20150310'),
             self::$publicLinkDB->days()
         );
 
         $this->assertEquals(
-            ['20121206', '20130614', '20141125', '20150310'],
+            array('20100310', '20121206', '20130614', '20141125', '20150310'),
             self::$privateLinkDB->days()
         );
     }
@@ -241,7 +257,7 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
         $link = self::$publicLinkDB->getLinkFromUrl('http://mediagoblin.org/');
 
         $this->assertNotEquals(false, $link);
-        $this->assertEquals(
+        $this->assertContains(
             'A free software media publishing platform',
             $link['description']
         );
@@ -264,7 +280,7 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
     public function testAllTags()
     {
         $this->assertEquals(
-            [
+            array(
                 'web' => 3,
                 'cartoon' => 2,
                 'gnu' => 2,
@@ -273,13 +289,19 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
                 'media' => 1,
                 'software' => 1,
                 'stallman' => 1,
-                'free' => 1
-            ],
-            self::$publicLinkDB->allTags()
+                'free' => 1,
+                '-exclude' => 1,
+                'hashtag' => 2,
+                // The DB contains a link with `sTuff` and another one with `stuff` tag.
+                // They need to be grouped with the first case found - order by date DESC: `sTuff`.
+                'sTuff' => 2,
+                'ut' => 1,
+            ),
+            self::$publicLinkDB->linksCountPerTag()
         );
 
         $this->assertEquals(
-            [
+            array(
                 'web' => 4,
                 'cartoon' => 3,
                 'gnu' => 2,
@@ -292,218 +314,332 @@ class LinkDBTest extends PHPUnit_Framework_TestCase
                 'html' => 1,
                 'w3c' => 1,
                 'css' => 1,
-                'Mercurial' => 1
-            ],
-            self::$privateLinkDB->allTags()
+                'Mercurial' => 1,
+                'sTuff' => 2,
+                '-exclude' => 1,
+                '.hidden' => 1,
+                'hashtag' => 2,
+                'tag1' => 1,
+                'tag2' => 1,
+                'tag3' => 1,
+                'tag4' => 1,
+                'ut' => 1,
+            ),
+            self::$privateLinkDB->linksCountPerTag()
+        );
+        $this->assertEquals(
+            array(
+                'web' => 4,
+                'cartoon' => 2,
+                'gnu' => 1,
+                'dev' => 1,
+                'samba' => 1,
+                'media' => 1,
+                'html' => 1,
+                'w3c' => 1,
+                'css' => 1,
+                'Mercurial' => 1,
+                '.hidden' => 1,
+                'hashtag' => 1,
+            ),
+            self::$privateLinkDB->linksCountPerTag(['web'])
+        );
+        $this->assertEquals(
+            array(
+                'web' => 1,
+                'html' => 1,
+                'w3c' => 1,
+                'css' => 1,
+                'Mercurial' => 1,
+            ),
+            self::$privateLinkDB->linksCountPerTag(['web'], 'private')
         );
     }
 
     /**
-     * Filter links using a tag
+     * Test real_url without redirector.
      */
-    public function testFilterOneTag()
+    public function testLinkRealUrlWithoutRedirector()
     {
-        $this->assertEquals(
-            3,
-            sizeof(self::$publicLinkDB->filterTags('web', false))
-        );
-
-        $this->assertEquals(
-            4,
-            sizeof(self::$privateLinkDB->filterTags('web', false))
-        );
+        $db = new LinkDB(self::$testDatastore, false, false);
+        foreach($db as $link) {
+            $this->assertEquals($link['url'], $link['real_url']);
+        }
     }
 
     /**
-     * Filter links using a tag - case-sensitive
+     * Test real_url with redirector.
      */
-    public function testFilterCaseSensitiveTag()
+    public function testLinkRealUrlWithRedirector()
     {
-        $this->assertEquals(
-            0,
-            sizeof(self::$privateLinkDB->filterTags('mercurial', true))
-        );
+        $redirector = 'http://redirector.to?';
+        $db = new LinkDB(self::$testDatastore, false, false, $redirector);
+        foreach($db as $link) {
+            $this->assertStringStartsWith($redirector, $link['real_url']);
+            $this->assertNotFalse(strpos($link['real_url'], urlencode('://')));
+        }
 
-        $this->assertEquals(
-            1,
-            sizeof(self::$privateLinkDB->filterTags('Mercurial', true))
-        );
+        $db = new LinkDB(self::$testDatastore, false, false, $redirector, false);
+        foreach($db as $link) {
+            $this->assertStringStartsWith($redirector, $link['real_url']);
+            $this->assertFalse(strpos($link['real_url'], urlencode('://')));
+        }
     }
 
     /**
-     * Filter links using a tag combination
+     * Test filter with string.
      */
-    public function testFilterMultipleTags()
+    public function testFilterString()
     {
-        $this->assertEquals(
-            1,
-            sizeof(self::$publicLinkDB->filterTags('dev cartoon', false))
-        );
-
+        $tags = 'dev cartoon';
+        $request = array('searchtags' => $tags);
         $this->assertEquals(
             2,
-            sizeof(self::$privateLinkDB->filterTags('dev cartoon', false))
+            count(self::$privateLinkDB->filterSearch($request, true, false))
         );
     }
 
     /**
-     * Filter links using a non-existent tag
+     * Test filter with string.
      */
-    public function testFilterUnknownTag()
+    public function testFilterArray()
     {
+        $tags = array('dev', 'cartoon');
+        $request = array('searchtags' => $tags);
         $this->assertEquals(
-            0,
-            sizeof(self::$publicLinkDB->filterTags('null', false))
+            2,
+            count(self::$privateLinkDB->filterSearch($request, true, false))
         );
     }
 
     /**
-     * Return links for a given day
+     * Test hidden tags feature:
+     *  tags starting with a dot '.' are only visible when logged in.
      */
-    public function testFilterDay()
+    public function testHiddenTags()
     {
+        $tags = '.hidden';
+        $request = array('searchtags' => $tags);
         $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterDay('20121206'))
+            1,
+            count(self::$privateLinkDB->filterSearch($request, true, false))
         );
 
         $this->assertEquals(
-            3,
-            sizeof(self::$privateLinkDB->filterDay('20121206'))
+            0,
+            count(self::$publicLinkDB->filterSearch($request, true, false))
         );
     }
 
     /**
-     * 404 - day not found
+     * Test filterHash() with a valid smallhash.
      */
-    public function testFilterUnknownDay()
+    public function testFilterHashValid()
     {
+        $request = smallHash('20150310_114651');
         $this->assertEquals(
-            0,
-            sizeof(self::$publicLinkDB->filterDay('19700101'))
+            1,
+            count(self::$publicLinkDB->filterHash($request))
         );
-
+        $request = smallHash('20150310_114633' . 8);
         $this->assertEquals(
-            0,
-            sizeof(self::$privateLinkDB->filterDay('19700101'))
+            1,
+            count(self::$publicLinkDB->filterHash($request))
         );
     }
 
     /**
-     * Use an invalid date format
+     * Test filterHash() with an invalid smallhash.
+     *
+     * @expectedException LinkNotFoundException
      */
-    public function testFilterInvalidDay()
+    public function testFilterHashInValid1()
     {
-        $this->assertEquals(
-            0,
-            sizeof(self::$privateLinkDB->filterDay('Rainy day, dream away'))
-        );
-
-        // TODO: check input format
-        $this->assertEquals(
-            6,
-            sizeof(self::$privateLinkDB->filterDay('20'))
-        );
+        $request = 'blabla';
+        self::$publicLinkDB->filterHash($request);
     }
 
     /**
-     * Retrieve a link entry with its hash
+     * Test filterHash() with an empty smallhash.
+     *
+     * @expectedException LinkNotFoundException
      */
-    public function testFilterSmallHash()
+    public function testFilterHashInValid()
     {
-        $links = self::$privateLinkDB->filterSmallHash('IuWvgA');
+        self::$publicLinkDB->filterHash('');
+    }
 
-        $this->assertEquals(
-            1,
-            sizeof($links)
-        );
+    /**
+     * Test reorder with asc/desc parameter.
+     */
+    public function testReorderLinksDesc()
+    {
+        self::$privateLinkDB->reorder('ASC');
+        $linkIds = array(42, 4, 9, 1, 0, 7, 6, 8, 41);
+        $cpt = 0;
+        foreach (self::$privateLinkDB as $key => $value) {
+            $this->assertEquals($linkIds[$cpt++], $key);
+        }
+        self::$privateLinkDB->reorder('DESC');
+        $linkIds = array_reverse($linkIds);
+        $cpt = 0;
+        foreach (self::$privateLinkDB as $key => $value) {
+            $this->assertEquals($linkIds[$cpt++], $key);
+        }
+    }
 
-        $this->assertEquals(
-            'MediaGoblin',
-            $links['20130614_184135']['title']
-        );
-        
+    /**
+     * Test rename tag with a valid value present in multiple links
+     */
+    public function testRenameTagMultiple()
+    {
+        self::$refDB->write(self::$testDatastore);
+        $linkDB = new LinkDB(self::$testDatastore, true, false);
+
+        $res = $linkDB->renameTag('cartoon', 'Taz');
+        $this->assertEquals(3, count($res));
+        $this->assertContains(' Taz ', $linkDB[4]['tags']);
+        $this->assertContains(' Taz ', $linkDB[1]['tags']);
+        $this->assertContains(' Taz ', $linkDB[0]['tags']);
     }
 
     /**
-     * No link for this hash
+     * Test rename tag with a valid value
      */
-    public function testFilterUnknownSmallHash()
+    public function testRenameTagCaseSensitive()
     {
-        $this->assertEquals(
-            0,
-            sizeof(self::$privateLinkDB->filterSmallHash('Iblaah'))
-        );
+        self::$refDB->write(self::$testDatastore);
+        $linkDB = new LinkDB(self::$testDatastore, true, false, '');
+
+        $res = $linkDB->renameTag('sTuff', 'Taz');
+        $this->assertEquals(1, count($res));
+        $this->assertEquals('Taz', $linkDB[41]['tags']);
     }
 
     /**
-     * Full-text search - result from a link's URL
+     * Test rename tag with invalid values
      */
-    public function testFilterFullTextURL()
+    public function testRenameTagInvalid()
     {
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('ars.userfriendly.org'))
-        );
+        $linkDB = new LinkDB(self::$testDatastore, false, false);
+
+        $this->assertFalse($linkDB->renameTag('', 'test'));
+        $this->assertFalse($linkDB->renameTag('', ''));
+        // tag non existent
+        $this->assertEquals([], $linkDB->renameTag('test', ''));
+        $this->assertEquals([], $linkDB->renameTag('test', 'retest'));
     }
 
     /**
-     * Full-text search - result from a link's title only
+     * Test delete tag with a valid value
      */
-    public function testFilterFullTextTitle()
+    public function testDeleteTag()
     {
-        // use miscellaneous cases
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('userfriendly -'))
-        );
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('UserFriendly -'))
-        );
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('uSeRFrIendlY -'))
-        );
+        self::$refDB->write(self::$testDatastore);
+        $linkDB = new LinkDB(self::$testDatastore, true, false);
 
-        // use miscellaneous case and offset
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('RFrIendL'))
-        );
+        $res = $linkDB->renameTag('cartoon', null);
+        $this->assertEquals(3, count($res));
+        $this->assertNotContains('cartoon', $linkDB[4]['tags']);
     }
 
     /**
-     * Full-text search - result from the link's description only
+     * Test linksCountPerTag all tags without filter.
+     * Equal occurrences should be sorted alphabetically.
      */
-    public function testFilterFullTextDescription()
+    public function testCountLinkPerTagAllNoFilter()
     {
-        $this->assertEquals(
-            1,
-            sizeof(self::$publicLinkDB->filterFullText('media publishing'))
-        );
+        $expected = [
+            'web' => 4,
+            'cartoon' => 3,
+            'dev' => 2,
+            'gnu' => 2,
+            'hashtag' => 2,
+            'sTuff' => 2,
+            '-exclude' => 1,
+            '.hidden' => 1,
+            'Mercurial' => 1,
+            'css' => 1,
+            'free' => 1,
+            'html' => 1,
+            'media' => 1,
+            'samba' => 1,
+            'software' => 1,
+            'stallman' => 1,
+            'tag1' => 1,
+            'tag2' => 1,
+            'tag3' => 1,
+            'tag4' => 1,
+            'ut' => 1,
+            'w3c' => 1,
+        ];
+        $tags = self::$privateLinkDB->linksCountPerTag();
+
+        $this->assertEquals($expected, $tags, var_export($tags, true));
     }
 
     /**
-     * Full-text search - result from the link's tags only
+     * Test linksCountPerTag all tags with filter.
+     * Equal occurrences should be sorted alphabetically.
      */
-    public function testFilterFullTextTags()
+    public function testCountLinkPerTagAllWithFilter()
     {
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('gnu'))
-        );
+        $expected = [
+            'gnu' => 2,
+            'hashtag' => 2,
+            '-exclude' => 1,
+            '.hidden' => 1,
+            'free' => 1,
+            'media' => 1,
+            'software' => 1,
+            'stallman' => 1,
+            'stuff' => 1,
+            'web' => 1,
+        ];
+        $tags = self::$privateLinkDB->linksCountPerTag(['gnu']);
+
+        $this->assertEquals($expected, $tags, var_export($tags, true));
     }
 
     /**
-     * Full-text search - result set from mixed sources
+     * Test linksCountPerTag public tags with filter.
+     * Equal occurrences should be sorted alphabetically.
      */
-    public function testFilterFullTextMixed()
+    public function testCountLinkPerTagPublicWithFilter()
     {
-        $this->assertEquals(
-            2,
-            sizeof(self::$publicLinkDB->filterFullText('free software'))
-        );
+        $expected = [
+            'gnu' => 2,
+            'hashtag' => 2,
+            '-exclude' => 1,
+            '.hidden' => 1,
+            'free' => 1,
+            'media' => 1,
+            'software' => 1,
+            'stallman' => 1,
+            'stuff' => 1,
+            'web' => 1,
+        ];
+        $tags = self::$privateLinkDB->linksCountPerTag(['gnu'], 'public');
+
+        $this->assertEquals($expected, $tags, var_export($tags, true));
+    }
+
+    /**
+     * Test linksCountPerTag public tags with filter.
+     * Equal occurrences should be sorted alphabetically.
+     */
+    public function testCountLinkPerTagPrivateWithFilter()
+    {
+        $expected = [
+            'cartoon' => 1,
+            'dev' => 1,
+            'tag1' => 1,
+            'tag2' => 1,
+            'tag3' => 1,
+            'tag4' => 1,
+        ];
+        $tags = self::$privateLinkDB->linksCountPerTag(['dev'], 'private');
+
+        $this->assertEquals($expected, $tags, var_export($tags, true));
     }
 }
-?>