SolrWritersTest::testComplexNegativeFilterQueryString() - Code Metrics - Inspection of "WIP: Add nested filtering via Criteria and Criteri..." - silverstripe/silverstripe-fulltextsearch - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#150)

unknown

created 2018-07-12 01:27 UTC

testComplexNegativeFilterQueryString() A

↳ Parent: SolrWritersTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	45
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	24
nc	1
nop	0
dl	0
loc	45
rs	9.536
c	0
b	0
f	0

<?php

namespace SilverStripe\FullTextSearch\Tests;

use \InvalidArgumentException;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\FullTextSearch\Search\Adapters\SolrSearchAdapter;
use SilverStripe\FullTextSearch\Search\Criteria\SearchCriteria;
use SilverStripe\FullTextSearch\Search\Criteria\SearchCriterion;
use SilverStripe\FullTextSearch\Search\Queries\SearchQuery;
use SilverStripe\FullTextSearch\Solr\Writers\SolrSearchQueryWriterBasic;
use SilverStripe\FullTextSearch\Solr\Writers\SolrSearchQueryWriterIn;
use SilverStripe\FullTextSearch\Solr\Writers\SolrSearchQueryWriterRange;
use SilverStripe\FullTextSearch\Tests\SolrIndexTest\SolrIndexTest_FakeIndex;

/**
 * Class SolrWritersTest
 * @package SilverStripe\FullTextSearch\Tests
 */
