UserGroupsTest::setMockSources() - Code Metrics - Inspection of "Refactored UserGroups service to make use of sourc..." - nerds-and-company/schematic - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#97)

by Bart

created 2017-04-21 11:38 UTC

UserGroupsTest::setMockSources() A

↳ Parent: UserGroupsTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	9
nc	1
nop	0

<?php

namespace NerdsAndCompany\Schematic\Services;

use Craft\Craft;
use Craft\BaseTest;
use Craft\UserGroupModel;
use Craft\UserGroupsService;
use Craft\UserPermissionsService;
use NerdsAndCompany\Schematic\Models\Result;
use PHPUnit_Framework_MockObject_MockObject as Mock;

/**
 * Class UserGroupsTest.
 *
 * @author    Nerds & Company
 * @copyright Copyright (c) 2015-2017, Nerds & Company
 * @license   MIT
 *
 * @link      http://www.nerds.company
 *
 * @coversDefaultClass NerdsAndCompany\Schematic\Services\UserGroups
 * @covers ::__construct
 * @covers ::<!public>
 */
class UserGroupsTest extends BaseTest
{
    //==============================================================================================================
    //=================================================  TESTS  ====================================================
    //==============================================================================================================

    /**
     * @covers ::export
     * @dataProvider provideValidUserGroups
     *
     * @param UserGroupModel[] $groups
     * @param string[]         $groupPermissions
     * @param array            $expectedResult
     */
    public function testSuccessfulExport(array $groups, array $groupPermissions, array $expectedResult = [])
    {
        $this->setMockUserGroupsService();
        $this->setMockUserPermissionsService($groupPermissions);
        $this->setMockSources();

        $schematicUserGroupsService = new UserGroups();

        $actualResult = $schematicUserGroupsService->export($groups);

        $this->assertSame($expectedResult, $actualResult);
    }

    /**
     * @covers ::import
     * @dataProvider provideValidUserGroupDefinitions
     *
     * @param array $groupDefinitions
     */
    public function testSuccessfulImport(array $groupDefinitions)
    {
        $this->setMockUserGroupsService();
        $this->setMockUserPermissionsService();
        $this->setMockSources();

        $schematicUserGroupsService = new UserGroups();

        $import = $schematicUserGroupsService->import($groupDefinitions);

        $this->assertTrue($import instanceof Result);
        $this->assertFalse($import->hasErrors());
    }

    /**
     * @covers ::import
     * @dataProvider provideValidUserGroupDefinitions
     *
     * @param array $groupDefinitions
     */
    public function testImportWhereSavingGroupFails(array $groupDefinitions)
    {
        $this->setMockUserGroupsService(false);
        $this->setMockUserPermissionsService();
        $this->setMockSources();

        $schematicUserGroupsService = new UserGroups();
        $import = $schematicUserGroupsService->import($groupDefinitions);

        $this->assertTrue($import instanceof Result);
        if (!empty($groupDefinitions)) {
            $this->assertTrue($import->hasErrors());
        }
    }

    /**
     * @covers ::import
     * @dataProvider provideValidUserGroupDefinitions
     *
     * @param array $groupDefinitions
     */
    public function testImportWithForceOption(array $groupDefinitions)
    {
        $this->setMockUserGroupsService();
        $this->setMockUserPermissionsService();
        $this->setMockSources();

        $schematicUserGroupsService = new UserGroups();

        $import = $schematicUserGroupsService->import($groupDefinitions, true);

        $this->assertTrue($import instanceof Result);
        $this->assertFalse($import->hasErrors());
    }

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

