[github/shaarli/Shaarli.git] / tests / api / controllers / GetLinksTest.php

<?php
namespace Shaarli\Api\Controllers;

use Shaarli\Config\ConfigManager;

use Slim\Container;
use Slim\Http\Environment;
use Slim\Http\Request;
use Slim\Http\Response;

/**
 * Class GetLinksTest
 *
 * Test get Link list REST API service.
 *
 * @see http://shaarli.github.io/api-documentation/#links-links-collection-get
 *
 * @package Shaarli\Api\Controllers
 */
class GetLinksTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var string datastore to test write operations
     */
    protected static $testDatastore = 'sandbox/datastore.php';

    /**
     * @var ConfigManager instance
     */
    protected $conf;

    /**
     * @var \ReferenceLinkDB instance.
     */
    protected $refDB = null;

    /**
     * @var Container instance.
     */
    protected $container;

    /**
     * @var Links controller instance.
     */
    protected $controller;

    /**
     * Number of JSON field per link.
     */
    const NB_FIELDS_LINK = 9;

    /**
     * Before every test, instantiate a new Api with its config, plugins and links.
     */
    public function setUp()
    {
        $this->conf = new ConfigManager('tests/utils/config/configJson');
        $this->refDB = new \ReferenceLinkDB();
        $this->refDB->write(self::$testDatastore);

        $this->container = new Container();
        $this->container['conf'] = $this->conf;
        $this->container['db'] = new \LinkDB(self::$testDatastore, true, false);
        $this->container['history'] = null;

        $this->controller = new Links($this->container);
    }

    /**
     * After every test, remove the test datastore.
     */
    public function tearDown()
    {
        @unlink(self::$testDatastore);
    }

    /**
     * Test basic getLinks service: returns all links.
     */
    public function testGetLinks()
    {
        // Used by index_url().
        $_SERVER['SERVER_NAME'] = 'domain.tld';
        $_SERVER['SERVER_PORT'] = 80;
        $_SERVER['SCRIPT_NAME'] = '/';

        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
        ]);
        $request = Request::createFromEnvironment($env);

        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals($this->refDB->countLinks(), count($data));

        // Check order
        $order = [41, 8, 6, 7, 0, 1, 9, 4, 42];
        $cpt = 0;
        foreach ($data as $link) {
            $this->assertEquals(self::NB_FIELDS_LINK, count($link));
            $this->assertEquals($order[$cpt++], $link['id']);
        }

        // Check first element fields
        $first = $data[0];
        $this->assertEquals('http://domain.tld/?WDWyig', $first['url']);
        $this->assertEquals('WDWyig', $first['shorturl']);
        $this->assertEquals('Link title: @website', $first['title']);
        $this->assertEquals(
            'Stallman has a beard and is part of the Free Software Foundation (or not). Seriously, read this. #hashtag',
            $first['description']
        );
        $this->assertEquals('sTuff', $first['tags'][0]);
        $this->assertEquals(false, $first['private']);
        $this->assertEquals(
            \DateTime::createFromFormat(\LinkDB::LINK_DATE_FORMAT, '20150310_114651')->format(\DateTime::ATOM),
            $first['created']
        );
        $this->assertEmpty($first['updated']);

        // Multi tags
        $link = $data[1];
        $this->assertEquals(7, count($link['tags']));

        // Update date
        $this->assertEquals(
            \DateTime::createFromFormat(\LinkDB::LINK_DATE_FORMAT, '20160803_093033')->format(\DateTime::ATOM),
            $link['updated']
        );
    }

    /**
     * Test getLinks service with offset and limit parameter:
     *   limit=1 and offset=1 should return only the second link, ID=8 (ordered by creation date DESC).
     */
    public function testGetLinksOffsetLimit()
    {
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'offset=1&limit=1'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(1, count($data));
        $this->assertEquals(8, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
    }

    /**
     * Test getLinks with limit=all (return all link).
     */
    public function testGetLinksLimitAll()
    {
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'limit=all'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals($this->refDB->countLinks(), count($data));
        // Check order
        $order = [41, 8, 6, 7, 0, 1, 9, 4, 42];
        $cpt = 0;
        foreach ($data as $link) {
            $this->assertEquals(self::NB_FIELDS_LINK, count($link));
            $this->assertEquals($order[$cpt++], $link['id']);
        }
    }

    /**
     * Test getLinks service with offset and limit parameter:
     *   limit=1 and offset=1 should return only the second link, ID=8 (ordered by creation date DESC).
     */
    public function testGetLinksOffsetTooHigh()
    {
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'offset=100'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEmpty(count($data));
    }

    /**
     * Test getLinks with visibility parameter set to all
     */
    public function testGetLinksVisibilityAll()
    {
        $env = Environment::mock(
            [
                'REQUEST_METHOD' => 'GET',
                'QUERY_STRING' => 'visibility=all'
            ]
        );
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string)$response->getBody(), true);
        $this->assertEquals($this->refDB->countLinks(), count($data));
        $this->assertEquals(41, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
    }

    /**
     * Test getLinks with visibility parameter set to private
     */
    public function testGetLinksVisibilityPrivate()
    {
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'visibility=private'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals($this->refDB->countPrivateLinks(), count($data));
        $this->assertEquals(6, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
    }

    /**
     * Test getLinks with visibility parameter set to public
     */
    public function testGetLinksVisibilityPublic()
    {
        $env = Environment::mock(
            [
                'REQUEST_METHOD' => 'GET',
                'QUERY_STRING' => 'visibility=public'
            ]
        );
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string)$response->getBody(), true);
        $this->assertEquals($this->refDB->countPublicLinks(), count($data));
        $this->assertEquals(41, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
    }

    /**
     * Test getLinks service with offset and limit parameter:
     *   limit=1 and offset=1 should return only the second link, ID=8 (ordered by creation date DESC).
     */
    public function testGetLinksSearchTerm()
    {
        // Only in description - 1 result
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm=Tropical'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(1, count($data));
        $this->assertEquals(1, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));

        // Only in tags - 1 result
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm=tag3'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(1, count($data));
        $this->assertEquals(0, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));

        // Multiple results (2)
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm=stallman'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(2, count($data));
        $this->assertEquals(41, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
        $this->assertEquals(8, $data[1]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));

        // Multiword - 2 results
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm=stallman+software'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(2, count($data));
        $this->assertEquals(41, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
        $this->assertEquals(8, $data[1]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));

        // URL encoding
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm='. urlencode('@web')
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(2, count($data));
        $this->assertEquals(41, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
        $this->assertEquals(8, $data[1]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));
    }

    public function testGetLinksSearchTermNoResult()
    {
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm=nope'
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(0, count($data));
    }

    public function testGetLinksSearchTags()
    {
        // Single tag
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=dev',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(2, count($data));
        $this->assertEquals(0, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
        $this->assertEquals(4, $data[1]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));

        // Multitag + exclude
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=stuff+-gnu',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(1, count($data));
        $this->assertEquals(41, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));

        // wildcard: placeholder at the start
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=*Tuff',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(2, count($data));
        $this->assertEquals(41, $data[0]['id']);

        // wildcard: placeholder at the end
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=c*',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(4, count($data));
        $this->assertEquals(6, $data[0]['id']);

        // wildcard: placeholder at the middle
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=w*b',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(4, count($data));
        $this->assertEquals(6, $data[0]['id']);

        // wildcard: match all
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=*',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(9, count($data));
        $this->assertEquals(41, $data[0]['id']);

        // wildcard: optional ('*' does not need to expand)
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=*stuff*',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(2, count($data));
        $this->assertEquals(41, $data[0]['id']);

        // wildcard: exclusions
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=*a*+-*e*',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(1, count($data));
        $this->assertEquals(41, $data[0]['id']); // finds '#hashtag' in descr.

        // wildcard: exclude all
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchtags=-*',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(0, count($data));
    }

    /**
     * Test getLinks service with search tags+terms.
     */
    public function testGetLinksSearchTermsAndTags()
    {
        $env = Environment::mock([
            'REQUEST_METHOD' => 'GET',
            'QUERY_STRING' => 'searchterm=poke&searchtags=dev',
        ]);
        $request = Request::createFromEnvironment($env);
        $response = $this->controller->getLinks($request, new Response());
        $this->assertEquals(200, $response->getStatusCode());
        $data = json_decode((string) $response->getBody(), true);
        $this->assertEquals(1, count($data));
        $this->assertEquals(0, $data[0]['id']);
        $this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
    }
}
Commit	Line	Data
c3b00963	1	<?php
c3b00963 A	2	namespace Shaarli\Api\Controllers;
c3b00963 A	3
3c66e564	4	use Shaarli\Config\ConfigManager;
c3b00963 A	5
	6	use Slim\Container;
	7	use Slim\Http\Environment;
	8	use Slim\Http\Request;
	9	use Slim\Http\Response;
	10
	11	/**
16e3d006	12	* Class GetLinksTest
c3b00963	13	*
16e3d006 A	14	* Test get Link list REST API service.
	15	*
	16	* @see http://shaarli.github.io/api-documentation/#links-links-collection-get
c3b00963 A	17	*
	18	* @package Shaarli\Api\Controllers
	19	*/
