ModelManagerTest::testCollections() - Code Metrics - Inspection of "Add PHPStan check" - sonata-project/SonataDoctrineMongoDBAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — fix_phpstorm ( 0f3b31 )

unknown

created 2019-12-11 21:47 UTC

ModelManagerTest::testCollections() A

↳ Parent: ModelManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	23
rs	9.552
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?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\TestCase;
use Sonata\AdminBundle\Datagrid\Datagrid;
use Sonata\AdminBundle\Datagrid\DatagridInterface;
use Sonata\AdminBundle\Filter\FilterInterface;
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 Symfony\Bridge\Doctrine\ManagerRegistry;

class ModelManagerTest extends TestCase
{
    public function testSortParameters(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);

        $manager = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $datagrid1 = $this->createMock(Datagrid::class);
        $datagrid2 = $this->createMock(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);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $parameters = $manager->getSortParameters($field2, $datagrid1);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $parameters = $manager->getSortParameters($field3, $datagrid1);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $parameters = $manager->getSortParameters($field3, $datagrid2);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $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->createMock(DocumentManager::class);

        $registry = $this->createMock(ManagerRegistry::class);

        $modelManager = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $metadataFactory = $this->createMock(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 getMetadataForEmbeddedDocument()
    {
        $metadata = new ClassMetadata(EmbeddedDocument::class);

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

        return $metadata;
    }

    public function getMetadataForAssociatedDocument()
    {
        $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;
    }

    public function getMetadataForContainerDocument()
    {
        $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;
    }

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

        $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);

        $manager = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertInstanceOf($class, $object = $manager->modelReverseTransform(
            $class,
            [
                'schmeckles' => 42,
                'multi_word_property' => 'hello',
            ]
        ));
        $this->assertSame(42, $object->getSchmeckles());
        $this->assertSame('hello', $object->getMultiWordProperty());
    }

    public function testCollections(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);
        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $item1 = 'item1';
        $item2 = 'item2';
        $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);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $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
    {
        $registry = $this->createMock(ManagerRegistry::class);
        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $result = $model->modelTransform('thisIsNotUsed', 'doWeNeedThisMethod');
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $this->assertSame('doWeNeedThisMethod', $result);
    }

    public function testGetPaginationParameters(): void
    {
        $datagrid = $this->createMock(DatagridInterface::class);
        $filter = $this->createMock(FilterInterface::class);
        $registry = $this->createMock(ManagerRegistry::class);

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

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

        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $result = $model->getPaginationParameters($datagrid, $page = 5);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

    public function testGetModelInstanceException(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);

        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

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

    public function testGetModelInstanceForProtectedDocument(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);

        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

    public function testFindBadId(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);

        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

    public function testGetUrlsafeIdentifierException(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);

        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $model->getNormalizedIdentifier('test');
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    public function testGetUrlsafeIdentifierNull(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);

        $model = new ModelManager($registry);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

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

// Instead of
acceptsInteger($x);

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


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\TestCase;
22			use Sonata\AdminBundle\Datagrid\Datagrid;
23			use Sonata\AdminBundle\Datagrid\DatagridInterface;
24			use Sonata\AdminBundle\Filter\FilterInterface;
25			use Sonata\DoctrineMongoDBAdminBundle\Admin\FieldDescription;
26			use Sonata\DoctrineMongoDBAdminBundle\Model\ModelManager;
27			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\AbstractDocument;
28			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\AssociatedDocument;
29			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\ContainerDocument;
30			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\EmbeddedDocument;
31			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\ProtectedDocument;
32			use Sonata\DoctrineMongoDBAdminBundle\Tests\Fixtures\Document\SimpleDocument;
33			use Symfony\Bridge\Doctrine\ManagerRegistry;
34
35			class ModelManagerTest extends TestCase
36			{
37			public function testSortParameters(): void
38			{
39			$registry = $this->createMock(ManagerRegistry::class);
40

sonata-project / SonataDoctrineMongoDBAdminBundle

Push — fix_phpstorm ( 0f3b31 )

ModelManagerTest::testCollections() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like