DoctrineDataCollectorTest::testDoesNotCollectEntities() - Code Metrics - Inspection of "Add a feature switch to trigger SchemaValidator in..." - doctrine/DoctrineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9a24ae...4e60cd )

by Gabriel

created 2020-01-07 09:12 UTC

testDoesNotCollectEntities() A

↳ Parent: DoctrineDataCollectorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.7333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Doctrine\Bundle\DoctrineBundle\Tests\DataCollector;

use Doctrine\Bundle\DoctrineBundle\DataCollector\DoctrineDataCollector;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use PHPUnit\Framework\TestCase;
use ReflectionClass;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

class DoctrineDataCollectorTest extends TestCase
{
    const FIRST_ENTITY  = 'TestBundle\Test\Entity\Test1';
    const SECOND_ENTITY = 'TestBundle\Test\Entity\Test2';

    public function testCollectEntities()
    {
        $manager   = $this->getMockBuilder('Doctrine\ORM\EntityManager')->disableOriginalConstructor()->getMock();
        $config    = $this->getMockBuilder('Doctrine\ORM\Configuration')->getMock();
        $factory   = $this->getMockBuilder('Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory')
            ->setMethods(['getLoadedMetadata'])->getMockForAbstractClass();
        $collector = $this->createCollector(['default' => $manager]);

        $manager->expects($this->any())
            ->method('getMetadataFactory')
            ->will($this->returnValue($factory));
        $manager->expects($this->any())
            ->method('getConfiguration')
            ->will($this->returnValue($config));

        $config->expects($this->once())
            ->method('isSecondLevelCacheEnabled')
            ->will($this->returnValue(false));

        $metadatas = [
            $this->createEntityMetadata(self::FIRST_ENTITY),
            $this->createEntityMetadata(self::SECOND_ENTITY),
            $this->createEntityMetadata(self::FIRST_ENTITY),
        ];
        $factory->expects($this->once())
            ->method('getLoadedMetadata')
            ->will($this->returnValue($metadatas));

        $collector->collect(new Request(), new Response());

        $entities = $collector->getEntities();
        $this->assertArrayHasKey('default', $entities);
        $this->assertCount(2, $entities['default']);
    }

    public function testDoesNotCollectEntities() : void
    {
        $manager   = $this->createMock('Doctrine\ORM\EntityManager');
        $config    = $this->createMock('Doctrine\ORM\Configuration');
        $collector = $this->createCollector(['default' => $manager], false);

        $manager->expects($this->never())
            ->method('getMetadataFactory');
        $manager->method('getConfiguration')
            ->will($this->returnValue($config));

        $collector->collect(new Request(), new Response());

        $this->assertEmpty($collector->getMappingErrors());
        $this->assertEmpty($collector->getEntities());
    }

    public function testGetGroupedQueries()
    {
        $logger            = $this->getMockBuilder('Doctrine\DBAL\Logging\DebugStack')->getMock();
        $logger->queries   = [];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $logger->queries[] = [
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            'sql' => 'SELECT * FROM foo WHERE bar = :bar',
            'params' => [':bar' => 1],
            'types' => null,
            'executionMS' => 32,
        ];
        $logger->queries[] = [
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            'sql' => 'SELECT * FROM foo WHERE bar = :bar',
            'params' => [':bar' => 2],
            'types' => null,
            'executionMS' => 25,
        ];
        $collector         = $this->createCollector([]);
        $collector->addLogger('default', $logger);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $collector->collect(new Request(), new Response());
        $groupedQueries = $collector->getGroupedQueries();
        $this->assertCount(1, $groupedQueries['default']);
        $this->assertSame('SELECT * FROM foo WHERE bar = :bar', $groupedQueries['default'][0]['sql']);
        $this->assertSame(2, $groupedQueries['default'][0]['count']);

        $logger->queries[] = [
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            'sql' => 'SELECT * FROM bar',
            'params' => [],
            'types' => null,
            'executionMS' => 25,
        ];
        $collector->collect(new Request(), new Response());
        $groupedQueries = $collector->getGroupedQueries();
        $this->assertCount(2, $groupedQueries['default']);
        $this->assertSame('SELECT * FROM bar', $groupedQueries['default'][1]['sql']);
        $this->assertSame(1, $groupedQueries['default'][1]['count']);
    }

