SelectTest::testLimit() - Code Metrics - Inspection of "Merge branch '0.9' into develop" - bytic/database - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( b6dff7...455f41 )

by Gabriel

created 2020-09-02 12:01 UTC

SelectTest::testLimit() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.7
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/** @noinspection SqlResolve */

/** @noinspection SqlNoDataSourceInspection */

namespace Nip\Database\Tests\Query;

use Mockery as m;
use Nip\Database\Adapters\MySQLi;
use Nip\Database\Connections\Connection;
use Nip\Database\Query\Select;
use Nip\Database\Tests\AbstractTest;

/**
 * Class SelectTest
 * @package Nip\Database\Tests\Query
 *
 * @property Select $object
 */
class SelectTest extends AbstractTest
{
    /**
     * @var \UnitTester
     */
    protected $tester;

    /**
     * @var Connection
     */
    protected $connection;

    /**
     * @var Select
     */
    protected $selectQuery;

    public function testSelectSimple()
    {
        $array = ['id, name as new_name', 'table2.test', 'MAX(pos) as pos'];
        call_user_func_array([$this->selectQuery, 'cols'], $array);
        $this->selectQuery->from('table x')->where('id = 5');

        static::assertEquals(
            'SELECT id, name as new_name, table2.test, MAX(pos) as pos FROM table x WHERE id = 5',
            $this->selectQuery->assemble()
        );
    }

    public function testSimpleSelectDistinct()
    {
        $this->selectQuery->cols('id, name')->options('distinct')->from('table x')->where('id = 5');
        static::assertEquals(
            "SELECT DISTINCT id, name FROM table x WHERE id = 5",
            $this->selectQuery->assemble()
        );
    }

    public function testWhereAndWhere()
    {
        $this->selectQuery->cols('id, name')->from('table x');
        $this->selectQuery->where('id = 5')->where("active = 'yes'");
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes'",
            $this->selectQuery->assemble()
        );
        $this->object->cols('id, name')->from('table x');
        $this->object->where('id = 5')->where("active = 'yes'");
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes'",
            $this->object->assemble());
    }

    public function testWhereOrWhere()
    {
        $this->selectQuery->cols('id, name')->from('table x');
        $this->selectQuery->where('id = 5')->orWhere('id = 7');
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 OR id = 7",
            $this->selectQuery->assemble()
        $this->object->cols('id, name')->from('table x');

        $this->object->where('id = 5')->orWhere('id = 7');
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 OR id = 7",
            $this->object->assemble()
        );
    }

    public function testInitializeCondition()
    {
        $condition = $this->object->getCondition("lorem ipsum");
        static::assertThat($condition, $this->isInstanceOf("Nip\Database\Query\Condition\Condition"));
    }

    public function testNested()
    {
        $this->selectQuery->from("table1");
        $this->object->from("table1");

        $query = $this->connection->newQuery();
        $query->from("table2");
        $query->where("id != 5");

        $this->object->where("id NOT IN ?", $query);

        static::assertEquals(
            "SELECT * FROM `table1` WHERE id NOT IN (SELECT * FROM `table2` WHERE id != 5)",
            $this->object->assemble()
        );
    }

    public function testUnion()
    {
        $this->object->from("table1");

        $query = $this->connection->newQuery();
        $query->from("table2");

        $union = $this->object->union($query);

        static::assertEquals("SELECT * FROM `table1` UNION SELECT * FROM `table2`", $union->assemble());
    }

    public function testJoinTableName()
    {
        $this->object->from("table1");
        $this->object->join("table2", ['id', 'id_table1']);

        static::assertEquals(
            "SELECT * FROM `table1` JOIN `table2` ON `table1`.`id` = `table2`.`id_table1`",
            $this->object->assemble()
        );
    }

    public function testJoinTableNameWithAlias()
    {
        $this->object->from("table1");
        $this->object->join(["table2", "alias"], ['id', 'id_table1']);

        static::assertEquals(
            "SELECT * FROM `table1` JOIN `table2` AS `alias` ON `table1`.`id` = `table2`.`id_table1`",
            $this->object->assemble()
        );
    }

    public function testJoinSubQuery()
    {
        $this->object->from("table1");

        $query = $this->connection->newQuery();
        $query->from("table2");

        $this->object->join([$query, "alias"], ['id', 'id_table1']);

        static::assertEquals(
            'SELECT * FROM `table1` JOIN (SELECT * FROM `table2`) AS `alias` ON `table1`.`id` = `alias`.`id_table1`',
            $this->object->assemble()
        );
    }

    public function testHasPart()
    {
        $this->object->cols('id, name');
        self::assertTrue($this->object->hasPart('cols'));

        $this->object->setCols('id, name');
        self::assertTrue($this->object->hasPart('cols'));

        $this->object->limit('');
        self::assertFalse($this->object->hasPart('limit'));

        $this->object->limit('6');
        self::assertTrue($this->object->hasPart('limit'));

        self::assertFalse($this->object->hasPart('where'));
    }

    public function testLimit()
    {
        $this->object->cols('id, name')->from('table x');
        $this->object->where('id = 5')->where("active = 'yes'");
        $this->object->limit(5);

        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes' LIMIT 5",
            $this->object->assemble()
        );

        $this->object->limit(5, 10);
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes' LIMIT 5,10",
            $this->object->assemble()
        );
    }

    protected function setUp()
    {
        parent::setUp();
        $this->object = new Select();

        $adapterMock = m::mock(MySQLi::class)->shouldDeferMissing();
        $adapterMock->shouldReceive('cleanData')->andReturnUsing(function ($data) {
            return $data;
        });
        $this->connection = new Connection(false);
        $this->connection->setAdapter($adapterMock);
        $this->object->setManager($this->connection);
    }
}


