ExpressionBuilderTest - 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 A

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	519
Duplicated Lines	76.11 %
Coupling/Cohesion

Components	1
Dependencies	3
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
wmc	27
c	1
b	0
f	0
lcom	1
cbo	3
dl	395
loc	519
rs	10
24 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	9	2
A	testInheritance()	0	4	1
A	testAndX()	17	17	1
A	testOrX()	17	17	1
A	testAsc()	0	18	1
A	testDesc()	0	18	1
A	testEq()	21	21	1
A	testNeq()	21	21	1
A	testLt()	21	21	1
A	testLte()	21	21	1
A	testGt()	21	21	1
A	testGte()	21	21	1
A	testExists()	21	21	1
A	testIn()	21	21	1
A	testNotIn()	21	21	1
A	testIsNull()	21	21	1
A	testIsNotNull()	21	21	1
A	testLike()	23	23	2
A	testNotLike()	23	23	2
B	testBetween()	42	42	1
B	testNotBetween()	42	42	1
A	likeProvider()	0	9	1
A	createQueryBuilderMock()	0	6	1
A	createExprMock()	0	6	1
How to fix Duplicated Code

<?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\MongoDB;

use Doctrine\ODM\MongoDB\Query\Builder;
use Doctrine\ODM\MongoDB\Query\Expr;
use Lug\Component\Grid\DataSource\Doctrine\MongoDB\ExpressionBuilder;
use Lug\Component\Grid\DataSource\ExpressionBuilderInterface;

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

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|Builder
     */
    private $queryBuilder;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        if (!class_exists(Builder::class)) {
            $this->markTestSkipped();
        }

        $this->queryBuilder = $this->createQueryBuilderMock();
        $this->expressionBuilder = new ExpressionBuilder($this->queryBuilder);
    }

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

    public function testAndX()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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->exactly(2))
            ->method('addAnd')
            ->withConsecutive(
                [$expression1 = 'expression1'],
                [$expression2 = 'expression2']
            );

        $this->assertSame($expr, $this->expressionBuilder->andX([$expression1, $expression2]));
    }

    public function testOrX()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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->exactly(2))
            ->method('addOr')
            ->withConsecutive(
                [$expression1 = 'expression1'],
                [$expression2 = 'expression2']
            );

        $this->assertSame($expr, $this->expressionBuilder->orX([$expression1, $expression2]));
    }

    public function testAsc()
    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('sort')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo('ASC')
            )
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->asc($x));
    }

    public function testDesc()
    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('sort')
            ->with(
                $this->identicalTo($x = 'property'),
                $this->identicalTo('DESC')
            )
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->desc($x));
    }

    public function testEq()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('equals')
            ->with($this->identicalTo($y = 'value'))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->eq($x, $y));
    }

    public function testNeq()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('notEqual')
            ->with($this->identicalTo($y = 'value'))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->neq($x, $y));
    }

    public function testLt()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('lt')
            ->with($this->identicalTo($y = 'value'))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->lt($x, $y));
    }

    public function testLte()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('lte')
            ->with($this->identicalTo($y = 'value'))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->lte($x, $y));
    }

    public function testGt()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('gt')
            ->with($this->identicalTo($y = 'value'))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->gt($x, $y));
    }

    public function testGte()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('gte')
            ->with($this->identicalTo($y = 'value'))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->gte($x, $y));
    }

    public function testExists()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('exists')
            ->with($this->identicalTo(true))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->exists($x));
    }

    public function testIn()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('in')
            ->with($this->identicalTo($y = ['value']))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->in($x, $y));
    }

    public function testNotIn()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('notIn')
            ->with($this->identicalTo($y = ['value']))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->notIn($x, $y));
    }

    public function testIsNull()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('equals')
            ->with($this->identicalTo(null))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->isNull($x));
    }

    public function testIsNotNull()

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('notEqual')
            ->with($this->identicalTo(null))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->isNotNull($x));
    }

    /**
     * @dataProvider likeProvider
     */
    public function testLike($like, $regex)

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('equals')
            ->with($this->callback(function ($parameter) use ($regex) {
                return $parameter instanceof \MongoRegex && (string) $parameter === $regex;
            }))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->like($x, $like));
    }

    /**
     * @dataProvider likeProvider
     */
    public function testNotLike($like, $regex)

    {
        $this->queryBuilder
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('expr')
            ->will($this->returnValue($expr = $this->createExprMock()));

        $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('field')
            ->with($this->identicalTo($x = 'property'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->once())
            ->method('not')
            ->with($this->callback(function ($parameter) use ($regex) {
                return $parameter instanceof \MongoRegex && (string) $parameter === $regex;
            }))
            ->will($this->returnSelf());

        $this->assertSame($expr, $this->expressionBuilder->notLike($x, $like));
    }

    public function testBetween()

    {
        $this->queryBuilder
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->exactly(3))
            ->method('expr')
            ->willReturnOnConsecutiveCalls(
                $gteExpr = $this->createExprMock(),
                $lteExpr = $this->createExprMock(),
                $expr = $this->createExprMock()
            );

        $gteExpr
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('field')
            ->with($this->identicalTo($value = 'property'))
            ->will($this->returnSelf());

        $gteExpr
            ->expects($this->once())
            ->method('gte')
            ->with($this->identicalTo($x = 'from'))
            ->will($this->returnSelf());

        $lteExpr
            ->expects($this->once())
            ->method('field')
            ->with($this->identicalTo($value))
            ->will($this->returnSelf());

        $lteExpr
            ->expects($this->once())
            ->method('lte')
            ->with($this->identicalTo($y = 'to'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->exactly(2))
            ->method('addAnd')
            ->withConsecutive([$gteExpr], [$lteExpr]);

        $this->assertSame($expr, $this->expressionBuilder->between($value, $x, $y));
    }

    public function testNotBetween()

    {
        $this->queryBuilder
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->exactly(3))
            ->method('expr')
            ->willReturnOnConsecutiveCalls(
                $gteExpr = $this->createExprMock(),
                $lteExpr = $this->createExprMock(),
                $expr = $this->createExprMock()
            );

        $gteExpr
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('field')
            ->with($this->identicalTo($value = 'property'))
            ->will($this->returnSelf());

        $gteExpr
            ->expects($this->once())
            ->method('lt')
            ->with($this->identicalTo($x = 'from'))
            ->will($this->returnSelf());

        $lteExpr
            ->expects($this->once())
            ->method('field')
            ->with($this->identicalTo($value))
            ->will($this->returnSelf());

        $lteExpr
            ->expects($this->once())
            ->method('gt')
            ->with($this->identicalTo($y = 'to'))
            ->will($this->returnSelf());

        $expr
            ->expects($this->exactly(2))
            ->method('addOr')
            ->withConsecutive([$gteExpr], [$lteExpr]);

        $this->assertSame($expr, $this->expressionBuilder->notBetween($value, $x, $y));
    }

    /**
     * @return mixed[]
     */
    public function likeProvider()
    {
        return [
            'none'  => ['foo', '/^foo$/'],
            'start' => ['%foo', '/^.*?foo$/'],
            'end'   => ['foo%', '/^foo.*?$/'],
            'both'  => ['%foo%', '/^.*?foo.*?$/'],
        ];
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|Builder
     */
    private function createQueryBuilderMock()
    {
        return $this->getMockBuilder(Builder::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

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

1			<?php
2
3			/*
4			* This file is part of the Lug package.
5			*
6			* (c) Eric GELOEN <[email protected]>
7			*
8			* For the full copyright and license information, please read the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Lug\Component\Grid\Tests\DataSource\Doctrine\MongoDB;
13
14			use Doctrine\ODM\MongoDB\Query\Builder;
15			use Doctrine\ODM\MongoDB\Query\Expr;
16			use Lug\Component\Grid\DataSource\Doctrine\MongoDB\ExpressionBuilder;
17			use Lug\Component\Grid\DataSource\ExpressionBuilderInterface;
18
19			/**
20			* @author GeLo <[email protected]>
21			*/
22			class ExpressionBuilderTest extends \PHPUnit_Framework_TestCase
23			{
24			/**
25			* @var ExpressionBuilder
26			*/
27			private $expressionBuilder;
28
29			/**
30			* @var \PHPUnit_Framework_MockObject_MockObject\|Builder
31			*/
32			private $queryBuilder;
33
34			/**
35			* {@inheritdoc}
36			*/
37			protected function setUp()
38			{
39			if (!class_exists(Builder::class)) {
40			$this->markTestSkipped();
php-lug / lug

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

ExpressionBuilderTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

24 Methods

How to fix Duplicated Code

Duplicated Code

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

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
