[github/shaarli/Shaarli.git] / tests / LinkFilterTest.php

<?php

require_once 'application/LinkFilter.php';

/**
 * Class LinkFilterTest.
 */
class LinkFilterTest extends PHPUnit_Framework_TestCase
{
    /**
     * @var LinkFilter instance.
     */
    protected static $linkFilter;

    /**
     * @var ReferenceLinkDB instance
     */
    protected static $refDB;

    /**
     * Instanciate linkFilter with ReferenceLinkDB data.
     */
    public static function setUpBeforeClass()
    {
        self::$refDB = new ReferenceLinkDB();
        self::$linkFilter = new LinkFilter(self::$refDB->getLinks());
    }

    /**
     * Blank filter.
     */
    public function testFilter()
    {
        $this->assertEquals(
            self::$refDB->countLinks(),
            count(self::$linkFilter->filter('', ''))
        );

        $this->assertEquals(
            self::$refDB->countLinks(),
            count(self::$linkFilter->filter('', '', 'all'))
        );

        $this->assertEquals(
            self::$refDB->countLinks(),
            count(self::$linkFilter->filter('', '', 'randomstr'))
        );

        // Private only.
        $this->assertEquals(
            self::$refDB->countPrivateLinks(),
            count(self::$linkFilter->filter('', '', false, 'private'))
        );

        // Public only.
        $this->assertEquals(
            self::$refDB->countPublicLinks(),
            count(self::$linkFilter->filter('', '', false, 'public'))
        );

        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, ''))
        );

        $this->assertEquals(
            self::$refDB->countUntaggedLinks(),
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, /*$request=*/'', /*$casesensitive=*/false, /*$visibility=*/'all', /*$untaggedonly=*/true))
        );

        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, ''))
        );
    }

    /**
     * Filter links using a tag
     */
    public function testFilterOneTag()
    {
        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false))
        );

        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'all'))
        );

        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'default-blabla'))
        );

        // Private only.
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'private'))
        );

        // Public only.
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'public'))
        );
    }

    /**
     * Filter links using a tag - case-sensitive
     */
    public function testFilterCaseSensitiveTag()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'mercurial', true))
        );

        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'Mercurial', true))
        );
    }

    /**
     * Filter links using a tag combination
     */
    public function testFilterMultipleTags()
    {
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'dev cartoon', false))
        );
    }

    /**
     * Filter links using a non-existent tag
     */
    public function testFilterUnknownTag()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'null', false))
        );
    }

    /**
     * Return links for a given day
     */
    public function testFilterDay()
    {
        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20121206'))
        );
    }

    /**
     * 404 - day not found
     */
    public function testFilterUnknownDay()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '19700101'))
        );
    }

    /**
     * Use an invalid date format
     * @expectedException              Exception
     * @expectedExceptionMessageRegExp /Invalid date format/
     */
    public function testFilterInvalidDayWithChars()
    {
        self::$linkFilter->filter(LinkFilter::$FILTER_DAY, 'Rainy day, dream away');
    }

    /**
     * Use an invalid date format
     * @expectedException              Exception
     * @expectedExceptionMessageRegExp /Invalid date format/
     */
    public function testFilterInvalidDayDigits()
    {
        self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20');
    }

    /**
     * Retrieve a link entry with its hash
     */
    public function testFilterSmallHash()
    {
        $links = self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'IuWvgA');

        $this->assertEquals(
            1,
            count($links)
        );

        $this->assertEquals(
            'MediaGoblin',
            $links[7]['title']
        );
    }

    /**
     * No link for this hash
     *
     * @expectedException LinkNotFoundException
     */
    public function testFilterUnknownSmallHash()
    {
        self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'Iblaah');
    }

    /**
     * Full-text search - no result found.
     */
    public function testFilterFullTextNoResult()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'azertyuiop'))
        );
    }

    /**
     * Full-text search - result from a link's URL
     */
    public function testFilterFullTextURL()
    {
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
        );
        
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars org'))
        );
    }

    /**
     * Full-text search - result from a link's title only
     */
    public function testFilterFullTextTitle()
    {
        // use miscellaneous cases
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'userfriendly -'))
        );
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'UserFriendly -'))
        );
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
        );

        // use miscellaneous case and offset
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'RFrIendL'))
        );
    }

    /**
     * Full-text search - result from the link's description only
     */
    public function testFilterFullTextDescription()
    {
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'publishing media'))
        );
        
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'mercurial w3c'))
        );
        
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '"free software"'))
        );        
    }

    /**
     * Full-text search - result from the link's tags only
     */
    public function testFilterFullTextTags()
    {
        $this->assertEquals(
            6,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web'))
        );

        $this->assertEquals(
            6,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'all'))
        );

        $this->assertEquals(
            6,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'bla'))
        );

        // Private only.
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'private'))
        );

        // Public only.
        $this->assertEquals(
            5,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'public'))
        );
    }

    /**
     * Full-text search - result set from mixed sources
     */
    public function testFilterFullTextMixed()
    {
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free software'))
        );
    }

    /**
     * Full-text search - test exclusion with '-'.
     */
    public function testExcludeSearch()
    {
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free -gnu'))
        );

        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '-revolution'))
        );
    }

    /**
     * Full-text search - test AND, exact terms and exclusion combined, across fields.
     */
    public function testMultiSearch()
    {
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"Free Software " stallman "read this" @website stuff'
            ))
        );

        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"free software " stallman "read this" -beard @website stuff'
            ))
        );
    }

    /**
     * Full-text search - make sure that exact search won't work across fields.
     */
    public function testSearchExactTermMultiFieldsKo()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"designer naming"'
            ))
        );

        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"designernaming"'
            ))
        );
    }

    /**
     * Tag search with exclusion.
     */
    public function testTagFilterWithExclusion()
    {
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'gnu -free'))
        );

        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, '-free'))
        );
    }

    /**
     * Test crossed search (terms + tags).
     */
    public function testFilterCrossedSearch()
    {
        $terms = '"Free Software " stallman "read this" @website stuff';
        $tags = 'free';
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array($tags, $terms)
            ))
        );
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array('', $terms)
            ))
        );
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array(false, 'PSR-2')
            ))
        );
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array($tags, '')
            ))
        );
        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                ''
            ))
        );
    }

    /**
     * Filter links by #hashtag.
     */
    public function testFilterByHashtag()
    {
        $hashtag = 'hashtag';
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG,
                $hashtag
            ))
        );

        $hashtag = 'private';
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG,
                $hashtag,
                false,
                'private'
            ))
        );
    }
}
Commit	Line	Data
822bffce A	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 LinkFilter instance.
	12	*/
	13	protected static $linkFilter;
	14