16e3d006	20	class GetLinksTest extends \PHPUnit_Framework_TestCase
c3b00963 A	21	{
	22	/**
	23	* @var string datastore to test write operations
	24	*/
	25	protected static $testDatastore = 'sandbox/datastore.php';
	26
	27	/**
3c66e564	28	* @var ConfigManager instance
c3b00963 A	29	*/
	30	protected $conf;
	31
	32	/**
	33	* @var \ReferenceLinkDB instance.
	34	*/
	35	protected $refDB = null;
	36
	37	/**
	38	* @var Container instance.
	39	*/
	40	protected $container;
	41
	42	/**
	43	* @var Links controller instance.
	44	*/
	45	protected $controller;
	46
	47	/**
	48	* Number of JSON field per link.
	49	*/
	50	const NB_FIELDS_LINK = 9;
	51
	52	/**
	53	* Before every test, instantiate a new Api with its config, plugins and links.
	54	*/
	55	public function setUp()
	56	{
3c66e564	57	$this->conf = new ConfigManager('tests/utils/config/configJson');
c3b00963 A	58	$this->refDB = new \ReferenceLinkDB();
	59	$this->refDB->write(self::$testDatastore);
	60
	61	$this->container = new Container();
	62	$this->container['conf'] = $this->conf;
	63	$this->container['db'] = new \LinkDB(self::$testDatastore, true, false);
813849e5	64	$this->container['history'] = null;
c3b00963 A	65
	66	$this->controller = new Links($this->container);
	67	}
	68
	69	/**
	70	* After every test, remove the test datastore.
	71	*/
	72	public function tearDown()
	73	{
	74	@unlink(self::$testDatastore);
	75	}
	76
	77	/**
	78	* Test basic getLinks service: returns all links.
	79	*/
	80	public function testGetLinks()
	81	{
	82	// Used by index_url().
	83	$_SERVER['SERVER_NAME'] = 'domain.tld';
	84	$_SERVER['SERVER_PORT'] = 80;
	85	$_SERVER['SCRIPT_NAME'] = '/';
	86
	87	$env = Environment::mock([
	88	'REQUEST_METHOD' => 'GET',
	89	]);
	90	$request = Request::createFromEnvironment($env);
	91
	92	$response = $this->controller->getLinks($request, new Response());
	93	$this->assertEquals(200, $response->getStatusCode());
	94	$data = json_decode((string) $response->getBody(), true);
	95	$this->assertEquals($this->refDB->countLinks(), count($data));
	96
	97	// Check order
7d86f40b	98	$order = [41, 8, 6, 7, 0, 1, 9, 4, 42];
c3b00963 A	99	$cpt = 0;
	100	foreach ($data as $link) {
	101	$this->assertEquals(self::NB_FIELDS_LINK, count($link));
	102	$this->assertEquals($order[$cpt++], $link['id']);
	103	}
	104
16e3d006	105	// Check first element fields
c3b00963 A	106	$first = $data[0];
	107	$this->assertEquals('http://domain.tld/?WDWyig', $first['url']);
	108	$this->assertEquals('WDWyig', $first['shorturl']);
	109	$this->assertEquals('Link title: @website', $first['title']);
	110	$this->assertEquals(
	111	'Stallman has a beard and is part of the Free Software Foundation (or not). Seriously, read this. #hashtag',
	112	$first['description']
	113	);
	114	$this->assertEquals('sTuff', $first['tags'][0]);
	115	$this->assertEquals(false, $first['private']);
	116	$this->assertEquals(
	117	\DateTime::createFromFormat(\LinkDB::LINK_DATE_FORMAT, '20150310_114651')->format(\DateTime::ATOM),
	118	$first['created']
	119	);
	120	$this->assertEmpty($first['updated']);
	121
	122	// Multi tags
	123	$link = $data[1];
	124	$this->assertEquals(7, count($link['tags']));
	125
	126	// Update date
	127	$this->assertEquals(
	128	\DateTime::createFromFormat(\LinkDB::LINK_DATE_FORMAT, '20160803_093033')->format(\DateTime::ATOM),
	129	$link['updated']
	130	);
	131	}
	132
	133	/**
	134	* Test getLinks service with offset and limit parameter:
	135	* limit=1 and offset=1 should return only the second link, ID=8 (ordered by creation date DESC).
	136	*/
	137	public function testGetLinksOffsetLimit()
	138	{
	139	$env = Environment::mock([
	140	'REQUEST_METHOD' => 'GET',
	141	'QUERY_STRING' => 'offset=1&limit=1'
	142	]);
	143	$request = Request::createFromEnvironment($env);
	144	$response = $this->controller->getLinks($request, new Response());
	145	$this->assertEquals(200, $response->getStatusCode());
	146	$data = json_decode((string) $response->getBody(), true);
	147	$this->assertEquals(1, count($data));
	148	$this->assertEquals(8, $data[0]['id']);
	149	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	150	}
	151
	152	/**
	153	* Test getLinks with limit=all (return all link).
	154	*/
	155	public function testGetLinksLimitAll()
	156	{
	157	$env = Environment::mock([
	158	'REQUEST_METHOD' => 'GET',
	159	'QUERY_STRING' => 'limit=all'
	160	]);
	161	$request = Request::createFromEnvironment($env);
	162	$response = $this->controller->getLinks($request, new Response());
	163	$this->assertEquals(200, $response->getStatusCode());
	164	$data = json_decode((string) $response->getBody(), true);
	165	$this->assertEquals($this->refDB->countLinks(), count($data));
	166	// Check order
7d86f40b	167	$order = [41, 8, 6, 7, 0, 1, 9, 4, 42];
c3b00963 A	168	$cpt = 0;
	169	foreach ($data as $link) {
	170	$this->assertEquals(self::NB_FIELDS_LINK, count($link));
	171	$this->assertEquals($order[$cpt++], $link['id']);
	172	}
	173	}
	174
	175	/**
	176	* Test getLinks service with offset and limit parameter:
	177	* limit=1 and offset=1 should return only the second link, ID=8 (ordered by creation date DESC).
	178	*/
	179	public function testGetLinksOffsetTooHigh()
	180	{
	181	$env = Environment::mock([
	182	'REQUEST_METHOD' => 'GET',
	183	'QUERY_STRING' => 'offset=100'
	184	]);
	185	$request = Request::createFromEnvironment($env);
	186	$response = $this->controller->getLinks($request, new Response());
	187	$this->assertEquals(200, $response->getStatusCode());
	188	$data = json_decode((string) $response->getBody(), true);
	189	$this->assertEmpty(count($data));
	190	}
	191
	192	/**
c37a6f82	193	* Test getLinks with visibility parameter set to all
c3b00963	194	*/
c37a6f82	195	public function testGetLinksVisibilityAll()
c3b00963	196	{
c37a6f82 A	197	$env = Environment::mock(
	198	[
	199	'REQUEST_METHOD' => 'GET',
	200	'QUERY_STRING' => 'visibility=all'
	201	]
	202	);
c3b00963 A	203	$request = Request::createFromEnvironment($env);
	204	$response = $this->controller->getLinks($request, new Response());
	205	$this->assertEquals(200, $response->getStatusCode());
c37a6f82 A	206	$data = json_decode((string)$response->getBody(), true);
	207	$this->assertEquals($this->refDB->countLinks(), count($data));
	208	$this->assertEquals(41, $data[0]['id']);
c3b00963	209	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
c37a6f82	210	}
c3b00963	211
c37a6f82 A	212	/**
	213	* Test getLinks with visibility parameter set to private
	214	*/
	215	public function testGetLinksVisibilityPrivate()
	216	{
c3b00963 A	217	$env = Environment::mock([
c3b00963 A	218	'REQUEST_METHOD' => 'GET',
c37a6f82	219	'QUERY_STRING' => 'visibility=private'
c3b00963 A	220	]);
	221	$request = Request::createFromEnvironment($env);
	222	$response = $this->controller->getLinks($request, new Response());
	223	$this->assertEquals(200, $response->getStatusCode());
	224	$data = json_decode((string) $response->getBody(), true);
	225	$this->assertEquals($this->refDB->countPrivateLinks(), count($data));
	226	$this->assertEquals(6, $data[0]['id']);
	227	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	228	}
	229
	230	/**
c37a6f82	231	* Test getLinks with visibility parameter set to public
c3b00963	232	*/
c37a6f82	233	public function testGetLinksVisibilityPublic()
c3b00963 A	234	{
	235	$env = Environment::mock(
	236	[
	237	'REQUEST_METHOD' => 'GET',
c37a6f82	238	'QUERY_STRING' => 'visibility=public'
c3b00963 A	239	]
	240	);
	241	$request = Request::createFromEnvironment($env);
	242	$response = $this->controller->getLinks($request, new Response());
	243	$this->assertEquals(200, $response->getStatusCode());
	244	$data = json_decode((string)$response->getBody(), true);
c37a6f82	245	$this->assertEquals($this->refDB->countPublicLinks(), count($data));
c3b00963 A	246	$this->assertEquals(41, $data[0]['id']);
	247	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	248	}
	249
	250	/**
	251	* Test getLinks service with offset and limit parameter:
	252	* limit=1 and offset=1 should return only the second link, ID=8 (ordered by creation date DESC).
	253	*/
	254	public function testGetLinksSearchTerm()
	255	{
	256	// Only in description - 1 result
	257	$env = Environment::mock([
	258	'REQUEST_METHOD' => 'GET',
	259	'QUERY_STRING' => 'searchterm=Tropical'
	260	]);
	261	$request = Request::createFromEnvironment($env);
	262	$response = $this->controller->getLinks($request, new Response());
	263	$this->assertEquals(200, $response->getStatusCode());
	264	$data = json_decode((string) $response->getBody(), true);
	265	$this->assertEquals(1, count($data));
	266	$this->assertEquals(1, $data[0]['id']);
	267	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	268
	269	// Only in tags - 1 result
	270	$env = Environment::mock([
	271	'REQUEST_METHOD' => 'GET',
	272	'QUERY_STRING' => 'searchterm=tag3'
	273	]);
	274	$request = Request::createFromEnvironment($env);
	275	$response = $this->controller->getLinks($request, new Response());
	276	$this->assertEquals(200, $response->getStatusCode());
	277	$data = json_decode((string) $response->getBody(), true);
	278	$this->assertEquals(1, count($data));
	279	$this->assertEquals(0, $data[0]['id']);
	280	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	281
	282	// Multiple results (2)
	283	$env = Environment::mock([
	284	'REQUEST_METHOD' => 'GET',
	285	'QUERY_STRING' => 'searchterm=stallman'
	286	]);
	287	$request = Request::createFromEnvironment($env);
	288	$response = $this->controller->getLinks($request, new Response());
	289	$this->assertEquals(200, $response->getStatusCode());
	290	$data = json_decode((string) $response->getBody(), true);
	291	$this->assertEquals(2, count($data));
	292	$this->assertEquals(41, $data[0]['id']);
	293	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	294	$this->assertEquals(8, $data[1]['id']);
	295	$this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));
	296
	297	// Multiword - 2 results
	298	$env = Environment::mock([
	299	'REQUEST_METHOD' => 'GET',
	300	'QUERY_STRING' => 'searchterm=stallman+software'
	301	]);
	302	$request = Request::createFromEnvironment($env);
	303	$response = $this->controller->getLinks($request, new Response());
	304	$this->assertEquals(200, $response->getStatusCode());
	305	$data = json_decode((string) $response->getBody(), true);
	306	$this->assertEquals(2, count($data));
	307	$this->assertEquals(41, $data[0]['id']);
	308	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	309	$this->assertEquals(8, $data[1]['id']);
