ModelManagerTest - Code Metrics - Inspection of "Merge remote-tracking branch 'upstream/3.x'" - sonata-project/SonataDoctrineMongoDBAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eaaca4...7cda52 )

unknown

created 2020-07-31 15:17 UTC

ModelManagerTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	391
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	22
lcom	1
cbo	4
dl	0
loc	391
rs	10
c	0
b	0
f	0

22 Methods

Rating	Name	Size	Complexity
A	getMetadataForEmbeddedDocument()	14	1
A	getMetadataForAssociatedDocument()	23	1
A	getMetadataForContainerDocument()	32	1
A	setUp()	7	1
A	testNormalizedIdentifierException()	8	1
A	getWrongDocuments()	10	1
A	testGetNormalizedIdentifierNull()	6	1
A	testSortParameters()	51	1
A	testGetParentMetadataForProperty()	48	1
A	testModelReverseTransformWithSetter()	18	1
A	testModelReverseTransformFailsWithPrivateSetter()	9	1
A	testModelReverseTransformFailsWithPrivateProperties()	9	1
A	testModelReverseTransformFailsWithPrivateProperties2()	9	1
A	testCollections()	22	1
A	testModelTransform()	9	1
A	testGetPaginationParameters()	20	1
A	testGetModelInstanceException()	8	1
A	testGetModelInstanceForProtectedDocument()	6	1
A	testFindBadId()	6	1
A	testGetUrlSafeIdentifierException()	8	1
A	testGetUrlSafeIdentifierNull()	6	1
A	createModelManagerForClass()	23	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\DoctrineMongoDBAdminBundle\Tests\Model;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\FieldDescriptionInterface;
use Sonata\AdminBundle\Datagrid\Datagrid;
use Sonata\AdminBundle\Datagrid\DatagridInterface;
use Sonata\DoctrineMongoDBAdminBundle\Admin\FieldDescription;
use Sonata\DoctrineMongoDBAdminBundle\Model\ModelManager;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\AbstractDocument;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\AssociatedDocument;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\ContainerDocument;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\EmbeddedDocument;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\ProtectedDocument;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\SimpleDocument;
use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\SimpleDocumentWithPrivateSetter;
use Symfony\Bridge\Doctrine\ManagerRegistry;
use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

final class ModelManagerTest extends TestCase
{
    /**
     * @var PropertyAccessor
     */
    private $propertyAccessor;

    /**
     * @var Stub&ManagerRegistry
     */
    private $registry;

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