7f96d9ec A	15	/**
	16	* @var ReferenceLinkDB instance
	17	*/
	18	protected static $refDB;
	19
822bffce A	20	/**
	21	* Instanciate linkFilter with ReferenceLinkDB data.
	22	*/
	23	public static function setUpBeforeClass()
	24	{
7f96d9ec A	25	self::$refDB = new ReferenceLinkDB();
7f96d9ec A	26	self::$linkFilter = new LinkFilter(self::$refDB->getLinks());
822bffce A	27	}
	28
	29	/**
	30	* Blank filter.
	31	*/
	32	public function testFilter()
	33	{
	34	$this->assertEquals(
7f96d9ec	35	self::$refDB->countLinks(),
822bffce A	36	count(self::$linkFilter->filter('', ''))
	37	);
	38
7f96d9ec A	39	$this->assertEquals(
	40	self::$refDB->countLinks(),
	41	count(self::$linkFilter->filter('', '', 'all'))
	42	);
	43
	44	$this->assertEquals(
	45	self::$refDB->countLinks(),
	46	count(self::$linkFilter->filter('', '', 'randomstr'))
	47	);
	48
822bffce A	49	// Private only.
822bffce A	50	$this->assertEquals(
7f96d9ec A	51	self::$refDB->countPrivateLinks(),
	52	count(self::$linkFilter->filter('', '', false, 'private'))
	53	);
	54
	55	// Public only.
	56	$this->assertEquals(
	57	self::$refDB->countPublicLinks(),
	58	count(self::$linkFilter->filter('', '', false, 'public'))
822bffce	59	);
c51fae92 A	60
c51fae92 A	61	$this->assertEquals(
89baf23d	62	ReferenceLinkDB::$NB_LINKS_TOTAL,
c51fae92 A	63	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, ''))
	64	);
	65
