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

Failed Conditions

Push — 2.11.x ( c2b8e6...130e15 )

by Sergei

created 2020-01-28 14:07 UTC

ExpressionBuilderTest::provideDataForOr() A

↳ Parent: ExpressionBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	38
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	19
c	0
b	0
f	0
dl	0
loc	38
rs	9.6333
cc	1
nc	1
nop	0

<?php

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();

        foreach ($parts as $part) {
            $composite->add($part);
        }

        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();

        foreach ($parts as $part) {
            $composite->add($part);
        }

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

doctrine / dbal

Push — 2.11.x ( c2b8e6...130e15 )

ExpressionBuilderTest::provideDataForOr() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like