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

Completed

Pull Request — master (#1120)

unknown

created 2020-01-06 21:04 UTC

DoctrineDataCollectorTest::testCollectEntities() A

↳ Parent: DoctrineDataCollectorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	34
rs	9.376
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 testDoNotCollectEntities() : 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->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 testDoNotCollectEntities() : 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->getEntities());
66			}
67
68			public function testGetGroupedQueries()
69			{
70			$logger = $this->getMockBuilder('Doctrine\DBAL\Logging\DebugStack')->getMock();
71			$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...
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			'sql' => 'SELECT * FROM foo WHERE bar = :bar',
74			'params' => [':bar' => 1],
75			'types' => null,
76			'executionMS' => 32,
77			];
78			$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...
79			'sql' => 'SELECT * FROM foo WHERE bar = :bar',
80			'params' => [':bar' => 2],
81			'types' => null,
82			'executionMS' => 25,
83			];
84			$collector = $this->createCollector([]);
85			$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...
86			$collector->collect(new Request(), new Response());
87			$groupedQueries = $collector->getGroupedQueries();
88			$this->assertCount(1, $groupedQueries['default']);
89			$this->assertSame('SELECT * FROM foo WHERE bar = :bar', $groupedQueries['default'][0]['sql']);
90			$this->assertSame(2, $groupedQueries['default'][0]['count']);
91
92			$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...
93			'sql' => 'SELECT * FROM bar',
94			'params' => [],
95			'types' => null,
96			'executionMS' => 25,
97			];
98			$collector->collect(new Request(), new Response());
99			$groupedQueries = $collector->getGroupedQueries();
100			$this->assertCount(2, $groupedQueries['default']);
101			$this->assertSame('SELECT * FROM bar', $groupedQueries['default'][1]['sql']);
102			$this->assertSame(1, $groupedQueries['default'][1]['count']);
103			}
104
105			/**
106			* @param string $entityFQCN
107			*
108			* @return ClassMetadataInfo
109			*/
110			private function createEntityMetadata($entityFQCN)
111			{
112			$metadata = new ClassMetadataInfo($entityFQCN);
113			$metadata->name = $entityFQCN;
114			$metadata->reflClass = new ReflectionClass('stdClass');
115
116			return $metadata;
117			}
118
119			/**
120			* @param array $managers
121			*
122			* @return DoctrineDataCollector
123			*/
124			private function createCollector(array $managers, bool $shouldValidateSchema = true)
125			{
126			$registry = $this->getMockBuilder('Doctrine\Persistence\ManagerRegistry')->getMock();
127			$registry
128			->expects($this->any())
129			->method('getConnectionNames')
130			->will($this->returnValue(['default' => 'doctrine.dbal.default_connection']));
131			$registry
132			->expects($this->any())
133			->method('getManagerNames')
134			->will($this->returnValue(['default' => 'doctrine.orm.default_entity_manager']));
135			$registry
136			->expects($this->any())
137			->method('getManagers')
138			->will($this->returnValue($managers));
139
140			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...
141			}
142			}
143

doctrine / DoctrineBundle

Pull Request — master (#1120)

DoctrineDataCollectorTest::testCollectEntities() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like