7d86f40b A	66	$this->assertEquals(
7d86f40b A	67	self::$refDB->countUntaggedLinks(),
f210d94f	68	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, /$request=/'', /$casesensitive=/false, /$visibility=/'all', /$untaggedonly=/true))
7d86f40b A	69	);
7d86f40b A	70
c51fae92	71	$this->assertEquals(
89baf23d	72	ReferenceLinkDB::$NB_LINKS_TOTAL,
c51fae92 A	73	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, ''))
c51fae92 A	74	);
822bffce A	75	}
	76
	77	/**
	78	* Filter links using a tag
	79	*/
	80	public function testFilterOneTag()
	81	{
	82	$this->assertEquals(
	83	4,
	84	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false))
	85	);
	86
7f96d9ec A	87	$this->assertEquals(
	88	4,
	89	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'all'))
	90	);
	91
	92	$this->assertEquals(
	93	4,
	94	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'default-blabla'))
	95	);
	96
822bffce A	97	// Private only.
	98	$this->assertEquals(
	99	1,
7f96d9ec A	100	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'private'))
	101	);
	102
	103	// Public only.
	104	$this->assertEquals(
	105	3,
	106	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'public'))
822bffce A	107	);
	108	}
	109
	110	/**
	111	* Filter links using a tag - case-sensitive
	112	*/
	113	public function testFilterCaseSensitiveTag()
	114	{
	115	$this->assertEquals(
	116	0,
	117	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'mercurial', true))
	118	);
	119
	120	$this->assertEquals(
	121	1,
	122	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'Mercurial', true))
	123	);
	124	}
	125
	126	/**
	127	* Filter links using a tag combination
	128	*/
	129	public function testFilterMultipleTags()
	130	{
	131	$this->assertEquals(
	132	2,
	133	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'dev cartoon', false))
	134	);
	135	}
	136
	137	/**
	138	* Filter links using a non-existent tag
	139	*/
	140	public function testFilterUnknownTag()
	141	{
	142	$this->assertEquals(
	143	0,
	144	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'null', false))
	145	);
	146	}
	147
	148	/**
	149	* Return links for a given day
	150	*/
	151	public function testFilterDay()
	152	{
	153	$this->assertEquals(
7d86f40b	154	4,
822bffce A	155	count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20121206'))
	156	);
	157	}
	158
	159	/**
	160	* 404 - day not found
	161	*/
	162	public function testFilterUnknownDay()
	163	{
	164	$this->assertEquals(
	165	0,
	166	count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '19700101'))
	167	);
	168	}
	169
	170	/**
	171	* Use an invalid date format
	172	* @expectedException Exception
	173	* @expectedExceptionMessageRegExp /Invalid date format/
	174	*/
	175	public function testFilterInvalidDayWithChars()
	176	{
	177	self::$linkFilter->filter(LinkFilter::$FILTER_DAY, 'Rainy day, dream away');
	178	}
	179
	180	/**
	181	* Use an invalid date format
	182	* @expectedException Exception
	183	* @expectedExceptionMessageRegExp /Invalid date format/
	184	*/
	185	public function testFilterInvalidDayDigits()
	186	{
	187	self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20');
	188	}
	189
	190	/**
	191	* Retrieve a link entry with its hash
	192	*/
	193	public function testFilterSmallHash()
	194	{
	195	$links = self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'IuWvgA');
	196
	197	$this->assertEquals(
	198	1,
	199	count($links)
	200	);
	201
	202	$this->assertEquals(
	203	'MediaGoblin',
c3dfd899	204	$links[7]['title']
822bffce A	205	);
	206	}
	207
	208	/**
	209	* No link for this hash
528a6f8a A	210	*
528a6f8a A	211	* @expectedException LinkNotFoundException
822bffce A	212	*/
	213	public function testFilterUnknownSmallHash()
	214	{
528a6f8a	215	self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'Iblaah');
822bffce A	216	}
822bffce A	217
522b278b A	218	/**
	219	* Full-text search - no result found.
	220	*/
	221	public function testFilterFullTextNoResult()
	222	{
	223	$this->assertEquals(
	224	0,
	225	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'azertyuiop'))
	226	);
	227	}
	228
