AbstractSelectQueryTest::testGroupConditionsAsOr() - Code Metrics - mdiyakov/DoctrineSolrBundle - Measure and Improve Code Quality continuously with Scrutinizer

AbstractSelectQueryTest::testGroupConditionsAsOr() A
last analyzed 2018-07-01 14:40 UTC

↳ Parent: AbstractSelectQueryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	28
rs	9.472
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Mdiyakov\DoctrineSolrBundle\Tests\Query\Select;

use Mdiyakov\DoctrineSolrBundle\Query\Select\AbstractSelectQuery;

class AbstractSelectQueryTest extends \PHPUnit_Framework_TestCase
{

    public function testAddConfigFieldOrWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $fieldName = 'type';
        $documentFieldName = 'discriminator';
        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\ConfigEntityField');
        $searchTerm = 'search';

        $schema->expects($this->any())
            ->method('getConfigFieldByName')
            ->with($fieldName)
            ->will($this->returnValue($field));
        ;

        $query->addConfigFieldOrWhere($fieldName, $searchTerm);
        $query->addConfigFieldOrWhere($fieldName, $searchTerm);
        $query->addConfigFieldOrWhere($fieldName, $searchTerm, true);
        $query->addConfigFieldOrWhere($fieldName, $searchTerm, true, true);
        $query->addConfigFieldOrWhere($fieldName, $searchTerm, false, true);

