DatagridBuilderTest::testFixFieldDescriptionWithAssociationMapping() - Code Metrics - Inspection of "Add tests to builders" - sonata-project/SonataDoctrineMongoDBAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 3.x (#387)

unknown

created 2020-08-03 06:14 UTC

testFixFieldDescriptionWithAssociationMapping() A

↳ Parent: DatagridBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	31
rs	9.424
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\Builder;

use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Admin\FieldDescriptionCollection;
use Sonata\AdminBundle\Datagrid\Datagrid;
use Sonata\AdminBundle\Datagrid\DatagridInterface;
use Sonata\AdminBundle\Datagrid\Pager;
use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;
use Sonata\AdminBundle\Filter\FilterFactoryInterface;
use Sonata\AdminBundle\Guesser\TypeGuesserInterface;
use Sonata\AdminBundle\Translator\FormLabelTranslatorStrategy;
use Sonata\DoctrineMongoDBAdminBundle\Admin\FieldDescription;
use Sonata\DoctrineMongoDBAdminBundle\Builder\DatagridBuilder;
use Sonata\DoctrineMongoDBAdminBundle\Filter\ModelFilter;
use Sonata\DoctrineMongoDBAdminBundle\Model\ModelManager;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\Form\Guess\Guess;
use Symfony\Component\Form\Guess\TypeGuess;

final class DatagridBuilderTest extends TestCase
{
    /**
     * @var DatagridBuilder
     */
    private $datagridBuilder;

    /**
     * @var MockObject&TypeGuesserInterface
     */
    private $typeGuesser;

    /**
     * @var MockObject&FormFactoryInterface
     */
    private $formFactory;

    /**
     * @var MockObject&FilterFactoryInterface
     */
    private $filterFactory;

    /**
     * @var MockObject&AdminInterface
     */
    private $admin;

    /**
     * @var MockObject&ModelManager
     */
    private $modelManager;

    protected function setUp(): void
    {
        $this->formFactory = $this->createStub(FormFactoryInterface::class);
        $this->filterFactory = $this->createMock(FilterFactoryInterface::class);
        $this->typeGuesser = $this->createStub(TypeGuesserInterface::class);

        $this->datagridBuilder = new DatagridBuilder(
            $this->formFactory,
            $this->filterFactory,
            $this->typeGuesser
        );

        $this->admin = $this->createMock(AdminInterface::class);
        $this->modelManager = $this->createMock(ModelManager::class);

        $this->admin
            ->method('getClass')
            ->willReturn('FakeClass');
        $this->admin
            ->method('getModelManager')
            ->willReturn($this->modelManager);
    }

    public function testGetBaseDatagrid(): void
    {
        $proxyQuery = $this->createStub(ProxyQueryInterface::class);
        $fieldDescription = $this->createStub(FieldDescriptionCollection::class);
        $formBuilder = $this->createStub(FormBuilderInterface::class);

        $this->admin->method('createQuery')->willReturn($proxyQuery);
        $this->admin->method('getList')->willReturn($fieldDescription);

        $this->modelManager->method('getIdentifierFieldNames')->willReturn(['id']);

        $this->formFactory->method('createNamedBuilder')->willReturn($formBuilder);

        $this->assertInstanceOf(
            Datagrid::class,
            $datagrid = $this->datagridBuilder->getBaseDatagrid($this->admin)
        );
        $this->assertInstanceOf(Pager::class, $datagrid->getPager());
    }

    public function testFixFieldDescription(): void
    {
        $fieldMapping = [
            'fieldName' => 'plainField',
            'name' => 'plainField',
            'columnName' => 'plainField',
            'type' => 'string',
        ];

        $classMetadata = $this->createMock(ClassMetadata::class);
        $classMetadata->fieldMappings = [
            'plainField' => $fieldMapping,
        ];

        $fieldDescription = new FieldDescription();
        $fieldDescription->setName('plainField');

        $this->modelManager->method('hasMetadata')->willReturn(true);

        $this->modelManager
            ->expects($this->once())
            ->method('getParentMetadataForProperty')
            ->willReturn([$classMetadata, 'plainField', $parentAssociationMapping = []]);

        $this->datagridBuilder->fixFieldDescription($this->admin, $fieldDescription);

        $this->assertSame($fieldMapping, $fieldDescription->getOption('field_mapping'));
        $this->assertTrue($fieldDescription->getOption('global_search'));
    }

    public function testFixFieldDescriptionWithAssociationMapping(): void
    {
        $associationMapping = [
            'fieldName' => 'associatedDocument',
            'name' => 'associatedDocument',
        ];
        $classMetadata = $this->createMock(ClassMetadata::class);

        $classMetadata->associationMappings = [
            'associatedDocument' => $associationMapping,
        ];

        $fieldDescription = new FieldDescription();
        $fieldDescription->setName('associatedDocument');
        $fieldDescription->setMappingType(ClassMetadata::ONE);

        $this->admin
            ->expects($this->once())
            ->method('attachAdminClass');

        $this->modelManager->method('hasMetadata')->willReturn(true);

        $this->modelManager
            ->expects($this->once())
            ->method('getParentMetadataForProperty')
            ->willReturn([$classMetadata, 'associatedDocument', $parentAssociationMapping = []]);

        $this->datagridBuilder->fixFieldDescription($this->admin, $fieldDescription);

        $this->assertSame($associationMapping, $fieldDescription->getOption('association_mapping'));
    }

    public function testAddFilterNoType(): void
    {
        $this->admin
            ->expects($this->once())
            ->method('addFilterFieldDescription');

        $datagrid = $this->createMock(DatagridInterface::class);
        $guessType = new TypeGuess(ModelFilter::class, [
            'guess_option' => 'guess_value',
            'guess_array_option' => [
                'guess_array_value',
            ],
        ], Guess::VERY_HIGH_CONFIDENCE);

        $fieldDescription = new FieldDescription();
        $fieldDescription->setName('test');

        $this->typeGuesser->method('guessType')->willReturn($guessType);

        $this->modelManager
            ->expects($this->once())
            ->method('hasMetadata')->willReturn(false);

        $this->admin->method('getCode')->willReturn('someFakeCode');

        $this->filterFactory->method('create')->willReturn(new ModelFilter());

        $this->admin->method('getLabelTranslatorStrategy')->willReturn(new FormLabelTranslatorStrategy());

        $datagrid
            ->expects($this->once())
            ->method('addFilter')
            ->with($this->isInstanceOf(ModelFilter::class));

        $this->filterFactory
            ->expects($this->once())
            ->method('create')
            ->with('test', ModelFilter::class);

        $this->datagridBuilder->addFilter(
            $datagrid,
            null,
            $fieldDescription,
            $this->admin
        );

        $this->assertSame('guess_value', $fieldDescription->getOption('guess_option'));
        $this->assertSame(['guess_array_value'], $fieldDescription->getOption('guess_array_option'));
    }

    public function testAddFilterWithType(): void
    {
        $this->admin
            ->expects($this->once())
            ->method('addFilterFieldDescription');

        $datagrid = $this->createMock(DatagridInterface::class);

        $fieldDescription = new FieldDescription();
        $fieldDescription->setName('test');

        $this->filterFactory->method('create')->willReturn(new ModelFilter());

        $this->admin->method('getLabelTranslatorStrategy')->willReturn(new FormLabelTranslatorStrategy());

        $datagrid
            ->expects($this->once())
            ->method('addFilter')
            ->with($this->isInstanceOf(ModelFilter::class));

        $this->datagridBuilder->addFilter(
            $datagrid,
            ModelFilter::class,
            $fieldDescription,
            $this->admin
        );

        $this->assertSame(ModelFilter::class, $fieldDescription->getType());
    }
}


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\Builder;
15
16			use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
17			use PHPUnit\Framework\MockObject\MockObject;
18			use PHPUnit\Framework\TestCase;
19			use Sonata\AdminBundle\Admin\AdminInterface;
20			use Sonata\AdminBundle\Admin\FieldDescriptionCollection;
21			use Sonata\AdminBundle\Datagrid\Datagrid;
22			use Sonata\AdminBundle\Datagrid\DatagridInterface;
23			use Sonata\AdminBundle\Datagrid\Pager;
24			use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;
25			use Sonata\AdminBundle\Filter\FilterFactoryInterface;
26			use Sonata\AdminBundle\Guesser\TypeGuesserInterface;
27			use Sonata\AdminBundle\Translator\FormLabelTranslatorStrategy;
28			use Sonata\DoctrineMongoDBAdminBundle\Admin\FieldDescription;
29			use Sonata\DoctrineMongoDBAdminBundle\Builder\DatagridBuilder;
30			use Sonata\DoctrineMongoDBAdminBundle\Filter\ModelFilter;
31			use Sonata\DoctrineMongoDBAdminBundle\Model\ModelManager;
32			use Symfony\Component\Form\FormBuilderInterface;
33			use Symfony\Component\Form\FormFactoryInterface;
34			use Symfony\Component\Form\Guess\Guess;
35			use Symfony\Component\Form\Guess\TypeGuess;
36
37			final class DatagridBuilderTest extends TestCase
38			{
39			/**
40			* @var DatagridBuilder
41			*/
42			private $datagridBuilder;
43
44			/**
45			* @var MockObject&TypeGuesserInterface
46			*/
47			private $typeGuesser;
48
49			/**
50			* @var MockObject&FormFactoryInterface
51			*/
52			private $formFactory;
53
54			/**
55			* @var MockObject&FilterFactoryInterface
56			*/
57			private $filterFactory;
58
59			/**
60			* @var MockObject&AdminInterface
61			*/
62			private $admin;
63
64			/**
65			* @var MockObject&ModelManager
66			*/
67			private $modelManager;
68
69			protected function setUp(): void
70			{
71			$this->formFactory = $this->createStub(FormFactoryInterface::class);
72			$this->filterFactory = $this->createMock(FilterFactoryInterface::class);
73			$this->typeGuesser = $this->createStub(TypeGuesserInterface::class);
74
75			$this->datagridBuilder = new DatagridBuilder(
76			$this->formFactory,
77			$this->filterFactory,
78			$this->typeGuesser
79			);
80
81			$this->admin = $this->createMock(AdminInterface::class);
82			$this->modelManager = $this->createMock(ModelManager::class);
83
84			$this->admin
85			->method('getClass')
86			->willReturn('FakeClass');
87			$this->admin
88			->method('getModelManager')
89			->willReturn($this->modelManager);
90			}
91
92			public function testGetBaseDatagrid(): void
93			{
94			$proxyQuery = $this->createStub(ProxyQueryInterface::class);
95			$fieldDescription = $this->createStub(FieldDescriptionCollection::class);
96			$formBuilder = $this->createStub(FormBuilderInterface::class);
97
98			$this->admin->method('createQuery')->willReturn($proxyQuery);
99			$this->admin->method('getList')->willReturn($fieldDescription);
100
101			$this->modelManager->method('getIdentifierFieldNames')->willReturn(['id']);
102
103			$this->formFactory->method('createNamedBuilder')->willReturn($formBuilder);
104
105			$this->assertInstanceOf(
106			Datagrid::class,
107			$datagrid = $this->datagridBuilder->getBaseDatagrid($this->admin)
108			);
109			$this->assertInstanceOf(Pager::class, $datagrid->getPager());
110			}
111
112			public function testFixFieldDescription(): void
113			{
114			$fieldMapping = [
115			'fieldName' => 'plainField',
116			'name' => 'plainField',
117			'columnName' => 'plainField',
118			'type' => 'string',
119			];
120
121			$classMetadata = $this->createMock(ClassMetadata::class);
122			$classMetadata->fieldMappings = [
123			'plainField' => $fieldMapping,
124			];
125
126			$fieldDescription = new FieldDescription();
127			$fieldDescription->setName('plainField');
128
129			$this->modelManager->method('hasMetadata')->willReturn(true);
130
131			$this->modelManager
132			->expects($this->once())
133			->method('getParentMetadataForProperty')
134			->willReturn([$classMetadata, 'plainField', $parentAssociationMapping = []]);
135
136			$this->datagridBuilder->fixFieldDescription($this->admin, $fieldDescription);
137
138			$this->assertSame($fieldMapping, $fieldDescription->getOption('field_mapping'));
139			$this->assertTrue($fieldDescription->getOption('global_search'));
140			}
141
142			public function testFixFieldDescriptionWithAssociationMapping(): void
143			{
144			$associationMapping = [
145			'fieldName' => 'associatedDocument',
146			'name' => 'associatedDocument',
147			];
148			$classMetadata = $this->createMock(ClassMetadata::class);
149
150			$classMetadata->associationMappings = [
151			'associatedDocument' => $associationMapping,
152			];
153
154			$fieldDescription = new FieldDescription();
155			$fieldDescription->setName('associatedDocument');
156			$fieldDescription->setMappingType(ClassMetadata::ONE);
157
158			$this->admin
159			->expects($this->once())
160			->method('attachAdminClass');
161
162			$this->modelManager->method('hasMetadata')->willReturn(true);
163
164			$this->modelManager
165			->expects($this->once())
166			->method('getParentMetadataForProperty')
167			->willReturn([$classMetadata, 'associatedDocument', $parentAssociationMapping = []]);
168
169			$this->datagridBuilder->fixFieldDescription($this->admin, $fieldDescription);
170
171			$this->assertSame($associationMapping, $fieldDescription->getOption('association_mapping'));
172			}
173
174			public function testAddFilterNoType(): void
175			{
176			$this->admin
177			->expects($this->once())
178			->method('addFilterFieldDescription');
179
180			$datagrid = $this->createMock(DatagridInterface::class);
181			$guessType = new TypeGuess(ModelFilter::class, [
182			'guess_option' => 'guess_value',
183			'guess_array_option' => [
184			'guess_array_value',
185			],
186			], Guess::VERY_HIGH_CONFIDENCE);
187
188			$fieldDescription = new FieldDescription();
189			$fieldDescription->setName('test');
190
191			$this->typeGuesser->method('guessType')->willReturn($guessType);
192
193			$this->modelManager
194			->expects($this->once())
195			->method('hasMetadata')->willReturn(false);
196
197			$this->admin->method('getCode')->willReturn('someFakeCode');
198
199			$this->filterFactory->method('create')->willReturn(new ModelFilter());
200
201			$this->admin->method('getLabelTranslatorStrategy')->willReturn(new FormLabelTranslatorStrategy());
202
203			$datagrid
204			->expects($this->once())
205			->method('addFilter')
206			->with($this->isInstanceOf(ModelFilter::class));
207
208			$this->filterFactory
209			->expects($this->once())
210			->method('create')
211			->with('test', ModelFilter::class);
212
213			$this->datagridBuilder->addFilter(
214			$datagrid,
215			null,
216			$fieldDescription,
217			$this->admin
218			);
219
220			$this->assertSame('guess_value', $fieldDescription->getOption('guess_option'));
221			$this->assertSame(['guess_array_value'], $fieldDescription->getOption('guess_array_option'));
222			}
223
224			public function testAddFilterWithType(): void
225			{
226			$this->admin
227			->expects($this->once())
228			->method('addFilterFieldDescription');
229
230			$datagrid = $this->createMock(DatagridInterface::class);
231
232			$fieldDescription = new FieldDescription();
233			$fieldDescription->setName('test');
234
235			$this->filterFactory->method('create')->willReturn(new ModelFilter());
236
237			$this->admin->method('getLabelTranslatorStrategy')->willReturn(new FormLabelTranslatorStrategy());
238
239			$datagrid
240			->expects($this->once())
241			->method('addFilter')
242			->with($this->isInstanceOf(ModelFilter::class));
243
244			$this->datagridBuilder->addFilter(
245			$datagrid,
246			ModelFilter::class,
247			$fieldDescription,
248			$this->admin
249			);
250
251			$this->assertSame(ModelFilter::class, $fieldDescription->getType());
252			}
253			}
254

sonata-project / SonataDoctrineMongoDBAdminBundle

Pull Request — 3.x (#387)

testFixFieldDescriptionWithAssociationMapping() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like