822bffce A	229	/**
	230	* Full-text search - result from a link's URL
	231	*/
	232	public function testFilterFullTextURL()
	233	{
	234	$this->assertEquals(
	235	2,
	236	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
	237	);
ebd8075a FV	238
	239	$this->assertEquals(
	240	2,
	241	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars org'))
	242	);
822bffce A	243	}
	244
	245	/**
	246	* Full-text search - result from a link's title only
	247	*/
	248	public function testFilterFullTextTitle()
	249	{
	250	// use miscellaneous cases
	251	$this->assertEquals(
	252	2,
	253	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'userfriendly -'))
	254	);
	255	$this->assertEquals(
	256	2,
	257	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'UserFriendly -'))
	258	);
	259	$this->assertEquals(
	260	2,
	261	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
	262	);
	263
	264	// use miscellaneous case and offset
	265	$this->assertEquals(
	266	2,
	267	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'RFrIendL'))
	268	);
	269	}
	270
	271	/**
	272	* Full-text search - result from the link's description only
	273	*/
	274	public function testFilterFullTextDescription()
	275	{
	276	$this->assertEquals(
	277	1,
ebd8075a FV	278	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'publishing media'))
	279	);
	280
	281	$this->assertEquals(
	282	1,
	283	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'mercurial w3c'))
822bffce	284	);
ebd8075a FV	285
ebd8075a FV	286	$this->assertEquals(
bedd176a	287	3,
ebd8075a FV	288	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '"free software"'))
ebd8075a FV	289	);
822bffce A	290	}
	291
	292	/**
	293	* Full-text search - result from the link's tags only
	294	*/
	295	public function testFilterFullTextTags()
	296	{
	297	$this->assertEquals(
7f96d9ec A	298	6,
	299	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web'))
	300	);
	301
	302	$this->assertEquals(
	303	6,
	304	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'all'))
	305	);
	306
	307	$this->assertEquals(
	308	6,
	309	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'bla'))
822bffce A	310	);
	311
	312	// Private only.
	313	$this->assertEquals(
	314	1,
7f96d9ec A	315	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'private'))
	316	);
	317
	318	// Public only.
	319	$this->assertEquals(
	320	5,
	321	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'public'))
822bffce A	322	);
	323	}
	324
	325	/**
	326	* Full-text search - result set from mixed sources
	327	*/
	328	public function testFilterFullTextMixed()
	329	{
	330	$this->assertEquals(
bedd176a	331	3,
822bffce A	332	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free software'))
	333	);
	334	}