    /**
     * @return array
     */
    public function provideValidUserGroups()
    {
        return [
            'emptyArray' => [
                'userGroups' => [],
                'groupPermissions' => [],
                'expectedResult' => [],
            ],
            'single group without permissions' => [
                'userGroups' => [
                    'group1' => $this->getMockUserGroup(1),
                ],
                'groupPermissions' => [
                    [1, []],
                ],
                'expectedResult' => [
                    'groupHandle1' => [
                        'name' => 'groupName1',
                        'permissions' => [],
                    ],
                ],
            ],
            'multiple groups without permissions' => [
                'userGroups' => [
                    'group1' => $this->getMockUserGroup(1),
                    'group2' => $this->getMockUserGroup(2),
                ],
                'groupPermissions' => [
                    [1, []],
                    [2, []],
                ],
                'expectedResult' => [
                    'groupHandle1' => [
                        'name' => 'groupName1',
                        'permissions' => [],
                    ],
                    'groupHandle2' => [
                        'name' => 'groupName2',
                        'permissions' => [],
                    ],
                ],
            ],
            'single group with permissions' => [
                'userGroups' => [
                    'group1' => $this->getMockUserGroup(1),
                ],
                'groupPermissions' => [
                    [1, [
                        'accesssitewhensystemisoff',
                        'performupdates',
                        'editentries:1',
                        'editglobalset:1',
                        'viewassetsource:1',

                    ]],
                ],
                'expectedResult' => [
                    'groupHandle1' => [
                        'name' => 'groupName1',
                        'permissions' => [
                            'accessSiteWhenSystemIsOff',
                            'editEntries:sectionHandle1',
                            'editGlobalSet:globalSetHandle1',
                            'performUpdates',
                            'viewAssetSource:assetSourceHandle1',
                        ],
                    ],
                ],
            ],
        ];
    }

    /**
     * @return array
     */
    public function provideValidUserGroupDefinitions()
    {
        return [
            'emptyArray' => [
                'groupDefinitions' => [],
            ],
            'single group without permissions' => [
                'groupDefinitions' => [
                    'groupHandle1' => [
                        'name' => 'groupName1',
                        'permissions' => [],
                    ],
                ],
            ],
            'single group with permissions' => [
                'groupDefinitions' => [
                    'groupHandle1' => [
                        'name' => 'groupName1',
                        'permissions' => [
                            'accessSiteWhenSystemIsOff',
                            'performUpdates',
                            'editEntries:sectionHandle1',
                            'editGlobalSet:globalSetHandle1',
                            'viewAssetSource:assetSourceHandle1',
                        ],
                    ],
                ],
            ],
        ];
    }

    //==============================================================================================================
    //=================================================  MOCKS  ====================================================
    //==============================================================================================================

    /**
     * @param string $groupId
     *
     * @return Mock|UserGroupModel
     */
    private function getMockUserGroup($groupId)
    {
        $mockUserGroup = $this->getMockBuilder(UserGroupModel::class)
            ->disableOriginalConstructor()
            ->getMock();

        $mockUserGroup->expects($this->any())
            ->method('__get')
            ->willReturnMap([
                ['id', $groupId],
                ['handle', 'groupHandle'.$groupId],
                ['name', 'groupName'.$groupId],
            ]);

        $mockUserGroup->expects($this->any())
            ->method('getAllErrors')
            ->willReturn([
                'ohnoes' => 'horrible error',
            ]);

        return $mockUserGroup;
    }

    /**
     * @param bool $success
     *
     * @return UserGroupsService|Mock
     */
    private function setMockUserGroupsService($success = true)
    {
        $mockUserGroupsService = $this->getMockBuilder(UserGroupsService::class)
            ->disableOriginalConstructor()
            ->getMock();

        $mockUserGroupsService->expects($this->any())
            ->method('getAllGroups')
            ->with('handle')
            ->willReturn($this->getMockuserGroups(2));

        $mockUserGroupsService->expects($this->any())
            ->method('saveGroup')
            ->with($this->isInstanceOf(UserGroupModel::class))
            ->willReturn($success);

        $this->setComponent(Craft::app(), 'userGroups', $mockUserGroupsService);

        return $mockUserGroupsService;
    }

    /**
     * @param int $count
     *
     * @return array
     */
    private function getMockUserGroups($count)
    {
        $mockUserGroups = [];
        for ($x = 0; $x <= $count; ++$x) {
            $mockUserGroups['groupHandle'.$x] = $this->getMockUserGroup($x);
        }

        return $mockUserGroups;
    }

