PermissionCriterionResolverTest - Code Metrics - Inspection of "EZP-29850: As a Developer I want API to assign a S..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9a380f...b40ee9 )

by Łukasz

created 2019-01-28 11:29 UTC

PermissionCriterionResolverTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	397
Duplicated Lines	17.88 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
dl	71
loc	397
c	0
b	0
f	0
rs	10
wmc	11
lcom	1
cbo	7

9 Methods

Rating	Name	Duplication	Size	Complexity
A	testConstructor()	17	17	1
B	providerForTestGetPermissionsCriterion()	0	216	1
B	mockServices()	0	55	1
A	testGetPermissionsCriterion()	0	13	1
A	providerForTestGetPermissionsCriterionBooleanPermissionSets()	0	7	1
A	testGetPermissionsCriterionBooleanPermissionSets()	15	15	1
A	getPermissionCriterionResolverMock()	13	13	1
A	getPermissionResolverMock()	13	13	2
A	getLimitationServiceMock()	13	13	2

How to fix Duplicated Code

<?php

/**
 * File contains: eZ\Publish\Core\Repository\Tests\Service\Mock\PermissionCriterionHandlerTest class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Repository\Tests\Permission;

use eZ\Publish\API\Repository\Values\Content\Query\Criterion;
use eZ\Publish\API\Repository\Values\User\Limitation;
use eZ\Publish\API\Repository\Values\User\User;
use eZ\Publish\API\Repository\PermissionResolver;
use eZ\Publish\Core\Limitation\TargetOnlyLimitationType;
use eZ\Publish\Core\Repository\Permission\PermissionCriterionResolver;
use eZ\Publish\Core\Repository\Values\User\Policy;
use eZ\Publish\Core\Repository\Helper\LimitationService;
use eZ\Publish\SPI\Limitation\Type;
use PHPUnit\Framework\TestCase;

/**
 * Mock test case for PermissionCriterionResolver.
 */
class PermissionCriterionResolverTest extends TestCase
{
    /**
     * Test for the __construct() method.
     */
    public function testConstructor()
    {
        $permissionResolverMock = $this->getPermissionResolverMock();
        $limitationServiceMock = $this->getLimitationServiceMock();
        $criterionResolver = $this->getPermissionCriterionResolverMock();

        $this->assertAttributeSame(

            $permissionResolverMock,
            'permissionResolver',
            $criterionResolver
        );
        $this->assertAttributeSame(

            $limitationServiceMock,
            'limitationService',
            $criterionResolver
        );
    }