21979ff1	335
bedd176a A	336	/**
	337	* Full-text search - test exclusion with '-'.
	338	*/
	339	public function testExcludeSearch()
	340	{
	341	$this->assertEquals(
	342	1,
522b278b	343	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free -gnu'))
bedd176a A	344	);
	345
	346	$this->assertEquals(
7d86f40b	347	ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
522b278b	348	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '-revolution'))
bedd176a A	349	);
	350	}
	351
	352	/**
522b278b	353	* Full-text search - test AND, exact terms and exclusion combined, across fields.
bedd176a A	354	*/
	355	public function testMultiSearch()
	356	{
	357	$this->assertEquals(
	358	2,
522b278b A	359	count(self::$linkFilter->filter(
	360	LinkFilter::$FILTER_TEXT,
	361	'"Free Software " stallman "read this" @website stuff'
	362	))
bedd176a A	363	);
	364
	365	$this->assertEquals(
	366	1,
522b278b A	367	count(self::$linkFilter->filter(
	368	LinkFilter::$FILTER_TEXT,
	369	'"free software " stallman "read this" -beard @website stuff'
	370	))
	371	);
	372	}
	373
	374	/**
	375	* Full-text search - make sure that exact search won't work across fields.
	376	*/
	377	public function testSearchExactTermMultiFieldsKo()
	378	{
	379	$this->assertEquals(
	380	0,
	381	count(self::$linkFilter->filter(
	382	LinkFilter::$FILTER_TEXT,
	383	'"designer naming"'
	384	))
	385	);
	386
	387	$this->assertEquals(
	388	0,
	389	count(self::$linkFilter->filter(
	390	LinkFilter::$FILTER_TEXT,
	391	'"designernaming"'
	392	))
bedd176a A	393	);
	394	}
	395
21979ff1 A	396	/**
	397	* Tag search with exclusion.
	398	*/
	399	public function testTagFilterWithExclusion()
	400	{
	401	$this->assertEquals(
	402	1,
	403	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'gnu -free'))
	404	);
	405
	406	$this->assertEquals(
7d86f40b	407	ReferenceLinkDB::$NB_LINKS_TOTAL - 1,
21979ff1 A	408	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, '-free'))
	409	);
	410	}
c51fae92 A	411
	412	/**
	413	* Test crossed search (terms + tags).
	414	*/
	415	public function testFilterCrossedSearch()
	416	{
	417	$terms = '"Free Software " stallman "read this" @website stuff';
	418	$tags = 'free';
	419	$this->assertEquals(
	420	1,
	421	count(self::$linkFilter->filter(
	422	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	423	array($tags, $terms)
	424	))
	425	);
	426	$this->assertEquals(
	427	2,
	428	count(self::$linkFilter->filter(
	429	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	430	array('', $terms)
	431	))
	432	);
	433	$this->assertEquals(
7d86f40b A	434	1,
	435	count(self::$linkFilter->filter(
	436	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	437	array(false, 'PSR-2')
	438	))
	439	);
	440	$this->assertEquals(
c51fae92 A	441	1,
	442	count(self::$linkFilter->filter(
	443	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	444	array($tags, '')
	445	))
	446	);
	447	$this->assertEquals(
89baf23d	448	ReferenceLinkDB::$NB_LINKS_TOTAL,
c51fae92 A	449	count(self::$linkFilter->filter(
	450	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	451	''
	452	))
	453	);
	454	}
9ccca401 A	455
	456	/**
	457	* Filter links by #hashtag.
	458	*/
	459	public function testFilterByHashtag()
	460	{
	461	$hashtag = 'hashtag';
	462	$this->assertEquals(
	463	3,
	464	count(self::$linkFilter->filter(
	465	LinkFilter::$FILTER_TAG,
	466	$hashtag
	467	))
	468	);
	469
	470	$hashtag = 'private';
	471	$this->assertEquals(
	472	1,
	473	count(self::$linkFilter->filter(
	474	LinkFilter::$FILTER_TAG,
	475	$hashtag,
	476	false,
7f96d9ec	477	'private'
9ccca401 A	478	))
	479	);
	480	}
822bffce	481	}