QueryBuilderTest - Code Metrics - Inspection of "kw_mapper - play with workflows and checks 4 - dat..." - alex-kalanis/kw_mapper - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 50dc03...2f2ddd )

by Petr

created 2022-06-19 02:17 UTC

QueryBuilderTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	246
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	21
eloc	136
c	1
b	0
f	0
dl	0
loc	246
rs	10

<?php

namespace StorageTests\Database;


use Builder;
use Builder2;
use CommonTestClass;
use kalanis\kw_mapper\Interfaces\IQueryBuilder;
use kalanis\kw_mapper\MapperException;
use kalanis\kw_mapper\Storage\Database\Dialects\EmptyDialect;
use kalanis\kw_mapper\Storage\Database\Dialects\MySQL;
use kalanis\kw_mapper\Storage\Shared\QueryBuilder;


class QueryBuilderTest extends CommonTestClass
{
    public function testBuilderColumn(): void
    {
        $data = new QueryBuilder\Column();
        $data->setData('foo', 'bar', 'baz', 'anf');
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals('baz', $data->getColumnAlias());
        $this->assertEquals('anf', $data->getAggregate());
    }

    public function testBuilderCondition(): void
    {
        $data = new QueryBuilder\Condition();
        $data->setData('foo', 'bar', 'baz', 'anf');
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals('baz', $data->getOperation());
        $this->assertEquals('anf', $data->getColumnKey());
    }

    public function testBuilderGroup(): void
    {
        $data = new QueryBuilder\Group();
        $data->setData('foo', 'bar');
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
    }

    public function testBuilderJoin(): void
    {
        $data = new QueryBuilder\Join();
        $data->setData('foo', 'bar', 'baz', 'anf', 'bvt', 'xcu', 'xdh');
        $this->assertEquals('foo', $data->getJoinUnderAlias());
        $this->assertEquals('bar', $data->getNewTableName());
        $this->assertEquals('baz', $data->getNewColumnName());
        $this->assertEquals('anf', $data->getKnownTableName());
        $this->assertEquals('bvt', $data->getKnownColumnName());
        $this->assertEquals('xcu', $data->getSide());
        $this->assertEquals('xdh', $data->getTableAlias());
    }

    public function testBuilderOrder(): void
    {
        $data = new QueryBuilder\Order();
        $data->setData('foo', 'bar', 'baz');
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals('baz', $data->getDirection());
    }

    public function testBuilderProperty(): void
    {
        $data = new QueryBuilder\Property();
        $data->setData('foo', 'bar', 'baz');
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals('baz', $data->getColumnKey());
    }

    /**
     * @throws MapperException
     */
    public function testColumnFail(): void
    {
        $builder = new Builder();
        $this->expectException(MapperException::class);
        $builder->addColumn('foo', 'bar', 'baz', 'anf');
    }

    /**
     * @throws MapperException
     */
    public function testColumnPass(): void
    {
        $builder = new Builder();
        $builder->addColumn('foo', 'bar', 'baz');
        $data = $builder->getColumns();
        $data = reset($data);
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals('baz', $data->getColumnAlias());
    }

    /**
     * @throws MapperException
     */
    public function testConditionFail(): void
    {
        $builder = new Builder();
        $this->expectException(MapperException::class);
        $builder->addCondition('foo', 'bar', 'baz', 'anf');
    }

    /**
     * @throws MapperException
     */
    public function testConditionPass(): void
    {
        $builder = new Builder();
        $builder->addCondition('foo', 'bar', IQueryBuilder::OPERATION_EQ, 'anf');
        $data = $builder->getConditions();
        $data = reset($data);
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals(IQueryBuilder::OPERATION_EQ, $data->getOperation());
        $this->assertEquals('anf', $builder->getParams()[$data->getColumnKey()]);
        $builder->resetCounter();
    }

    public function testProperty(): void
    {
        $builder = new Builder();
        $builder->addProperty('foo', 'bar', 'baz');
        $data = $builder->getProperties();
        $data = reset($data);
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals('baz', $builder->getParams()[$data->getColumnKey()]);
        $builder->resetCounter();
    }

    public function testJoin(): void
    {
        $builder = new Builder();
        $builder->addJoin('foo', 'bar', 'baz', 'anf', 'bvt', 'xcu', 'xdh');
        $data = $builder->getJoins();
        $data = reset($data);
        $this->assertEquals('foo', $data->getJoinUnderAlias());
        $this->assertEquals('bar', $data->getNewTableName());
        $this->assertEquals('baz', $data->getNewColumnName());
        $this->assertEquals('anf', $data->getKnownTableName());
        $this->assertEquals('bvt', $data->getKnownColumnName());
        $this->assertEquals('xcu', $data->getSide());
        $this->assertEquals('xdh', $data->getTableAlias());
    }

