PermissionCriterionResolverTest::mockServices() - Code Metrics - Inspection of "Merge branch '6.12'" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2d5a91...5e6a60 )

by André

created 2017-11-08 11:23 UTC

PermissionCriterionResolverTest::mockServices() B

↳ Parent: PermissionCriterionResolverTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	38
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	28
nc	1
nop	3
dl	0
loc	38
rs	8.8571
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\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'));

        $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->getMockBuilder(User::class)->getMockForAbstractClass();
        $limitationTypeMock = $this->getMockBuilder(Type::class)->getMockForAbstractClass();
        $limitationServiceMock = $this->getLimitationServiceMock(['getLimitationType']);
        $permissionResolverMock = $this->getPermissionResolverMock(
            [
                'hasAccess',
                'getCurrentUserReference',
            ]
        );

        $limitationTypeMock
            ->expects($this->any())
            ->method('getCriterion')
            ->with(
                $this->isInstanceOf(Limitation::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);
        $criterionResolver = $this->getPermissionCriterionResolverMock(null);

        $permissionsCriterion = $criterionResolver->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));

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

ezsystems / ezpublish-kernel

Push — master ( 2d5a91...5e6a60 )

PermissionCriterionResolverTest::mockServices() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like