    public function providerForTestGetPermissionsCriterion()
    {
        $criterionMock = $this
            ->getMockBuilder(Criterion::class)
            ->disableOriginalConstructor()
            ->getMock();
        $limitationMock = $this
            ->getMockBuilder(Limitation::class)
            ->getMockForAbstractClass();
        $limitationMock
            ->expects($this->any())
            ->method('getIdentifier')
            ->will($this->returnValue('limitationIdentifier'));

        $targetOnlyLimitationMock = $this->createMock(Limitation::class);
        $targetOnlyLimitationMock
            ->expects($this->any())
            ->method('getIdentifier')
            ->willReturn('targetOnlyLimitationIdentifier');

        $policy1 = new Policy(['limitations' => [$limitationMock]]);
        $policy2 = new Policy(['limitations' => [$limitationMock, $limitationMock]]);
        $policy3 = new Policy(['limitations' => [$limitationMock, $targetOnlyLimitationMock]]);

        return [
            [
                $criterionMock,
                1,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy1],
                    ],
                ],
                $criterionMock,
            ],
            [
                $criterionMock,
                2,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy1, $policy1],
                    ],
                ],
                new Criterion\LogicalOr([$criterionMock, $criterionMock]),
            ],
            [
                $criterionMock,
                0,
                [
                    [
                        'limitation' => null,
                        'policies' => [new Policy(['limitations' => '*']), $policy1],
                    ],
                ],
                false,
            ],
            [
                $criterionMock,
                0,
                [
                    [
                        'limitation' => null,
                        'policies' => [new Policy(['limitations' => []]), $policy1],
                    ],
                ],
                false,
            ],
            [
                $criterionMock,
                2,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy2],
                    ],
                ],
                new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
            ],
            [
                $criterionMock,
                3,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy1, $policy2],
                    ],
                ],
                new Criterion\LogicalOr(
                    [
                        $criterionMock,
                        new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
                    ]
                ),
            ],
            [
                $criterionMock,
                2,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy1],
                    ],
                    [
                        'limitation' => null,
                        'policies' => [$policy1],
                    ],
                ],
                new Criterion\LogicalOr([$criterionMock, $criterionMock]),
            ],
            [
                $criterionMock,
                3,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy1],
                    ],
                    [
                        'limitation' => null,
                        'policies' => [$policy1, $policy1],
                    ],
                ],
                new Criterion\LogicalOr([$criterionMock, $criterionMock, $criterionMock]),
            ],
            [
                $criterionMock,
                3,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy2],
                    ],
                    [
                        'limitation' => null,
                        'policies' => [$policy1],
                    ],
                ],
                new Criterion\LogicalOr(
                    [
                        new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
                        $criterionMock,
                    ]
                ),
            ],
            [
                $criterionMock,
                2,
                [
                    [
                        'limitation' => $limitationMock,
                        'policies' => [$policy1],
                    ],
                ],
                new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
            ],
            [
                $criterionMock,
                4,
                [
                    [
                        'limitation' => $limitationMock,
                        'policies' => [$policy1],
                    ],
                    [
                        'limitation' => $limitationMock,
                        'policies' => [$policy1],
                    ],
                ],
                new Criterion\LogicalOr(
                    [
                        new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
                        new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
                    ]
                ),
            ],
            [
                $criterionMock,
                1,
                [
                    [
                        'limitation' => $limitationMock,
                        'policies' => [new Policy(['limitations' => '*'])],
                    ],
                ],
                $criterionMock,
            ],
            [
                $criterionMock,
                2,
                [
                    [
                        'limitation' => $limitationMock,
                        'policies' => [new Policy(['limitations' => '*'])],
                    ],
                    [
                        'limitation' => $limitationMock,
                        'policies' => [new Policy(['limitations' => '*'])],
                    ],
                ],
                new Criterion\LogicalOr([$criterionMock, $criterionMock]),
            ],
            [
                $criterionMock,
                2,
                [
                    [
                        'limitation' => null,
                        'policies' => [$policy3],
                    ],
                ],
                new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
            ],
        ];
    }

    protected function mockServices($criterionMock, $limitationCount, $permissionSets)
    {
        $userMock = $this->getMockBuilder(User::class)->getMockForAbstractClass();
        $limitationServiceMock = $this->getLimitationServiceMock(['getLimitationType']);
        $limitationTypeMock = $this->getMockBuilder(Type::class)->getMockForAbstractClass();
        $targetOnlyLimitationTypeMock = $this->createMock(TargetOnlyLimitationType::class);
        $permissionResolverMock = $this->getPermissionResolverMock(
            [
                'hasAccess',
                'getCurrentUserReference',
            ]
        );

        $limitationTypeMock
            ->expects($this->any())
            ->method('getCriterion')
            ->with(
                $this->isInstanceOf(Limitation::class),
                $this->equalTo($userMock)
            )
            ->will($this->returnValue($criterionMock));

        $targetOnlyLimitationTypeMock
            ->expects($this->never())
            ->method('getCriterion');

        $targetOnlyLimitationTypeMock
            ->expects($this->any())
            ->method('getCriterionByTarget')
            ->with(
                $this->isInstanceOf(Limitation::class),
                $this->equalTo($userMock),
                $this->anything()
            )
            ->willReturn($criterionMock);

        $limitationServiceMock
            ->expects($this->exactly($limitationCount))
            ->method('getLimitationType')
            ->willReturnMap([
                ['limitationIdentifier', $limitationTypeMock],
                ['targetOnlyLimitationIdentifier', $targetOnlyLimitationTypeMock],
            ]);

        $permissionResolverMock
            ->expects($this->once())
            ->method('hasAccess')
            ->with($this->equalTo('content'), $this->equalTo('read'))
            ->will($this->returnValue($permissionSets));

        $permissionResolverMock
            ->expects($this->once())
            ->method('getCurrentUserReference')
            ->will($this->returnValue($userMock));
    }

    /**
     * Test for the getPermissionsCriterion() method.
     *
     * @dataProvider providerForTestGetPermissionsCriterion
     */
    public function testGetPermissionsCriterion(
        $criterionMock,
        $limitationCount,
        $permissionSets,
        $expectedCriterion
    ) {
        $this->mockServices($criterionMock, $limitationCount, $permissionSets);
        $criterionResolver = $this->getPermissionCriterionResolverMock(null);

        $permissionsCriterion = $criterionResolver->getPermissionsCriterion('content', 'read', []);

        $this->assertEquals($expectedCriterion, $permissionsCriterion);
    }

    public function providerForTestGetPermissionsCriterionBooleanPermissionSets()
    {
        return [
            [true],
            [false],
        ];
    }

    /**
     * Test for the getPermissionsCriterion() method.
     *
     * @dataProvider providerForTestGetPermissionsCriterionBooleanPermissionSets
     */
    public function testGetPermissionsCriterionBooleanPermissionSets($permissionSets)
    {
        $permissionResolverMock = $this->getPermissionResolverMock(['hasAccess']);
        $permissionResolverMock
            ->expects($this->once())
            ->method('hasAccess')
            ->with($this->equalTo('testModule'), $this->equalTo('testFunction'))
            ->will($this->returnValue($permissionSets));

        $criterionResolver = $this->getPermissionCriterionResolverMock(null);

        $permissionsCriterion = $criterionResolver->getPermissionsCriterion('testModule', 'testFunction');

        $this->assertEquals($permissionSets, $permissionsCriterion);
    }

    /**
     * Returns the PermissionCriterionResolver to test with $methods mocked.
     *
     * @param string[]|null $methods
     *
     * @return \PHPUnit\Framework\MockObject\MockObject|\eZ\Publish\Core\Repository\Permission\PermissionCriterionResolver
     */
    protected function getPermissionCriterionResolverMock($methods = [])
    {
        return $this
            ->getMockBuilder(PermissionCriterionResolver::class)
            ->setMethods($methods)
            ->setConstructorArgs(
                [
                    $this->getPermissionResolverMock(),
                    $this->getLimitationServiceMock(),
                ]
            )
            ->getMock();
    }

    protected $permissionResolverMock;

    protected function getPermissionResolverMock($methods = [])
    {
        // Tests first calls here with methods set before initiating PermissionCriterionResolver with same instance.
        if ($this->permissionResolverMock !== null) {
            return $this->permissionResolverMock;
        }

        return $this->permissionResolverMock = $this
            ->getMockBuilder(PermissionResolver::class)
            ->setMethods($methods)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
    }

    protected $limitationServiceMock;

    protected function getLimitationServiceMock($methods = [])
    {
        // Tests first calls here with methods set before initiating PermissionCriterionResolver with same instance.
        if ($this->limitationServiceMock !== null) {
            return $this->limitationServiceMock;
        }

        return $this->limitationServiceMock = $this
            ->getMockBuilder(LimitationService::class)
            ->setMethods($methods)
            ->disableOriginalConstructor()
            ->getMock();
    }
}