    /**
     * @param array $permissions
     * @param bool  $success
     *
     * @return UserPermissionsService|Mock
     */
    private function setMockUserPermissionsService(array $permissions = [], $success = true)
    {
        $mockUserPermissionsService = $this->getMockBuilder(UserPermissionsService::class)
            ->disableOriginalConstructor()
            ->getMock();

        $mockUserPermissionsService->expects($this->any())
            ->method('getAllPermissions')
            ->willReturn($this->getAllPermissionsExample());

        $mockUserPermissionsService->expects($this->any())
            ->method('getPermissionsByGroupId')
            ->willReturnMap($permissions);

        $mockUserPermissionsService->expects($this->any())
            ->method('saveGroupPermissions')
            ->willReturn($success);

        $this->setComponent(Craft::app(), 'userPermissions', $mockUserPermissionsService);

        return $mockUserPermissionsService;
    }

    /**
     * @return Mock|Sources
     */
    private function setMockSources()
    {
        $mockSources = $this->getMockBuilder(Sources::class)
            ->disableOriginalConstructor()
            ->getMock();

        $mockSources->expects($this->any())
            ->method('getSource')
            ->will($this->returnCallback(array($this, 'getMockSourceCallback')));

        $this->setComponent(Craft::app(), 'schematic_sources', $mockSources);

        return $mockSources;
    }

    /**
     * @param string $fieldType
     * @param string $source
     * @param string $fromIndex
     * @param string $toIndex
     *
     * @return string
     */
    public function getMockSourceCallback($fieldType, $source, $fromIndex, $toIndex)
    {
        switch ($source) {
            case 'editEntries:sectionHandle1':
                return 'editEntries:1';
            case 'editEntries:1':
                return 'editEntries:sectionHandle1';
            case 'editGlobalSet:globalSetHandle1':
                return 'editGlobalSet:1';
            case 'editGlobalSet:1':
                return 'editGlobalSet:globalSetHandle1';
            case 'viewAssetSource:assetSourceHandle1':
                return 'viewAssetSource:1';
            case 'viewAssetSource:1':
                return 'viewAssetSource:assetSourceHandle1';
            default:
                return $source;
        }
    }

    /**
     * @return array of example permissions
     */
    private function getAllPermissionsExample()
    {
        return [
            'General' => [
                'accessSiteWhenSystemIsOff' => [
                    'nested' => [
                        'accessCpWhenSystemIsOff' => [],
                        'performUpdates' => [],
                        'accessPlugin-PluginName1' => [],
                        'accessPlugin-PluginName2' => [],
                    ],
                ],
            ],
            'Users' => [
                'editUsers' => [
                    'nested' => [
                        'registerUsers' => [],
                        'assignUserPermissions' => [],
                        'administrateUsers' => [
                            'nested' => [
                                'changeUserEmails' => [],
                            ],
                        ],
                        'deleteUsers' => [],
                    ],
                ],
            ],
            'Section - 1' => [
                'editEntries:1' => [
                    'nested' => [
                        'publishEntries:1' => [],
                        'editPeerEntryDrafts:1' => [
                            'nested' => [
                                'publishPeerEntryDrafts:1' => [],
                                'deletePeerEntryDrafts:1' => [],
                            ],
                        ],
                    ],
                ],
            ],
            'Section - 2' => [
                'editEntries:2' => [
                    'nested' => [
                        'publishEntries:2' => [],
                        'editPeerEntryDrafts:2' => [
                            'nested' => [
                                'publishPeerEntryDrafts:2' => [],
                                'deletePeerEntryDrafts:2' => [],
                            ],
                        ],
                    ],
                ],
            ],
            'GlobalSet - 1' => [
                'editGlobalSet:1' => [],
            ],
            'AssetSources - 1' => [
                'viewAssetSource:1' => [
                    'nested' => [
                        'uploadToAssetSource:1' => [],
                        'createSubfoldersInAssetSource:1' => [],
                        'removeFromAssetSource:1' => [],
                    ],
                ],
            ],
        ];
    }
}