    /**
     * @throws MapperException
     */
    public function testOrderFail(): void
    {
        $builder = new Builder();
        $this->expectException(MapperException::class);
        $builder->addOrderBy('foo', 'bar', 'baz');
    }

    /**
     * @throws MapperException
     */
    public function testOrderPass(): void
    {
        $builder = new Builder();
        $builder->addOrderBy('foo', 'bar', IQueryBuilder::ORDER_DESC);
        $data = $builder->getOrdering();
        $data = reset($data);
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals(IQueryBuilder::ORDER_DESC, $data->getDirection());
    }

    public function testGroup(): void
    {
        $builder = new Builder();
        $builder->addGroupBy('foo', 'bar');
        $data = $builder->getGrouping();
        $data = reset($data);
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
    }

    /**
     * @throws MapperException
     */
    public function testHavingFail(): void
    {
        $builder = new Builder();
        $this->expectException(MapperException::class);
        $builder->addHavingCondition('foo', 'bar', 'baz', 'anf');
    }

    /**
     * @throws MapperException
     */
    public function testHavingPass(): void
    {
        $builder = new Builder();
        $builder->addHavingCondition('foo', 'bar', IQueryBuilder::OPERATION_EQ, 'anf');
        $data = $builder->getHavingCondition();
        $data = reset($data);
        $this->assertEquals('foo', $data->getTableName());
        $this->assertEquals('bar', $data->getColumnName());
        $this->assertEquals(IQueryBuilder::OPERATION_EQ, $data->getOperation());
        $this->assertEquals('anf', $builder->getParams()[$data->getColumnKey()]);
        $builder->resetCounter();
    }

    public function testLimits(): void
    {
        $builder = new Builder();
        $builder->setLimits(75, 12);
        $this->assertEquals(75, $builder->getOffset());
        $this->assertEquals(12, $builder->getLimit());
        $builder->setLimit(null);
        $this->assertEmpty($builder->getLimit());
        $builder->setOffset(null);
        $this->assertEmpty($builder->getOffset());
    }

    public function testBasics(): void
    {
        $builder = new Builder();
        $builder->setBaseTable('foo');
        $this->assertEquals('foo', $builder->getBaseTable());
        $builder->setRelations(IQueryBuilder::RELATION_OR);
        $this->assertEquals(IQueryBuilder::RELATION_OR, $builder->getRelation());
        $builder->setRelations('dfg');
        $this->assertEquals(IQueryBuilder::RELATION_OR, $builder->getRelation());
        $builder->clearColumns();
        $builder->clear();
    }

    public function testJoins(): void
    {
        $builder = new Builder2(new MySQL());
        $builder->addJoin('foo', 'bar', 'baz', 'anf', 'bvt', 'CROSS', 'xdh');
        $data = $builder->getJoins();
        $data = reset($data);
        $this->assertEquals('foo', $data->getJoinUnderAlias());
        $this->assertEquals('bar', $data->getNewTableName());
        $this->assertEquals('baz', $data->getNewColumnName());
        $this->assertEquals('anf', $data->getKnownTableName());
        $this->assertEquals('bvt', $data->getKnownColumnName());
        $this->assertEquals('CROSS', $data->getSide());
        $this->assertEquals('xdh', $data->getTableAlias());
    }

    /**
     * @throws MapperException
     */
    public function testJoinsFail(): void
    {
        $builder = new Builder2(new EmptyDialect());
        $this->expectException(MapperException::class);
        $builder->addJoin('foo', 'bar', 'baz', 'anf', 'bvt', 'xcu', 'xdh');
    }
}