    /**
     * @param string $entityFQCN
     *
     * @return ClassMetadataInfo
     */
    private function createEntityMetadata($entityFQCN)
    {
        $metadata            = new ClassMetadataInfo($entityFQCN);
        $metadata->name      = $entityFQCN;
        $metadata->reflClass = new ReflectionClass('stdClass');

        return $metadata;
    }

    /**
     * @param array $managers
     *
     * @return DoctrineDataCollector
     */
    private function createCollector(array $managers, bool $shouldValidateSchema = true)
    {
        $registry = $this->getMockBuilder('Doctrine\Persistence\ManagerRegistry')->getMock();
        $registry
            ->expects($this->any())
            ->method('getConnectionNames')
            ->will($this->returnValue(['default' => 'doctrine.dbal.default_connection']));
        $registry
            ->expects($this->any())
            ->method('getManagerNames')
            ->will($this->returnValue(['default' => 'doctrine.orm.default_entity_manager']));
        $registry
            ->expects($this->any())
            ->method('getManagers')
            ->will($this->returnValue($managers));

        return new DoctrineDataCollector($registry, $shouldValidateSchema);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
}


1			<?php
2
3			namespace Doctrine\Bundle\DoctrineBundle\Tests\DataCollector;
4
5			use Doctrine\Bundle\DoctrineBundle\DataCollector\DoctrineDataCollector;
6			use Doctrine\ORM\Mapping\ClassMetadataInfo;
7			use PHPUnit\Framework\TestCase;
8			use ReflectionClass;
9			use Symfony\Component\HttpFoundation\Request;
10			use Symfony\Component\HttpFoundation\Response;
11
12			class DoctrineDataCollectorTest extends TestCase
13			{
14			const FIRST_ENTITY = 'TestBundle\Test\Entity\Test1';
15			const SECOND_ENTITY = 'TestBundle\Test\Entity\Test2';
16
17			public function testCollectEntities()
18			{
19			$manager = $this->getMockBuilder('Doctrine\ORM\EntityManager')->disableOriginalConstructor()->getMock();
20			$config = $this->getMockBuilder('Doctrine\ORM\Configuration')->getMock();
21			$factory = $this->getMockBuilder('Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory')
22			->setMethods(['getLoadedMetadata'])->getMockForAbstractClass();
23			$collector = $this->createCollector(['default' => $manager]);
24
25			$manager->expects($this->any())
26			->method('getMetadataFactory')
27			->will($this->returnValue($factory));
28			$manager->expects($this->any())
29			->method('getConfiguration')
30			->will($this->returnValue($config));
31
32			$config->expects($this->once())
33			->method('isSecondLevelCacheEnabled')
34			->will($this->returnValue(false));
35
36			$metadatas = [
37			$this->createEntityMetadata(self::FIRST_ENTITY),
38			$this->createEntityMetadata(self::SECOND_ENTITY),
39			$this->createEntityMetadata(self::FIRST_ENTITY),
40			];
41			$factory->expects($this->once())
42			->method('getLoadedMetadata')
43			->will($this->returnValue($metadatas));
44
45			$collector->collect(new Request(), new Response());
46
47			$entities = $collector->getEntities();
48			$this->assertArrayHasKey('default', $entities);
49			$this->assertCount(2, $entities['default']);
50			}
51
52			public function testDoesNotCollectEntities() : void
53			{
54			$manager = $this->createMock('Doctrine\ORM\EntityManager');
55			$config = $this->createMock('Doctrine\ORM\Configuration');
56			$collector = $this->createCollector(['default' => $manager], false);
57
58			$manager->expects($this->never())
59			->method('getMetadataFactory');
60			$manager->method('getConfiguration')
61			->will($this->returnValue($config));
62
63			$collector->collect(new Request(), new Response());
64
65			$this->assertEmpty($collector->getMappingErrors());
66			$this->assertEmpty($collector->getEntities());
67			}
68
69			public function testGetGroupedQueries()
70			{
71			$logger = $this->getMockBuilder('Doctrine\DBAL\Logging\DebugStack')->getMock();
72			$logger->queries = [];
			0 ignored issues – show Bug introduced 2018-04-02 19:31 UTC by Report Bug Copy Issue Report Accessing `queries` on the interface `PHPUnit\Framework\MockObject\MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
73			$logger->queries[] = [
			0 ignored issues – show Bug introduced 2018-04-02 19:31 UTC by Report Bug Copy Issue Report Accessing `queries` on the interface `PHPUnit\Framework\MockObject\MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
74			'sql' => 'SELECT * FROM foo WHERE bar = :bar',
75			'params' => [':bar' => 1],
76			'types' => null,
77			'executionMS' => 32,
78			];
79			$logger->queries[] = [
			0 ignored issues – show Bug introduced 2018-04-02 19:31 UTC by Report Bug Copy Issue Report Accessing `queries` on the interface `PHPUnit\Framework\MockObject\MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
80			'sql' => 'SELECT * FROM foo WHERE bar = :bar',
81			'params' => [':bar' => 2],
82			'types' => null,
83			'executionMS' => 25,
84			];
85			$collector = $this->createCollector([]);
86			$collector->addLogger('default', $logger);
			0 ignored issues – show Documentation introduced 2018-03-30 14:39 UTC by Report Bug Copy Issue Report `$logger` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `object<Doctrine\DBAL\Logging\DebugStack>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
87			$collector->collect(new Request(), new Response());
88			$groupedQueries = $collector->getGroupedQueries();
89			$this->assertCount(1, $groupedQueries['default']);
90			$this->assertSame('SELECT * FROM foo WHERE bar = :bar', $groupedQueries['default'][0]['sql']);
91			$this->assertSame(2, $groupedQueries['default'][0]['count']);
92
93			$logger->queries[] = [
			0 ignored issues – show Bug introduced 2018-04-02 19:31 UTC by Report Bug Copy Issue Report Accessing `queries` on the interface `PHPUnit\Framework\MockObject\MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
94			'sql' => 'SELECT * FROM bar',
95			'params' => [],
96			'types' => null,
97			'executionMS' => 25,
98			];
99			$collector->collect(new Request(), new Response());
100			$groupedQueries = $collector->getGroupedQueries();
101			$this->assertCount(2, $groupedQueries['default']);
102			$this->assertSame('SELECT * FROM bar', $groupedQueries['default'][1]['sql']);
103			$this->assertSame(1, $groupedQueries['default'][1]['count']);
104			}
105
106			/**
107			* @param string $entityFQCN
108			*
109			* @return ClassMetadataInfo
110			*/
111			private function createEntityMetadata($entityFQCN)
112			{
113			$metadata = new ClassMetadataInfo($entityFQCN);
114			$metadata->name = $entityFQCN;
115			$metadata->reflClass = new ReflectionClass('stdClass');
116
117			return $metadata;
118			}
119
120			/**
121			* @param array $managers
122			*
123			* @return DoctrineDataCollector
124			*/
125			private function createCollector(array $managers, bool $shouldValidateSchema = true)
126			{
127			$registry = $this->getMockBuilder('Doctrine\Persistence\ManagerRegistry')->getMock();
128			$registry
129			->expects($this->any())
130			->method('getConnectionNames')
131			->will($this->returnValue(['default' => 'doctrine.dbal.default_connection']));
132			$registry
133			->expects($this->any())
134			->method('getManagerNames')
135			->will($this->returnValue(['default' => 'doctrine.orm.default_entity_manager']));
136			$registry
137			->expects($this->any())
138			->method('getManagers')
139			->will($this->returnValue($managers));
140
141			return new DoctrineDataCollector($registry, $shouldValidateSchema);
			0 ignored issues – show Documentation introduced 2020-01-06 14:02 UTC by Report Bug Copy Issue Report `$registry` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `object<Doctrine\Persistence\ManagerRegistry>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
142			}
143			}
144

doctrine / DoctrineBundle

Push — master ( 9a24ae...4e60cd )

testDoesNotCollectEntities() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like