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

Completed

Pull Request — 3.x (#380)

unknown

created 2020-07-27 13:38 UTC

DatagridBuilderTest::testGetBaseDatagrid() A

↳ Parent: DatagridBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.6333
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;

/**
 * @author Sullivan Senechal <[email protected]>
 * @author Marko Kunic <[email protected]>
 */
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->createStub(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
    {
        $classMetadata = $this->createMock(ClassMetadata::class);

        $fieldDescription = new FieldDescription();
        $fieldDescription->setName('test');
        $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, 'someField', $parentAssociationMapping = []]);

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

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

        $datagrid = $this->createMock(DatagridInterface::class);
        $guessType = new TypeGuess(ModelFilter::class, [
            'name' => '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->datagridBuilder->addFilter(
            $datagrid,
            null,
            $fieldDescription,
            $this->admin
        );
    }
}


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			/**
38			* @author Sullivan Senechal <[email protected]>
39			* @author Marko Kunic <[email protected]>
40			*/
41			final class DatagridBuilderTest extends TestCase
42			{
43			/**
44			* @var DatagridBuilder
45			*/
46			private $datagridBuilder;
47
48			/**
49			* @var MockObject&TypeGuesserInterface
50			*/
51			private $typeGuesser;
52
53			/**
54			* @var MockObject&FormFactoryInterface
55			*/
56			private $formFactory;
57
58			/**
59			* @var MockObject&FilterFactoryInterface
60			*/
61			private $filterFactory;
62
63			/**
64			* @var MockObject&AdminInterface
65			*/
66			private $admin;
67
68			/**
69			* @var MockObject&ModelManager
70			*/
71			private $modelManager;
72
73			protected function setUp(): void
74			{
75			$this->formFactory = $this->createStub(FormFactoryInterface::class);
76			$this->filterFactory = $this->createStub(FilterFactoryInterface::class);
77			$this->typeGuesser = $this->createStub(TypeGuesserInterface::class);
78
79			$this->datagridBuilder = new DatagridBuilder(
80			$this->formFactory,
81			$this->filterFactory,
82			$this->typeGuesser
83			);
84
85			$this->admin = $this->createMock(AdminInterface::class);
86			$this->modelManager = $this->createMock(ModelManager::class);
87
88			$this->admin
89			->method('getClass')
90			->willReturn('FakeClass');
91			$this->admin
92			->method('getModelManager')
93			->willReturn($this->modelManager);
94			}
95
96			public function testGetBaseDatagrid(): void
97			{
98			$proxyQuery = $this->createStub(ProxyQueryInterface::class);
99			$fieldDescription = $this->createStub(FieldDescriptionCollection::class);
100			$formBuilder = $this->createStub(FormBuilderInterface::class);
101
102			$this->admin->method('createQuery')->willReturn($proxyQuery);
103			$this->admin->method('getList')->willReturn($fieldDescription);
104
105			$this->modelManager->method('getIdentifierFieldNames')->willReturn(['id']);
106
107			$this->formFactory->method('createNamedBuilder')->willReturn($formBuilder);
108
109			$this->assertInstanceOf(
110			Datagrid::class,
111			$datagrid = $this->datagridBuilder->getBaseDatagrid($this->admin)
112			);
113			$this->assertInstanceOf(Pager::class, $datagrid->getPager());
114			}
115
116			public function testFixFieldDescription(): void
117			{
118			$classMetadata = $this->createMock(ClassMetadata::class);
119
120			$fieldDescription = new FieldDescription();
121			$fieldDescription->setName('test');
122			$fieldDescription->setMappingType(ClassMetadata::ONE);
123
124			$this->admin
125			->expects($this->once())
126			->method('attachAdminClass');
127
128			$this->modelManager->method('hasMetadata')->willReturn(true);
129
130			$this->modelManager
131			->expects($this->once())
132			->method('getParentMetadataForProperty')
133			->willReturn([$classMetadata, 'someField', $parentAssociationMapping = []]);
134
135			$this->datagridBuilder->fixFieldDescription($this->admin, $fieldDescription);
136			}
137
138			public function testAddFilterNoType(): void
139			{
140			$this->admin
141			->expects($this->once())
142			->method('addFilterFieldDescription');
143
144			$datagrid = $this->createMock(DatagridInterface::class);
145			$guessType = new TypeGuess(ModelFilter::class, [
146			'name' => 'value',
147			], Guess::VERY_HIGH_CONFIDENCE);
148
149			$fieldDescription = new FieldDescription();
150			$fieldDescription->setName('test');
151
152			$this->typeGuesser->method('guessType')->willReturn($guessType);
153
154			$this->modelManager
155			->expects($this->once())
156			->method('hasMetadata')->willReturn(false);
157
158			$this->admin->method('getCode')->willReturn('someFakeCode');
159
160			$this->filterFactory->method('create')->willReturn(new ModelFilter());
161
162			$this->admin->method('getLabelTranslatorStrategy')->willReturn(new FormLabelTranslatorStrategy());
163
164			$datagrid
165			->expects($this->once())
166			->method('addFilter')
167			->with($this->isInstanceOf(ModelFilter::class));
168
169			$this->datagridBuilder->addFilter(
170			$datagrid,
171			null,
172			$fieldDescription,
173			$this->admin
174			);
175			}
176			}
177

sonata-project / SonataDoctrineMongoDBAdminBundle

Pull Request — 3.x (#380)

DatagridBuilderTest::testGetBaseDatagrid() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like