MappingVisitorTest::setUp() - Code Metrics - Inspection of "Support matching Criteria on PersistentCollection..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#5669)

by Jeremy

created 2016-02-16 04:57 UTC

MappingVisitorTest::setUp() B

↳ Parent: MappingVisitorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	28
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	28
rs	8.8571
cc	1
eloc	18
nc	1
nop	0

<?php


namespace Doctrine\Tests\ORM\Persisters\Collection\Expr;


use Doctrine\Common\Collections\Expr\Comparison;
use Doctrine\Common\Collections\Expr\Value;
use Doctrine\Common\Collections\Expr\CompositeExpression;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\QuoteStrategy;
use Doctrine\ORM\Persisters\Collection\Expr\MappingVisitor;

class MappingVisitorTest extends \PHPUnit_Framework_TestCase
{
    /** @var  QuoteStrategy */
    private $quoteStrategy;
    /** @var  MappingVisitor */
    private $sut;

    protected function setUp()
    {
        parent::setUp();

        /** @var ClassMetadata $metadata */
        $metadata = $this->getMockBuilder('\Doctrine\ORM\Mapping\ClassMetadata')
            ->disableOriginalConstructor()
            ->getMock();

        /** @var AbstractPlatform $platform */
        $platform = $this->getMockBuilder('\Doctrine\DBAL\Platforms\AbstractPlatform')
            ->disableOriginalConstructor()
            ->getMock();

        $this->quoteStrategy = $this->getMockBuilder('\Doctrine\ORM\Mapping\QuoteStrategy')
            ->getMock();

        $this->quoteStrategy->expects($this->any())
            ->method('getColumnName')
            ->with('field', $metadata, $platform)
            ->willReturn('column');

        $this->sut = new MappingVisitor(
            $this->quoteStrategy,
            $metadata,
            $platform
        );
    }


    public function testWalkComparisonReturnsComparisonWithMappedField()
    {
        $expr = new Comparison('field', Comparison::GT, 73);
        /** @var Comparison $mapped */
        $mapped = $this->sut->dispatch($expr);
        static::assertInstanceOf('\Doctrine\Common\Collections\Expr\Comparison', $mapped);
        static::assertEquals('column', $mapped->getField());
        static::assertEquals($expr->getOperator(), $mapped->getOperator());
        static::assertEquals($expr->getValue(), $mapped->getValue());

    }

    public function testWalkValueReturnsValue()
    {
        $value = new Value('foo');
        static::assertSame($value, $this->sut->dispatch($value));
    }

    public function testWalkCompositeExpressionReturnsMappedCompositeExpression()
    {
        $gtExpr = new Comparison('field', Comparison::GT, 73);
        $ltExpr = new Comparison('field', Comparison::LT, 53);

        $composite = new CompositeExpression(
            CompositeExpression::TYPE_OR, [$gtExpr, $ltExpr]);

        /** @var CompositeExpression $mapped */
        $mapped = $this->sut->dispatch($composite);
        static::assertInstanceOf('\Doctrine\Common\Collections\Expr\CompositeExpression', $mapped);
        /** @var Comparison[]|Value[] $mappedExpressions */
        $mappedExpressions = $mapped->getExpressionList();

        static::assertCount(2, $mappedExpressions);

        static::assertInstanceOf('\Doctrine\Common\Collections\Expr\Comparison', $mappedExpressions[0]);
        static::assertInstanceOf('\Doctrine\Common\Collections\Expr\Comparison', $mappedExpressions[1]);

        static::assertEquals('column', $mappedExpressions[0]->getField());
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.
}
        static::assertEquals('column', $mappedExpressions[1]->getField());

        static::assertEquals($gtExpr->getOperator(), $mappedExpressions[0]->getOperator());
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.
}
        static::assertEquals($ltExpr->getOperator(), $mappedExpressions[1]->getOperator());

        static::assertEquals($gtExpr->getValue(), $mappedExpressions[0]->getValue());
        static::assertEquals($ltExpr->getValue(), $mappedExpressions[1]->getValue());
    }
}


