MyShaarli/tests/LinkDBTest.php

648 lines
18 KiB
PHP
Raw Normal View History

<?php
/**
* 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';
/**
* Unitary tests for LinkDB
*/
class LinkDBTest extends PHPUnit_Framework_TestCase
{
// datastore to test write operations
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;
/**
* Instantiates public and private LinkDBs with test data
*
* The reference datastore contains public and private links that
* will be used to test LinkDB's methods:
* - access filtering (public/private),
* - link searches:
* - by day,
* - by tag,
* - by text,
* - etc.
*/
public static function setUpBeforeClass()
{
self::$refDB = new ReferenceLinkDB();
self::$refDB->write(self::$testDatastore);
self::$publicLinkDB = new LinkDB(self::$testDatastore, false, false);
self::$privateLinkDB = new LinkDB(self::$testDatastore, true, false);
}
/**
* Resets test data for each test
*/
protected function setUp()
{
if (file_exists(self::$testDatastore)) {
unlink(self::$testDatastore);
}
}
/**
* Allows to test LinkDB's private methods
*
* @see
* https://sebastian-bergmann.de/archives/881-Testing-Your-Privates.html
* http://stackoverflow.com/a/2798203
*/
protected static function getMethod($name)
{
$class = new ReflectionClass('LinkDB');
$method = $class->getMethod($name);
$method->setAccessible(true);
return $method;
}
/**
* Instantiate LinkDB objects - logged in user
*/
public function testConstructLoggedIn()
{
new LinkDB(self::$testDatastore, true, false);
$this->assertFileExists(self::$testDatastore);
}
/**
* Instantiate LinkDB objects - logged out or public instance
*/
public function testConstructLoggedOut()
{
new LinkDB(self::$testDatastore, false, false);
$this->assertFileExists(self::$testDatastore);
}
/**
* Attempt to instantiate a LinkDB whereas the datastore is not writable
*
* @expectedException IOException
* @expectedExceptionMessageRegExp /Error accessing "null"/
*/
public function testConstructDatastoreNotWriteable()
{
new LinkDB('null/store.db', false, false);
}
/**
* The DB doesn't exist, ensure it is created with dummy content
*/
public function testCheckDBNew()
{
$linkDB = new LinkDB(self::$testDatastore, false, false);
unlink(self::$testDatastore);
$this->assertFileNotExists(self::$testDatastore);
$checkDB = self::getMethod('check');
$checkDB->invokeArgs($linkDB, array());
$this->assertFileExists(self::$testDatastore);
// ensure the correct data has been written
$this->assertGreaterThan(0, filesize(self::$testDatastore));
}
/**
* The DB exists, don't do anything
*/
public function testCheckDBLoad()
{
$linkDB = new LinkDB(self::$testDatastore, false, false);
$datastoreSize = filesize(self::$testDatastore);
$this->assertGreaterThan(0, $datastoreSize);
$checkDB = self::getMethod('check');
$checkDB->invokeArgs($linkDB, array());
// ensure the datastore is left unmodified
$this->assertEquals(
$datastoreSize,
filesize(self::$testDatastore)
);
}
/**
* Load an empty DB
*/
public function testReadEmptyDB()
{
file_put_contents(self::$testDatastore, '<?php /* S7QysKquBQA= */ ?>');
$emptyDB = new LinkDB(self::$testDatastore, false, false);
$this->assertEquals(0, sizeof($emptyDB));
$this->assertEquals(0, count($emptyDB));
}
/**
* Load public links from the DB
*/
public function testReadPublicDB()
{
$this->assertEquals(
self::$refDB->countPublicLinks(),
sizeof(self::$publicLinkDB)
);
}
/**
* Load public and private links from the DB
*/
public function testReadPrivateDB()
{
$this->assertEquals(
self::$refDB->countLinks(),
sizeof(self::$privateLinkDB)
);
}
/**
* Save the links to the DB
*/
public function testSave()
{
$testDB = new LinkDB(self::$testDatastore, true, false);
$dbSize = sizeof($testDB);
$link = array(
2016-11-28 16:17:25 +01:00
'id' => 42,
'title'=>'an additional link',
'url'=>'http://dum.my',
'description'=>'One more',
'private'=>0,
'created'=> DateTime::createFromFormat(LinkDB::LINK_DATE_FORMAT, '20150518_190000'),
'tags'=>'unit test'
);
2016-11-28 16:17:25 +01:00
$testDB[$link['id']] = $link;
$testDB->save('tests');
$testDB = new LinkDB(self::$testDatastore, true, false);
$this->assertEquals($dbSize + 1, sizeof($testDB));
}
/**
* Count existing links
*/
public function testCount()
{
$this->assertEquals(
self::$refDB->countPublicLinks(),
self::$publicLinkDB->count()
);
$this->assertEquals(
self::$refDB->countLinks(),
self::$privateLinkDB->count()
);
}
/**
* 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(
array('20100309', '20100310', '20121206', '20121207', '20130614', '20150310'),
self::$publicLinkDB->days()
);
$this->assertEquals(
array('20100309', '20100310', '20121206', '20121207', '20130614', '20141125', '20150310'),
self::$privateLinkDB->days()
);
}
/**
* The URL corresponds to an existing entry in the DB
*/
public function testGetKnownLinkFromURL()
{
$link = self::$publicLinkDB->getLinkFromUrl('http://mediagoblin.org/');
$this->assertNotEquals(false, $link);
$this->assertContains(
'A free software media publishing platform',
$link['description']
);
}
/**
* The URL is not in the DB
*/
public function testGetUnknownLinkFromURL()
{
$this->assertEquals(
false,
self::$publicLinkDB->getLinkFromUrl('http://dev.null')
);
}
/**
* Lists all tags
*/
public function testAllTags()
{
$this->assertEquals(
array(
'web' => 3,
'cartoon' => 2,
'gnu' => 2,
'dev' => 1,
'samba' => 1,
'media' => 1,
'software' => 1,
'stallman' => 1,
'free' => 1,
'-exclude' => 1,
2016-11-28 16:17:25 +01:00
'hashtag' => 2,
// The DB contains a link with `sTuff` and another one with `stuff` tag.
2016-11-28 16:17:25 +01:00
// They need to be grouped with the first case found - order by date DESC: `sTuff`.
'sTuff' => 2,
2016-11-28 16:17:25 +01:00
'ut' => 1,
),
self::$publicLinkDB->linksCountPerTag()
);
$this->assertEquals(
array(
'web' => 4,
'cartoon' => 3,
'gnu' => 2,
'dev' => 2,
'samba' => 1,
'media' => 1,
'software' => 1,
'stallman' => 1,
'free' => 1,
'html' => 1,
'w3c' => 1,
'css' => 1,
'Mercurial' => 1,
'sTuff' => 2,
'-exclude' => 1,
'.hidden' => 1,
'hashtag' => 2,
'tag1' => 1,
'tag2' => 1,
'tag3' => 1,
'tag4' => 1,
2016-11-28 16:17:25 +01:00
'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')
);
}
/**
* Test real_url without redirector.
*/
public function testLinkRealUrlWithoutRedirector()
{
$db = new LinkDB(self::$testDatastore, false, false);
foreach ($db as $link) {
$this->assertEquals($link['url'], $link['real_url']);
}
}
/**
* Test real_url with redirector.
*/
public function testLinkRealUrlWithRedirector()
{
$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('://')));
}
$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('://')));
}
}
/**
* Test filter with string.
*/
public function testFilterString()
{
$tags = 'dev cartoon';
$request = array('searchtags' => $tags);
$this->assertEquals(
2,
count(self::$privateLinkDB->filterSearch($request, true, false))
);
}
/**
* Test filter with string.
*/
public function testFilterArray()
{
$tags = array('dev', 'cartoon');
$request = array('searchtags' => $tags);
$this->assertEquals(
2,
count(self::$privateLinkDB->filterSearch($request, true, false))
);
}
/**
* Test hidden tags feature:
* tags starting with a dot '.' are only visible when logged in.
*/
public function testHiddenTags()
{
$tags = '.hidden';
$request = array('searchtags' => $tags);
$this->assertEquals(
1,
count(self::$privateLinkDB->filterSearch($request, true, false))
);
$this->assertEquals(
0,
count(self::$publicLinkDB->filterSearch($request, true, false))
);
}
/**
* Test filterHash() with a valid smallhash.
*/
public function testFilterHashValid()
{
$request = smallHash('20150310_114651');
$this->assertEquals(
1,
count(self::$publicLinkDB->filterHash($request))
);
2016-11-28 16:17:25 +01:00
$request = smallHash('20150310_114633' . 8);
$this->assertEquals(
1,
count(self::$publicLinkDB->filterHash($request))
);
}
/**
* Test filterHash() with an invalid smallhash.
*
* @expectedException LinkNotFoundException
*/
public function testFilterHashInValid1()
{
$request = 'blabla';
self::$publicLinkDB->filterHash($request);
}
/**
* Test filterHash() with an empty smallhash.
*
* @expectedException LinkNotFoundException
*/
public function testFilterHashInValid()
{
self::$publicLinkDB->filterHash('');
}
2016-11-28 16:17:25 +01:00
/**
* Test reorder with asc/desc parameter.
*/
public function testReorderLinksDesc()
{
self::$privateLinkDB->reorder('ASC');
$stickyIds = [11, 10];
$standardIds = [42, 4, 9, 1, 0, 7, 6, 8, 41];
$linkIds = array_merge($stickyIds, $standardIds);
$cpt = 0;
foreach (self::$privateLinkDB as $key => $value) {
$this->assertEquals($linkIds[$cpt++], $key);
2016-11-28 16:17:25 +01:00
}
self::$privateLinkDB->reorder('DESC');
$linkIds = array_merge(array_reverse($stickyIds), array_reverse($standardIds));
$cpt = 0;
foreach (self::$privateLinkDB as $key => $value) {
$this->assertEquals($linkIds[$cpt++], $key);
2016-11-28 16:17:25 +01:00
}
}
/**
* 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']);
}
/**
* Test rename tag with a valid value
*/
public function testRenameTagCaseSensitive()
{
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']);
}
/**
* Test rename tag with invalid values
*/
public function testRenameTagInvalid()
{
$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'));
}
/**
* Test delete tag with a valid value
*/
public function testDeleteTag()
{
self::$refDB->write(self::$testDatastore);
$linkDB = new LinkDB(self::$testDatastore, true, false);
$res = $linkDB->renameTag('cartoon', null);
$this->assertEquals(3, count($res));
$this->assertNotContains('cartoon', $linkDB[4]['tags']);
}
/**
* Test linksCountPerTag all tags without filter.
* Equal occurrences should be sorted alphabetically.
*/
public function testCountLinkPerTagAllNoFilter()
{
$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));
}
/**
* Test linksCountPerTag all tags with filter.
* Equal occurrences should be sorted alphabetically.
*/
public function testCountLinkPerTagAllWithFilter()
{
$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));
}
/**
* Test linksCountPerTag public tags with filter.
* Equal occurrences should be sorted alphabetically.
*/
public function testCountLinkPerTagPublicWithFilter()
{
$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));
}
}