1		<?php
2
3		/**
4		* File contains: eZ\Publish\Core\Repository\Tests\Service\Mock\PermissionCriterionHandlerTest class.
5		*
6		* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7		* @license For full copyright and license information view LICENSE file distributed with this source code.
8		*/
9		namespace eZ\Publish\Core\Repository\Tests\Permission;
10
11		use eZ\Publish\API\Repository\Values\Content\Query\Criterion;
12		use eZ\Publish\API\Repository\Values\User\Limitation;
13		use eZ\Publish\API\Repository\Values\User\User;
14		use eZ\Publish\API\Repository\PermissionResolver;
15		use eZ\Publish\Core\Limitation\TargetOnlyLimitationType;
16		use eZ\Publish\Core\Repository\Permission\PermissionCriterionResolver;
17		use eZ\Publish\Core\Repository\Values\User\Policy;
18		use eZ\Publish\Core\Repository\Helper\LimitationService;
19		use eZ\Publish\SPI\Limitation\Type;
20		use PHPUnit\Framework\TestCase;
21
22		/**
23		* Mock test case for PermissionCriterionResolver.
24		*/
25		class PermissionCriterionResolverTest extends TestCase
26		{
27		/**
28		* Test for the __construct() method.
29		*/
30	View Code Duplication	public function testConstructor()
31		{
32		$permissionResolverMock = $this->getPermissionResolverMock();
33		$limitationServiceMock = $this->getLimitationServiceMock();
34		$criterionResolver = $this->getPermissionCriterionResolverMock();
35
36		$this->assertAttributeSame(
		0 ignored issues – show Deprecated Code introduced 2019-01-14 12:17 UTC by Report Bug Copy Issue Report The method `PHPUnit\Framework\Assert::assertAttributeSame()` has been deprecated with message: https://github.com/sebastianbergmann/phpunit/issues/3338 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
37		$permissionResolverMock,
38		'permissionResolver',
39		$criterionResolver
40		);
41		$this->assertAttributeSame(
		0 ignored issues – show Deprecated Code introduced 2019-01-14 12:17 UTC by Report Bug Copy Issue Report The method `PHPUnit\Framework\Assert::assertAttributeSame()` has been deprecated with message: https://github.com/sebastianbergmann/phpunit/issues/3338 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
42		$limitationServiceMock,
43		'limitationService',
44		$criterionResolver
45		);
46		}
47
48		public function providerForTestGetPermissionsCriterion()
49		{
50		$criterionMock = $this
51		->getMockBuilder(Criterion::class)
52		->disableOriginalConstructor()
53		->getMock();
54		$limitationMock = $this
55		->getMockBuilder(Limitation::class)
56		->getMockForAbstractClass();
57		$limitationMock
58		->expects($this->any())
59		->method('getIdentifier')
60		->will($this->returnValue('limitationIdentifier'));
61
62		$targetOnlyLimitationMock = $this->createMock(Limitation::class);
63		$targetOnlyLimitationMock
64		->expects($this->any())
65		->method('getIdentifier')
66		->willReturn('targetOnlyLimitationIdentifier');
67
68		$policy1 = new Policy(['limitations' => [$limitationMock]]);
69		$policy2 = new Policy(['limitations' => [$limitationMock, $limitationMock]]);
70		$policy3 = new Policy(['limitations' => [$limitationMock, $targetOnlyLimitationMock]]);
71
72		return [
73		[
74		$criterionMock,
75		1,
76		[
77		[
78		'limitation' => null,
79		'policies' => [$policy1],
80		],
81		],
82		$criterionMock,
83		],
84		[
85		$criterionMock,
86		2,
87		[
88		[
89		'limitation' => null,
90		'policies' => [$policy1, $policy1],
91		],
92		],
93		new Criterion\LogicalOr([$criterionMock, $criterionMock]),
94		],
95		[
96		$criterionMock,
97		0,
98		[
99		[
100		'limitation' => null,
101		'policies' => [new Policy(['limitations' => '*']), $policy1],
102		],
103		],
104		false,
105		],
106		[
107		$criterionMock,
108		0,
109		[
110		[
111		'limitation' => null,
112		'policies' => [new Policy(['limitations' => []]), $policy1],
113		],
114		],
115		false,
116		],
117		[
118		$criterionMock,
119		2,
120		[
121		[
122		'limitation' => null,
123		'policies' => [$policy2],
124		],
125		],
126		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
127		],
128		[
129		$criterionMock,
130		3,
131		[
132		[
133		'limitation' => null,
134		'policies' => [$policy1, $policy2],
135		],
136		],
137		new Criterion\LogicalOr(
138		[
139		$criterionMock,
140		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
141		]
142		),
143		],
144		[
145		$criterionMock,
146		2,
147		[
148		[
149		'limitation' => null,
150		'policies' => [$policy1],
151		],
152		[
153		'limitation' => null,
154		'policies' => [$policy1],
155		],
156		],
157		new Criterion\LogicalOr([$criterionMock, $criterionMock]),
158		],
159		[
160		$criterionMock,
161		3,
162		[
163		[
164		'limitation' => null,
165		'policies' => [$policy1],
166		],
167		[
168		'limitation' => null,
169		'policies' => [$policy1, $policy1],
170		],
171		],
172		new Criterion\LogicalOr([$criterionMock, $criterionMock, $criterionMock]),
173		],
174		[
175		$criterionMock,
176		3,
177		[
178		[
179		'limitation' => null,
180		'policies' => [$policy2],
181		],
182		[
183		'limitation' => null,
184		'policies' => [$policy1],
185		],
186		],
187		new Criterion\LogicalOr(
188		[
189		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
190		$criterionMock,
191		]
192		),
193		],
194		[
195		$criterionMock,
196		2,
197		[
198		[
199		'limitation' => $limitationMock,
200		'policies' => [$policy1],
201		],
202		],
203		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
204		],
205		[
206		$criterionMock,
207		4,
208		[
209		[
210		'limitation' => $limitationMock,
211		'policies' => [$policy1],
212		],
213		[
214		'limitation' => $limitationMock,
215		'policies' => [$policy1],
216		],
217		],
218		new Criterion\LogicalOr(
219		[
220		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
221		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
222		]
223		),
224		],
225		[
226		$criterionMock,
227		1,
228		[
229		[
230		'limitation' => $limitationMock,
231		'policies' => [new Policy(['limitations' => '*'])],
232		],
233		],
234		$criterionMock,
235		],
236		[
237		$criterionMock,
238		2,
239		[
240		[
241		'limitation' => $limitationMock,
242		'policies' => [new Policy(['limitations' => '*'])],
243		],
244		[
245		'limitation' => $limitationMock,
246		'policies' => [new Policy(['limitations' => '*'])],
247		],
248		],
249		new Criterion\LogicalOr([$criterionMock, $criterionMock]),
250		],
251		[
252		$criterionMock,
253		2,
254		[
255		[
256		'limitation' => null,
257		'policies' => [$policy3],
258		],
259		],
260		new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
261		],
262		];
263		}
264
265		protected function mockServices($criterionMock, $limitationCount, $permissionSets)
266		{
267		$userMock = $this->getMockBuilder(User::class)->getMockForAbstractClass();
268		$limitationServiceMock = $this->getLimitationServiceMock(['getLimitationType']);
269		$limitationTypeMock = $this->getMockBuilder(Type::class)->getMockForAbstractClass();
270		$targetOnlyLimitationTypeMock = $this->createMock(TargetOnlyLimitationType::class);
271		$permissionResolverMock = $this->getPermissionResolverMock(
272		[
273		'hasAccess',
274		'getCurrentUserReference',
275		]
276		);
277
278		$limitationTypeMock
279		->expects($this->any())
280		->method('getCriterion')
281		->with(
282		$this->isInstanceOf(Limitation::class),
283		$this->equalTo($userMock)
284		)
285		->will($this->returnValue($criterionMock));
286
287		$targetOnlyLimitationTypeMock
288		->expects($this->never())
289		->method('getCriterion');
290
291		$targetOnlyLimitationTypeMock
292		->expects($this->any())
293		->method('getCriterionByTarget')
294		->with(
295		$this->isInstanceOf(Limitation::class),
296		$this->equalTo($userMock),
297		$this->anything()
298		)
299		->willReturn($criterionMock);
300
301		$limitationServiceMock
302		->expects($this->exactly($limitationCount))
303		->method('getLimitationType')
304		->willReturnMap([
305		['limitationIdentifier', $limitationTypeMock],
306		['targetOnlyLimitationIdentifier', $targetOnlyLimitationTypeMock],
307		]);
308
309		$permissionResolverMock
310		->expects($this->once())
311		->method('hasAccess')
312		->with($this->equalTo('content'), $this->equalTo('read'))
313		->will($this->returnValue($permissionSets));
314
315		$permissionResolverMock
316		->expects($this->once())
317		->method('getCurrentUserReference')
318		->will($this->returnValue($userMock));
319		}
320
321		/**
322		* Test for the getPermissionsCriterion() method.
323		*
324		* @dataProvider providerForTestGetPermissionsCriterion
325		*/
326		public function testGetPermissionsCriterion(
327		$criterionMock,
328		$limitationCount,
329		$permissionSets,
330		$expectedCriterion
331		) {
332		$this->mockServices($criterionMock, $limitationCount, $permissionSets);
333		$criterionResolver = $this->getPermissionCriterionResolverMock(null);
334
335		$permissionsCriterion = $criterionResolver->getPermissionsCriterion('content', 'read', []);
336
337		$this->assertEquals($expectedCriterion, $permissionsCriterion);
338		}
339
340		public function providerForTestGetPermissionsCriterionBooleanPermissionSets()
341		{
342		return [
343		[true],
344		[false],
345		];
346		}
347
348		/**
349		* Test for the getPermissionsCriterion() method.
350		*
351		* @dataProvider providerForTestGetPermissionsCriterionBooleanPermissionSets
352		*/
353	View Code Duplication	public function testGetPermissionsCriterionBooleanPermissionSets($permissionSets)
354		{
355		$permissionResolverMock = $this->getPermissionResolverMock(['hasAccess']);
356		$permissionResolverMock
357		->expects($this->once())
358		->method('hasAccess')
359		->with($this->equalTo('testModule'), $this->equalTo('testFunction'))
360		->will($this->returnValue($permissionSets));
361
362		$criterionResolver = $this->getPermissionCriterionResolverMock(null);
363
364		$permissionsCriterion = $criterionResolver->getPermissionsCriterion('testModule', 'testFunction');
365
366		$this->assertEquals($permissionSets, $permissionsCriterion);
367		}
368
369		/**
370		* Returns the PermissionCriterionResolver to test with $methods mocked.
371		*
372		* @param string[]\|null $methods
373		*
374		* @return \PHPUnit\Framework\MockObject\MockObject\|\eZ\Publish\Core\Repository\Permission\PermissionCriterionResolver
375		*/
376	View Code Duplication	protected function getPermissionCriterionResolverMock($methods = [])
377		{
378		return $this
379		->getMockBuilder(PermissionCriterionResolver::class)
380		->setMethods($methods)
381		->setConstructorArgs(
382		[
383		$this->getPermissionResolverMock(),
384		$this->getLimitationServiceMock(),
385		]
386		)
387		->getMock();
388		}
389
390		protected $permissionResolverMock;
391
392	View Code Duplication	protected function getPermissionResolverMock($methods = [])
393		{
394		// Tests first calls here with methods set before initiating PermissionCriterionResolver with same instance.
395		if ($this->permissionResolverMock !== null) {
396		return $this->permissionResolverMock;
397		}
398
399		return $this->permissionResolverMock = $this
400		->getMockBuilder(PermissionResolver::class)
401		->setMethods($methods)
402		->disableOriginalConstructor()
403		->getMockForAbstractClass();
404		}
405
406		protected $limitationServiceMock;
407
408	View Code Duplication	protected function getLimitationServiceMock($methods = [])
409		{
410		// Tests first calls here with methods set before initiating PermissionCriterionResolver with same instance.
411		if ($this->limitationServiceMock !== null) {
412		return $this->limitationServiceMock;
413		}
414
415		return $this->limitationServiceMock = $this
416		->getMockBuilder(LimitationService::class)
417		->setMethods($methods)
418		->disableOriginalConstructor()
419		->getMock();
420		}
421		}
422

ezsystems / ezpublish-kernel

Push — master ( 9a380f...b40ee9 )

PermissionCriterionResolverTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

9 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like