1			<?php
2
3			/** @noinspection SqlResolve */
4
5			/** @noinspection SqlNoDataSourceInspection */
6
7			namespace Nip\Database\Tests\Query;
8
9			use Mockery as m;
10			use Nip\Database\Adapters\MySQLi;
11			use Nip\Database\Connections\Connection;
12			use Nip\Database\Query\Select;
13			use Nip\Database\Tests\AbstractTest;
14
15			/**
16			* Class SelectTest
17			* @package Nip\Database\Tests\Query
18			*
19			* @property Select $object
20			*/
21			class SelectTest extends AbstractTest
22			{
23			/**
24			* @var \UnitTester
25			*/
26			protected $tester;
27
28			/**
29			* @var Connection
30			*/
31			protected $connection;
32
33			/**
34			* @var Select
35			*/
36			protected $selectQuery;
37
38			public function testSelectSimple()
39			{
40			$array = ['id, name as new_name', 'table2.test', 'MAX(pos) as pos'];
41			call_user_func_array([$this->selectQuery, 'cols'], $array);
42			$this->selectQuery->from('table x')->where('id = 5');
43
44			static::assertEquals(
45			'SELECT id, name as new_name, table2.test, MAX(pos) as pos FROM table x WHERE id = 5',
46			$this->selectQuery->assemble()
47			);
48			}
49
50			public function testSimpleSelectDistinct()
51			{
52			$this->selectQuery->cols('id, name')->options('distinct')->from('table x')->where('id = 5');
53			static::assertEquals(
54			"SELECT DISTINCT id, name FROM table x WHERE id = 5",
55			$this->selectQuery->assemble()
56			);
57			}
58
59			public function testWhereAndWhere()
60			{
61			$this->selectQuery->cols('id, name')->from('table x');
62			$this->selectQuery->where('id = 5')->where("active = 'yes'");
63			static::assertEquals(
64			"SELECT id, name FROM table x WHERE id = 5 AND active = 'yes'",
65			$this->selectQuery->assemble()
66			);
67			$this->object->cols('id, name')->from('table x');
68			$this->object->where('id = 5')->where("active = 'yes'");
69			static::assertEquals(
70			"SELECT id, name FROM table x WHERE id = 5 AND active = 'yes'",
71			$this->object->assemble());
72			}
73
74			public function testWhereOrWhere()
75			{
76			$this->selectQuery->cols('id, name')->from('table x');
77			$this->selectQuery->where('id = 5')->orWhere('id = 7');
78			static::assertEquals(
79			"SELECT id, name FROM table x WHERE id = 5 OR id = 7",
80			$this->selectQuery->assemble()
81			$this->object->cols('id, name')->from('table x');
			0 ignored issues – show Bug introduced 2020-09-02 12:13 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_VARIABLE, expecting ',' or ')' Loading history...
82			$this->object->where('id = 5')->orWhere('id = 7');
83			static::assertEquals(
84			"SELECT id, name FROM table x WHERE id = 5 OR id = 7",
85			$this->object->assemble()
86			);
87			}
88
89			public function testInitializeCondition()
90			{
91			$condition = $this->object->getCondition("lorem ipsum");
92			static::assertThat($condition, $this->isInstanceOf("Nip\Database\Query\Condition\Condition"));
93			}
94
95			public function testNested()
96			{
97			$this->selectQuery->from("table1");
98			$this->object->from("table1");
99
100			$query = $this->connection->newQuery();
101			$query->from("table2");
102			$query->where("id != 5");
103
104			$this->object->where("id NOT IN ?", $query);
105
106			static::assertEquals(
107			"SELECT * FROM `table1` WHERE id NOT IN (SELECT * FROM `table2` WHERE id != 5)",
108			$this->object->assemble()
109			);
110			}
111
112			public function testUnion()
113			{
114			$this->object->from("table1");
115
116			$query = $this->connection->newQuery();
117			$query->from("table2");
118
119			$union = $this->object->union($query);
120
121			static::assertEquals("SELECT * FROM `table1` UNION SELECT * FROM `table2`", $union->assemble());
122			}
123
124			public function testJoinTableName()
125			{
126			$this->object->from("table1");
127			$this->object->join("table2", ['id', 'id_table1']);
128
129			static::assertEquals(
130			"SELECT * FROM `table1` JOIN `table2` ON `table1`.`id` = `table2`.`id_table1`",
131			$this->object->assemble()
132			);
133			}
134
135			public function testJoinTableNameWithAlias()
136			{
137			$this->object->from("table1");
138			$this->object->join(["table2", "alias"], ['id', 'id_table1']);
139
140			static::assertEquals(
141			"SELECT * FROM `table1` JOIN `table2` AS `alias` ON `table1`.`id` = `table2`.`id_table1`",
142			$this->object->assemble()
143			);
144			}
145
146			public function testJoinSubQuery()
147			{
148			$this->object->from("table1");
149
150			$query = $this->connection->newQuery();
151			$query->from("table2");
152
153			$this->object->join([$query, "alias"], ['id', 'id_table1']);
154
155			static::assertEquals(
156			'SELECT * FROM `table1` JOIN (SELECT * FROM `table2`) AS `alias` ON `table1`.`id` = `alias`.`id_table1`',
157			$this->object->assemble()
158			);
159			}
160
161			public function testHasPart()
162			{
163			$this->object->cols('id, name');
164			self::assertTrue($this->object->hasPart('cols'));
165
166			$this->object->setCols('id, name');
167			self::assertTrue($this->object->hasPart('cols'));
168
169			$this->object->limit('');
170			self::assertFalse($this->object->hasPart('limit'));
171
172			$this->object->limit('6');
173			self::assertTrue($this->object->hasPart('limit'));
174
175			self::assertFalse($this->object->hasPart('where'));
176			}
177
178			public function testLimit()
179			{
180			$this->object->cols('id, name')->from('table x');
181			$this->object->where('id = 5')->where("active = 'yes'");
182			$this->object->limit(5);
183
184			static::assertEquals(
185			"SELECT id, name FROM table x WHERE id = 5 AND active = 'yes' LIMIT 5",
186			$this->object->assemble()
187			);
188
189			$this->object->limit(5, 10);
190			static::assertEquals(
191			"SELECT id, name FROM table x WHERE id = 5 AND active = 'yes' LIMIT 5,10",
192			$this->object->assemble()
193			);
194			}
195
196			protected function setUp()
197			{
198			parent::setUp();
199			$this->object = new Select();
200
201			$adapterMock = m::mock(MySQLi::class)->shouldDeferMissing();
202			$adapterMock->shouldReceive('cleanData')->andReturnUsing(function ($data) {
203			return $data;
204			});
205			$this->connection = new Connection(false);
206			$this->connection->setAdapter($adapterMock);
207			$this->object->setManager($this->connection);
208			}
209			}
210

bytic / database

Push — master ( b6dff7...455f41 )

SelectTest::testLimit() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like