PermissionsCriterionHandlerTest::getLimitationServiceMock() - Code Metrics - Inspection of "EZP-31278: Injected LimitationService into the Rep..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ba78f6...0a7dac )

by Łukasz

created 2020-02-26 10:33 UTC

PermissionsCriterionHandlerTest::getLimitationServiceMock() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	12
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	1
dl	12
loc	12
rs	9.8666
c	0
b	0
f	0

<?php

/**
 * @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\Service\Mock;

use eZ\Publish\Core\Repository\Tests\Service\Mock\Base as BaseServiceMockTest;
use eZ\Publish\Core\Repository\PermissionsCriterionHandler;
use eZ\Publish\API\Repository\Values\Content\Query\Criterion;
use eZ\Publish\API\Repository\PermissionResolver;
use eZ\Publish\API\Repository\Values\User\Limitation as APILimitation;
use eZ\Publish\Core\Repository\Values\User\Policy;

/**
 * Mock test case for PermissionCriterionHandler.
 *
 * @deprecated
 */
class PermissionsCriterionHandlerTest extends BaseServiceMockTest
{
    public function providerForTestAddPermissionsCriterionWithBooleanPermission()
    {
        return [
            [true],
            [false],
        ];
    }

    /**
     * Test for the addPermissionsCriterion() method.
     *
     * @dataProvider providerForTestAddPermissionsCriterionWithBooleanPermission
     */
    public function testAddPermissionsCriterionWithBooleanPermission($permissionsCriterion)
    {
        $handler = $this->getPermissionsCriterionHandlerMock(['getPermissionsCriterion']);
        $criterionMock = $this->createMock(Criterion::class);

        $handler
            ->expects($this->once())
            ->method('getPermissionsCriterion')
            ->will($this->returnValue($permissionsCriterion));

        /* @var \eZ\Publish\API\Repository\Values\Content\Query\Criterion $criterionMock */
        $result = $handler->addPermissionsCriterion($criterionMock);

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

    public function providerForTestAddPermissionsCriterion()
    {
        $criterionMock = $this->createMock(Criterion::class);

        return [
            [
                $criterionMock,
                new Criterion\LogicalAnd([]),
                new Criterion\LogicalAnd([$criterionMock]),
            ],
            [
                $criterionMock,
                $criterionMock,
                new Criterion\LogicalAnd([$criterionMock, $criterionMock]),
            ],
        ];
    }

    /**
     * Test for the addPermissionsCriterion() method.
     *
     * @dataProvider providerForTestAddPermissionsCriterion
     */
    public function testAddPermissionsCriterion($permissionsCriterionMock, $givenCriterion, $expectedCriterion)
    {
        $handler = $this->getPermissionsCriterionHandlerMock(['getPermissionsCriterion']);
        $handler
            ->expects($this->once())
            ->method('getPermissionsCriterion')
            ->will($this->returnValue($permissionsCriterionMock));

        /* @var \eZ\Publish\API\Repository\Values\Content\Query\Criterion $criterionMock */
        $result = $handler->addPermissionsCriterion($givenCriterion);

        $this->assertTrue($result);
        $this->assertEquals($expectedCriterion, $givenCriterion);
    }

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

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

        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]),
            ],
        ];
    }

    protected function mockServices($criterionMock, $limitationCount, $permissionSets)
    {
        $userMock = $this->createMock('eZ\\Publish\\API\\Repository\\Values\\User\\User');
        $limitationTypeMock = $this->createMock('eZ\\Publish\\SPI\\Limitation\\Type');
        $limitationServiceMock = $this->getLimitationServiceMock();
        $permissionResolverMock = $this->getPermissionResolverMock(
            [
                'hasAccess',
                'getCurrentUserReference',
            ]
        );

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

        $limitationServiceMock
            ->expects($this->exactly($limitationCount))
            ->method('getLimitationType')
            ->with($this->equalTo('limitationIdentifier'))
            ->will($this->returnValue($limitationTypeMock));

        $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);
        $handler = $this->getPermissionsCriterionHandlerMock(null);

        $permissionsCriterion = $handler->getPermissionsCriterion();

        $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));
        $handler = $this->getPermissionsCriterionHandlerMock(null);

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

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

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

    protected $permissionResolverMock;

    protected function getPermissionResolverMock($methods = [])
    {
        if ($this->permissionResolverMock === null) {
            $this->permissionResolverMock = $this
                ->getMockBuilder(PermissionResolver::class)
                ->setMethods($methods)
                ->disableOriginalConstructor()
                ->getMockForAbstractClass();
        }

        return $this->permissionResolverMock;
    }
}


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

ezsystems / ezpublish-kernel

Push — master ( ba78f6...0a7dac )

PermissionsCriterionHandlerTest::getLimitationServiceMock() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like