1			<?php
2
3
4			namespace Doctrine\Tests\ORM\Persisters\Collection\Expr;
5
6
7			use Doctrine\Common\Collections\Expr\Comparison;
8			use Doctrine\Common\Collections\Expr\Value;
9			use Doctrine\Common\Collections\Expr\CompositeExpression;
10			use Doctrine\DBAL\Platforms\AbstractPlatform;
11			use Doctrine\ORM\Mapping\ClassMetadata;
12			use Doctrine\ORM\Mapping\QuoteStrategy;
13			use Doctrine\ORM\Persisters\Collection\Expr\MappingVisitor;
14
15			class MappingVisitorTest extends \PHPUnit_Framework_TestCase
16			{
17			/** @var QuoteStrategy */
18			private $quoteStrategy;
19			/** @var MappingVisitor */
20			private $sut;
21
22			protected function setUp()
23			{
24			parent::setUp();
25
26			/** @var ClassMetadata $metadata */
27			$metadata = $this->getMockBuilder('\Doctrine\ORM\Mapping\ClassMetadata')
28			->disableOriginalConstructor()
29			->getMock();
30
31			/** @var AbstractPlatform $platform */
32			$platform = $this->getMockBuilder('\Doctrine\DBAL\Platforms\AbstractPlatform')
33			->disableOriginalConstructor()
34			->getMock();
35
36			$this->quoteStrategy = $this->getMockBuilder('\Doctrine\ORM\Mapping\QuoteStrategy')
37			->getMock();
38
39			$this->quoteStrategy->expects($this->any())
40			->method('getColumnName')
41			->with('field', $metadata, $platform)
42			->willReturn('column');
43
44			$this->sut = new MappingVisitor(
45			$this->quoteStrategy,
46			$metadata,
47			$platform
48			);
49			}
50
51
52			public function testWalkComparisonReturnsComparisonWithMappedField()
53			{
54			$expr = new Comparison('field', Comparison::GT, 73);
55			/** @var Comparison $mapped */
56			$mapped = $this->sut->dispatch($expr);
57			static::assertInstanceOf('\Doctrine\Common\Collections\Expr\Comparison', $mapped);
58			static::assertEquals('column', $mapped->getField());
59			static::assertEquals($expr->getOperator(), $mapped->getOperator());
60			static::assertEquals($expr->getValue(), $mapped->getValue());
61
62			}
63
64			public function testWalkValueReturnsValue()
65			{
66			$value = new Value('foo');
67			static::assertSame($value, $this->sut->dispatch($value));
68			}
69
70			public function testWalkCompositeExpressionReturnsMappedCompositeExpression()
71			{
72			$gtExpr = new Comparison('field', Comparison::GT, 73);
73			$ltExpr = new Comparison('field', Comparison::LT, 53);
74
75			$composite = new CompositeExpression(
76			CompositeExpression::TYPE_OR, [$gtExpr, $ltExpr]);
77
78			/** @var CompositeExpression $mapped */
79			$mapped = $this->sut->dispatch($composite);
80			static::assertInstanceOf('\Doctrine\Common\Collections\Expr\CompositeExpression', $mapped);
81			/** @var Comparison[]\|Value[] $mappedExpressions */
82			$mappedExpressions = $mapped->getExpressionList();
83
84			static::assertCount(2, $mappedExpressions);
85
86			static::assertInstanceOf('\Doctrine\Common\Collections\Expr\Comparison', $mappedExpressions[0]);
87			static::assertInstanceOf('\Doctrine\Common\Collections\Expr\Comparison', $mappedExpressions[1]);
88
89			static::assertEquals('column', $mappedExpressions[0]->getField());
			0 ignored issues – show Bug introduced 2016-02-16 05:23 UTC by Report Bug Copy Issue Report The method `getField` does only exist in `Doctrine\Common\Collections\Expr\Comparison`, but not in `Doctrine\Common\Collections\Expr\Value`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
90			static::assertEquals('column', $mappedExpressions[1]->getField());
91
92			static::assertEquals($gtExpr->getOperator(), $mappedExpressions[0]->getOperator());
			0 ignored issues – show Bug introduced 2016-02-16 05:23 UTC by Report Bug Copy Issue Report The method `getOperator` does only exist in `Doctrine\Common\Collections\Expr\Comparison`, but not in `Doctrine\Common\Collections\Expr\Value`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
93			static::assertEquals($ltExpr->getOperator(), $mappedExpressions[1]->getOperator());
94
95			static::assertEquals($gtExpr->getValue(), $mappedExpressions[0]->getValue());
96			static::assertEquals($ltExpr->getValue(), $mappedExpressions[1]->getValue());
97			}
98			}
99

doctrine / orm

Pull Request — master (#5669)

MappingVisitorTest::setUp() B

Complexity

Size

Duplication

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like