        $this->assertEquals(
            sprintf('(%1$s:"%2$s" OR %1$s:"%2$s" OR (*:* AND -%1$s:"%2$s") OR (*:* AND -%1$s:%2$s) OR %1$s:%2$s) AND ()',
                $documentFieldName,
                $searchTerm
            ),
            $query->getQueryString()
        );
    }

    public function testAddAndWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'title';
        $documentFieldName = 'd_title';
        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $searchTerm = 'search+-?*';
        $searchTermFiltered = 'search\+\-\?\*';
        $searchTermWildcardFiltered = 'search\+\-?*';

        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addAndWhere($entityFieldName, $searchTerm);
        $query->addAndWhere($entityFieldName, $searchTerm);
        $query->addAndWhere($entityFieldName, $searchTerm, true);
        $query->addAndWhere($entityFieldName, $searchTerm, false, true);
        $query->addAndWhere($entityFieldName, $searchTerm, true, true);
        $this->assertEquals(
            sprintf('(%1$s:"%2$s" AND %1$s:"%2$s" AND (*:* AND -%1$s:"%2$s") AND %1$s:%3$s AND (*:* AND -%1$s:%3$s)) AND ()',
                $documentFieldName,
                $searchTermFiltered,
                $searchTermWildcardFiltered
            ),
            $query->getQueryString()
        );
    }

    public function testReset()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'title';
        $documentFieldName = 'd_title';
        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $searchTerm = 'search';

        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addAndWhere($entityFieldName, $searchTerm);
        $query->addAndWhere($entityFieldName, $searchTerm);
        $query->addAndWhere($entityFieldName, $searchTerm, true);
        $query->addOrWhere($entityFieldName, $searchTerm, false, true);
        $query->addAndWhere($entityFieldName, $searchTerm, true, true);

        $client->expects($this->once())->method('createSelect')
            ->will($this->returnValue(
                $this->getMockBuilder('Solarium\QueryType\Select\Query\Query')->disableOriginalConstructor()->getMock()
            ));

        $query->reset();
        $this->assertEquals( '', $query->getQueryString());
    }

    public function testAddOrWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'title';
        $documentFieldName = 'd_title';
        $searchTerm = 'search';
        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');

        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addOrWhere($entityFieldName, $searchTerm);
        $query->addOrWhere($entityFieldName, $searchTerm);
        $query->addOrWhere($entityFieldName, $searchTerm, true);
        $query->addOrWhere($entityFieldName, $searchTerm, false, true);
        $query->addOrWhere($entityFieldName, $searchTerm, true, true);
        $this->assertEquals(
            sprintf('(%1$s:"%2$s" OR %1$s:"%2$s" OR (*:* AND -%1$s:"%2$s") OR %1$s:%2$s OR (*:* AND -%1$s:%2$s)) AND ()',
                $documentFieldName,
                $searchTerm
            ),
            $query->getQueryString()
        );
    }

    public function testAddOrWhereWithPriority()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'title';
        $documentFieldName = 'd_title';
        $searchTerm = 'search';
        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField', 10);

        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addOrWhere($entityFieldName, $searchTerm);
        $query->addOrWhere($entityFieldName, $searchTerm);
        $query->addOrWhere($entityFieldName, $searchTerm, true);
        $query->addOrWhere($entityFieldName, $searchTerm, false, true);
        $query->addOrWhere($entityFieldName, $searchTerm, true, true);

        $this->assertEquals(
            sprintf('(%1$s:("%2$s")^10 OR %1$s:("%2$s")^10 OR (*:* AND -%1$s:("%2$s")^10) OR %1$s:(%2$s)^10 OR (*:* AND -%1$s:(%2$s)^10)) AND ()',
                $documentFieldName,
                $searchTerm
            ),
            $query->getQueryString()
        );
    }


    public function testAddRangeOrWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'amount';
        $documentFieldName = 'd_amount';
        $from = 3;
        $to = 89;

        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');

        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addRangeOrWhere($entityFieldName, $from, $to);
        $query->addRangeOrWhere($entityFieldName, $from, $to, true);
        $query->addRangeOrWhere($entityFieldName, $from, $to, true, true);
        $query->addRangeOrWhere($entityFieldName, $from, $to, false, true);
        $query->addRangeOrWhere($entityFieldName, $from, $to, false, false , true);
        $query->addRangeOrWhere($entityFieldName, $from, $to, false, true, true);
        $this->assertEquals(
            sprintf('(%3$s:[%1$s TO %2$s] OR %3$s:{%1$s TO %2$s] OR %3$s:{%1$s TO %2$s} OR %3$s:[%1$s TO %2$s} OR (*:* AND -%3$s:[%1$s TO %2$s]) OR (*:* AND -%3$s:[%1$s TO %2$s})) AND ()',
                $from,
                $to,
                $documentFieldName
            ),
            $query->getQueryString()
        );
    }

    public function testAddRangeAndWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'amount';
        $documentFieldName = 'd_amount';
        $from = 3;
        $to = 89;

        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addRangeAndWhere($entityFieldName, $from, $to);
        $query->addRangeAndWhere($entityFieldName, $from, $to, true);
        $query->addRangeAndWhere($entityFieldName, $from, $to, true, true);
        $query->addRangeAndWhere($entityFieldName, $from, $to, false, true);
        $query->addRangeAndWhere($entityFieldName, $from, $to, false, false, true);
        $query->addRangeAndWhere($entityFieldName, $from, $to, false, true, true);
        $this->assertEquals(
            sprintf('(%3$s:[%1$s TO %2$s] AND %3$s:{%1$s TO %2$s] AND %3$s:{%1$s TO %2$s} AND %3$s:[%1$s TO %2$s} AND (*:* AND -%3$s:[%1$s TO %2$s]) AND (*:* AND -%3$s:[%1$s TO %2$s})) AND ()',
                $from,
                $to,
                $documentFieldName
            ),
            $query->getQueryString()
        );
    }


    public function testAddFuzzyAndWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'category';
        $documentFieldName = 'd_category';
        $searchTerm = 'search';
        $distance = 19;

        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addFuzzyAndWhere($entityFieldName, $searchTerm);
        $query->addFuzzyAndWhere($entityFieldName, $searchTerm);
        $query->addFuzzyAndWhere($entityFieldName, $searchTerm, true);
        $query->addFuzzyAndWhere($entityFieldName, $searchTerm, true, $distance);
        $this->assertEquals(
            sprintf('(%1$s:%2$s~1 AND %1$s:%2$s~1 AND (*:* AND -%1$s:%2$s~1) AND (*:* AND -%1$s:%2$s~19)) AND ()',
                $documentFieldName,
                $searchTerm,
                $distance
            ),
            $query->getQueryString()
        );
    }


    public function testAddFuzzyOrWhere()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'category';
        $documentFieldName = 'd_category';
        $searchTerm = 'search';
        $distance = 19;

        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addFuzzyOrWhere($entityFieldName, $searchTerm);
        $query->addFuzzyOrWhere($entityFieldName, $searchTerm);
        $query->addFuzzyOrWhere($entityFieldName, $searchTerm, true);
        $query->addFuzzyOrWhere($entityFieldName, $searchTerm, true, $distance);
        $this->assertEquals(
            sprintf('(%1$s:%2$s~1 OR %1$s:%2$s~1 OR (*:* AND -%1$s:%2$s~1) OR (*:* AND -%1$s:%2$s~19)) AND ()',
                $documentFieldName,
                $searchTerm,
                $distance
            ),
            $query->getQueryString()
        );
    }

    public function testGroupConditionsAsOr()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'category';
        $documentFieldName = 'd_category';
        $searchTerm = 'search';

        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addFuzzyOrWhere($entityFieldName, $searchTerm);
        $query->addAndWhere($entityFieldName, $searchTerm);
        $query->groupConditionsAsOr();
        $query->addOrWhere($entityFieldName, $searchTerm);

        $this->assertEquals(
            sprintf('((%1$s:%2$s~1 AND %1$s:"search") OR %1$s:"%2$s") AND ()',
                $documentFieldName,
                $searchTerm
            ),
            $query->getQueryString()
        );
    }


    public function testGroupConditionsAsAnd()
    {
        $schema = $this->getSchemaMock();
        $client = $this->getClientMock();
        $query = $this->getQueryMock($client, $schema);

        $entityFieldName = 'category';
        $documentFieldName = 'd_category';
        $searchTerm = 'search';

        $field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
        $schema->expects($this->any())
            ->method('getFieldByEntityFieldName')
            ->with($entityFieldName)
            ->will($this->returnValue($field));
        ;

        $query->addFuzzyOrWhere($entityFieldName, $searchTerm);
        $query->addAndWhere($entityFieldName, $searchTerm);
        $query->groupConditionsAsAnd();
        $query->addOrWhere($entityFieldName, $searchTerm);

        $this->assertEquals(
            sprintf('(%1$s:"%2$s" AND (%1$s:%2$s~1 AND %1$s:"search")) AND ()',
                $documentFieldName,
                $searchTerm
            ),
            $query->getQueryString()
        );
    }


    private function getSchemaMock()
    {
        $schema = $this->getMockBuilder('Mdiyakov\DoctrineSolrBundle\Schema\Schema')->disableOriginalConstructor()->getMock();
        $discriminatorField = $this->getMockBuilder('Mdiyakov\DoctrineSolrBundle\Schema\Field\ConfigEntityField')->disableOriginalConstructor()->getMock();
        $primaryKeyField = $this->getMockBuilder('Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\Field')->disableOriginalConstructor()->getMock();

        $schema->expects($this->at(0))->method('getDiscriminatorConfigField')
            ->will($this->returnValue($discriminatorField));

        $schema->expects($this->at(1))->method('getEntityPrimaryKeyField')
            ->will($this->returnValue($primaryKeyField));

        return $schema;
    }

    /**
     * @param $client
     * @param $schema
     * @return \PHPUnit_Framework_MockObject_MockObject|AbstractSelectQuery
     */
    private function getQueryMock($client, $schema)
    {
        /** @var AbstractSelectQuery|\PHPUnit_Framework_MockObject_MockObject $query */
        return $this->getMockForAbstractClass('Mdiyakov\DoctrineSolrBundle\Query\Select\AbstractSelectQuery', [$client, $schema]);
    }

    private function getClientMock()
    {
        $client = $this->getMockBuilder('Solarium\Client')->disableOriginalConstructor()->getMock();

        $client->expects($this->at(0))->method('createSelect')
            ->will($this->returnValue(
                $this->getMockBuilder('Solarium\QueryType\Select\Query\Query')->disableOriginalConstructor()->getMock()
            ));

        return $client;
    }

    /**
     * @param string $documentFieldName
     * @param string $fieldClass
     * @param int $priorityValue
     * @return \PHPUnit_Framework_MockObject_MockObject
     */
    private function getFieldMock($documentFieldName, $fieldClass, $priorityValue = null)
    {
        $field = $this->getMockBuilder($fieldClass)->disableOriginalConstructor()->getMock();
        $field->expects($this->any())
            ->method('getPriority')
            ->will($this->returnValue($priorityValue));

        $field->expects($this->any())
            ->method('getDocumentFieldName')
            ->will($this->returnValue($documentFieldName));

        return $field;
    }
}

