QueryBuilderFactoryTest::testCanBuildQueriesUsingOrOperator() - Code Metrics - Inspection of "fix scrutinizer configuration" - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 2.2 (#98)

by Simone

created 2018-01-18 15:55 UTC

QueryBuilderFactoryTest::testCanBuildQueriesUsingOrOperator() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
c	2
b	1
f	0
dl	0
loc	26
rs	8.8571
cc	1
eloc	22
nc	1
nop	0

<?php

namespace Mado\QueryBundle\Tests\Objects;

use Mado\QueryBundle\Queries\QueryBuilderFactory;
use PHPUnit\Framework\TestCase;

class QueryBuilderFactoryTest extends TestCase
{
    public function setUp()
    {
        $this->manager = \Doctrine\ORM\EntityManager::create(array(
            'driver' => 'pdo_sqlite',
            'path' => __DIR__ . '/../../data/db.sqlite',
        ),
        \Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration(
            array(__DIR__."/src"),
            true
        ));
    }

    public function testProvideOneSingleResult()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields([ 'id' ]);
        $queryBuilderFactory->setAndFilters([ 'id|eq' => 33 ]);
        $queryBuilderFactory->createQueryBuilder(MySimpleEntity::class, 'e');
        $queryBuilderFactory->filter();

        $doctrineQueryBuilder = $queryBuilderFactory->getQueryBuilder();
        $doctrineQueryBuilder->setMaxResults(1);

        $this->assertEquals(
            "SELECT m0_.id AS id_0 FROM MySimpleEntity m0_ WHERE m0_.id = ? LIMIT 1",
            $doctrineQueryBuilder->getQuery()->getSql()
        );
    }

    public function testSampleQueryMakedWithQueryBuilderFactory()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields([ 'id' ]);
        $queryBuilderFactory->setAndFilters([ 'id|eq' => 33 ]);
        $queryBuilderFactory->createQueryBuilder(MySimpleEntity::class, 'e');
        $queryBuilderFactory->filter();

        $this->assertEquals(
            "SELECT m0_.id AS id_0 FROM MySimpleEntity m0_ WHERE m0_.id = ?",
            $queryBuilderFactory->getQueryBuilder()->getQuery()->getSql()
        );

        $this->assertContains(
            "SELECT e FROM Mado\QueryBundle\Tests\Objects\MySimpleEntity e WHERE e.id = :field_id",
            $queryBuilderFactory->getQueryBuilder()->getQuery()->getDql()
        );
    }

    public function testOneToManyQueryMakedHandly()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields([ 'id' ]);
        $queryBuilderFactory->setRel([ 'group' ]);
        $queryBuilderFactory->setAndFilters([
            '_embedded.group.name|contains|1' => 'ad',
            '_embedded.group.name|contains|2' => 'ns',
            '_embedded.group.name|contains|3' => 'dm',
            '_embedded.group.name|contains|4' => 'mi',
        ]);
        $queryBuilderFactory->createQueryBuilder(User::class, 'e');
        $queryBuilderFactory->filter();

        $this->assertEquals(
            "SELECT" .
            " u0_.id AS id_0," .
            " u0_.username AS username_1," .
            " u0_.group_id AS group_id_2 " .
            "FROM User u0_ " .
            "INNER JOIN Group g1_ ON u0_.group_id = g1_.id " .
            "WHERE g1_.name LIKE ? " .
            "AND g1_.name LIKE ? " .
            "AND g1_.name LIKE ? " .
            "AND g1_.name LIKE ?",
            $queryBuilderFactory->getQueryBuilder()->getQuery()->getSql()
        );
    }

    public function testFiltersMustContainsAlsoFieldEquality()
    {
        $factory = new QueryBuilderFactory($this->manager);

        $validFilters = [
            'eq',
            'neq',
            'gt',
            'gte',
            'lt',
            'lte',
            'startswith',
            'contains',
            'notcontains',
            'endswith',
            'list',
            'nlist',
            'field_eq',
        ];

        $this->assertEquals(
            $validFilters,
            $factory->getAvailableFilters()
        );
    }

    public function testGetFields()
    {
        $fields = ['id'];
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields($fields);
        $fieldsReturned = $queryBuilderFactory->getFields();

        $this->assertEquals($fields, $fieldsReturned);
    }

    /**
     * @expectedException \RuntimeException
     */
    public function testGetFieldsThrowExceptionIfNull()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->getFields();
    }

    public function testSetOrFilters()
    {
        $filters = ['id'];
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setOrFilters($filters);

        $this->assertAttributeEquals($filters, 'orFilters', $queryBuilderFactory);
    }

    public function testGetOrFilters()
    {
        $filters = ['id'];
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setOrFilters($filters);
        $fieldsReturned = $queryBuilderFactory->getOrFilters();

        $this->assertEquals($filters, $fieldsReturned);
    }

    public function testSetSorting()
    {
        $sorting = ['id'];
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setSorting($sorting);

        $this->assertAttributeEquals($sorting, 'sorting', $queryBuilderFactory);
    }

    public function testGetFilters()
    {
        $filters = ['id'];
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setAndFilters($filters);
        $fieldsReturned = $queryBuilderFactory->getAndFilters();

        $this->assertEquals($filters, $fieldsReturned);
    }

    /**
     * @expectedException Mado\QueryBundle\Component\Meta\Exceptions\UnInitializedQueryBuilderException
     */
    public function testGetQueryBuilderThrowExceptionIfNull()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->getQueryBuilder();
    }

    public function testGetRel()
    {
        $rel = 'foo';
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setRel($rel);
        $relReturned = $queryBuilderFactory->getRel();

        $this->assertEquals($rel, $relReturned);
    }

    public function testSetPrinting()
    {
        $print = 'foo';
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setPrinting($print);

        $this->assertAttributeEquals($print, 'printing', $queryBuilderFactory);
    }

    public function testGetPrinting()
    {
        $print = 'foo';
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setPrinting($print);
        $printReturned = $queryBuilderFactory->getPrinting();

        $this->assertEquals($print, $printReturned);
    }

    public function testSetPage()
    {
        $page = 100;
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setPage($page);

        $this->assertAttributeEquals($page, 'page', $queryBuilderFactory);
    }

    public function testGetPage()
    {
        $page = 100;
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setPage($page);
        $pageReturned = $queryBuilderFactory->getPage();

        $this->assertEquals($page, $pageReturned);
    }

    public function testSetPageLength()
    {
        $pageLength = 100;
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setPageLength($pageLength);

        $this->assertAttributeEquals($pageLength, 'pageLength', $queryBuilderFactory);
    }

    public function testGetPageLength()
    {
        $pageLength = 100;
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setPageLength($pageLength);
        $pageLengthReturned = $queryBuilderFactory->getPageLength();

        $this->assertEquals($pageLength, $pageLengthReturned);
    }

    public function testSetSelect()
    {
        $select = 'foo';
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setSelect($select);

        $this->assertAttributeEquals($select, 'select', $queryBuilderFactory);
    }

    public function testGetSelect()
    {
        $select = 'foo';
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setSelect($select);
        $selectReturned = $queryBuilderFactory->getSelect();

        $this->assertEquals($select, $selectReturned);
    }

    public function testCanBuildQueriesUsingOrOperator()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields([ 'id' ]);
        $queryBuilderFactory->setRel([ 'group' ]);
        $queryBuilderFactory->setOrFilters([
            '_embedded.group.name|contains|1' => 'ad',
            '_embedded.group.name|contains|2' => 'ns',
            '_embedded.group.name|contains|3' => 'dm',
            '_embedded.group.name|contains|4' => 'mi',
        ]);
        $queryBuilderFactory->createQueryBuilder(User::class, 'e');
        $queryBuilderFactory->filter();

        $this->assertEquals(
            "SELECT" .
            " u0_.id AS id_0," .
            " u0_.username AS username_1," .
            " u0_.group_id AS group_id_2 " .
            "FROM User u0_ " .
            "INNER JOIN Group g1_ ON u0_.group_id = g1_.id " .
            "WHERE g1_.name LIKE ? " .
            "OR g1_.name LIKE ? " .
            "OR g1_.name LIKE ? " .
            "OR g1_.name LIKE ?",
            $queryBuilderFactory->getQueryBuilder()->getQuery()->getSql()
        );
    }

    /** @expectedException \Mado\QueryBundle\Exceptions\MissingFiltersException */
    public function testThrowMissingFiltersExceptionsWheneverFiltersAreMissing()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->filter();
    }

    /**
     * @expectedException        \RuntimeException
     * @expectedExceptionMessage Oops! Fields are not defined
     */
    public function testCantSortWithoutFields()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->sort();
    }

    /**
     * @expectedException        \RuntimeException
     * @expectedExceptionMessage Oops! Sorting is not defined
     */
    public function testThrowExceptionWheneverSortIsRequestedWithoutSorting()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields(['foo', 'bar']);
        $queryBuilderFactory->sort();
    }

    /**
     * @expectedException        \RuntimeException
     * @expectedExceptionMessage Oops! QueryBuilder was never initialized
     */
    public function testThrowExceptionWhenQueryBuilderIsNotInitialized()
    {
        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields(['foo', 'bar']);
        $queryBuilderFactory->setSorting(['foo' => 'bar']);
        $queryBuilderFactory->sort();
    }

    public function testApplySortingJustForEntityFields()
    {
        $this->queryBuilder = $this
            ->getMockBuilder('Doctrine\ORM\QueryBuilder')
            ->disableOriginalConstructor()
            ->getMock();
        $this->queryBuilder->expects($this->once())
            ->method('select')
            ->with('alias')
            ->willReturn($this->queryBuilder);
        $this->queryBuilder->expects($this->once())
            ->method('from')
            ->with('EntityName')
            ->willReturn($this->queryBuilder);

        $this->manager = $this
            ->getMockBuilder('Doctrine\ORM\EntityManager')
            ->disableOriginalConstructor()
            ->getMock();
        $this->manager->expects($this->once())
            ->method('createQueryBuilder')
            ->with('EntityName')
            ->willReturn($this->queryBuilder);

        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields(['foo', 'bar']);
        $queryBuilderFactory->setSorting(['foo' => 'bar']);
        $queryBuilderFactory->createQueryBuilder('EntityName', 'alias');
        $queryBuilderFactory->sort();
    }

    public function testApplySortingAlsoOnRelationsField()
    {
        $this->queryBuilder = $this
            ->getMockBuilder('Doctrine\ORM\QueryBuilder')
            ->disableOriginalConstructor()
            ->getMock();
        $this->queryBuilder->expects($this->once())
            ->method('select')
            ->with('alias')
            ->willReturn($this->queryBuilder);
        $this->queryBuilder->expects($this->once())
            ->method('from')
            ->with('EntityName')
            ->willReturn($this->queryBuilder);
        $this->queryBuilder->expects($this->once())
            ->method('join')
            ->with('alias.ciao', 'table_fizz');

        $this->metadata = $this
            ->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadata')
            ->disableOriginalConstructor()
            ->getMock();
        $this->metadata->expects($this->once())
            ->method('hasAssociation')
            ->with('fizz')
            ->willReturn(true);
        $this->metadata->expects($this->once())
            ->method('getAssociationMapping')
            ->with('fizz')
            ->willReturn([
                'fieldName'    => 'ciao',
                'targetEntity' => 'someEntityName',
            ]);

        $this->manager = $this
            ->getMockBuilder('Doctrine\ORM\EntityManager')
            ->disableOriginalConstructor()
            ->getMock();
        $this->manager->expects($this->once())
            ->method('createQueryBuilder')
            ->with('EntityName')
            ->willReturn($this->queryBuilder);
        $this->manager->expects($this->once())
            ->method('getClassMetadata')
            ->with('EntityName')
            ->willReturn($this->metadata);

        $queryBuilderFactory = new QueryBuilderFactory($this->manager);
        $queryBuilderFactory->setFields(['foo', 'bar']);
        $queryBuilderFactory->setSorting(['_embedded.fizz.buzz' => 'bar']);
        $queryBuilderFactory->createQueryBuilder('EntityName', 'alias');
        $queryBuilderFactory->sort();
    }
}

