ExpressionBuilderTest.php 6.22 KB
Newer Older
1 2 3 4
<?php

namespace Doctrine\Tests\DBAL\Query\Expression;

jeroendedauw's avatar
jeroendedauw committed
5 6
use Doctrine\DBAL\Query\Expression\CompositeExpression;
use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
7

8 9 10
/**
 * @group DBAL-12
 */
11 12
class ExpressionBuilderTest extends \Doctrine\Tests\DbalTestCase
{
Gabriel Caruso's avatar
Gabriel Caruso committed
13 14 15
    /**
     * @var ExpressionBuilder
     */
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 25 26 27
        $conn->expects($this->any())
             ->method('getExpressionBuilder')
             ->will($this->returnValue($this->expr));
    }
28

29 30 31 32 33 34
    /**
     * @dataProvider provideDataForAndX
     */
    public function testAndX($parts, $expected)
    {
        $composite = $this->expr->andX();
35

36 37 38
        foreach ($parts as $part) {
            $composite->add($part);
        }
39

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

43 44 45 46
    public function provideDataForAndX()
    {
        return array(
            array(
47
                array('u.user = 1'),
48 49 50
                'u.user = 1'
            ),
            array(
51
                array('u.user = 1', 'u.group_id = 1'),
52 53 54
                '(u.user = 1) AND (u.group_id = 1)'
            ),
            array(
55
                array('u.user = 1'),
56 57 58
                'u.user = 1'
            ),
            array(
59
                array('u.group_id = 1', 'u.group_id = 2'),
60 61 62 63
                '(u.group_id = 1) AND (u.group_id = 2)'
            ),
            array(
                array(
64
                    'u.user = 1',
65 66 67 68
                    new CompositeExpression(
                        CompositeExpression::TYPE_OR,
                        array('u.group_id = 1', 'u.group_id = 2')
                    )
69
                ),
70 71 72 73
                '(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))'
            ),
            array(
                array(
74
                    'u.group_id = 1',
75 76 77 78
                    new CompositeExpression(
                        CompositeExpression::TYPE_AND,
                        array('u.user = 1', 'u.group_id = 2')
                    )
79
                ),
80 81 82 83
                '(u.group_id = 1) AND ((u.user = 1) AND (u.group_id = 2))'
            ),
        );
    }
84

85 86 87 88 89 90
    /**
     * @dataProvider provideDataForOrX
     */
    public function testOrX($parts, $expected)
    {
        $composite = $this->expr->orX();
91

92 93 94
        foreach ($parts as $part) {
            $composite->add($part);
        }
95

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

99 100 101 102
    public function provideDataForOrX()
    {
        return array(
            array(
103
                array('u.user = 1'),
104 105 106
                'u.user = 1'
            ),
            array(
107
                array('u.user = 1', 'u.group_id = 1'),
108 109 110
                '(u.user = 1) OR (u.group_id = 1)'
            ),
            array(
111
                array('u.user = 1'),
112 113 114
                'u.user = 1'
            ),
            array(
115
                array('u.group_id = 1', 'u.group_id = 2'),
116 117 118 119
                '(u.group_id = 1) OR (u.group_id = 2)'
            ),
            array(
                array(
120
                    'u.user = 1',
121 122 123 124
                    new CompositeExpression(
                        CompositeExpression::TYPE_OR,
                        array('u.group_id = 1', 'u.group_id = 2')
                    )
125
                ),
126 127 128 129
                '(u.user = 1) OR ((u.group_id = 1) OR (u.group_id = 2))'
            ),
            array(
                array(
130
                    'u.group_id = 1',
131 132 133 134
                    new CompositeExpression(
                        CompositeExpression::TYPE_AND,
                        array('u.user = 1', 'u.group_id = 2')
                    )
135
                ),
136 137 138 139
                '(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))'
            ),
        );
    }
140

141 142 143 144 145 146
    /**
     * @dataProvider provideDataForComparison
     */
    public function testComparison($leftExpr, $operator, $rightExpr, $expected)
    {
        $part = $this->expr->comparison($leftExpr, $operator, $rightExpr);
147

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

151 152 153 154 155 156 157 158 159 160 161
    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'),
        );
    }
162

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

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

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

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

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

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

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

198 199
    public function testIsNotNull()
    {
200
        self::assertEquals('u.updated IS NOT NULL', $this->expr->isNotNull('u.updated'));
201
    }
202 203 204

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

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

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

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