ExpressionBuilderTest::testNotLikeWithEscape() - Code Metrics - Inspection of "Merge pull request #3013 from greg0ire/escape_like..." - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 69742a...ea7657 )

by Marco

created 2018-02-17 22:09 UTC

ExpressionBuilderTest::testNotLikeWithEscape() A

↳ Parent: ExpressionBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	0

<?php

namespace Doctrine\Tests\DBAL\Query\Expression;

use Doctrine\DBAL\Query\Expression\CompositeExpression;
use Doctrine\DBAL\Query\Expression\ExpressionBuilder;

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

    protected function setUp()
    {
        $conn = $this->createMock('Doctrine\DBAL\Connection');

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

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

    /**
     * @dataProvider provideDataForAndX
     */
    public function testAndX($parts, $expected)
    {
        $composite = $this->expr->andX();

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

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

    public function provideDataForAndX()
    {
        return array(
            array(
                array('u.user = 1'),
                'u.user = 1'
            ),
            array(
                array('u.user = 1', 'u.group_id = 1'),
                '(u.user = 1) AND (u.group_id = 1)'
            ),
            array(
                array('u.user = 1'),
                'u.user = 1'
            ),
            array(
                array('u.group_id = 1', 'u.group_id = 2'),
                '(u.group_id = 1) AND (u.group_id = 2)'
            ),
            array(
                array(
                    'u.user = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_OR,
                        array('u.group_id = 1', 'u.group_id = 2')
                    )
                ),
                '(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))'
            ),
            array(
                array(
                    'u.group_id = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_AND,
                        array('u.user = 1', 'u.group_id = 2')
                    )
                ),
                '(u.group_id = 1) AND ((u.user = 1) AND (u.group_id = 2))'
            ),
        );
    }

    /**
     * @dataProvider provideDataForOrX
     */
    public function testOrX($parts, $expected)
    {
        $composite = $this->expr->orX();

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

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

    public function provideDataForOrX()
    {
        return array(
            array(
                array('u.user = 1'),
                'u.user = 1'
            ),
            array(
                array('u.user = 1', 'u.group_id = 1'),
                '(u.user = 1) OR (u.group_id = 1)'
            ),
            array(
                array('u.user = 1'),
                'u.user = 1'
            ),
            array(
                array('u.group_id = 1', 'u.group_id = 2'),
                '(u.group_id = 1) OR (u.group_id = 2)'
            ),
            array(
                array(
                    'u.user = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_OR,
                        array('u.group_id = 1', 'u.group_id = 2')
                    )
                ),
                '(u.user = 1) OR ((u.group_id = 1) OR (u.group_id = 2))'
            ),
            array(
                array(
                    'u.group_id = 1',
                    new CompositeExpression(
                        CompositeExpression::TYPE_AND,
                        array('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($leftExpr, $operator, $rightExpr, $expected)
    {
        $part = $this->expr->comparison($leftExpr, $operator, $rightExpr);

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

    public function provideDataForComparison()
    {
        return array(
            array('u.user_id', ExpressionBuilder::EQ, '1', 'u.user_id = 1'),
            array('u.user_id', ExpressionBuilder::NEQ, '1', 'u.user_id <> 1'),
            array('u.salary', ExpressionBuilder::LT, '10000', 'u.salary < 10000'),
            array('u.salary', ExpressionBuilder::LTE, '10000', 'u.salary <= 10000'),
            array('u.salary', ExpressionBuilder::GT, '10000', 'u.salary > 10000'),
            array('u.salary', ExpressionBuilder::GTE, '10000', 'u.salary >= 10000'),
        );
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

doctrine / dbal

Push — master ( 69742a...ea7657 )

ExpressionBuilderTest::testNotLikeWithEscape() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like