/** @Entity() */
class MySimpleEntity
{
    /** @Id @Column(type="integer") */
    private $id;
}

/** @Entity() */
class User
{
    /** @Id @Column(type="integer") */
    private $id;
    /** @Column(type="string") */
    private $username;
    /** @ManyToOne(targetEntity="Group", inversedBy="member") */
    private $group;
}

/** @Entity() */
class Group
{
    /** @Id @Column(type="integer") */
    private $id;
    /** @Column(type="string") */
    private $name;
    /** @OneToMany(targetEntity="User", mappedBy="member") */
    private $members;
}


1			<?php
2
3			namespace Mado\QueryBundle\Tests\Objects;
4
5			use Mado\QueryBundle\Queries\QueryBuilderFactory;
6			use PHPUnit\Framework\TestCase;
7
8			class QueryBuilderFactoryTest extends TestCase
9			{
10			public function setUp()
11			{
12			$this->manager = \Doctrine\ORM\EntityManager::create(array(
13			'driver' => 'pdo_sqlite',
14			'path' => __DIR__ . '/../../data/db.sqlite',
15			),
16			\Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration(
17			array(__DIR__."/src"),
18			true
19			));
20			}
21
22			public function testProvideOneSingleResult()
23			{
24			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
25			$queryBuilderFactory->setFields([ 'id' ]);
26			$queryBuilderFactory->setAndFilters([ 'id\|eq' => 33 ]);
27			$queryBuilderFactory->createQueryBuilder(MySimpleEntity::class, 'e');
28			$queryBuilderFactory->filter();
29
30			$doctrineQueryBuilder = $queryBuilderFactory->getQueryBuilder();
31			$doctrineQueryBuilder->setMaxResults(1);
32
33			$this->assertEquals(
34			"SELECT m0_.id AS id_0 FROM MySimpleEntity m0_ WHERE m0_.id = ? LIMIT 1",
35			$doctrineQueryBuilder->getQuery()->getSql()
36			);
37			}
38
39			public function testSampleQueryMakedWithQueryBuilderFactory()
40			{
41			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
42			$queryBuilderFactory->setFields([ 'id' ]);
43			$queryBuilderFactory->setAndFilters([ 'id\|eq' => 33 ]);
44			$queryBuilderFactory->createQueryBuilder(MySimpleEntity::class, 'e');
45			$queryBuilderFactory->filter();
46
47			$this->assertEquals(
48			"SELECT m0_.id AS id_0 FROM MySimpleEntity m0_ WHERE m0_.id = ?",
49			$queryBuilderFactory->getQueryBuilder()->getQuery()->getSql()
50			);
51
52			$this->assertContains(
53			"SELECT e FROM Mado\QueryBundle\Tests\Objects\MySimpleEntity e WHERE e.id = :field_id",
54			$queryBuilderFactory->getQueryBuilder()->getQuery()->getDql()
55			);
56			}
57
58			public function testOneToManyQueryMakedHandly()
59			{
60			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
61			$queryBuilderFactory->setFields([ 'id' ]);
62			$queryBuilderFactory->setRel([ 'group' ]);
63			$queryBuilderFactory->setAndFilters([
64			'_embedded.group.name\|contains\|1' => 'ad',
65			'_embedded.group.name\|contains\|2' => 'ns',
66			'_embedded.group.name\|contains\|3' => 'dm',
67			'_embedded.group.name\|contains\|4' => 'mi',
68			]);
69			$queryBuilderFactory->createQueryBuilder(User::class, 'e');
70			$queryBuilderFactory->filter();
71
72			$this->assertEquals(
73			"SELECT" .
74			" u0_.id AS id_0," .
75			" u0_.username AS username_1," .
76			" u0_.group_id AS group_id_2 " .
77			"FROM User u0_ " .
78			"INNER JOIN Group g1_ ON u0_.group_id = g1_.id " .
79			"WHERE g1_.name LIKE ? " .
80			"AND g1_.name LIKE ? " .
81			"AND g1_.name LIKE ? " .
82			"AND g1_.name LIKE ?",
83			$queryBuilderFactory->getQueryBuilder()->getQuery()->getSql()
84			);
85			}
86
87			public function testFiltersMustContainsAlsoFieldEquality()
88			{
89			$factory = new QueryBuilderFactory($this->manager);
90
91			$validFilters = [
92			'eq',
93			'neq',
94			'gt',
95			'gte',
96			'lt',
97			'lte',
98			'startswith',
99			'contains',
100			'notcontains',
101			'endswith',
102			'list',
103			'nlist',
104			'field_eq',
105			];
106
107			$this->assertEquals(
108			$validFilters,
109			$factory->getAvailableFilters()
110			);
111			}
112
113			public function testGetFields()
114			{
115			$fields = ['id'];
116			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
117			$queryBuilderFactory->setFields($fields);
118			$fieldsReturned = $queryBuilderFactory->getFields();
119
120			$this->assertEquals($fields, $fieldsReturned);
121			}
122
123			/**
124			* @expectedException \RuntimeException
125			*/
126			public function testGetFieldsThrowExceptionIfNull()
127			{
128			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
129			$queryBuilderFactory->getFields();
130			}
131
132			public function testSetOrFilters()
133			{
134			$filters = ['id'];
135			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
136			$queryBuilderFactory->setOrFilters($filters);
137
138			$this->assertAttributeEquals($filters, 'orFilters', $queryBuilderFactory);
139			}
140
141			public function testGetOrFilters()
142			{
143			$filters = ['id'];
144			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
145			$queryBuilderFactory->setOrFilters($filters);
146			$fieldsReturned = $queryBuilderFactory->getOrFilters();
147
148			$this->assertEquals($filters, $fieldsReturned);
149			}
150
151			public function testSetSorting()
152			{
153			$sorting = ['id'];
154			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
155			$queryBuilderFactory->setSorting($sorting);
156
157			$this->assertAttributeEquals($sorting, 'sorting', $queryBuilderFactory);
158			}
159
160			public function testGetFilters()
161			{
162			$filters = ['id'];
163			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
164			$queryBuilderFactory->setAndFilters($filters);
165			$fieldsReturned = $queryBuilderFactory->getAndFilters();
166
167			$this->assertEquals($filters, $fieldsReturned);
168			}
169
170			/**
171			* @expectedException Mado\QueryBundle\Component\Meta\Exceptions\UnInitializedQueryBuilderException
172			*/
173			public function testGetQueryBuilderThrowExceptionIfNull()
174			{
175			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
176			$queryBuilderFactory->getQueryBuilder();
177			}
178
179			public function testGetRel()
180			{
181			$rel = 'foo';
182			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
183			$queryBuilderFactory->setRel($rel);
184			$relReturned = $queryBuilderFactory->getRel();
185
186			$this->assertEquals($rel, $relReturned);
187			}
188
189			public function testSetPrinting()
190			{
191			$print = 'foo';
192			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
193			$queryBuilderFactory->setPrinting($print);
194
195			$this->assertAttributeEquals($print, 'printing', $queryBuilderFactory);
196			}
197
198			public function testGetPrinting()
199			{
200			$print = 'foo';
201			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
202			$queryBuilderFactory->setPrinting($print);
203			$printReturned = $queryBuilderFactory->getPrinting();
204
205			$this->assertEquals($print, $printReturned);
206			}
207
208			public function testSetPage()
209			{
210			$page = 100;
211			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
212			$queryBuilderFactory->setPage($page);
213
214			$this->assertAttributeEquals($page, 'page', $queryBuilderFactory);
215			}
216
217			public function testGetPage()
218			{
219			$page = 100;
220			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
221			$queryBuilderFactory->setPage($page);
222			$pageReturned = $queryBuilderFactory->getPage();
223
224			$this->assertEquals($page, $pageReturned);
225			}
226
227			public function testSetPageLength()
228			{
229			$pageLength = 100;
230			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
231			$queryBuilderFactory->setPageLength($pageLength);
232
233			$this->assertAttributeEquals($pageLength, 'pageLength', $queryBuilderFactory);
234			}
235
236			public function testGetPageLength()
237			{
238			$pageLength = 100;
239			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
240			$queryBuilderFactory->setPageLength($pageLength);
241			$pageLengthReturned = $queryBuilderFactory->getPageLength();
242
243			$this->assertEquals($pageLength, $pageLengthReturned);
244			}
245
246			public function testSetSelect()
247			{
248			$select = 'foo';
249			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
250			$queryBuilderFactory->setSelect($select);
251
252			$this->assertAttributeEquals($select, 'select', $queryBuilderFactory);
253			}
254
255			public function testGetSelect()
256			{
257			$select = 'foo';
258			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
259			$queryBuilderFactory->setSelect($select);
260			$selectReturned = $queryBuilderFactory->getSelect();
261
262			$this->assertEquals($select, $selectReturned);
263			}
264
265			public function testCanBuildQueriesUsingOrOperator()
266			{
267			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
268			$queryBuilderFactory->setFields([ 'id' ]);
269			$queryBuilderFactory->setRel([ 'group' ]);
270			$queryBuilderFactory->setOrFilters([
271			'_embedded.group.name\|contains\|1' => 'ad',
272			'_embedded.group.name\|contains\|2' => 'ns',
273			'_embedded.group.name\|contains\|3' => 'dm',
274			'_embedded.group.name\|contains\|4' => 'mi',
275			]);
276			$queryBuilderFactory->createQueryBuilder(User::class, 'e');
277			$queryBuilderFactory->filter();
278
279			$this->assertEquals(
280			"SELECT" .
281			" u0_.id AS id_0," .
282			" u0_.username AS username_1," .
283			" u0_.group_id AS group_id_2 " .
284			"FROM User u0_ " .
285			"INNER JOIN Group g1_ ON u0_.group_id = g1_.id " .
286			"WHERE g1_.name LIKE ? " .
287			"OR g1_.name LIKE ? " .
288			"OR g1_.name LIKE ? " .
289			"OR g1_.name LIKE ?",
290			$queryBuilderFactory->getQueryBuilder()->getQuery()->getSql()
291			);
292			}
293
294			/** @expectedException \Mado\QueryBundle\Exceptions\MissingFiltersException */
295			public function testThrowMissingFiltersExceptionsWheneverFiltersAreMissing()
296			{
297			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
298			$queryBuilderFactory->filter();
299			}
300
301			/**
302			* @expectedException \RuntimeException
303			* @expectedExceptionMessage Oops! Fields are not defined
304			*/
305			public function testCantSortWithoutFields()
306			{
307			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
308			$queryBuilderFactory->sort();
309			}
310
311			/**
312			* @expectedException \RuntimeException
313			* @expectedExceptionMessage Oops! Sorting is not defined
314			*/
315			public function testThrowExceptionWheneverSortIsRequestedWithoutSorting()
316			{
317			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
318			$queryBuilderFactory->setFields(['foo', 'bar']);
319			$queryBuilderFactory->sort();
320			}
321
322			/**
323			* @expectedException \RuntimeException
324			* @expectedExceptionMessage Oops! QueryBuilder was never initialized
325			*/
326			public function testThrowExceptionWhenQueryBuilderIsNotInitialized()
327			{
328			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
329			$queryBuilderFactory->setFields(['foo', 'bar']);
330			$queryBuilderFactory->setSorting(['foo' => 'bar']);
331			$queryBuilderFactory->sort();
332			}
333
334			public function testApplySortingJustForEntityFields()
335			{
336			$this->queryBuilder = $this
337			->getMockBuilder('Doctrine\ORM\QueryBuilder')
338			->disableOriginalConstructor()
339			->getMock();
340			$this->queryBuilder->expects($this->once())
341			->method('select')
342			->with('alias')
343			->willReturn($this->queryBuilder);
344			$this->queryBuilder->expects($this->once())
345			->method('from')
346			->with('EntityName')
347			->willReturn($this->queryBuilder);
348
349			$this->manager = $this
350			->getMockBuilder('Doctrine\ORM\EntityManager')
351			->disableOriginalConstructor()
352			->getMock();
353			$this->manager->expects($this->once())
354			->method('createQueryBuilder')
355			->with('EntityName')
356			->willReturn($this->queryBuilder);
357
358			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
359			$queryBuilderFactory->setFields(['foo', 'bar']);
360			$queryBuilderFactory->setSorting(['foo' => 'bar']);
361			$queryBuilderFactory->createQueryBuilder('EntityName', 'alias');
362			$queryBuilderFactory->sort();
363			}
364
365			public function testApplySortingAlsoOnRelationsField()
366			{
367			$this->queryBuilder = $this
368			->getMockBuilder('Doctrine\ORM\QueryBuilder')
369			->disableOriginalConstructor()
370			->getMock();
371			$this->queryBuilder->expects($this->once())
372			->method('select')
373			->with('alias')
374			->willReturn($this->queryBuilder);
375			$this->queryBuilder->expects($this->once())
376			->method('from')
377			->with('EntityName')
378			->willReturn($this->queryBuilder);
379			$this->queryBuilder->expects($this->once())
380			->method('join')
381			->with('alias.ciao', 'table_fizz');
382
383			$this->metadata = $this
384			->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadata')
385			->disableOriginalConstructor()
386			->getMock();
387			$this->metadata->expects($this->once())
388			->method('hasAssociation')
389			->with('fizz')
390			->willReturn(true);
391			$this->metadata->expects($this->once())
392			->method('getAssociationMapping')
393			->with('fizz')
394			->willReturn([
395			'fieldName' => 'ciao',
396			'targetEntity' => 'someEntityName',
397			]);
398
399			$this->manager = $this
400			->getMockBuilder('Doctrine\ORM\EntityManager')
401			->disableOriginalConstructor()
402			->getMock();
403			$this->manager->expects($this->once())
404			->method('createQueryBuilder')
405			->with('EntityName')
406			->willReturn($this->queryBuilder);
407			$this->manager->expects($this->once())
408			->method('getClassMetadata')
409			->with('EntityName')
410			->willReturn($this->metadata);
411
412			$queryBuilderFactory = new QueryBuilderFactory($this->manager);
413			$queryBuilderFactory->setFields(['foo', 'bar']);
414			$queryBuilderFactory->setSorting(['_embedded.fizz.buzz' => 'bar']);
415			$queryBuilderFactory->createQueryBuilder('EntityName', 'alias');
416			$queryBuilderFactory->sort();
417			}
418			}
419
420			/** @Entity() */
421			class MySimpleEntity
422			{
423			/** @Id @Column(type="integer") */
424			private $id;
425			}
426
427			/** @Entity() */
428			class User
429			{
430			/** @Id @Column(type="integer") */
431			private $id;
432			/** @Column(type="string") */
433			private $username;
434			/** @ManyToOne(targetEntity="Group", inversedBy="member") */
435			private $group;
436			}
437
438			/** @Entity() */
439			class Group
440			{
441			/** @Id @Column(type="integer") */
442			private $id;
443			/** @Column(type="string") */
444			private $name;
445			/** @OneToMany(targetEntity="User", mappedBy="member") */
446			private $members;
447			}
448

studiomado / query-bundle

GitHub Access Token became invalid

Pull Request — 2.2 (#98)

QueryBuilderFactoryTest::testCanBuildQueriesUsingOrOperator() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like