PermissionCriterionResolverTest::getPermissionCriterionResolverMock() - Code Metrics - Inspection of "EZP-30675: Replaced deprecated PHPUnit asserts wit..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6a9705...322f11 )

unknown

created 2019-06-19 08:23 UTC

getPermissionCriterionResolverMock() A

↳ Parent: PermissionCriterionResolverTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	13
Ratio	100 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	1
dl	13
loc	13
rs	9.8333
c	0
b	0
f	0

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

ezsystems / ezpublish-kernel

Push — master ( 6a9705...322f11 )

getPermissionCriterionResolverMock() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like