310	$this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));
311
312	// URL encoding
313	$env = Environment::mock([
314	'REQUEST_METHOD' => 'GET',
315	'QUERY_STRING' => 'searchterm='. urlencode('@web')
316	]);
317	$request = Request::createFromEnvironment($env);
318	$response = $this->controller->getLinks($request, new Response());
319	$this->assertEquals(200, $response->getStatusCode());
320	$data = json_decode((string) $response->getBody(), true);
321	$this->assertEquals(2, count($data));
322	$this->assertEquals(41, $data[0]['id']);
323	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
324	$this->assertEquals(8, $data[1]['id']);
325	$this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));
326	}
327
328	public function testGetLinksSearchTermNoResult()
329	{
330	$env = Environment::mock([
331	'REQUEST_METHOD' => 'GET',
332	'QUERY_STRING' => 'searchterm=nope'
333	]);
334	$request = Request::createFromEnvironment($env);
335	$response = $this->controller->getLinks($request, new Response());
336	$this->assertEquals(200, $response->getStatusCode());
337	$data = json_decode((string) $response->getBody(), true);
338	$this->assertEquals(0, count($data));
339	}
340
341	public function testGetLinksSearchTags()
342	{
343	// Single tag
344	$env = Environment::mock([
345	'REQUEST_METHOD' => 'GET',
346	'QUERY_STRING' => 'searchtags=dev',
347	]);
348	$request = Request::createFromEnvironment($env);
349	$response = $this->controller->getLinks($request, new Response());
350	$this->assertEquals(200, $response->getStatusCode());
351	$data = json_decode((string) $response->getBody(), true);
352	$this->assertEquals(2, count($data));
353	$this->assertEquals(0, $data[0]['id']);
354	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
355	$this->assertEquals(4, $data[1]['id']);
356	$this->assertEquals(self::NB_FIELDS_LINK, count($data[1]));
357
358	// Multitag + exclude
359	$env = Environment::mock([
360	'REQUEST_METHOD' => 'GET',
361	'QUERY_STRING' => 'searchtags=stuff+-gnu',
362	]);
363	$request = Request::createFromEnvironment($env);
364	$response = $this->controller->getLinks($request, new Response());
365	$this->assertEquals(200, $response->getStatusCode());
366	$data = json_decode((string) $response->getBody(), true);
367	$this->assertEquals(1, count($data));
368	$this->assertEquals(41, $data[0]['id']);
369	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
341527ba WE	370
	371	// wildcard: placeholder at the start
	372	$env = Environment::mock([
	373	'REQUEST_METHOD' => 'GET',
	374	'QUERY_STRING' => 'searchtags=*Tuff',
	375	]);
	376	$request = Request::createFromEnvironment($env);
	377	$response = $this->controller->getLinks($request, new Response());
	378	$this->assertEquals(200, $response->getStatusCode());
	379	$data = json_decode((string) $response->getBody(), true);
	380	$this->assertEquals(2, count($data));
	381	$this->assertEquals(41, $data[0]['id']);
	382
	383	// wildcard: placeholder at the end
	384	$env = Environment::mock([
	385	'REQUEST_METHOD' => 'GET',
	386	'QUERY_STRING' => 'searchtags=c*',
	387	]);
	388	$request = Request::createFromEnvironment($env);
	389	$response = $this->controller->getLinks($request, new Response());
	390	$this->assertEquals(200, $response->getStatusCode());
	391	$data = json_decode((string) $response->getBody(), true);
	392	$this->assertEquals(4, count($data));
	393	$this->assertEquals(6, $data[0]['id']);
	394
	395	// wildcard: placeholder at the middle
	396	$env = Environment::mock([
	397	'REQUEST_METHOD' => 'GET',
	398	'QUERY_STRING' => 'searchtags=w*b',
	399	]);
	400	$request = Request::createFromEnvironment($env);
	401	$response = $this->controller->getLinks($request, new Response());
	402	$this->assertEquals(200, $response->getStatusCode());
	403	$data = json_decode((string) $response->getBody(), true);
	404	$this->assertEquals(4, count($data));
	405	$this->assertEquals(6, $data[0]['id']);
	406
	407	// wildcard: match all
	408	$env = Environment::mock([
	409	'REQUEST_METHOD' => 'GET',
	410	'QUERY_STRING' => 'searchtags=*',
	411	]);
	412	$request = Request::createFromEnvironment($env);
	413	$response = $this->controller->getLinks($request, new Response());
	414	$this->assertEquals(200, $response->getStatusCode());
	415	$data = json_decode((string) $response->getBody(), true);
	416	$this->assertEquals(9, count($data));
	417	$this->assertEquals(41, $data[0]['id']);
	418
	419	// wildcard: optional ('*' does not need to expand)
	420	$env = Environment::mock([
	421	'REQUEST_METHOD' => 'GET',
	422	'QUERY_STRING' => 'searchtags=stuff',
	423	]);
	424	$request = Request::createFromEnvironment($env);
	425	$response = $this->controller->getLinks($request, new Response());
	426	$this->assertEquals(200, $response->getStatusCode());
	427	$data = json_decode((string) $response->getBody(), true);
	428	$this->assertEquals(2, count($data));
	429	$this->assertEquals(41, $data[0]['id']);
	430
	431	// wildcard: exclusions
	432	$env = Environment::mock([
	433	'REQUEST_METHOD' => 'GET',
434	'QUERY_STRING' => 'searchtags=a+-e',
435	]);
436	$request = Request::createFromEnvironment($env);
437	$response = $this->controller->getLinks($request, new Response());
438	$this->assertEquals(200, $response->getStatusCode());
439	$data = json_decode((string) $response->getBody(), true);
440	$this->assertEquals(1, count($data));
441	$this->assertEquals(41, $data[0]['id']); // finds '#hashtag' in descr.
442
443	// wildcard: exclude all
444	$env = Environment::mock([
445	'REQUEST_METHOD' => 'GET',
446	'QUERY_STRING' => 'searchtags=-*',
447	]);
448	$request = Request::createFromEnvironment($env);
449	$response = $this->controller->getLinks($request, new Response());
450	$this->assertEquals(200, $response->getStatusCode());
451	$data = json_decode((string) $response->getBody(), true);
452	$this->assertEquals(0, count($data));
c3b00963 A	453	}
	454
	455	/**
	456	* Test getLinks service with search tags+terms.
	457	*/
	458	public function testGetLinksSearchTermsAndTags()
	459	{
	460	$env = Environment::mock([
	461	'REQUEST_METHOD' => 'GET',
	462	'QUERY_STRING' => 'searchterm=poke&searchtags=dev',
	463	]);
	464	$request = Request::createFromEnvironment($env);
	465	$response = $this->controller->getLinks($request, new Response());
	466	$this->assertEquals(200, $response->getStatusCode());
	467	$data = json_decode((string) $response->getBody(), true);
	468	$this->assertEquals(1, count($data));
	469	$this->assertEquals(0, $data[0]['id']);
	470	$this->assertEquals(self::NB_FIELDS_LINK, count($data[0]));
	471	}
	472	}