ExpressionBuilderTest::testNeq() - Code Metrics - Inspection of "Move more code from bundles to components" - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 74c3c7...591b88 )

by Eric
created 2016-02-27 11:48 UTC
ExpressionBuilderTest::testNeq() A

↳ Parent: ExpressionBuilderTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	13
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
c	1
b	0
f	0
dl	0
loc	13
rs	9.4285
cc	1
eloc	9
nc	1
nop	0
<?php

/*
 * This file is part of the Lug package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Lug\Component\Grid\Tests\DataSource\Doctrine\ORM;

use Doctrine\ORM\Query\Expr;
use Lug\Component\Grid\DataSource\Doctrine\ORM\ExpressionBuilder;
use Lug\Component\Grid\DataSource\ExpressionBuilderInterface;

/**
 * @author GeLo <[email protected]>
 */
class ExpressionBuilderTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var ExpressionBuilder
     */
    private $builder;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|Expr
     */
    private $expr;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        $this->expr = $this->createExprMock();
        $this->builder = new ExpressionBuilder($this->expr);
    }

    public function testInheritance()
    {
        $this->assertInstanceOf(ExpressionBuilderInterface::class, $this->builder);
    }

    public function testAndX()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('andX')
            ->with(
                $this->identicalTo($expression1 = 'expression1'),
                $this->identicalTo($expression2 = 'expression2')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->andX([$expression1, $expression2]));
    }

    public function testOrX()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('orX')
            ->with(
                $this->identicalTo($expression1 = 'expression1'),
                $this->identicalTo($expression2 = 'expression2')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->orX([$expression1, $expression2]));
    }

    public function testAsc()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('asc')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->asc($x));
    }

    public function testDesc()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('desc')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->desc($x));
    }

    public function testEq()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('eq')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->eq($x, $y));
    }

    public function testNeq()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('neq')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->neq($x, $y));
    }

    public function testLt()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('lt')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->lt($x, $y));
    }

    public function testLte()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('lte')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->lte($x, $y));
    }

    public function testGt()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('gt')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->gt($x, $y));
    }

    public function testGte()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('gte')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->gte($x, $y));
    }

    public function testExists()

    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('exists')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->exists($x));
    }

    public function testIn()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('in')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->in($x, $y));
    }

    public function testNotIn()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('notIn')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->notIn($x, $y));
    }

    public function testIsNull()

    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('isNull')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->isNull($x));
    }

    public function testIsNotNull()

    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('isNotNull')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->isNotNull($x));
    }

    public function testLike()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('like')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->like($x, $y));
    }

    public function testNotLike()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('notLike')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo($y = 'placeholder')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->notLike($x, $y));
    }

    public function testBetween()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('between')
            ->with(
                $this->identicalTo($value = 'property'),
                $this->identicalTo($x = 'placeholder1'),
                $this->identicalTo($y = 'placeholder2')
            )
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->between($value, $x, $y));
    }

    public function testNotBetween()
    {
        $this->expr
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('between')
            ->with(
                $this->identicalTo($value = 'property'),
                $this->identicalTo($x = 'placeholder1'),
                $this->identicalTo($y = 'placeholder2')
            )
            ->will($this->returnValue($betweenExpression = 'between_expression'));

        $this->expr
            ->expects($this->once())
            ->method('not')
            ->with($this->identicalTo($betweenExpression))
            ->will($this->returnValue($expression = 'expression'));

        $this->assertSame($expression, $this->builder->notBetween($value, $x, $y));
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|Expr
     */
    private function createExprMock()
    {
        return $this->getMock(Expr::class);
    }
}

Push — master ( 74c3c7...591b88 )

ExpressionBuilderTest::testNeq() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

php-lug / lug

Push — master ( 74c3c7...591b88 )

ExpressionBuilderTest::testNeq() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
