ExpressionBuilderTest::testAndX() - Code Metrics - Inspection of "Merge pull request #3865 from BenMorel/remove-andx" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f076cc...ed4ac2 )

by Sergei

created 2020-01-30 15:33 UTC

ExpressionBuilderTest::testAndX() A

↳ Parent: ExpressionBuilderTest::provideDataForAnd()

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	4
dl	0
loc	9
rs	10
c	1
b	0
f	0
cc	2
nc	2
nop	2

<?php

declare(strict_types=1);

namespace Doctrine\Tests\DBAL\Query\Expression;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Query\Expression\CompositeExpression;
use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
use Doctrine\Tests\DbalTestCase;

/**
 * @group DBAL-12
 */
class ExpressionBuilderTest extends DbalTestCase
{
    /** @var ExpressionBuilder */
    protected $expr;

    protected function setUp() : void
    {
        $conn = $this->createMock(Connection::class);

        $this->expr = new ExpressionBuilder($conn);

        $conn->expects($this->any())
             ->method('getExpressionBuilder')
             ->will($this->returnValue($this->expr));
    }

    /**
     * @param string[]|CompositeExpression[] $parts
     *
     * @dataProvider provideDataForAnd
     */
    public function testAnd(array $parts, string $expected) : void
    {
        $composite = $this->expr->and(...$parts);

        self::assertEquals($expected, (string) $composite);
    }