1			<?php
2
3			namespace Mdiyakov\DoctrineSolrBundle\Tests\Query\Select;
4
5			use Mdiyakov\DoctrineSolrBundle\Query\Select\AbstractSelectQuery;
6
7			class AbstractSelectQueryTest extends \PHPUnit_Framework_TestCase
8			{
9
10			public function testAddConfigFieldOrWhere()
11			{
12			$schema = $this->getSchemaMock();
13			$client = $this->getClientMock();
14			$query = $this->getQueryMock($client, $schema);
15
16			$fieldName = 'type';
17			$documentFieldName = 'discriminator';
18			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\ConfigEntityField');
19			$searchTerm = 'search';
20
21			$schema->expects($this->any())
22			->method('getConfigFieldByName')
23			->with($fieldName)
24			->will($this->returnValue($field));
25			;
26
27			$query->addConfigFieldOrWhere($fieldName, $searchTerm);
28			$query->addConfigFieldOrWhere($fieldName, $searchTerm);
29			$query->addConfigFieldOrWhere($fieldName, $searchTerm, true);
30			$query->addConfigFieldOrWhere($fieldName, $searchTerm, true, true);
31			$query->addConfigFieldOrWhere($fieldName, $searchTerm, false, true);
32
33			$this->assertEquals(
34			sprintf('(%1$s:"%2$s" OR %1$s:"%2$s" OR (: AND -%1$s:"%2$s") OR (: AND -%1$s:%2$s) OR %1$s:%2$s) AND ()',
35			$documentFieldName,
36			$searchTerm
37			),
38			$query->getQueryString()
39			);
40			}
41
42			public function testAddAndWhere()
43			{
44			$schema = $this->getSchemaMock();
45			$client = $this->getClientMock();
46			$query = $this->getQueryMock($client, $schema);
47
48			$entityFieldName = 'title';
49			$documentFieldName = 'd_title';
50			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
51			$searchTerm = 'search+-?*';
52			$searchTermFiltered = 'search\+\-\?\*';
53			$searchTermWildcardFiltered = 'search\+\-?*';
54
55			$schema->expects($this->any())
56			->method('getFieldByEntityFieldName')
57			->with($entityFieldName)
58			->will($this->returnValue($field));
59			;
60
61			$query->addAndWhere($entityFieldName, $searchTerm);
62			$query->addAndWhere($entityFieldName, $searchTerm);
63			$query->addAndWhere($entityFieldName, $searchTerm, true);
64			$query->addAndWhere($entityFieldName, $searchTerm, false, true);
65			$query->addAndWhere($entityFieldName, $searchTerm, true, true);
66			$this->assertEquals(
67			sprintf('(%1$s:"%2$s" AND %1$s:"%2$s" AND (: AND -%1$s:"%2$s") AND %1$s:%3$s AND (: AND -%1$s:%3$s)) AND ()',
68			$documentFieldName,
69			$searchTermFiltered,
70			$searchTermWildcardFiltered
71			),
72			$query->getQueryString()
73			);
74			}
75
76			public function testReset()
77			{
78			$schema = $this->getSchemaMock();
79			$client = $this->getClientMock();
80			$query = $this->getQueryMock($client, $schema);
81
82			$entityFieldName = 'title';
83			$documentFieldName = 'd_title';
84			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
85			$searchTerm = 'search';
86
87			$schema->expects($this->any())
88			->method('getFieldByEntityFieldName')
89			->with($entityFieldName)
90			->will($this->returnValue($field));
91			;
92
93			$query->addAndWhere($entityFieldName, $searchTerm);
94			$query->addAndWhere($entityFieldName, $searchTerm);
95			$query->addAndWhere($entityFieldName, $searchTerm, true);
96			$query->addOrWhere($entityFieldName, $searchTerm, false, true);
97			$query->addAndWhere($entityFieldName, $searchTerm, true, true);
98
99			$client->expects($this->once())->method('createSelect')
100			->will($this->returnValue(
101			$this->getMockBuilder('Solarium\QueryType\Select\Query\Query')->disableOriginalConstructor()->getMock()
102			));
103
104			$query->reset();
105			$this->assertEquals( '', $query->getQueryString());
106			}
107
108			public function testAddOrWhere()
109			{
110			$schema = $this->getSchemaMock();
111			$client = $this->getClientMock();
112			$query = $this->getQueryMock($client, $schema);
113
114			$entityFieldName = 'title';
115			$documentFieldName = 'd_title';
116			$searchTerm = 'search';
117			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
118
119			$schema->expects($this->any())
120			->method('getFieldByEntityFieldName')
121			->with($entityFieldName)
122			->will($this->returnValue($field));
123			;
124
125			$query->addOrWhere($entityFieldName, $searchTerm);
126			$query->addOrWhere($entityFieldName, $searchTerm);
127			$query->addOrWhere($entityFieldName, $searchTerm, true);
128			$query->addOrWhere($entityFieldName, $searchTerm, false, true);
129			$query->addOrWhere($entityFieldName, $searchTerm, true, true);
130			$this->assertEquals(
131			sprintf('(%1$s:"%2$s" OR %1$s:"%2$s" OR (: AND -%1$s:"%2$s") OR %1$s:%2$s OR (: AND -%1$s:%2$s)) AND ()',
132			$documentFieldName,
133			$searchTerm
134			),
135			$query->getQueryString()
136			);
137			}
138
139			public function testAddOrWhereWithPriority()
140			{
141			$schema = $this->getSchemaMock();
142			$client = $this->getClientMock();
143			$query = $this->getQueryMock($client, $schema);
144
145			$entityFieldName = 'title';
146			$documentFieldName = 'd_title';
147			$searchTerm = 'search';
148			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField', 10);
149
150			$schema->expects($this->any())
151			->method('getFieldByEntityFieldName')
152			->with($entityFieldName)
153			->will($this->returnValue($field));
154			;
155
156			$query->addOrWhere($entityFieldName, $searchTerm);
157			$query->addOrWhere($entityFieldName, $searchTerm);
158			$query->addOrWhere($entityFieldName, $searchTerm, true);
159			$query->addOrWhere($entityFieldName, $searchTerm, false, true);
160			$query->addOrWhere($entityFieldName, $searchTerm, true, true);
161
162			$this->assertEquals(
163			sprintf('(%1$s:("%2$s")^10 OR %1$s:("%2$s")^10 OR (: AND -%1$s:("%2$s")^10) OR %1$s:(%2$s)^10 OR (: AND -%1$s:(%2$s)^10)) AND ()',
164			$documentFieldName,
165			$searchTerm
166			),
167			$query->getQueryString()
168			);
169			}
170
171
172			public function testAddRangeOrWhere()
173			{
174			$schema = $this->getSchemaMock();
175			$client = $this->getClientMock();
176			$query = $this->getQueryMock($client, $schema);
177
178			$entityFieldName = 'amount';
179			$documentFieldName = 'd_amount';
180			$from = 3;
181			$to = 89;
182
183			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
184
185			$schema->expects($this->any())
186			->method('getFieldByEntityFieldName')
187			->with($entityFieldName)
188			->will($this->returnValue($field));
189			;
190
191			$query->addRangeOrWhere($entityFieldName, $from, $to);
192			$query->addRangeOrWhere($entityFieldName, $from, $to, true);
193			$query->addRangeOrWhere($entityFieldName, $from, $to, true, true);
194			$query->addRangeOrWhere($entityFieldName, $from, $to, false, true);
195			$query->addRangeOrWhere($entityFieldName, $from, $to, false, false , true);
196			$query->addRangeOrWhere($entityFieldName, $from, $to, false, true, true);
197			$this->assertEquals(
198			sprintf('(%3$s:[%1$s TO %2$s] OR %3$s:{%1$s TO %2$s] OR %3$s:{%1$s TO %2$s} OR %3$s:[%1$s TO %2$s} OR (: AND -%3$s:[%1$s TO %2$s]) OR (: AND -%3$s:[%1$s TO %2$s})) AND ()',
199			$from,
200			$to,
201			$documentFieldName
202			),
203			$query->getQueryString()
204			);
205			}
206
207			public function testAddRangeAndWhere()
208			{
209			$schema = $this->getSchemaMock();
210			$client = $this->getClientMock();
211			$query = $this->getQueryMock($client, $schema);
212
213			$entityFieldName = 'amount';
214			$documentFieldName = 'd_amount';
215			$from = 3;
216			$to = 89;
217
218			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
219			$schema->expects($this->any())
220			->method('getFieldByEntityFieldName')
221			->with($entityFieldName)
222			->will($this->returnValue($field));
223			;
224
225			$query->addRangeAndWhere($entityFieldName, $from, $to);
226			$query->addRangeAndWhere($entityFieldName, $from, $to, true);
227			$query->addRangeAndWhere($entityFieldName, $from, $to, true, true);
228			$query->addRangeAndWhere($entityFieldName, $from, $to, false, true);
229			$query->addRangeAndWhere($entityFieldName, $from, $to, false, false, true);
230			$query->addRangeAndWhere($entityFieldName, $from, $to, false, true, true);
231			$this->assertEquals(
232			sprintf('(%3$s:[%1$s TO %2$s] AND %3$s:{%1$s TO %2$s] AND %3$s:{%1$s TO %2$s} AND %3$s:[%1$s TO %2$s} AND (: AND -%3$s:[%1$s TO %2$s]) AND (: AND -%3$s:[%1$s TO %2$s})) AND ()',
233			$from,
234			$to,
235			$documentFieldName
236			),
237			$query->getQueryString()
238			);
239			}
240
241
242			public function testAddFuzzyAndWhere()
243			{
244			$schema = $this->getSchemaMock();
245			$client = $this->getClientMock();
246			$query = $this->getQueryMock($client, $schema);
247
248			$entityFieldName = 'category';
249			$documentFieldName = 'd_category';
250			$searchTerm = 'search';
251			$distance = 19;
252
253			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
254			$schema->expects($this->any())
255			->method('getFieldByEntityFieldName')
256			->with($entityFieldName)
257			->will($this->returnValue($field));
258			;
259
260			$query->addFuzzyAndWhere($entityFieldName, $searchTerm);
261			$query->addFuzzyAndWhere($entityFieldName, $searchTerm);
262			$query->addFuzzyAndWhere($entityFieldName, $searchTerm, true);
263			$query->addFuzzyAndWhere($entityFieldName, $searchTerm, true, $distance);
264			$this->assertEquals(
265			sprintf('(%1$s:%2$s~1 AND %1$s:%2$s~1 AND (: AND -%1$s:%2$s~1) AND (: AND -%1$s:%2$s~19)) AND ()',
266			$documentFieldName,
267			$searchTerm,
268			$distance
269			),
270			$query->getQueryString()
271			);
272			}
273
274
275			public function testAddFuzzyOrWhere()
276			{
277			$schema = $this->getSchemaMock();
278			$client = $this->getClientMock();
279			$query = $this->getQueryMock($client, $schema);
280
281			$entityFieldName = 'category';
282			$documentFieldName = 'd_category';
283			$searchTerm = 'search';
284			$distance = 19;
285
286			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
287			$schema->expects($this->any())
288			->method('getFieldByEntityFieldName')
289			->with($entityFieldName)
290			->will($this->returnValue($field));
291			;
292
293			$query->addFuzzyOrWhere($entityFieldName, $searchTerm);
294			$query->addFuzzyOrWhere($entityFieldName, $searchTerm);
295			$query->addFuzzyOrWhere($entityFieldName, $searchTerm, true);
296			$query->addFuzzyOrWhere($entityFieldName, $searchTerm, true, $distance);
297			$this->assertEquals(
298			sprintf('(%1$s:%2$s~1 OR %1$s:%2$s~1 OR (: AND -%1$s:%2$s~1) OR (: AND -%1$s:%2$s~19)) AND ()',
299			$documentFieldName,
300			$searchTerm,
301			$distance
302			),
303			$query->getQueryString()
304			);
305			}
306
307			public function testGroupConditionsAsOr()
308			{
309			$schema = $this->getSchemaMock();
310			$client = $this->getClientMock();
311			$query = $this->getQueryMock($client, $schema);
312
313			$entityFieldName = 'category';
314			$documentFieldName = 'd_category';
315			$searchTerm = 'search';
316
317			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
318			$schema->expects($this->any())
319			->method('getFieldByEntityFieldName')
320			->with($entityFieldName)
321			->will($this->returnValue($field));
322			;
323
324			$query->addFuzzyOrWhere($entityFieldName, $searchTerm);
325			$query->addAndWhere($entityFieldName, $searchTerm);
326			$query->groupConditionsAsOr();
327			$query->addOrWhere($entityFieldName, $searchTerm);
328
329			$this->assertEquals(
330			sprintf('((%1$s:%2$s~1 AND %1$s:"search") OR %1$s:"%2$s") AND ()',
331			$documentFieldName,
332			$searchTerm
333			),
334			$query->getQueryString()
335			);
336			}
337
338
339			public function testGroupConditionsAsAnd()
340			{
341			$schema = $this->getSchemaMock();
342			$client = $this->getClientMock();
343			$query = $this->getQueryMock($client, $schema);
344
345			$entityFieldName = 'category';
346			$documentFieldName = 'd_category';
347			$searchTerm = 'search';
348
349			$field = $this->getFieldMock($documentFieldName, 'Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\StringField');
350			$schema->expects($this->any())
351			->method('getFieldByEntityFieldName')
352			->with($entityFieldName)
353			->will($this->returnValue($field));
354			;
355
356			$query->addFuzzyOrWhere($entityFieldName, $searchTerm);
357			$query->addAndWhere($entityFieldName, $searchTerm);
358			$query->groupConditionsAsAnd();
359			$query->addOrWhere($entityFieldName, $searchTerm);
360
361			$this->assertEquals(
362			sprintf('(%1$s:"%2$s" AND (%1$s:%2$s~1 AND %1$s:"search")) AND ()',
363			$documentFieldName,
364			$searchTerm
365			),
366			$query->getQueryString()
367			);
368			}
369
370
371			private function getSchemaMock()
372			{
373			$schema = $this->getMockBuilder('Mdiyakov\DoctrineSolrBundle\Schema\Schema')->disableOriginalConstructor()->getMock();
374			$discriminatorField = $this->getMockBuilder('Mdiyakov\DoctrineSolrBundle\Schema\Field\ConfigEntityField')->disableOriginalConstructor()->getMock();
375			$primaryKeyField = $this->getMockBuilder('Mdiyakov\DoctrineSolrBundle\Schema\Field\Entity\Field')->disableOriginalConstructor()->getMock();
376
377			$schema->expects($this->at(0))->method('getDiscriminatorConfigField')
378			->will($this->returnValue($discriminatorField));
379
380			$schema->expects($this->at(1))->method('getEntityPrimaryKeyField')
381			->will($this->returnValue($primaryKeyField));
382
383			return $schema;
384			}
385
386			/**
387			* @param $client
388			* @param $schema
389			* @return \PHPUnit_Framework_MockObject_MockObject\|AbstractSelectQuery
390			*/
391			private function getQueryMock($client, $schema)
392			{
393			/** @var AbstractSelectQuery\|\PHPUnit_Framework_MockObject_MockObject $query */
394			return $this->getMockForAbstractClass('Mdiyakov\DoctrineSolrBundle\Query\Select\AbstractSelectQuery', [$client, $schema]);
395			}
396
397			private function getClientMock()
398			{
399			$client = $this->getMockBuilder('Solarium\Client')->disableOriginalConstructor()->getMock();
400
401			$client->expects($this->at(0))->method('createSelect')
402			->will($this->returnValue(
403			$this->getMockBuilder('Solarium\QueryType\Select\Query\Query')->disableOriginalConstructor()->getMock()
404			));
405
406			return $client;
407			}
408
409			/**
410			* @param string $documentFieldName
411			* @param string $fieldClass
412			* @param int $priorityValue
413			* @return \PHPUnit_Framework_MockObject_MockObject
414			*/
415			private function getFieldMock($documentFieldName, $fieldClass, $priorityValue = null)
416			{
417			$field = $this->getMockBuilder($fieldClass)->disableOriginalConstructor()->getMock();
418			$field->expects($this->any())
419			->method('getPriority')
420			->will($this->returnValue($priorityValue));
421
422			$field->expects($this->any())
423			->method('getDocumentFieldName')
424			->will($this->returnValue($documentFieldName));
425
426			return $field;
427			}
428			}

mdiyakov / DoctrineSolrBundle

AbstractSelectQueryTest::testGroupConditionsAsOr() A last analyzed 2018-07-01 14:40 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AbstractSelectQueryTest::testGroupConditionsAsOr() A
last analyzed 2018-07-01 14:40 UTC