1			<?php
2
3			namespace NerdsAndCompany\Schematic\Services;
4
5			use Craft\Craft;
6			use Craft\BaseTest;
7			use Craft\UserGroupModel;
8			use Craft\UserGroupsService;
9			use Craft\UserPermissionsService;
10			use NerdsAndCompany\Schematic\Models\Result;
11			use PHPUnit_Framework_MockObject_MockObject as Mock;
12
13			/**
14			* Class UserGroupsTest.
15			*
16			* @author Nerds & Company
17			* @copyright Copyright (c) 2015-2017, Nerds & Company
18			* @license MIT
19			*
20			* @link http://www.nerds.company
21			*
22			* @coversDefaultClass NerdsAndCompany\Schematic\Services\UserGroups
23			* @covers ::__construct
24			* @covers ::<!public>
25			*/
26			class UserGroupsTest extends BaseTest
27			{
28			//==============================================================================================================
29			//================================================= TESTS ====================================================
30			//==============================================================================================================
31
32			/**
33			* @covers ::export
34			* @dataProvider provideValidUserGroups
35			*
36			* @param UserGroupModel[] $groups
37			* @param string[] $groupPermissions
38			* @param array $expectedResult
39			*/
40			public function testSuccessfulExport(array $groups, array $groupPermissions, array $expectedResult = [])
41			{
42			$this->setMockUserGroupsService();
43			$this->setMockUserPermissionsService($groupPermissions);
44			$this->setMockSources();
45
46			$schematicUserGroupsService = new UserGroups();
47
48			$actualResult = $schematicUserGroupsService->export($groups);
49
50			$this->assertSame($expectedResult, $actualResult);
51			}
52
53			/**
54			* @covers ::import
55			* @dataProvider provideValidUserGroupDefinitions
56			*
57			* @param array $groupDefinitions
58			*/
59			public function testSuccessfulImport(array $groupDefinitions)
60			{
61			$this->setMockUserGroupsService();
62			$this->setMockUserPermissionsService();
63			$this->setMockSources();
64
65			$schematicUserGroupsService = new UserGroups();
66
67			$import = $schematicUserGroupsService->import($groupDefinitions);
68
69			$this->assertTrue($import instanceof Result);
70			$this->assertFalse($import->hasErrors());
71			}
72
73			/**
74			* @covers ::import
75			* @dataProvider provideValidUserGroupDefinitions
76			*
77			* @param array $groupDefinitions
78			*/
79			public function testImportWhereSavingGroupFails(array $groupDefinitions)
80			{
81			$this->setMockUserGroupsService(false);
82			$this->setMockUserPermissionsService();
83			$this->setMockSources();
84
85			$schematicUserGroupsService = new UserGroups();
86			$import = $schematicUserGroupsService->import($groupDefinitions);
87
88			$this->assertTrue($import instanceof Result);
89			if (!empty($groupDefinitions)) {
90			$this->assertTrue($import->hasErrors());
91			}
92			}
93
94			/**
95			* @covers ::import
96			* @dataProvider provideValidUserGroupDefinitions
97			*
98			* @param array $groupDefinitions
99			*/
100			public function testImportWithForceOption(array $groupDefinitions)
101			{
102			$this->setMockUserGroupsService();
103			$this->setMockUserPermissionsService();
104			$this->setMockSources();
105
106			$schematicUserGroupsService = new UserGroups();
107
108			$import = $schematicUserGroupsService->import($groupDefinitions, true);
109
110			$this->assertTrue($import instanceof Result);
111			$this->assertFalse($import->hasErrors());
112			}
113
114			//==============================================================================================================
115			//============================================== PROVIDERS ===================================================
116			//==============================================================================================================
117
118			/**
119			* @return array
120			*/
121			public function provideValidUserGroups()
122			{
123			return [
124			'emptyArray' => [
125			'userGroups' => [],
126			'groupPermissions' => [],
127			'expectedResult' => [],
128			],
129			'single group without permissions' => [
130			'userGroups' => [
131			'group1' => $this->getMockUserGroup(1),
132			],
133			'groupPermissions' => [
134			[1, []],
135			],
136			'expectedResult' => [
137			'groupHandle1' => [
138			'name' => 'groupName1',
139			'permissions' => [],
140			],
141			],
142			],
143			'multiple groups without permissions' => [
144			'userGroups' => [
145			'group1' => $this->getMockUserGroup(1),
146			'group2' => $this->getMockUserGroup(2),
147			],
148			'groupPermissions' => [
149			[1, []],
150			[2, []],
151			],
152			'expectedResult' => [
153			'groupHandle1' => [
154			'name' => 'groupName1',
155			'permissions' => [],
156			],
157			'groupHandle2' => [
158			'name' => 'groupName2',
159			'permissions' => [],
160			],
161			],
162			],
163			'single group with permissions' => [
164			'userGroups' => [
165			'group1' => $this->getMockUserGroup(1),
166			],
167			'groupPermissions' => [
168			[1, [
169			'accesssitewhensystemisoff',
170			'performupdates',
171			'editentries:1',
172			'editglobalset:1',
173			'viewassetsource:1',
174
175			]],
176			],
177			'expectedResult' => [
178			'groupHandle1' => [
179			'name' => 'groupName1',
180			'permissions' => [
181			'accessSiteWhenSystemIsOff',
182			'editEntries:sectionHandle1',
183			'editGlobalSet:globalSetHandle1',
184			'performUpdates',
185			'viewAssetSource:assetSourceHandle1',
186			],
187			],
188			],
189			],
190			];
191			}
192
193			/**
194			* @return array
195			*/
196			public function provideValidUserGroupDefinitions()
197			{
198			return [
199			'emptyArray' => [
200			'groupDefinitions' => [],
201			],
202			'single group without permissions' => [
203			'groupDefinitions' => [
204			'groupHandle1' => [
205			'name' => 'groupName1',
206			'permissions' => [],
207			],
208			],
209			],
210			'single group with permissions' => [
211			'groupDefinitions' => [
212			'groupHandle1' => [
213			'name' => 'groupName1',
214			'permissions' => [
215			'accessSiteWhenSystemIsOff',
216			'performUpdates',
217			'editEntries:sectionHandle1',
218			'editGlobalSet:globalSetHandle1',
219			'viewAssetSource:assetSourceHandle1',
220			],
221			],
222			],
223			],
224			];
225			}
226
227			//==============================================================================================================
228			//================================================= MOCKS ====================================================
229			//==============================================================================================================
230
231			/**
232			* @param string $groupId
233			*
234			* @return Mock\|UserGroupModel
235			*/
236			private function getMockUserGroup($groupId)
237			{
238			$mockUserGroup = $this->getMockBuilder(UserGroupModel::class)
239			->disableOriginalConstructor()
240			->getMock();
241
242			$mockUserGroup->expects($this->any())
243			->method('__get')
244			->willReturnMap([
245			['id', $groupId],
246			['handle', 'groupHandle'.$groupId],
247			['name', 'groupName'.$groupId],
248			]);
249
250			$mockUserGroup->expects($this->any())
251			->method('getAllErrors')
252			->willReturn([
253			'ohnoes' => 'horrible error',
254			]);
255
256			return $mockUserGroup;
257			}
258
259			/**
260			* @param bool $success
261			*
262			* @return UserGroupsService\|Mock
263			*/
264			private function setMockUserGroupsService($success = true)
265			{
266			$mockUserGroupsService = $this->getMockBuilder(UserGroupsService::class)
267			->disableOriginalConstructor()
268			->getMock();
269
270			$mockUserGroupsService->expects($this->any())
271			->method('getAllGroups')
272			->with('handle')
273			->willReturn($this->getMockuserGroups(2));
274
275			$mockUserGroupsService->expects($this->any())
276			->method('saveGroup')
277			->with($this->isInstanceOf(UserGroupModel::class))
278			->willReturn($success);
279
280			$this->setComponent(Craft::app(), 'userGroups', $mockUserGroupsService);
281
282			return $mockUserGroupsService;
283			}
284
285			/**
286			* @param int $count
287			*
288			* @return array
289			*/
290			private function getMockUserGroups($count)
291			{
292			$mockUserGroups = [];
293			for ($x = 0; $x <= $count; ++$x) {
294			$mockUserGroups['groupHandle'.$x] = $this->getMockUserGroup($x);
295			}
296
297			return $mockUserGroups;
298			}
299
300			/**
301			* @param array $permissions
302			* @param bool $success
303			*
304			* @return UserPermissionsService\|Mock
305			*/
306			private function setMockUserPermissionsService(array $permissions = [], $success = true)
307			{
308			$mockUserPermissionsService = $this->getMockBuilder(UserPermissionsService::class)
309			->disableOriginalConstructor()
310			->getMock();
311
312			$mockUserPermissionsService->expects($this->any())
313			->method('getAllPermissions')
314			->willReturn($this->getAllPermissionsExample());
315
316			$mockUserPermissionsService->expects($this->any())
317			->method('getPermissionsByGroupId')
318			->willReturnMap($permissions);
319
320			$mockUserPermissionsService->expects($this->any())
321			->method('saveGroupPermissions')
322			->willReturn($success);
323
324			$this->setComponent(Craft::app(), 'userPermissions', $mockUserPermissionsService);
325
326			return $mockUserPermissionsService;
327			}
328
329			/**
330			* @return Mock\|Sources
331			*/
332			private function setMockSources()
333			{
334			$mockSources = $this->getMockBuilder(Sources::class)
335			->disableOriginalConstructor()
336			->getMock();
337
338			$mockSources->expects($this->any())
339			->method('getSource')
340			->will($this->returnCallback(array($this, 'getMockSourceCallback')));
341
342			$this->setComponent(Craft::app(), 'schematic_sources', $mockSources);
343
344			return $mockSources;
345			}
346
347			/**
348			* @param string $fieldType
349			* @param string $source
350			* @param string $fromIndex
351			* @param string $toIndex
352			*
353			* @return string
354			*/
355			public function getMockSourceCallback($fieldType, $source, $fromIndex, $toIndex)
356			{
357			switch ($source) {
358			case 'editEntries:sectionHandle1':
359			return 'editEntries:1';
360			case 'editEntries:1':
361			return 'editEntries:sectionHandle1';
362			case 'editGlobalSet:globalSetHandle1':
363			return 'editGlobalSet:1';
364			case 'editGlobalSet:1':
365			return 'editGlobalSet:globalSetHandle1';
366			case 'viewAssetSource:assetSourceHandle1':
367			return 'viewAssetSource:1';
368			case 'viewAssetSource:1':
369			return 'viewAssetSource:assetSourceHandle1';
370			default:
371			return $source;
372			}
373			}
374
375			/**
376			* @return array of example permissions
377			*/
378			private function getAllPermissionsExample()
379			{
380			return [
381			'General' => [
382			'accessSiteWhenSystemIsOff' => [
383			'nested' => [
384			'accessCpWhenSystemIsOff' => [],
385			'performUpdates' => [],
386			'accessPlugin-PluginName1' => [],
387			'accessPlugin-PluginName2' => [],
388			],
389			],
390			],
391			'Users' => [
392			'editUsers' => [
393			'nested' => [
394			'registerUsers' => [],
395			'assignUserPermissions' => [],
396			'administrateUsers' => [
397			'nested' => [
398			'changeUserEmails' => [],
399			],
400			],
401			'deleteUsers' => [],
402			],
403			],
404			],
405			'Section - 1' => [
406			'editEntries:1' => [
407			'nested' => [
408			'publishEntries:1' => [],
409			'editPeerEntryDrafts:1' => [
410			'nested' => [
411			'publishPeerEntryDrafts:1' => [],
412			'deletePeerEntryDrafts:1' => [],
413			],
414			],
415			],
416			],
417			],
418			'Section - 2' => [
419			'editEntries:2' => [
420			'nested' => [
421			'publishEntries:2' => [],
422			'editPeerEntryDrafts:2' => [
423			'nested' => [
424			'publishPeerEntryDrafts:2' => [],
425			'deletePeerEntryDrafts:2' => [],
426			],
427			],
428			],
429			],
430			],
431			'GlobalSet - 1' => [
432			'editGlobalSet:1' => [],
433			],
434			'AssetSources - 1' => [
435			'viewAssetSource:1' => [
436			'nested' => [
437			'uploadToAssetSource:1' => [],
438			'createSubfoldersInAssetSource:1' => [],
439			'removeFromAssetSource:1' => [],
440			],
441			],
442			],
443			];
444			}
445			}
446

nerds-and-company / schematic

Pull Request — master (#97)

UserGroupsTest::setMockSources() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like