FieldTest::provideFields() - Code Metrics - Inspection of "Merge branch 'master' into source-fix-test" - nerds-and-company/schematic - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — source-fix-test ( e3b467...5068b6 )

by Bart

created 2018-04-28 09:55 UTC

FieldTest::provideFields() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	29
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	21
nc	1
nop	0

<?php

namespace NerdsAndCompany\Schematic\Converters\Base;

use Craft;
use craft\base\Field as FieldModel;
use craft\fields\Categories as CategoriesField;
use craft\fields\PlainText as PlainTextField;
use Codeception\Test\Unit;

/**
 * Class FieldTest.
 *
 * @author    Nerds & Company
 * @copyright Copyright (c) 2015-2017, Nerds & Company
 * @license   MIT
 *
 * @see      http://www.nerds.company
 */
class FieldTest extends Unit
{
    /**
     * @var Field
     */
    private $converter;

    /**
     * Set the converter.
     *
     * @SuppressWarnings(PHPMD.CamelCaseMethodName)
     * phpcs:disable PSR2.Methods.MethodDeclaration.Underscore
     */
    protected function _before()
    {
        $this->converter = new Field();
    }

    //==============================================================================================================
    //=================================================  TESTS  ====================================================
    //==============================================================================================================

    /**
     * @dataProvider provideFields
     *
     * @param FieldModel $field
     * @param array      $definition
     */
    public function testGetRecordDefinition(FieldModel $field, array $definition)
    {
        if ($field instanceof CategoriesField) {
            $mockCategoryGroup = $this->getMockCategoryGroup(1);

            Craft::$app->categories->expects($this->any())
                                   ->method('getGroupById')
                                   ->with($field->group->id)
                                   ->willReturn($mockCategoryGroup);
        }

        $result = $this->converter->getRecordDefinition($field);

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

    /**
     * @dataProvider provideFields
     *
     * @param FieldModel $field
     * @param array      $definition
     * @param string     $groupStatus existing|new|invalid
     */
    public function testSaveRecord(FieldModel $field, array $definition, string $groupStatus)
    {
        Craft::$app->fields->expects($this->exactly(1))
                            ->method('getAllGroups')
                            ->willReturn([$this->getMockFieldGroup(1)]);

        Craft::$app->fields->expects($this->exactly('existing' == $groupStatus ? 0 : 1))
                          ->method('saveGroup')
                          ->willReturn('invalid' !== $groupStatus);

        Craft::$app->fields->expects($this->exactly(1))
                          ->method('saveField')
                          ->with($field)
                          ->willReturn(true);

        $result = $this->converter->saveRecord($field, $definition);

        $this->assertTrue($result);
    }

    /**
     * @dataProvider provideFields
     *
     * @param FieldModel $field
     */
    public function testDeleteRecord(FieldModel $field)
    {
        Craft::$app->fields->expects($this->exactly(1))
                            ->method('deleteField')
                            ->with($field);

        $this->converter->deleteRecord($field);
    }

    /**
     * @dataProvider provideFields
     *
     * @param FieldModel $field
     * @param array      $definition
     */
    public function testSetRecordAttributes(FieldModel $field, array $definition)
    {
        $newField = new PlainTextField();

        if ($field instanceof CategoriesField) {
            $newField = new CategoriesField();
            $mockCategoryGroup = $this->getMockCategoryGroup(1);

            Craft::$app->categories->expects($this->any())
                                   ->method('getGroupByHandle')
                                   ->with('categoryGroupHandle'.$field->group->id)
                                   ->willReturn($mockCategoryGroup);
        }

        $this->converter->setRecordAttributes($newField, $definition, []);

        $this->assertSame($field->name, $newField->name);
        $this->assertSame($field->handle, $newField->handle);

        if ($field instanceof CategoriesField) {
            $this->assertSame($field->source, $newField->source);
        }
    }

    //==============================================================================================================
    //==============================================  PROVIDERS  ===================================================
    //==============================================================================================================

    /**
     * @return array
     */
    public function provideFields()
    {
        $mockField1 = $this->getMockField(1, 1);
        $mockField2 = $this->getMockField(1, 2);
        $mockField3 = $this->getMockCategoriesField(1, 1);

        return [
            'valid field existing group' => [
                'field' => $mockField1,
                'definition' => $this->getMockFieldDefinition($mockField1),
                'groupStatus' => 'existing',
            ],
            'valid field new group' => [
                'field' => $mockField2,
                'definition' => $this->getMockFieldDefinition($mockField2),
                'groupStatus' => 'new',
            ],
            'valid field invalid group' => [
                'field' => $mockField2,
                'definition' => $this->getMockFieldDefinition($mockField2),
                'groupStatus' => 'invalid',
            ],
            'categories field existing group' => [
                'field' => $mockField3,
                'definition' => $this->getMockCategoriesFieldDefinition($mockField3),
                'groupStatus' => 'existing',
            ],
        ];
    }

    //==============================================================================================================
    //================================================  HELPERS  ===================================================
    //==============================================================================================================

    /**
     * @param FieldModel $mockField
     *
     * @return array
     */
    private function getMockFieldDefinition(FieldModel $mockField)
    {
        return [
            'class' => get_class($mockField),
            'attributes' => [
                'name' => 'fieldName'.$mockField->id,
                'handle' => 'fieldHandle'.$mockField->id,
                'instructions' => null,
                'translationMethod' => 'none',
                'translationKeyFormat' => null,
                'oldHandle' => null,
                'columnPrefix' => null,
                'required' => false,
                'sortOrder' => null,
            ],
            'group' => $mockField->group->name,
        ];
    }

    /**
     * @param CategoriesField $mockField
     *
     * @return array
     */
    private function getMockCategoriesFieldDefinition(CategoriesField $mockField)
    {
        $fieldDefinition = $this->getMockFieldDefinition($mockField);

        $fieldDefinition['attributes'] = array_merge([
            'branchLimit' => null,
            'sources' => '*',
            'source' => 'group:categoryGroupHandle1',
            'targetSiteId' => null,
            'viewMode' => null,
            'limit' => null,
            'selectionLabel' => null,
            'localizeRelations' => false,
            'allowMultipleSources' => true,
            'allowLimit' => true,
        ], $fieldDefinition['attributes']);

        return $fieldDefinition;
    }

    /**
     * @param int $fieldId
     * @param int $groupId
     *
     * @return Mock|FieldModel
     */
    private function getMockField(int $fieldId, int $groupId)
    {
        $mockField = $this->getMockBuilder(FieldModel::class)
                           ->setMethods(['getGroup'])
                           ->disableOriginalConstructor()
                           ->getMock();

        $this->setMockFieldAttributes($mockField, $fieldId, $groupId);

        return $mockField;
    }

    /**
     * @param int $fieldId
     * @param int $groupId
     *
     * @return Mock|Categories
     */
    private function getMockCategoriesField(int $fieldId, int $groupId)
    {
        $mockField = $this->getMockBuilder(CategoriesField::class)
                          ->setMethods(['getGroup'])
                          ->disableOriginalConstructor()
                          ->getMock();

        $this->setMockFieldAttributes($mockField, $fieldId, $groupId);

        $mockField->source = 'group:'.$groupId;

        return $mockField;
    }

    /**
     * @param Mock|FieldModel $mockField
     * @param int             $fieldId
     * @param int             $groupId
     */
    private function setMockFieldAttributes(FieldModel &$mockField, int $fieldId, int $groupId)
    {
        $mockField->id = $fieldId;
        $mockField->groupId = $fieldId;
        $mockField->handle = 'fieldHandle'.$fieldId;
        $mockField->name = 'fieldName'.$fieldId;

        $mockField->expects($this->any())
                  ->method('getGroup')
                  ->willReturn($this->getMockFieldGroup($groupId));
    }

    /**
     * Get a mock field group.
     *
     * @param int $groupId
     *
     * @return Mock|FieldGroup
     */
    private function getMockFieldGroup(int $groupId)
    {
        $mockGroup = $this->getMockBuilder(FieldGroup::class)
                          ->disableOriginalConstructor()
                          ->getMock();

        $mockGroup->id = $groupId;
        $mockGroup->name = 'fieldGroup'.$groupId;

        return $mockGroup;
    }

    /**
     * @param int $groupId
     *
     * @return Mock|CategoryGroup
     */
    private function getMockCategoryGroup(int $groupId)
    {
        $mockCategoryGroup = $this->getMockBuilder(CategoryGroup::class)
                                  ->disableOriginalConstructor()
                                  ->getMock();

        $mockCategoryGroup->id = $groupId;
        $mockCategoryGroup->handle = 'categoryGroupHandle'.$groupId;

        return $mockCategoryGroup;

        Craft::$app->categories->expects($this->any())
                               ->method('getGroupByHandle')
                               ->with('categoryGroupHandle'.$groupId)
                               ->willReturn($mockCategoryGroup);
    }
}


1			<?php
2
3			namespace NerdsAndCompany\Schematic\Converters\Base;
4
5			use Craft;
6			use craft\base\Field as FieldModel;
7			use craft\fields\Categories as CategoriesField;
8			use craft\fields\PlainText as PlainTextField;
9			use Codeception\Test\Unit;
10
11			/**
12			* Class FieldTest.
13			*
14			* @author Nerds & Company
15			* @copyright Copyright (c) 2015-2017, Nerds & Company
16			* @license MIT
17			*
18			* @see http://www.nerds.company
19			*/
20			class FieldTest extends Unit
21			{
22			/**
23			* @var Field
24			*/
25			private $converter;
26
27			/**
28			* Set the converter.
29			*
30			* @SuppressWarnings(PHPMD.CamelCaseMethodName)
31			* phpcs:disable PSR2.Methods.MethodDeclaration.Underscore
32			*/
33			protected function _before()
34			{
35			$this->converter = new Field();
36			}
37
38			//==============================================================================================================
39			//================================================= TESTS ====================================================
40			//==============================================================================================================
41
42			/**
43			* @dataProvider provideFields
44			*
45			* @param FieldModel $field
46			* @param array $definition
47			*/
48			public function testGetRecordDefinition(FieldModel $field, array $definition)
49			{
50			if ($field instanceof CategoriesField) {
51			$mockCategoryGroup = $this->getMockCategoryGroup(1);
52
53			Craft::$app->categories->expects($this->any())
54			->method('getGroupById')
55			->with($field->group->id)
56			->willReturn($mockCategoryGroup);
57			}
58
59			$result = $this->converter->getRecordDefinition($field);
60
61			$this->assertSame($definition, $result);
62			}
63
64			/**
65			* @dataProvider provideFields
66			*
67			* @param FieldModel $field
68			* @param array $definition
69			* @param string $groupStatus existing\|new\|invalid
70			*/
71			public function testSaveRecord(FieldModel $field, array $definition, string $groupStatus)
72			{
73			Craft::$app->fields->expects($this->exactly(1))
74			->method('getAllGroups')
75			->willReturn([$this->getMockFieldGroup(1)]);
76
77			Craft::$app->fields->expects($this->exactly('existing' == $groupStatus ? 0 : 1))
78			->method('saveGroup')
79			->willReturn('invalid' !== $groupStatus);
80
81			Craft::$app->fields->expects($this->exactly(1))
82			->method('saveField')
83			->with($field)
84			->willReturn(true);
85
86			$result = $this->converter->saveRecord($field, $definition);
87
88			$this->assertTrue($result);
89			}
90
91			/**
92			* @dataProvider provideFields
93			*
94			* @param FieldModel $field
95			*/
96			public function testDeleteRecord(FieldModel $field)
97			{
98			Craft::$app->fields->expects($this->exactly(1))
99			->method('deleteField')
100			->with($field);
101
102			$this->converter->deleteRecord($field);
103			}
104
105			/**
106			* @dataProvider provideFields
107			*
108			* @param FieldModel $field
109			* @param array $definition
110			*/
111			public function testSetRecordAttributes(FieldModel $field, array $definition)
112			{
113			$newField = new PlainTextField();
114
115			if ($field instanceof CategoriesField) {
116			$newField = new CategoriesField();
117			$mockCategoryGroup = $this->getMockCategoryGroup(1);
118
119			Craft::$app->categories->expects($this->any())
120			->method('getGroupByHandle')
121			->with('categoryGroupHandle'.$field->group->id)
122			->willReturn($mockCategoryGroup);
123			}
124
125			$this->converter->setRecordAttributes($newField, $definition, []);
126
127			$this->assertSame($field->name, $newField->name);
128			$this->assertSame($field->handle, $newField->handle);
129
130			if ($field instanceof CategoriesField) {
131			$this->assertSame($field->source, $newField->source);
132			}
133			}
134
135			//==============================================================================================================
136			//============================================== PROVIDERS ===================================================
137			//==============================================================================================================
138
139			/**
140			* @return array
141			*/
142			public function provideFields()
143			{
144			$mockField1 = $this->getMockField(1, 1);
145			$mockField2 = $this->getMockField(1, 2);
146			$mockField3 = $this->getMockCategoriesField(1, 1);
147
148			return [
149			'valid field existing group' => [
150			'field' => $mockField1,
151			'definition' => $this->getMockFieldDefinition($mockField1),
152			'groupStatus' => 'existing',
153			],
154			'valid field new group' => [
155			'field' => $mockField2,
156			'definition' => $this->getMockFieldDefinition($mockField2),
157			'groupStatus' => 'new',
158			],
159			'valid field invalid group' => [
160			'field' => $mockField2,
161			'definition' => $this->getMockFieldDefinition($mockField2),
162			'groupStatus' => 'invalid',
163			],
164			'categories field existing group' => [
165			'field' => $mockField3,
166			'definition' => $this->getMockCategoriesFieldDefinition($mockField3),
167			'groupStatus' => 'existing',
168			],
169			];
170			}
171
172			//==============================================================================================================
173			//================================================ HELPERS ===================================================
174			//==============================================================================================================
175
176			/**
177			* @param FieldModel $mockField
178			*
179			* @return array
180			*/
181			private function getMockFieldDefinition(FieldModel $mockField)
182			{
183			return [
184			'class' => get_class($mockField),
185			'attributes' => [
186			'name' => 'fieldName'.$mockField->id,
187			'handle' => 'fieldHandle'.$mockField->id,
188			'instructions' => null,
189			'translationMethod' => 'none',
190			'translationKeyFormat' => null,
191			'oldHandle' => null,
192			'columnPrefix' => null,
193			'required' => false,
194			'sortOrder' => null,
195			],
196			'group' => $mockField->group->name,
197			];
198			}
199
200			/**
201			* @param CategoriesField $mockField
202			*
203			* @return array
204			*/
205			private function getMockCategoriesFieldDefinition(CategoriesField $mockField)
206			{
207			$fieldDefinition = $this->getMockFieldDefinition($mockField);
208
209			$fieldDefinition['attributes'] = array_merge([
210			'branchLimit' => null,
211			'sources' => '*',
212			'source' => 'group:categoryGroupHandle1',
213			'targetSiteId' => null,
214			'viewMode' => null,
215			'limit' => null,
216			'selectionLabel' => null,
217			'localizeRelations' => false,
218			'allowMultipleSources' => true,
219			'allowLimit' => true,
220			], $fieldDefinition['attributes']);
221
222			return $fieldDefinition;
223			}
224
225			/**
226			* @param int $fieldId
227			* @param int $groupId
228			*
229			* @return Mock\|FieldModel
230			*/
231			private function getMockField(int $fieldId, int $groupId)
232			{
233			$mockField = $this->getMockBuilder(FieldModel::class)
234			->setMethods(['getGroup'])
235			->disableOriginalConstructor()
236			->getMock();
237
238			$this->setMockFieldAttributes($mockField, $fieldId, $groupId);
239
240			return $mockField;
241			}
242
243			/**
244			* @param int $fieldId
245			* @param int $groupId
246			*
247			* @return Mock\|Categories
248			*/
249			private function getMockCategoriesField(int $fieldId, int $groupId)
250			{
251			$mockField = $this->getMockBuilder(CategoriesField::class)
252			->setMethods(['getGroup'])
253			->disableOriginalConstructor()
254			->getMock();
255
256			$this->setMockFieldAttributes($mockField, $fieldId, $groupId);
257
258			$mockField->source = 'group:'.$groupId;
259
260			return $mockField;
261			}
262
263			/**
264			* @param Mock\|FieldModel $mockField
265			* @param int $fieldId
266			* @param int $groupId
267			*/
268			private function setMockFieldAttributes(FieldModel &$mockField, int $fieldId, int $groupId)
269			{
270			$mockField->id = $fieldId;
271			$mockField->groupId = $fieldId;
272			$mockField->handle = 'fieldHandle'.$fieldId;
273			$mockField->name = 'fieldName'.$fieldId;
274
275			$mockField->expects($this->any())
276			->method('getGroup')
277			->willReturn($this->getMockFieldGroup($groupId));
278			}
279
280			/**
281			* Get a mock field group.
282			*
283			* @param int $groupId
284			*
285			* @return Mock\|FieldGroup
286			*/
287			private function getMockFieldGroup(int $groupId)
288			{
289			$mockGroup = $this->getMockBuilder(FieldGroup::class)
290			->disableOriginalConstructor()
291			->getMock();
292
293			$mockGroup->id = $groupId;
294			$mockGroup->name = 'fieldGroup'.$groupId;
295
296			return $mockGroup;
297			}
298
299			/**
300			* @param int $groupId
301			*
302			* @return Mock\|CategoryGroup
303			*/
304			private function getMockCategoryGroup(int $groupId)
305			{
306			$mockCategoryGroup = $this->getMockBuilder(CategoryGroup::class)
307			->disableOriginalConstructor()
308			->getMock();
309
310			$mockCategoryGroup->id = $groupId;
311			$mockCategoryGroup->handle = 'categoryGroupHandle'.$groupId;
312
313			return $mockCategoryGroup;
314
315			Craft::$app->categories->expects($this->any())
316			->method('getGroupByHandle')
317			->with('categoryGroupHandle'.$groupId)
318			->willReturn($mockCategoryGroup);
319			}
320			}
321

nerds-and-company / schematic

Push — source-fix-test ( e3b467...5068b6 )

FieldTest::provideFields() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like