        $this->registry = $this->createStub(ManagerRegistry::class);
        $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
    }

    /**
     * @dataProvider getWrongDocuments
     *
     * @param mixed $document
     */
    public function testNormalizedIdentifierException($document): void
    {
        $manager = new ModelManager($this->registry, $this->propertyAccessor);

        $this->expectException(\RuntimeException::class);

        $manager->getNormalizedIdentifier($document);
    }

    public function getWrongDocuments(): iterable
    {
        yield [0];
        yield [1];
        yield [false];
        yield [true];
        yield [[]];
        yield [''];
        yield ['sonata-project'];
    }

    public function testGetNormalizedIdentifierNull(): void
    {
        $manager = new ModelManager($this->registry, $this->propertyAccessor);

        $this->assertNull($manager->getNormalizedIdentifier(null));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    public function testSortParameters(): void
    {
        $manager = new ModelManager($this->registry, $this->propertyAccessor);

        $datagrid1 = $this->createStub(Datagrid::class);
        $datagrid2 = $this->createStub(Datagrid::class);

        $field1 = new FieldDescription();
        $field1->setName('field1');

        $field2 = new FieldDescription();
        $field2->setName('field2');

        $field3 = new FieldDescription();
        $field3->setName('field3');
        $field3->setOption('sortable', 'field3sortBy');

        $datagrid1
            ->method('getValues')
            ->willReturn([
                '_sort_by' => $field1,
                '_sort_order' => 'ASC',
            ]);

        $datagrid2
            ->method('getValues')
            ->willReturn([
                '_sort_by' => $field3,
                '_sort_order' => 'ASC',
            ]);

        $parameters = $manager->getSortParameters($field1, $datagrid1);

        $this->assertSame('DESC', $parameters['filter']['_sort_order']);
        $this->assertSame('field1', $parameters['filter']['_sort_by']);

        $parameters = $manager->getSortParameters($field2, $datagrid1);

        $this->assertSame('ASC', $parameters['filter']['_sort_order']);
        $this->assertSame('field2', $parameters['filter']['_sort_by']);

        $parameters = $manager->getSortParameters($field3, $datagrid1);

        $this->assertSame('ASC', $parameters['filter']['_sort_order']);
        $this->assertSame('field3sortBy', $parameters['filter']['_sort_by']);

        $parameters = $manager->getSortParameters($field3, $datagrid2);

        $this->assertSame('DESC', $parameters['filter']['_sort_order']);
        $this->assertSame('field3sortBy', $parameters['filter']['_sort_by']);
    }

    public function testGetParentMetadataForProperty(): void
    {
        $containerDocumentClass = ContainerDocument::class;
        $associatedDocumentClass = AssociatedDocument::class;
        $embeddedDocumentClass = EmbeddedDocument::class;

        $dm = $this->createStub(DocumentManager::class);

        $modelManager = new ModelManager($this->registry, $this->propertyAccessor);

        $this->registry
            ->method('getManagerForClass')
            ->willReturn($dm);

        $metadataFactory = $this->createStub(ClassMetadataFactory::class);

        $dm
            ->method('getMetadataFactory')
            ->willReturn($metadataFactory);

        $containerDocumentMetadata = $this->getMetadataForContainerDocument();
        $associatedDocumentMetadata = $this->getMetadataForAssociatedDocument();
        $embeddedDocumentMetadata = $this->getMetadataForEmbeddedDocument();

        $metadataFactory->method('getMetadataFor')
            ->willReturnMap(
                [
                    [$containerDocumentClass, $containerDocumentMetadata],
                    [$embeddedDocumentClass, $embeddedDocumentMetadata],
                    [$associatedDocumentClass, $associatedDocumentMetadata],
                ]
            );

        /** @var ClassMetadata $metadata */
        [$metadata, $lastPropertyName] = $modelManager

            ->getParentMetadataForProperty($containerDocumentClass, 'plainField');
        $this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'integer');


        [$metadata, $lastPropertyName] = $modelManager

            ->getParentMetadataForProperty($containerDocumentClass, 'associatedDocument.plainField');
        $this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'string');


        [$metadata, $lastPropertyName] = $modelManager

            ->getParentMetadataForProperty($containerDocumentClass, 'embeddedDocument.plainField');
        $this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');


        $this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');

    }

    public function testModelReverseTransformWithSetter(): void
    {
        $class = SimpleDocument::class;

        $manager = $this->createModelManagerForClass($class);
        $object = $manager->modelReverseTransform(
            $class,
            [
                'schmeckles' => 42,
                'multi_word_property' => 'hello',
                'schwifty' => true,
            ]
        );
        $this->assertInstanceOf($class, $object);
        $this->assertSame(42, $object->getSchmeckles());
        $this->assertSame('hello', $object->getMultiWordProperty());
        $this->assertTrue($object->schwifty);
    }

    public function testModelReverseTransformFailsWithPrivateSetter(): void
    {
        $class = SimpleDocumentWithPrivateSetter::class;
        $manager = $this->createModelManagerForClass($class);

        $this->expectException(NoSuchPropertyException::class);

        $manager->modelReverseTransform($class, ['schmeckles' => 42]);
    }

    public function testModelReverseTransformFailsWithPrivateProperties(): void
    {
        $class = SimpleDocument::class;
        $manager = $this->createModelManagerForClass($class);

        $this->expectException(NoSuchPropertyException::class);

        $manager->modelReverseTransform($class, ['plumbus' => 42]);
    }

    public function testModelReverseTransformFailsWithPrivateProperties2(): void
    {
        $class = SimpleDocument::class;
        $manager = $this->createModelManagerForClass($class);

        $this->expectException(NoSuchPropertyException::class);

        $manager->modelReverseTransform($class, ['plumbus' => 42]);
    }

    public function testCollections(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $collection = $model->getModelCollectionInstance('whyDoWeEvenHaveThisParameter');
        $this->assertInstanceOf(ArrayCollection::class, $collection);

        $item1 = new \stdClass();
        $item2 = new \stdClass();
        $model->collectionAddElement($collection, $item1);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $model->collectionAddElement($collection, $item2);

        $this->assertTrue($model->collectionHasElement($collection, $item1));

        $model->collectionRemoveElement($collection, $item1);

        $this->assertFalse($model->collectionHasElement($collection, $item1));

        $model->collectionClear($collection);

        $this->assertTrue($collection->isEmpty());

    }

    public function testModelTransform(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $instance = new \stdClass();
        $result = $model->modelTransform('thisIsNotUsed', $instance);

        $this->assertSame($instance, $result);
    }

    public function testGetPaginationParameters(): void
    {
        $datagrid = $this->createMock(DatagridInterface::class);
        $fieldDescription = $this->createMock(FieldDescriptionInterface::class);

        $datagrid->expects($this->once())
            ->method('getValues')
            ->willReturn(['_sort_by' => $fieldDescription]);

        $fieldDescription->expects($this->once())
            ->method('getName')
            ->willReturn($name = 'test');

        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $result = $model->getPaginationParameters($datagrid, $page = 5);

        $this->assertSame($page, $result['filter']['_page']);
        $this->assertSame($name, $result['filter']['_sort_by']);
    }

    public function testGetModelInstanceException(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $this->expectException(\InvalidArgumentException::class);

        $model->getModelInstance(AbstractDocument::class);
    }

    public function testGetModelInstanceForProtectedDocument(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $this->assertInstanceOf(ProtectedDocument::class, $model->getModelInstance(ProtectedDocument::class));
    }

    public function testFindBadId(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $this->assertNull($model->find('notImportant', null));
    }

    public function testGetUrlSafeIdentifierException(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $this->expectException(\RuntimeException::class);

        $model->getNormalizedIdentifier(new \stdClass());
    }

    public function testGetUrlSafeIdentifierNull(): void
    {
        $model = new ModelManager($this->registry, $this->propertyAccessor);

        $this->assertNull($model->getNormalizedIdentifier(null));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    private function createModelManagerForClass(string $class): ModelManager
    {
        $metadataFactory = $this->createMock(ClassMetadataFactory::class);
        $modelManager = $this->createMock(ObjectManager::class);
        $registry = $this->createMock(ManagerRegistry::class);

        $classMetadata = new ClassMetadata($class);
        $classMetadata->reflClass = new \ReflectionClass($class);

        $modelManager->expects($this->once())
            ->method('getMetadataFactory')
            ->willReturn($metadataFactory);
        $metadataFactory->expects($this->once())
            ->method('getMetadataFor')
            ->with($class)
            ->willReturn($classMetadata);
        $registry->expects($this->once())
            ->method('getManagerForClass')
            ->with($class)
            ->willReturn($modelManager);

        return new ModelManager($registry, $this->propertyAccessor);
    }

    private function getMetadataForEmbeddedDocument(): ClassMetadata
    {
        $metadata = new ClassMetadata(EmbeddedDocument::class);

        $metadata->fieldMappings = [
            'plainField' => [
                'fieldName' => 'plainField',
                'columnName' => 'plainField',
                'type' => 'boolean',
            ],
        ];

        return $metadata;
    }

    private function getMetadataForAssociatedDocument(): ClassMetadata
    {
        $embeddedDocumentClass = EmbeddedDocument::class;

        $metadata = new ClassMetadata(AssociatedDocument::class);

        $metadata->fieldMappings = [
            'plainField' => [
                'fieldName' => 'plainField',
                'name' => 'plainField',
                'columnName' => 'plainField',
                'type' => 'string',
            ],
        ];

        $metadata->mapOneEmbedded([
            'fieldName' => 'embeddedDocument',
            'name' => 'embeddedDocument',
            'targetDocument' => $embeddedDocumentClass,
        ]);

        return $metadata;
    }

    private function getMetadataForContainerDocument(): ClassMetadata
    {
        $containerDocumentClass = ContainerDocument::class;
        $associatedDocumentClass = AssociatedDocument::class;
        $embeddedDocumentClass = EmbeddedDocument::class;

        $metadata = new ClassMetadata($containerDocumentClass);

        $metadata->fieldMappings = [
            'plainField' => [
                'fieldName' => 'plainField',
                'name' => 'plainField',
                'columnName' => 'plainField',
                'type' => 'integer',
            ],
        ];

        $metadata->associationMappings['associatedDocument'] = [
            'fieldName' => 'associatedDocument',
            'name' => 'associatedDocument',
            'targetDocument' => $associatedDocumentClass,
            'sourceDocument' => $containerDocumentClass,
        ];

        $metadata->mapOneEmbedded([
            'fieldName' => 'embeddedDocument',
            'name' => 'embeddedDocument',
            'targetDocument' => $embeddedDocumentClass,
        ]);

        return $metadata;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\DoctrineMongoDBAdminBundle\Tests\Model;
15
16			use Doctrine\Common\Collections\ArrayCollection;
17			use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory;
18			use Doctrine\Common\Persistence\ObjectManager;
19			use Doctrine\ODM\MongoDB\DocumentManager;
20			use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
21			use PHPUnit\Framework\MockObject\Stub;
22			use PHPUnit\Framework\TestCase;
23			use Sonata\AdminBundle\Admin\FieldDescriptionInterface;
24			use Sonata\AdminBundle\Datagrid\Datagrid;
25			use Sonata\AdminBundle\Datagrid\DatagridInterface;
26			use Sonata\DoctrineMongoDBAdminBundle\Admin\FieldDescription;
27			use Sonata\DoctrineMongoDBAdminBundle\Model\ModelManager;
28			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\AbstractDocument;
29			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\AssociatedDocument;
30			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\ContainerDocument;
31			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\EmbeddedDocument;
32			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\ProtectedDocument;
33			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\SimpleDocument;
34			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\SimpleDocumentWithPrivateSetter;
35			use Symfony\Bridge\Doctrine\ManagerRegistry;
36			use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
37			use Symfony\Component\PropertyAccess\PropertyAccess;
38			use Symfony\Component\PropertyAccess\PropertyAccessor;
39
40			final class ModelManagerTest extends TestCase
41			{
42			/**
43			* @var PropertyAccessor
44			*/
45			private $propertyAccessor;
46
47			/**
48			* @var Stub&ManagerRegistry
49			*/
50			private $registry;
51
52			protected function setUp(): void
53			{
54			parent::setUp();
55
56			$this->registry = $this->createStub(ManagerRegistry::class);
57			$this->propertyAccessor = PropertyAccess::createPropertyAccessor();
58			}
59
60			/**
61			* @dataProvider getWrongDocuments
62			*
63			* @param mixed $document
64			*/
65			public function testNormalizedIdentifierException($document): void
66			{
67			$manager = new ModelManager($this->registry, $this->propertyAccessor);
68
69			$this->expectException(\RuntimeException::class);
70
71			$manager->getNormalizedIdentifier($document);
72			}
73
74			public function getWrongDocuments(): iterable
75			{
76			yield [0];
77			yield [1];
78			yield [false];
79			yield [true];
80			yield [[]];
81			yield [''];
82			yield ['sonata-project'];
83			}
84
85			public function testGetNormalizedIdentifierNull(): void
86			{
87			$manager = new ModelManager($this->registry, $this->propertyAccessor);
88
89			$this->assertNull($manager->getNormalizedIdentifier(null));
			0 ignored issues – show Documentation introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report `null` is of type `null`, but the function expects a `object`. 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...
90			}
91
92			public function testSortParameters(): void
93			{
94			$manager = new ModelManager($this->registry, $this->propertyAccessor);
95
96			$datagrid1 = $this->createStub(Datagrid::class);
97			$datagrid2 = $this->createStub(Datagrid::class);
98
99			$field1 = new FieldDescription();
100			$field1->setName('field1');
101
102			$field2 = new FieldDescription();
103			$field2->setName('field2');
104
105			$field3 = new FieldDescription();
106			$field3->setName('field3');
107			$field3->setOption('sortable', 'field3sortBy');
108
109			$datagrid1
110			->method('getValues')
111			->willReturn([
112			'_sort_by' => $field1,
113			'_sort_order' => 'ASC',
114			]);
115
116			$datagrid2
117			->method('getValues')
118			->willReturn([
119			'_sort_by' => $field3,
120			'_sort_order' => 'ASC',
121			]);
122
123			$parameters = $manager->getSortParameters($field1, $datagrid1);
124
125			$this->assertSame('DESC', $parameters['filter']['_sort_order']);
126			$this->assertSame('field1', $parameters['filter']['_sort_by']);
127
128			$parameters = $manager->getSortParameters($field2, $datagrid1);
129
130			$this->assertSame('ASC', $parameters['filter']['_sort_order']);
131			$this->assertSame('field2', $parameters['filter']['_sort_by']);
132
133			$parameters = $manager->getSortParameters($field3, $datagrid1);
134
135			$this->assertSame('ASC', $parameters['filter']['_sort_order']);
136			$this->assertSame('field3sortBy', $parameters['filter']['_sort_by']);
137
138			$parameters = $manager->getSortParameters($field3, $datagrid2);
139
140			$this->assertSame('DESC', $parameters['filter']['_sort_order']);
141			$this->assertSame('field3sortBy', $parameters['filter']['_sort_by']);
142			}
143
144			public function testGetParentMetadataForProperty(): void
145			{
146			$containerDocumentClass = ContainerDocument::class;
147			$associatedDocumentClass = AssociatedDocument::class;
148			$embeddedDocumentClass = EmbeddedDocument::class;
149
150			$dm = $this->createStub(DocumentManager::class);
151
152			$modelManager = new ModelManager($this->registry, $this->propertyAccessor);
153
154			$this->registry
155			->method('getManagerForClass')
156			->willReturn($dm);
157
158			$metadataFactory = $this->createStub(ClassMetadataFactory::class);
159
160			$dm
161			->method('getMetadataFactory')
162			->willReturn($metadataFactory);
163
164			$containerDocumentMetadata = $this->getMetadataForContainerDocument();
165			$associatedDocumentMetadata = $this->getMetadataForAssociatedDocument();
166			$embeddedDocumentMetadata = $this->getMetadataForEmbeddedDocument();
167
168			$metadataFactory->method('getMetadataFor')
169			->willReturnMap(
170			[
171			[$containerDocumentClass, $containerDocumentMetadata],
172			[$embeddedDocumentClass, $embeddedDocumentMetadata],
173			[$associatedDocumentClass, $associatedDocumentMetadata],
174			]
175			);
176
177			/** @var ClassMetadata $metadata */
178			[$metadata, $lastPropertyName] = $modelManager
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history... Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$lastPropertyName` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
179			->getParentMetadataForProperty($containerDocumentClass, 'plainField');
180			$this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'integer');
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
181
182			[$metadata, $lastPropertyName] = $modelManager
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
183			->getParentMetadataForProperty($containerDocumentClass, 'associatedDocument.plainField');
184			$this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'string');
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
185
186			[$metadata, $lastPropertyName] = $modelManager
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
187			->getParentMetadataForProperty($containerDocumentClass, 'embeddedDocument.plainField');
188			$this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
189
190			$this->assertSame($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The variable `$metadata` does not exist. Did you mean `$metadataFactory`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
191			}
192
193			public function testModelReverseTransformWithSetter(): void
194			{
195			$class = SimpleDocument::class;
196
197			$manager = $this->createModelManagerForClass($class);
198			$object = $manager->modelReverseTransform(
199			$class,
200			[
201			'schmeckles' => 42,
202			'multi_word_property' => 'hello',
203			'schwifty' => true,
204			]
205			);
206			$this->assertInstanceOf($class, $object);
207			$this->assertSame(42, $object->getSchmeckles());
208			$this->assertSame('hello', $object->getMultiWordProperty());
209			$this->assertTrue($object->schwifty);
210			}
211
212			public function testModelReverseTransformFailsWithPrivateSetter(): void
213			{
214			$class = SimpleDocumentWithPrivateSetter::class;
215			$manager = $this->createModelManagerForClass($class);
216
217			$this->expectException(NoSuchPropertyException::class);
218
219			$manager->modelReverseTransform($class, ['schmeckles' => 42]);
220			}
221
222			public function testModelReverseTransformFailsWithPrivateProperties(): void
223			{
224			$class = SimpleDocument::class;
225			$manager = $this->createModelManagerForClass($class);
226
227			$this->expectException(NoSuchPropertyException::class);
228
229			$manager->modelReverseTransform($class, ['plumbus' => 42]);
230			}
231
232			public function testModelReverseTransformFailsWithPrivateProperties2(): void
233			{
234			$class = SimpleDocument::class;
235			$manager = $this->createModelManagerForClass($class);
236
237			$this->expectException(NoSuchPropertyException::class);
238
239			$manager->modelReverseTransform($class, ['plumbus' => 42]);
240			}
241
242			public function testCollections(): void
243			{
244			$model = new ModelManager($this->registry, $this->propertyAccessor);
245
246			$collection = $model->getModelCollectionInstance('whyDoWeEvenHaveThisParameter');
247			$this->assertInstanceOf(ArrayCollection::class, $collection);
248
249			$item1 = new \stdClass();
250			$item2 = new \stdClass();
251			$model->collectionAddElement($collection, $item1);
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report It seems like `$collection` defined by `$model->getModelCollecti...EvenHaveThisParameter')` on line `246` can also be of type `object<ArrayAccess>`; however, `Sonata\DoctrineMongoDBAd...:collectionAddElement()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
252			$model->collectionAddElement($collection, $item2);
253
254			$this->assertTrue($model->collectionHasElement($collection, $item1));
255
256			$model->collectionRemoveElement($collection, $item1);
257
258			$this->assertFalse($model->collectionHasElement($collection, $item1));
259
260			$model->collectionClear($collection);
261
262			$this->assertTrue($collection->isEmpty());
			0 ignored issues – show Bug introduced 2019-12-11 21:49 UTC by Report Bug Copy Issue Report The method `isEmpty` cannot be called on `$collection` (of type `array`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
263			}
264
265			public function testModelTransform(): void
266			{
267			$model = new ModelManager($this->registry, $this->propertyAccessor);
268
269			$instance = new \stdClass();
270			$result = $model->modelTransform('thisIsNotUsed', $instance);
271
272			$this->assertSame($instance, $result);
273			}
274
275			public function testGetPaginationParameters(): void
276			{
277			$datagrid = $this->createMock(DatagridInterface::class);
278			$fieldDescription = $this->createMock(FieldDescriptionInterface::class);
279
280			$datagrid->expects($this->once())
281			->method('getValues')
282			->willReturn(['_sort_by' => $fieldDescription]);
283
284			$fieldDescription->expects($this->once())
285			->method('getName')
286			->willReturn($name = 'test');
287
288			$model = new ModelManager($this->registry, $this->propertyAccessor);
289
290			$result = $model->getPaginationParameters($datagrid, $page = 5);
291
292			$this->assertSame($page, $result['filter']['_page']);
293			$this->assertSame($name, $result['filter']['_sort_by']);
294			}
295
296			public function testGetModelInstanceException(): void
297			{
298			$model = new ModelManager($this->registry, $this->propertyAccessor);
299
300			$this->expectException(\InvalidArgumentException::class);
301
302			$model->getModelInstance(AbstractDocument::class);
303			}
304
305			public function testGetModelInstanceForProtectedDocument(): void
306			{
307			$model = new ModelManager($this->registry, $this->propertyAccessor);
308
309			$this->assertInstanceOf(ProtectedDocument::class, $model->getModelInstance(ProtectedDocument::class));
310			}
311
312			public function testFindBadId(): void
313			{
314			$model = new ModelManager($this->registry, $this->propertyAccessor);
315
316			$this->assertNull($model->find('notImportant', null));
317			}
318
319			public function testGetUrlSafeIdentifierException(): void
320			{
321			$model = new ModelManager($this->registry, $this->propertyAccessor);
322
323			$this->expectException(\RuntimeException::class);
324
325			$model->getNormalizedIdentifier(new \stdClass());
326			}
327
328			public function testGetUrlSafeIdentifierNull(): void
329			{
330			$model = new ModelManager($this->registry, $this->propertyAccessor);
331
332			$this->assertNull($model->getNormalizedIdentifier(null));
			0 ignored issues – show Documentation introduced 2020-04-14 22:50 UTC by Report Bug Copy Issue Report `null` is of type `null`, but the function expects a `object`. 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...
333			}
334
335			private function createModelManagerForClass(string $class): ModelManager
336			{
337			$metadataFactory = $this->createMock(ClassMetadataFactory::class);
338			$modelManager = $this->createMock(ObjectManager::class);
339			$registry = $this->createMock(ManagerRegistry::class);
340
341			$classMetadata = new ClassMetadata($class);
342			$classMetadata->reflClass = new \ReflectionClass($class);
343
344			$modelManager->expects($this->once())
345			->method('getMetadataFactory')
346			->willReturn($metadataFactory);
347			$metadataFactory->expects($this->once())
348			->method('getMetadataFor')
349			->with($class)
350			->willReturn($classMetadata);
351			$registry->expects($this->once())
352			->method('getManagerForClass')
353			->with($class)
354			->willReturn($modelManager);
355
356			return new ModelManager($registry, $this->propertyAccessor);
357			}
358
359			private function getMetadataForEmbeddedDocument(): ClassMetadata
360			{
361			$metadata = new ClassMetadata(EmbeddedDocument::class);
362
363			$metadata->fieldMappings = [
364			'plainField' => [
365			'fieldName' => 'plainField',
366			'columnName' => 'plainField',
367			'type' => 'boolean',
368			],
369			];
370
371			return $metadata;
372			}
373
374			private function getMetadataForAssociatedDocument(): ClassMetadata
375			{
376			$embeddedDocumentClass = EmbeddedDocument::class;
377
378			$metadata = new ClassMetadata(AssociatedDocument::class);
379
380			$metadata->fieldMappings = [
381			'plainField' => [
382			'fieldName' => 'plainField',
383			'name' => 'plainField',
384			'columnName' => 'plainField',
385			'type' => 'string',
386			],
387			];
388
389			$metadata->mapOneEmbedded([
390			'fieldName' => 'embeddedDocument',
391			'name' => 'embeddedDocument',
392			'targetDocument' => $embeddedDocumentClass,
393			]);
394
395			return $metadata;
396			}
397
398			private function getMetadataForContainerDocument(): ClassMetadata
399			{
400			$containerDocumentClass = ContainerDocument::class;
401			$associatedDocumentClass = AssociatedDocument::class;
402			$embeddedDocumentClass = EmbeddedDocument::class;
403
404			$metadata = new ClassMetadata($containerDocumentClass);
405
406			$metadata->fieldMappings = [
407			'plainField' => [
408			'fieldName' => 'plainField',
409			'name' => 'plainField',
410			'columnName' => 'plainField',
411			'type' => 'integer',
412			],
413			];
414
415			$metadata->associationMappings['associatedDocument'] = [
416			'fieldName' => 'associatedDocument',
417			'name' => 'associatedDocument',
418			'targetDocument' => $associatedDocumentClass,
419			'sourceDocument' => $containerDocumentClass,
420			];
421
422			$metadata->mapOneEmbedded([
423			'fieldName' => 'embeddedDocument',
424			'name' => 'embeddedDocument',
425			'targetDocument' => $embeddedDocumentClass,
426			]);
427
428			return $metadata;
429			}
430			}
431

sonata-project / SonataDoctrineMongoDBAdminBundle

Push — master ( eaaca4...7cda52 )

ModelManagerTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

Duplication Side-by-Side

Filter issues like