spec\Sylius\Bundle\GridBundle\Doctrine\PHPCRODM\ExpressionBuilderSpec

Complexity

Total Complexity

17

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	let()	0	4	1
A	it_is_initializable()	0	4	1
A	it_builds_andx()	0	8	1
A	it_builds_orx()	0	8	1
A	it_builds_equals()	0	7	1
A	it_builds_not_equals()	0	7	1
A	it_builds_less_than_or_equal()	0	7	1
A	it_builds_greater_than()	0	7	1
A	it_builds_greater_than_or_equal()	0	7	1
A	it_builds_in()	0	7	1
A	it_builds_not_in()	0	7	1
A	it_builds_is_null()	0	6	1
A	it_builds_is_not_null()	0	6	1
A	it_builds_like()	0	7	1
A	it_builds_not_like()	0	6	1
A	it_orders_by()	0	7	1
A	it_adds_order_by()	0	9	1

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace spec\Sylius\Bundle\GridBundle\Doctrine\PHPCRODM;

use PhpSpec\ObjectBehavior;
use Prophecy\Argument;
use Doctrine\Common\Collections\ExpressionBuilder as CollectionsExpressionBuilder;
use Sylius\Bundle\GridBundle\Doctrine\PHPCRODM\ExpressionBuilder;
use Doctrine\Common\Collections\Expr\Comparison;
use Sylius\Bundle\GridBundle\Doctrine\PHPCRODM\ExtraComparison;

class ExpressionBuilderSpec extends ObjectBehavior
{
    function let(CollectionsExpressionBuilder $expressionBuilder)
    {
        $this->beConstructedWith($expressionBuilder);
    }

    function it_is_initializable()
    {
        $this->shouldHaveType(ExpressionBuilder::class);
    }

    function it_builds_andx(
        Comparison $comparison,
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->andX([$comparison]);
        $expressionBuilder->andX([$comparison])->shouldHaveBeenCalled();
    }

    function it_builds_orx(
        Comparison $comparison,
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->orX([$comparison]);
        $expressionBuilder->orX([$comparison])->shouldHaveBeenCalled();
    }

    function it_builds_equals(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->equals('o.foo', 'value');
        $expressionBuilder->eq('o.foo', 'value')->shouldHaveBeenCalled();
    }

    function it_builds_not_equals(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->notEquals('o.foo', 'value');
        $expressionBuilder->neq('o.foo', 'value')->shouldHaveBeenCalled();
    }

    function it_builds_less_than_or_equal(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->lessThanOrEqual('o.foo', 'value');
        $expressionBuilder->lte('o.foo', 'value')->shouldHaveBeenCalled();
    }

    function it_builds_greater_than(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->greaterThan('o.foo', 'value');
        $expressionBuilder->gt('o.foo', 'value')->shouldHaveBeenCalled();
    }

    function it_builds_greater_than_or_equal(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->greaterThanOrequal('o.foo', 'value');
        $expressionBuilder->gte('o.foo', 'value')->shouldHaveBeenCalled();
    }

    function it_builds_in(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->in('o.foo', ['value']);
        $expressionBuilder->in('o.foo', ['value'])->shouldHaveBeenCalled();
    }

    function it_builds_not_in(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->notIn('o.foo', ['value']);
        $expressionBuilder->notIn('o.foo', ['value'])->shouldHaveBeenCalled();
    }

    function it_builds_is_null()
    {
        $expr = $this->isNull('o.foo');
        $expr->getOperator()->shouldReturn(ExtraComparison::IS_NULL);
        $expr->getField()->shouldReturn('o.foo');
    }

    function it_builds_is_not_null()
    {
        $expr = $this->isNotNull('o.foo');
        $expr->getOperator()->shouldReturn(ExtraComparison::IS_NOT_NULL);
        $expr->getField()->shouldReturn('o.foo');
    }

    function it_builds_like(
        CollectionsExpressionBuilder $expressionBuilder
    )
    {
        $this->like('o.foo', 'value');
        $expressionBuilder->contains('o.foo', 'value')->shouldHaveBeenCalled();
    }

    function it_builds_not_like()
    {
        $expr = $this->notLike('o.foo', 'value');
        $expr->getOperator()->shouldReturn(ExtraComparison::NOT_CONTAINS);
        $expr->getField()->shouldReturn('o.foo');
    }

    function it_orders_by()
    {
        $this->orderBy('o.foo', 'asc');
        $this->getOrderBys()->shouldReturn([
            'o.foo' => 'asc',
        ]);
    }

    function it_adds_order_by()
    {
        $this->orderBy('o.foo', 'asc');
        $this->addOrderBy('o.bar', 'desc');
        $this->getOrderBys()->shouldReturn([
            'o.foo' => 'asc',
            'o.bar' => 'desc',
        ]);
    }
}