    /**
     * @return mixed[][]
     */
    public static function provideDataForAnd() : iterable
    {
        return [
            [
                ['u.user = 1'],
                'u.user = 1',
            ],
            [
                ['u.user = 1', 'u.group_id = 1'],
                '(u.user = 1) AND (u.group_id = 1)',
            ],
            [
                ['u.user = 1'],
                'u.user = 1',
            ],
            [
                ['u.group_id = 1', 'u.group_id = 2'],
                '(u.group_id = 1) AND (u.group_id = 2)',
            ],
            [
                [
                    'u.user = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_OR,
                        ['u.group_id = 1', 'u.group_id = 2']
                    ),
                ],
                '(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))',
            ],
            [
                [
                    'u.group_id = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_AND,
                        ['u.user = 1', 'u.group_id = 2']
                    ),
                ],
                '(u.group_id = 1) AND ((u.user = 1) AND (u.group_id = 2))',
            ],
        ];
    }

    /**
     * @param string[]|CompositeExpression[] $parts
     *
     * @dataProvider provideDataForOr
     */
    public function testOr(array $parts, string $expected) : void
    {
        $composite = $this->expr->or(...$parts);

        self::assertEquals($expected, (string) $composite);
    }

    /**
     * @return mixed[][]
     */
    public static function provideDataForOr() : iterable
    {
        return [
            [
                ['u.user = 1'],
                'u.user = 1',
            ],
            [
                ['u.user = 1', 'u.group_id = 1'],
                '(u.user = 1) OR (u.group_id = 1)',
            ],
            [
                ['u.user = 1'],
                'u.user = 1',
            ],
            [
                ['u.group_id = 1', 'u.group_id = 2'],
                '(u.group_id = 1) OR (u.group_id = 2)',
            ],
            [
                [
                    'u.user = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_OR,
                        ['u.group_id = 1', 'u.group_id = 2']
                    ),
                ],
                '(u.user = 1) OR ((u.group_id = 1) OR (u.group_id = 2))',
            ],
            [
                [
                    'u.group_id = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_AND,
                        ['u.user = 1', 'u.group_id = 2']
                    ),
                ],
                '(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))',
            ],
        ];
    }

    /**
     * @dataProvider provideDataForComparison
     */
    public function testComparison(string $leftExpr, string $operator, string $rightExpr, string $expected) : void
    {
        $part = $this->expr->comparison($leftExpr, $operator, $rightExpr);

        self::assertEquals($expected, (string) $part);
    }

    /**
     * @return mixed[][]
     */
    public static function provideDataForComparison() : iterable
    {
        return [
            ['u.user_id', ExpressionBuilder::EQ, '1', 'u.user_id = 1'],
            ['u.user_id', ExpressionBuilder::NEQ, '1', 'u.user_id <> 1'],
            ['u.salary', ExpressionBuilder::LT, '10000', 'u.salary < 10000'],
            ['u.salary', ExpressionBuilder::LTE, '10000', 'u.salary <= 10000'],
            ['u.salary', ExpressionBuilder::GT, '10000', 'u.salary > 10000'],
            ['u.salary', ExpressionBuilder::GTE, '10000', 'u.salary >= 10000'],
        ];
    }

    public function testEq() : void
    {
        self::assertEquals('u.user_id = 1', $this->expr->eq('u.user_id', '1'));
    }

    public function testNeq() : void
    {
        self::assertEquals('u.user_id <> 1', $this->expr->neq('u.user_id', '1'));
    }

    public function testLt() : void
    {
        self::assertEquals('u.salary < 10000', $this->expr->lt('u.salary', '10000'));
    }

    public function testLte() : void
    {
        self::assertEquals('u.salary <= 10000', $this->expr->lte('u.salary', '10000'));
    }

    public function testGt() : void
    {
        self::assertEquals('u.salary > 10000', $this->expr->gt('u.salary', '10000'));
    }

    public function testGte() : void
    {
        self::assertEquals('u.salary >= 10000', $this->expr->gte('u.salary', '10000'));
    }

    public function testIsNull() : void
    {
        self::assertEquals('u.deleted IS NULL', $this->expr->isNull('u.deleted'));
    }

    public function testIsNotNull() : void
    {
        self::assertEquals('u.updated IS NOT NULL', $this->expr->isNotNull('u.updated'));
    }

    public function testIn() : void
    {
        self::assertEquals('u.groups IN (1, 3, 4, 7)', $this->expr->in('u.groups', ['1', '3', '4', '7']));
    }

    public function testInWithPlaceholder() : void
    {
        self::assertEquals('u.groups IN (?)', $this->expr->in('u.groups', '?'));
    }

    public function testNotIn() : void
    {
        self::assertEquals('u.groups NOT IN (1, 3, 4, 7)', $this->expr->notIn('u.groups', ['1', '3', '4', '7']));
    }

    public function testNotInWithPlaceholder() : void
    {
        self::assertEquals('u.groups NOT IN (:values)', $this->expr->notIn('u.groups', ':values'));
    }

    public function testLikeWithoutEscape() : void
    {
        self::assertEquals("a.song LIKE 'a virgin'", $this->expr->like('a.song', "'a virgin'"));
    }

    public function testLikeWithEscape() : void
    {
        self::assertEquals(
            "a.song LIKE 'a virgin' ESCAPE '💩'",
            $this->expr->like('a.song', "'a virgin'", "'💩'")
        );
    }

    public function testNotLikeWithoutEscape() : void
    {
        self::assertEquals(
            "s.last_words NOT LIKE 'this'",
            $this->expr->notLike('s.last_words', "'this'")
        );
    }

    public function testNotLikeWithEscape() : void
    {
        self::assertEquals(
            "p.description NOT LIKE '20💩%' ESCAPE '💩'",
            $this->expr->notLike('p.description', "'20💩%'", "'💩'")
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\Tests\DBAL\Query\Expression;
6
7			use Doctrine\DBAL\Connection;
8			use Doctrine\DBAL\Query\Expression\CompositeExpression;
9			use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
10			use Doctrine\Tests\DbalTestCase;
11
12			/**
13			* @group DBAL-12
14			*/
15			class ExpressionBuilderTest extends DbalTestCase
16			{
17			/** @var ExpressionBuilder */
18			protected $expr;
19
20			protected function setUp() : void
21			{
22			$conn = $this->createMock(Connection::class);
23
24			$this->expr = new ExpressionBuilder($conn);
25
26			$conn->expects($this->any())
27			->method('getExpressionBuilder')
28			->will($this->returnValue($this->expr));
29			}
30
31			/**
32			* @param string[]\|CompositeExpression[] $parts
33			*
34			* @dataProvider provideDataForAnd
35			*/
36			public function testAnd(array $parts, string $expected) : void
37			{
38			$composite = $this->expr->and(...$parts);
39
40			self::assertEquals($expected, (string) $composite);
41			}
42
43			/**
44			* @return mixed[][]
45			*/
46			public static function provideDataForAnd() : iterable
47			{
48			return [
49			[
50			['u.user = 1'],
51			'u.user = 1',
52			],
53			[
54			['u.user = 1', 'u.group_id = 1'],
55			'(u.user = 1) AND (u.group_id = 1)',
56			],
57			[
58			['u.user = 1'],
59			'u.user = 1',
60			],
61			[
62			['u.group_id = 1', 'u.group_id = 2'],
63			'(u.group_id = 1) AND (u.group_id = 2)',
64			],
65			[
66			[
67			'u.user = 1',
68			new CompositeExpression(
69			CompositeExpression::TYPE_OR,
70			['u.group_id = 1', 'u.group_id = 2']
71			),
72			],
73			'(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))',
74			],
75			[
76			[
77			'u.group_id = 1',
78			new CompositeExpression(
79			CompositeExpression::TYPE_AND,
80			['u.user = 1', 'u.group_id = 2']
81			),
82			],
83			'(u.group_id = 1) AND ((u.user = 1) AND (u.group_id = 2))',
84			],
85			];
86			}
87
88			/**
89			* @param string[]\|CompositeExpression[] $parts
90			*
91			* @dataProvider provideDataForOr
92			*/
93			public function testOr(array $parts, string $expected) : void
94			{
95			$composite = $this->expr->or(...$parts);
96
97			self::assertEquals($expected, (string) $composite);
98			}
99
100			/**
101			* @return mixed[][]
102			*/
103			public static function provideDataForOr() : iterable
104			{
105			return [
106			[
107			['u.user = 1'],
108			'u.user = 1',
109			],
110			[
111			['u.user = 1', 'u.group_id = 1'],
112			'(u.user = 1) OR (u.group_id = 1)',
113			],
114			[
115			['u.user = 1'],
116			'u.user = 1',
117			],
118			[
119			['u.group_id = 1', 'u.group_id = 2'],
120			'(u.group_id = 1) OR (u.group_id = 2)',
121			],
122			[
123			[
124			'u.user = 1',
125			new CompositeExpression(
126			CompositeExpression::TYPE_OR,
127			['u.group_id = 1', 'u.group_id = 2']
128			),
129			],
130			'(u.user = 1) OR ((u.group_id = 1) OR (u.group_id = 2))',
131			],
132			[
133			[
134			'u.group_id = 1',
135			new CompositeExpression(
136			CompositeExpression::TYPE_AND,
137			['u.user = 1', 'u.group_id = 2']
138			),
139			],
140			'(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))',
141			],
142			];
143			}
144
145			/**
146			* @dataProvider provideDataForComparison
147			*/
148			public function testComparison(string $leftExpr, string $operator, string $rightExpr, string $expected) : void
149			{
150			$part = $this->expr->comparison($leftExpr, $operator, $rightExpr);
151
152			self::assertEquals($expected, (string) $part);
153			}
154
155			/**
156			* @return mixed[][]
157			*/
158			public static function provideDataForComparison() : iterable
159			{
160			return [
161			['u.user_id', ExpressionBuilder::EQ, '1', 'u.user_id = 1'],
162			['u.user_id', ExpressionBuilder::NEQ, '1', 'u.user_id <> 1'],
163			['u.salary', ExpressionBuilder::LT, '10000', 'u.salary < 10000'],
164			['u.salary', ExpressionBuilder::LTE, '10000', 'u.salary <= 10000'],
165			['u.salary', ExpressionBuilder::GT, '10000', 'u.salary > 10000'],
166			['u.salary', ExpressionBuilder::GTE, '10000', 'u.salary >= 10000'],
167			];
168			}
169
170			public function testEq() : void
171			{
172			self::assertEquals('u.user_id = 1', $this->expr->eq('u.user_id', '1'));
173			}
174
175			public function testNeq() : void
176			{
177			self::assertEquals('u.user_id <> 1', $this->expr->neq('u.user_id', '1'));
178			}
179
180			public function testLt() : void
181			{
182			self::assertEquals('u.salary < 10000', $this->expr->lt('u.salary', '10000'));
183			}
184
185			public function testLte() : void
186			{
187			self::assertEquals('u.salary <= 10000', $this->expr->lte('u.salary', '10000'));
188			}
189
190			public function testGt() : void
191			{
192			self::assertEquals('u.salary > 10000', $this->expr->gt('u.salary', '10000'));
193			}
194
195			public function testGte() : void
196			{
197			self::assertEquals('u.salary >= 10000', $this->expr->gte('u.salary', '10000'));
198			}
199
200			public function testIsNull() : void
201			{
202			self::assertEquals('u.deleted IS NULL', $this->expr->isNull('u.deleted'));
203			}
204
205			public function testIsNotNull() : void
206			{
207			self::assertEquals('u.updated IS NOT NULL', $this->expr->isNotNull('u.updated'));
208			}
209
210			public function testIn() : void
211			{
212			self::assertEquals('u.groups IN (1, 3, 4, 7)', $this->expr->in('u.groups', ['1', '3', '4', '7']));
213			}
214
215			public function testInWithPlaceholder() : void
216			{
217			self::assertEquals('u.groups IN (?)', $this->expr->in('u.groups', '?'));
218			}
219
220			public function testNotIn() : void
221			{
222			self::assertEquals('u.groups NOT IN (1, 3, 4, 7)', $this->expr->notIn('u.groups', ['1', '3', '4', '7']));
223			}
224
225			public function testNotInWithPlaceholder() : void
226			{
227			self::assertEquals('u.groups NOT IN (:values)', $this->expr->notIn('u.groups', ':values'));
228			}
229
230			public function testLikeWithoutEscape() : void
231			{
232			self::assertEquals("a.song LIKE 'a virgin'", $this->expr->like('a.song', "'a virgin'"));
233			}
234
235			public function testLikeWithEscape() : void
236			{
237			self::assertEquals(
238			"a.song LIKE 'a virgin' ESCAPE '💩'",
239			$this->expr->like('a.song', "'a virgin'", "'💩'")
240			);
241			}
242
243			public function testNotLikeWithoutEscape() : void
244			{
245			self::assertEquals(
246			"s.last_words NOT LIKE 'this'",
247			$this->expr->notLike('s.last_words', "'this'")
248			);
249			}
250
251			public function testNotLikeWithEscape() : void
252			{
253			self::assertEquals(
254			"p.description NOT LIKE '20💩%' ESCAPE '💩'",
255			$this->expr->notLike('p.description', "'20💩%'", "'💩'")
256			);
257			}
258			}
259

doctrine / dbal

Push — master ( f076cc...ed4ac2 )

ExpressionBuilderTest::testAndX() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like