class SolrWritersTest extends SapphireTest
{
    public function testBasicEqualQueryString()
    {
        $criteria = new SearchCriterion('Title', 'Test', SearchCriterion::EQUAL);
        $writer = SolrSearchQueryWriterBasic::create();
        $expected = '+(Title:"Test")';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicNotEqualQueryString()
    {
        $criteria = new SearchCriterion('Title', 'Test', SearchCriterion::NOT_EQUAL);
        $writer = SolrSearchQueryWriterBasic::create();
        $expected = '-(Title:"Test")';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicInQueryString()
    {
        $criteria = new SearchCriterion('ID', [1,2,3], SearchCriterion::IN);
        $writer = SolrSearchQueryWriterIn::create();
        $expected = '+(ID:1 ID:2 ID:3)';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicNotInQueryString()
    {
        $criteria = new SearchCriterion('ID', [1,2,3], SearchCriterion::NOT_IN);
        $writer = SolrSearchQueryWriterIn::create();
        $expected = '-(ID:1 ID:2 ID:3)';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicGreaterEqualQueryString()
    {
        $criteria = new SearchCriterion('Stock', 2, SearchCriterion::GREATER_EQUAL);
        $writer = SolrSearchQueryWriterRange::create();
        $expected = '+(Stock:[2 TO *])';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicGreaterQueryString()
    {
        $criteria = new SearchCriterion('Stock', 2, SearchCriterion::GREATER_THAN);
        $writer = SolrSearchQueryWriterRange::create();
        $expected = '+(Stock:{2 TO *})';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicLessEqualQueryString()
    {
        $criteria = new SearchCriterion('Stock', 2, SearchCriterion::LESS_EQUAL);
        $writer = SolrSearchQueryWriterRange::create();
        $expected = '+(Stock:[* TO 2])';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicLessQueryString()
    {
        $criteria = new SearchCriterion('Stock', 2, SearchCriterion::LESS_THAN);
        $writer = SolrSearchQueryWriterRange::create();
        $expected = '+(Stock:{* TO 2})';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicIsNullQueryString()
    {
        $criteria = new SearchCriterion('Stock', null, SearchCriterion::ISNULL);
        $writer = SolrSearchQueryWriterRange::create();
        $expected = '-(Stock:[* TO *])';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testBasicIsNotNullQueryString()
    {
        $criteria = new SearchCriterion('Stock', null, SearchCriterion::ISNOTNULL);
        $writer = SolrSearchQueryWriterRange::create();
        $expected = '+(Stock:[* TO *])';

        $this->assertEquals($expected, $writer->generateQueryString($criteria));
    }

    public function testConjunction()
    {
        $adapter = new SolrSearchAdapter();

        $this->assertEquals(' AND ', $adapter->getConjunctionFor(SearchCriteria::CONJUNCTION_AND));
        $this->assertEquals(' OR ', $adapter->getConjunctionFor(SearchCriteria::CONJUNCTION_OR));
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testConjunctionFailure()
    {
        $adapter = new SolrSearchAdapter();
        $adapter->getConjunctionFor('FAIL');
    }

    /**
     * @throws \Exception
     */
    public function testComplexPositiveFilterQueryString()
    {
        $expected = '+((+(Page_TaxonomyTerms_ID:"Lego") AND +(Page_TaxonomyTerms_ID:"StarWars") AND +(Stock:[5 TO *]))';
        $expected .= ' OR (+(Page_TaxonomyTerms_ID:"Books") AND +(Page_TaxonomyTerms_ID:"HarryPotter")';
        $expected .= ' AND +(Stock:[1 TO *])))';

        $legoCriteria = SearchCriteria::create(
            'Page_TaxonomyTerms_ID',
            [
                'Lego',
            ],
            SearchCriterion::IN
        );

        $legoCriteria->addAnd(
            'Page_TaxonomyTerms_ID',
            [
                'StarWars',
            ],
            SearchCriterion::IN
        );

        $legoCriteria->addAnd(
            'Stock',
            5,
            SearchCriterion::GREATER_EQUAL
        );

        $booksCriteria = SearchCriteria::create(
            'Page_TaxonomyTerms_ID',
            [
                'Books',
            ],
            SearchCriterion::IN
        );

        $booksCriteria->addAnd(
            'Page_TaxonomyTerms_ID',
            [
                'HarryPotter',
            ],
            SearchCriterion::IN
        );

        $booksCriteria->addAnd(
            'Stock',
            1,
            SearchCriterion::GREATER_EQUAL
        );

        // Combine the two criteria with an `OR` conjunction
        $criteria = SearchCriteria::create($legoCriteria)->addOr($booksCriteria);

        $query = SearchQuery::create();
        $query->filterBy($criteria);

        $index = new SolrIndexTest_FakeIndex();

        $this->assertTrue(in_array($expected, $index->getFiltersComponent($query)));
    }

    /**
     * @throws \Exception
     */
    public function testComplexNegativeFilterQueryString()
    {
        $expected = '+((-(Page_TaxonomyTerms_ID:"Lego" Page_TaxonomyTerms_ID:"StarWars") AND +(Stock:[* TO 5]))';
        $expected .= ' OR (-(Page_TaxonomyTerms_ID:"Books" Page_TaxonomyTerms_ID:"HarryPotter")';
        $expected .= ' AND +(Stock:[* TO 2])))';

        $legoCriteria = SearchCriteria::create(
            'Page_TaxonomyTerms_ID',
            [
                'Lego',
                'StarWars',
            ],
            SearchCriterion::NOT_IN
        );

        $legoCriteria->addAnd(
            'Stock',
            5,
            SearchCriterion::LESS_EQUAL
        );

        $booksCriteria = SearchCriteria::create(
            'Page_TaxonomyTerms_ID',
            [
                'Books',
                'HarryPotter',
            ],
            SearchCriterion::NOT_IN
        );

        $booksCriteria->addAnd(
            'Stock',
            2,
            SearchCriterion::LESS_EQUAL
        );

        // Combine the two criteria with an `OR` conjunction
        $criteria = SearchCriteria::create($legoCriteria)->addOr($booksCriteria);

        $query = SearchQuery::create();
        $query->filterBy($criteria);

        $index = new SolrIndexTest_FakeIndex();

        $this->assertTrue(in_array($expected, $index->getFiltersComponent($query)));
    }
}


1			<?php
2
3			namespace SilverStripe\FullTextSearch\Tests;
4
5			use \InvalidArgumentException;
6			use SilverStripe\Dev\SapphireTest;
7			use SilverStripe\FullTextSearch\Search\Adapters\SolrSearchAdapter;
8			use SilverStripe\FullTextSearch\Search\Criteria\SearchCriteria;
9			use SilverStripe\FullTextSearch\Search\Criteria\SearchCriterion;
10			use SilverStripe\FullTextSearch\Search\Queries\SearchQuery;
11			use SilverStripe\FullTextSearch\Solr\Writers\SolrSearchQueryWriterBasic;
12			use SilverStripe\FullTextSearch\Solr\Writers\SolrSearchQueryWriterIn;
13			use SilverStripe\FullTextSearch\Solr\Writers\SolrSearchQueryWriterRange;
14			use SilverStripe\FullTextSearch\Tests\SolrIndexTest\SolrIndexTest_FakeIndex;
15
16			/**
17			* Class SolrWritersTest
18			* @package SilverStripe\FullTextSearch\Tests
19			*/
20			class SolrWritersTest extends SapphireTest
21			{
22			public function testBasicEqualQueryString()
23			{
24			$criteria = new SearchCriterion('Title', 'Test', SearchCriterion::EQUAL);
25			$writer = SolrSearchQueryWriterBasic::create();
26			$expected = '+(Title:"Test")';
27
28			$this->assertEquals($expected, $writer->generateQueryString($criteria));
29			}
30
31			public function testBasicNotEqualQueryString()
32			{
33			$criteria = new SearchCriterion('Title', 'Test', SearchCriterion::NOT_EQUAL);
34			$writer = SolrSearchQueryWriterBasic::create();
35			$expected = '-(Title:"Test")';
36
37			$this->assertEquals($expected, $writer->generateQueryString($criteria));
38			}
39
40			public function testBasicInQueryString()
41			{
42			$criteria = new SearchCriterion('ID', [1,2,3], SearchCriterion::IN);
43			$writer = SolrSearchQueryWriterIn::create();
44			$expected = '+(ID:1 ID:2 ID:3)';
45
46			$this->assertEquals($expected, $writer->generateQueryString($criteria));
47			}
48
49			public function testBasicNotInQueryString()
50			{
51			$criteria = new SearchCriterion('ID', [1,2,3], SearchCriterion::NOT_IN);
52			$writer = SolrSearchQueryWriterIn::create();
53			$expected = '-(ID:1 ID:2 ID:3)';
54
55			$this->assertEquals($expected, $writer->generateQueryString($criteria));
56			}
57
58			public function testBasicGreaterEqualQueryString()
59			{
60			$criteria = new SearchCriterion('Stock', 2, SearchCriterion::GREATER_EQUAL);
61			$writer = SolrSearchQueryWriterRange::create();
62			$expected = '+(Stock:[2 TO *])';
63
64			$this->assertEquals($expected, $writer->generateQueryString($criteria));
65			}
66
67			public function testBasicGreaterQueryString()
68			{
69			$criteria = new SearchCriterion('Stock', 2, SearchCriterion::GREATER_THAN);
70			$writer = SolrSearchQueryWriterRange::create();
71			$expected = '+(Stock:{2 TO *})';
72
73			$this->assertEquals($expected, $writer->generateQueryString($criteria));
74			}
75
76			public function testBasicLessEqualQueryString()
77			{
78			$criteria = new SearchCriterion('Stock', 2, SearchCriterion::LESS_EQUAL);
79			$writer = SolrSearchQueryWriterRange::create();
80			$expected = '+(Stock:[* TO 2])';
81
82			$this->assertEquals($expected, $writer->generateQueryString($criteria));
83			}
84
85			public function testBasicLessQueryString()
86			{
87			$criteria = new SearchCriterion('Stock', 2, SearchCriterion::LESS_THAN);
88			$writer = SolrSearchQueryWriterRange::create();
89			$expected = '+(Stock:{* TO 2})';
90
91			$this->assertEquals($expected, $writer->generateQueryString($criteria));
92			}
93
94			public function testBasicIsNullQueryString()
95			{
96			$criteria = new SearchCriterion('Stock', null, SearchCriterion::ISNULL);
97			$writer = SolrSearchQueryWriterRange::create();
98			$expected = '-(Stock:[* TO *])';
99
100			$this->assertEquals($expected, $writer->generateQueryString($criteria));
101			}
102
103			public function testBasicIsNotNullQueryString()
104			{
105			$criteria = new SearchCriterion('Stock', null, SearchCriterion::ISNOTNULL);
106			$writer = SolrSearchQueryWriterRange::create();
107			$expected = '+(Stock:[* TO *])';
108
109			$this->assertEquals($expected, $writer->generateQueryString($criteria));
110			}
111
112			public function testConjunction()
113			{
114			$adapter = new SolrSearchAdapter();
115
116			$this->assertEquals(' AND ', $adapter->getConjunctionFor(SearchCriteria::CONJUNCTION_AND));
117			$this->assertEquals(' OR ', $adapter->getConjunctionFor(SearchCriteria::CONJUNCTION_OR));
118			}
119
120			/**
121			* @expectedException InvalidArgumentException
122			*/
123			public function testConjunctionFailure()
124			{
125			$adapter = new SolrSearchAdapter();
126			$adapter->getConjunctionFor('FAIL');
127			}
128
129			/**
130			* @throws \Exception
131			*/
132			public function testComplexPositiveFilterQueryString()
133			{
134			$expected = '+((+(Page_TaxonomyTerms_ID:"Lego") AND +(Page_TaxonomyTerms_ID:"StarWars") AND +(Stock:[5 TO *]))';
135			$expected .= ' OR (+(Page_TaxonomyTerms_ID:"Books") AND +(Page_TaxonomyTerms_ID:"HarryPotter")';
136			$expected .= ' AND +(Stock:[1 TO *])))';
137
138			$legoCriteria = SearchCriteria::create(
139			'Page_TaxonomyTerms_ID',
140			[
141			'Lego',
142			],
143			SearchCriterion::IN
144			);
145
146			$legoCriteria->addAnd(
147			'Page_TaxonomyTerms_ID',
148			[
149			'StarWars',
150			],
151			SearchCriterion::IN
152			);
153
154			$legoCriteria->addAnd(
155			'Stock',
156			5,
157			SearchCriterion::GREATER_EQUAL
158			);
159
160			$booksCriteria = SearchCriteria::create(
161			'Page_TaxonomyTerms_ID',
162			[
163			'Books',
164			],
165			SearchCriterion::IN
166			);
167
168			$booksCriteria->addAnd(
169			'Page_TaxonomyTerms_ID',
170			[
171			'HarryPotter',
172			],
173			SearchCriterion::IN
174			);
175
176			$booksCriteria->addAnd(
177			'Stock',
178			1,
179			SearchCriterion::GREATER_EQUAL
180			);
181
182			// Combine the two criteria with an `OR` conjunction
183			$criteria = SearchCriteria::create($legoCriteria)->addOr($booksCriteria);
184
185			$query = SearchQuery::create();
186			$query->filterBy($criteria);
187
188			$index = new SolrIndexTest_FakeIndex();
189
190			$this->assertTrue(in_array($expected, $index->getFiltersComponent($query)));
191			}
192
193			/**
194			* @throws \Exception
195			*/
196			public function testComplexNegativeFilterQueryString()
197			{
198			$expected = '+((-(Page_TaxonomyTerms_ID:"Lego" Page_TaxonomyTerms_ID:"StarWars") AND +(Stock:[* TO 5]))';
199			$expected .= ' OR (-(Page_TaxonomyTerms_ID:"Books" Page_TaxonomyTerms_ID:"HarryPotter")';
200			$expected .= ' AND +(Stock:[* TO 2])))';
201
202			$legoCriteria = SearchCriteria::create(
203			'Page_TaxonomyTerms_ID',
204			[
205			'Lego',
206			'StarWars',
207			],
208			SearchCriterion::NOT_IN
209			);
210
211			$legoCriteria->addAnd(
212			'Stock',
213			5,
214			SearchCriterion::LESS_EQUAL
215			);
216
217			$booksCriteria = SearchCriteria::create(
218			'Page_TaxonomyTerms_ID',
219			[
220			'Books',
221			'HarryPotter',
222			],
223			SearchCriterion::NOT_IN
224			);
225
226			$booksCriteria->addAnd(
227			'Stock',
228			2,
229			SearchCriterion::LESS_EQUAL
230			);
231
232			// Combine the two criteria with an `OR` conjunction
233			$criteria = SearchCriteria::create($legoCriteria)->addOr($booksCriteria);
234
235			$query = SearchQuery::create();
236			$query->filterBy($criteria);
237
238			$index = new SolrIndexTest_FakeIndex();
239
240			$this->assertTrue(in_array($expected, $index->getFiltersComponent($query)));
241			}
242			}
243

silverstripe / silverstripe-fulltextsearch

Pull Request — master (#150)

testComplexNegativeFilterQueryString() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like