UserGroupsTest::getMockSourceCallback() - 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-20 18:48 UTC

UserGroupsTest::getMockSourceCallback() B

↳ Parent: UserGroupsTest

Complexity

Conditions	7
Paths	7

Size

Total Lines	19
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	8.2222
c	0
b	0
f	0
cc	7
eloc	16
nc	7
nop	4

<?php

namespace NerdsAndCompany\Schematic\Services;

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

nerds-and-company / schematic

Pull Request — master (#97)

UserGroupsTest::getMockSourceCallback() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like