1			<?php
2
3			namespace StorageTests\Database;
4
5
6			use Builder;
7			use Builder2;
8			use CommonTestClass;
9			use kalanis\kw_mapper\Interfaces\IQueryBuilder;
10			use kalanis\kw_mapper\MapperException;
11			use kalanis\kw_mapper\Storage\Database\Dialects\EmptyDialect;
12			use kalanis\kw_mapper\Storage\Database\Dialects\MySQL;
13			use kalanis\kw_mapper\Storage\Shared\QueryBuilder;
14
15
16			class QueryBuilderTest extends CommonTestClass
17			{
18			public function testBuilderColumn(): void
19			{
20			$data = new QueryBuilder\Column();
21			$data->setData('foo', 'bar', 'baz', 'anf');
22			$this->assertEquals('foo', $data->getTableName());
23			$this->assertEquals('bar', $data->getColumnName());
24			$this->assertEquals('baz', $data->getColumnAlias());
25			$this->assertEquals('anf', $data->getAggregate());
26			}
27
28			public function testBuilderCondition(): void
29			{
30			$data = new QueryBuilder\Condition();
31			$data->setData('foo', 'bar', 'baz', 'anf');
32			$this->assertEquals('foo', $data->getTableName());
33			$this->assertEquals('bar', $data->getColumnName());
34			$this->assertEquals('baz', $data->getOperation());
35			$this->assertEquals('anf', $data->getColumnKey());
36			}
37
38			public function testBuilderGroup(): void
39			{
40			$data = new QueryBuilder\Group();
41			$data->setData('foo', 'bar');
42			$this->assertEquals('foo', $data->getTableName());
43			$this->assertEquals('bar', $data->getColumnName());
44			}
45
46			public function testBuilderJoin(): void
47			{
48			$data = new QueryBuilder\Join();
49			$data->setData('foo', 'bar', 'baz', 'anf', 'bvt', 'xcu', 'xdh');
50			$this->assertEquals('foo', $data->getJoinUnderAlias());
51			$this->assertEquals('bar', $data->getNewTableName());
52			$this->assertEquals('baz', $data->getNewColumnName());
53			$this->assertEquals('anf', $data->getKnownTableName());
54			$this->assertEquals('bvt', $data->getKnownColumnName());
55			$this->assertEquals('xcu', $data->getSide());
56			$this->assertEquals('xdh', $data->getTableAlias());
57			}
58
59			public function testBuilderOrder(): void
60			{
61			$data = new QueryBuilder\Order();
62			$data->setData('foo', 'bar', 'baz');
63			$this->assertEquals('foo', $data->getTableName());
64			$this->assertEquals('bar', $data->getColumnName());
65			$this->assertEquals('baz', $data->getDirection());
66			}
67
68			public function testBuilderProperty(): void
69			{
70			$data = new QueryBuilder\Property();
71			$data->setData('foo', 'bar', 'baz');
72			$this->assertEquals('foo', $data->getTableName());
73			$this->assertEquals('bar', $data->getColumnName());
74			$this->assertEquals('baz', $data->getColumnKey());
75			}
76
77			/**
78			* @throws MapperException
79			*/
80			public function testColumnFail(): void
81			{
82			$builder = new Builder();
83			$this->expectException(MapperException::class);
84			$builder->addColumn('foo', 'bar', 'baz', 'anf');
85			}
86
87			/**
88			* @throws MapperException
89			*/
90			public function testColumnPass(): void
91			{
92			$builder = new Builder();
93			$builder->addColumn('foo', 'bar', 'baz');
94			$data = $builder->getColumns();
95			$data = reset($data);
96			$this->assertEquals('foo', $data->getTableName());
97			$this->assertEquals('bar', $data->getColumnName());
98			$this->assertEquals('baz', $data->getColumnAlias());
99			}
100
101			/**
102			* @throws MapperException
103			*/
104			public function testConditionFail(): void
105			{
106			$builder = new Builder();
107			$this->expectException(MapperException::class);
108			$builder->addCondition('foo', 'bar', 'baz', 'anf');
109			}
110
111			/**
112			* @throws MapperException
113			*/
114			public function testConditionPass(): void
115			{
116			$builder = new Builder();
117			$builder->addCondition('foo', 'bar', IQueryBuilder::OPERATION_EQ, 'anf');
118			$data = $builder->getConditions();
119			$data = reset($data);
120			$this->assertEquals('foo', $data->getTableName());
121			$this->assertEquals('bar', $data->getColumnName());
122			$this->assertEquals(IQueryBuilder::OPERATION_EQ, $data->getOperation());
123			$this->assertEquals('anf', $builder->getParams()[$data->getColumnKey()]);
124			$builder->resetCounter();
125			}
126
127			public function testProperty(): void
128			{
129			$builder = new Builder();
130			$builder->addProperty('foo', 'bar', 'baz');
131			$data = $builder->getProperties();
132			$data = reset($data);
133			$this->assertEquals('foo', $data->getTableName());
134			$this->assertEquals('bar', $data->getColumnName());
135			$this->assertEquals('baz', $builder->getParams()[$data->getColumnKey()]);
136			$builder->resetCounter();
137			}
138
139			public function testJoin(): void
140			{
141			$builder = new Builder();
142			$builder->addJoin('foo', 'bar', 'baz', 'anf', 'bvt', 'xcu', 'xdh');
143			$data = $builder->getJoins();
144			$data = reset($data);
145			$this->assertEquals('foo', $data->getJoinUnderAlias());
146			$this->assertEquals('bar', $data->getNewTableName());
147			$this->assertEquals('baz', $data->getNewColumnName());
148			$this->assertEquals('anf', $data->getKnownTableName());
149			$this->assertEquals('bvt', $data->getKnownColumnName());
150			$this->assertEquals('xcu', $data->getSide());
151			$this->assertEquals('xdh', $data->getTableAlias());
152			}
153
154			/**
155			* @throws MapperException
156			*/
157			public function testOrderFail(): void
158			{
159			$builder = new Builder();
160			$this->expectException(MapperException::class);
161			$builder->addOrderBy('foo', 'bar', 'baz');
162			}
163
164			/**
165			* @throws MapperException
166			*/
167			public function testOrderPass(): void
168			{
169			$builder = new Builder();
170			$builder->addOrderBy('foo', 'bar', IQueryBuilder::ORDER_DESC);
171			$data = $builder->getOrdering();
172			$data = reset($data);
173			$this->assertEquals('foo', $data->getTableName());
174			$this->assertEquals('bar', $data->getColumnName());
175			$this->assertEquals(IQueryBuilder::ORDER_DESC, $data->getDirection());
176			}
177
178			public function testGroup(): void
179			{
180			$builder = new Builder();
181			$builder->addGroupBy('foo', 'bar');
182			$data = $builder->getGrouping();
183			$data = reset($data);
184			$this->assertEquals('foo', $data->getTableName());
185			$this->assertEquals('bar', $data->getColumnName());
186			}
187
188			/**
189			* @throws MapperException
190			*/
191			public function testHavingFail(): void
192			{
193			$builder = new Builder();
194			$this->expectException(MapperException::class);
195			$builder->addHavingCondition('foo', 'bar', 'baz', 'anf');
196			}
197
198			/**
199			* @throws MapperException
200			*/
201			public function testHavingPass(): void
202			{
203			$builder = new Builder();
204			$builder->addHavingCondition('foo', 'bar', IQueryBuilder::OPERATION_EQ, 'anf');
205			$data = $builder->getHavingCondition();
206			$data = reset($data);
207			$this->assertEquals('foo', $data->getTableName());
208			$this->assertEquals('bar', $data->getColumnName());
209			$this->assertEquals(IQueryBuilder::OPERATION_EQ, $data->getOperation());
210			$this->assertEquals('anf', $builder->getParams()[$data->getColumnKey()]);
211			$builder->resetCounter();
212			}
213
214			public function testLimits(): void
215			{
216			$builder = new Builder();
217			$builder->setLimits(75, 12);
218			$this->assertEquals(75, $builder->getOffset());
219			$this->assertEquals(12, $builder->getLimit());
220			$builder->setLimit(null);
221			$this->assertEmpty($builder->getLimit());
222			$builder->setOffset(null);
223			$this->assertEmpty($builder->getOffset());
224			}
225
226			public function testBasics(): void
227			{
228			$builder = new Builder();
229			$builder->setBaseTable('foo');
230			$this->assertEquals('foo', $builder->getBaseTable());
231			$builder->setRelations(IQueryBuilder::RELATION_OR);
232			$this->assertEquals(IQueryBuilder::RELATION_OR, $builder->getRelation());
233			$builder->setRelations('dfg');
234			$this->assertEquals(IQueryBuilder::RELATION_OR, $builder->getRelation());
235			$builder->clearColumns();
236			$builder->clear();
237			}
238
239			public function testJoins(): void
240			{
241			$builder = new Builder2(new MySQL());
242			$builder->addJoin('foo', 'bar', 'baz', 'anf', 'bvt', 'CROSS', 'xdh');
243			$data = $builder->getJoins();
244			$data = reset($data);
245			$this->assertEquals('foo', $data->getJoinUnderAlias());
246			$this->assertEquals('bar', $data->getNewTableName());
247			$this->assertEquals('baz', $data->getNewColumnName());
248			$this->assertEquals('anf', $data->getKnownTableName());
249			$this->assertEquals('bvt', $data->getKnownColumnName());
250			$this->assertEquals('CROSS', $data->getSide());
251			$this->assertEquals('xdh', $data->getTableAlias());
252			}
253
254			/**
255			* @throws MapperException
256			*/
257			public function testJoinsFail(): void
258			{
259			$builder = new Builder2(new EmptyDialect());
260			$this->expectException(MapperException::class);
261			$builder->addJoin('foo', 'bar', 'baz', 'anf', 'bvt', 'xcu', 'xdh');
262			}
263			}
264

alex-kalanis / kw_mapper

Push — master ( 50dc03...2f2ddd )

QueryBuilderTest A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like