RepositoryTest - Code Metrics - Inspection of "Disabled HTTP caching on REST content draft load" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — ezp26445-rest_draft_http_cache ( 5bd2b6...c1f4a6 )

unknown
created 2016-10-20 08:54 UTC
RepositoryTest B

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	1151
Duplicated Lines	24.07 %
Coupling/Cohesion

Components	2
Dependencies	11
Importance

Changes
Metric	Value
dl	277
loc	1151
rs	7.027
c	0
b	0
f	0
wmc	48
lcom	2
cbo	11
26 Methods

Rating	Name	Duplication	Size	Complexity
A	providerForTestHasAccessReturnsTrue()	0	68	1
B	testHasAccessReturnsTrue()	24	24	2
B	providerForTestHasAccessReturnsFalse()	0	40	1
B	testHasAccessReturnsFalse()	24	24	2
A	testHasAccessReturnsFalseButSudoSoTrue()	0	18	1
A	providerForTestHasAccessReturnsPermissionSets()	50	50	1
B	testHasAccessReturnsPermissionSets()	16	75	6
A	providerForTestHasAccessReturnsException()	50	50	1
B	testHasAccessReturnsException()	19	72	6
B	providerForTestHasAccessReturnsPermissionSetsWithRoleLimitation()	38	38	1
B	testHasAccessReturnsPermissionSetsWithRoleLimitation()	0	87	4
A	createRole()	0	20	2
A	providerForTestCanUserSimple()	0	8	1
B	testCanUserSimple()	0	26	1
B	testCanUserWithoutLimitations()	0	45	1
B	getPermissionSetsMock()	0	34	1
A	providerForTestCanUserComplex()	0	75	1
C	testCanUserComplex()	0	104	7
A	testCanUserThrowsInvalidArgumentException()	0	22	1
A	testSetAndGetCurrentUser()	0	12	1
B	testGetCurrentUserReturnsAnonymousUser()	0	34	1
A	testBeginTransaction()	0	13	1
A	testCommit()	13	13	1
A	testCommitThrowsRuntimeException()	15	15	1
A	testRollback()	13	13	1
A	testRollbackThrowsRuntimeException()	15	15	1
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like RepositoryTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use RepositoryTest, and based on these observations, apply Extract Interface, too.
<?php

/**
 * File contains: eZ\Publish\Core\Repository\Tests\Service\Mock\RepositoryTest 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.
 *
 * @version //autogentag//
 */
namespace eZ\Publish\Core\Repository\Tests\Service\Mock;

use eZ\Publish\API\Repository\Repository;
use eZ\Publish\Core\Repository\Values\User\UserReference;
use eZ\Publish\Core\Base\Exceptions\NotFound\LimitationNotFoundException;
use eZ\Publish\Core\Repository\Tests\Service\Mock\Base as BaseServiceMockTest;
use eZ\Publish\SPI\Persistence\User\RoleAssignment;
use eZ\Publish\SPI\Persistence\User\Role;
use eZ\Publish\SPI\Persistence\User\Policy;

/**
 * Mock test case for Repository.
 */
class RepositoryTest extends BaseServiceMockTest
{
    public function providerForTestHasAccessReturnsTrue()
    {
        return array(
            array(
                array(
                    25 => $this->createRole(
                        array(
                            array('dummy-module', 'dummy-function', 'dummy-limitation'),
                            array('dummy-module2', 'dummy-function2', 'dummy-limitation2'),
                        ),
                        25
                    ),
                    26 => $this->createRole(
                        array(
                            array('*', 'dummy-function', 'dummy-limitation'),
                        ),
                        26
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 25,
                        )
                    ),
                    new RoleAssignment(
                        array(
                            'roleId' => 26,
                        )
                    ),
                ),
            ),
            array(
                array(
                    27 => $this->createRole(
                        array(
                            array('test-module', '*', 'dummy-limitation'),
                        ),
                        27
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 27,
                        )
                    ),
                ),
            ),
            array(
                array(
                    28 => $this->createRole(
                        array(
                            array('test-module', 'test-function', '*'),
                        ),
                        28
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 28,
                        )
                    ),
                ),
            ),
        );
    }

    /**
     * Test for the hasAccess() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::hasAccess
     * @dataProvider providerForTestHasAccessReturnsTrue
     */
    public function testHasAccessReturnsTrue(array $roles, array $roleAssignments)
    {
        /** @var $userHandlerMock \PHPUnit_Framework_MockObject_MockObject */
        $userHandlerMock = $this->getPersistenceMock()->userHandler();
        $mockedRepository = $this->getRepository();

        $userHandlerMock
            ->expects($this->once())
            ->method('loadRoleAssignmentsByGroupId')
            ->with($this->isType('integer'), $this->equalTo(true))
            ->will($this->returnValue($roleAssignments));

        foreach ($roleAssignments as $at => $roleAssignment) {
            $userHandlerMock
                ->expects($this->at($at + 1))
                ->method('loadRole')
                ->with($roleAssignment->roleId)
                ->will($this->returnValue($roles[$roleAssignment->roleId]));
        }

        $result = $mockedRepository->hasAccess('test-module', 'test-function');

        self::assertEquals(true, $result);
    }

    public function providerForTestHasAccessReturnsFalse()
    {
        return array(
            array(array(), array()),
            array(
                array(
                    29 => $this->createRole(
                        array(
                            array('dummy-module', 'dummy-function', 'dummy-limitation'),
                        ),
                        29
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 29,
                        )
                    ),
                ),
            ),
            array(
                array(
                    30 => $this->createRole(
                        array(
                            array('test-module', 'dummy-function', 'dummy-limitation'),
                        ),
                        30
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 30,
                        )
                    ),
                ),
            ),
        );
    }

    /**
     * Test for the hasAccess() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::hasAccess
     * @dataProvider providerForTestHasAccessReturnsFalse
     */
    public function testHasAccessReturnsFalse(array $roles, array $roleAssignments)
    {
        /** @var $userHandlerMock \PHPUnit_Framework_MockObject_MockObject */
        $userHandlerMock = $this->getPersistenceMock()->userHandler();
        $mockedRepository = $this->getRepository();

        $userHandlerMock
            ->expects($this->once())
            ->method('loadRoleAssignmentsByGroupId')
            ->with($this->isType('integer'), $this->equalTo(true))
            ->will($this->returnValue($roleAssignments));

        foreach ($roleAssignments as $at => $roleAssignment) {
            $userHandlerMock
                ->expects($this->at($at + 1))
                ->method('loadRole')
                ->with($roleAssignment->roleId)
                ->will($this->returnValue($roles[$roleAssignment->roleId]));
        }

        $result = $mockedRepository->hasAccess('test-module', 'test-function');

        self::assertEquals(false, $result);
    }

    /**
     * Test for the sudo() & hasAccess() method.
     *
     * @covers \eZ\Publish\Core\Repository\Repository::sudo
     * @covers \eZ\Publish\API\Repository\Repository::hasAccess
     * @dataProvider providerForTestHasAccessReturnsFalse
     */
    public function testHasAccessReturnsFalseButSudoSoTrue(array $roles, array $roleAssignments)

    {
        /** @var $userHandlerMock \PHPUnit_Framework_MockObject_MockObject */
        $userHandlerMock = $this->getPersistenceMock()->userHandler();
        $mockedRepository = $this->getRepository();

        $userHandlerMock
            ->expects($this->never())
            ->method($this->anything());

        $result = $mockedRepository->sudo(
            function (Repository $repo) {
                return $repo->hasAccess('test-module', 'test-function');
            }
        );

        self::assertEquals(true, $result);
    }

    /**
     * @return array
     */
    public function providerForTestHasAccessReturnsPermissionSets()
    {
        return array(
            array(
                array(
                    31 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'test-limitation'),
                        ),
                        31
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 31,
                        )
                    ),
                ),
            ),
            array(
                array(
                    31 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'test-limitation'),
                        ),
                        31
                    ),
                    32 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'test-limitation2'),
                        ),
                        32
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 31,
                        )
                    ),
                    new RoleAssignment(
                        array(
                            'roleId' => 32,
                        )
                    ),
                ),
            ),
        );
    }

    /**
     * Test for the hasAccess() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::hasAccess
     * @dataProvider providerForTestHasAccessReturnsPermissionSets
     */
    public function testHasAccessReturnsPermissionSets(array $roles, array $roleAssignments)
    {
        /** @var $userHandlerMock \PHPUnit_Framework_MockObject_MockObject */
        $userHandlerMock = $this->getPersistenceMock()->userHandler();
        $roleDomainMapper = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Helper\\RoleDomainMapper',
            array('buildDomainPolicyObject'),
            array(),
            '',
            false
        );
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('getRoleDomainMapper', 'getCurrentUserReference'),
            array(
                $this->getPersistenceMock(),
                $this->getSPIMockHandler('Search\\Handler'),
            )
        );

        $repositoryMock
            ->expects($this->once())
            ->method('getRoleDomainMapper')
            ->will($this->returnValue($roleDomainMapper));
        $repositoryMock
            ->expects($this->once())
            ->method('getCurrentUserReference')
            ->will($this->returnValue(new UserReference(14)));

        $userHandlerMock
            ->expects($this->once())
            ->method('loadRoleAssignmentsByGroupId')
            ->with($this->isType('integer'), $this->equalTo(true))
            ->will($this->returnValue($roleAssignments));

        foreach ($roleAssignments as $at => $roleAssignment) {
            $userHandlerMock
                ->expects($this->at($at + 1))
                ->method('loadRole')
                ->with($roleAssignment->roleId)
                ->will($this->returnValue($roles[$roleAssignment->roleId]));
        }

        $permissionSets = array();
        /* @var $roleAssignments \eZ\Publish\SPI\Persistence\User\RoleAssignment[] */
        $count = 0;
        foreach ($roleAssignments as $i => $roleAssignment) {
            $permissionSet = array('limitation' => null);
            foreach ($roles[$roleAssignment->roleId]->policies as $k => $policy) {

                $policyName = 'policy-' . $i . '-' . $k;
                if ($policy->limitations === 'notfound') {
                    $return = $this->throwException(new LimitationNotFoundException('notfound'));
                    $this->setExpectedException('eZ\Publish\Core\Base\Exceptions\NotFound\LimitationNotFoundException');
                } else {
                    $return = $this->returnValue($policyName);
                    $permissionSet['policies'][] = $policyName;
                }

                $roleDomainMapper
                    ->expects($this->at($count++))
                    ->method('buildDomainPolicyObject')
                    ->with($policy)
                    ->will($return);
            }
            if (!empty($permissionSet['policies'])) {
                $permissionSets[] = $permissionSet;
            }
        }

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        self::assertEquals(
            $permissionSets,
            $repositoryMock->hasAccess('test-module', 'test-function')
        );
    }

    /**
     * @return array
     */
    public function providerForTestHasAccessReturnsException()
    {
        return array(
            array(
                array(
                    31 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'notfound'),
                        ),
                        31
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 31,
                        )
                    ),
                ),
            ),
            array(
                array(
                    31 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'test-limitation'),
                        ),
                        31
                    ),
                    32 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'notfound'),
                        ),
                        32
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 31,
                        )
                    ),
                    new RoleAssignment(
                        array(
                            'roleId' => 32,
                        )
                    ),
                ),
            ),
        );
    }

    /**
     * Test for the hasAccess() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::hasAccess
     * @dataProvider providerForTestHasAccessReturnsException
     * @expectedException \eZ\Publish\Core\Base\Exceptions\NotFound\LimitationNotFoundException
     */
    public function testHasAccessReturnsException(array $roles, array $roleAssignments)
    {
        /** @var $userHandlerMock \PHPUnit_Framework_MockObject_MockObject */
        $userHandlerMock = $this->getPersistenceMock()->userHandler();
        $roleDomainMapper = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Helper\\RoleDomainMapper',
            array('buildDomainPolicyObject'),
            array(),
            '',
            false
        );
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('getRoleDomainMapper', 'getCurrentUserReference'),
            array(
                $this->getPersistenceMock(),
                $this->getSPIMockHandler('Search\\Handler'),
            )
        );

        $repositoryMock
            ->expects($this->once())
            ->method('getRoleDomainMapper')
            ->will($this->returnValue($roleDomainMapper));
        $repositoryMock
            ->expects($this->once())
            ->method('getCurrentUserReference')
            ->will($this->returnValue(new UserReference(14)));

        $userHandlerMock
            ->expects($this->once())
            ->method('loadRoleAssignmentsByGroupId')
            ->with($this->isType('integer'), $this->equalTo(true))
            ->will($this->returnValue($roleAssignments));

        foreach ($roleAssignments as $at => $roleAssignment) {
            $userHandlerMock
                ->expects($this->at($at + 1))
                ->method('loadRole')
                ->with($roleAssignment->roleId)
                ->will($this->returnValue($roles[$roleAssignment->roleId]));
        }

        $permissionSets = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        /* @var $roleAssignments \eZ\Publish\SPI\Persistence\User\RoleAssignment[] */
        $count = 0;
        foreach ($roleAssignments as $i => $roleAssignment) {
            $permissionSet = array('limitation' => null);
            foreach ($roles[$roleAssignment->roleId]->policies as $k => $policy) {

                $policyName = 'policy-' . $i . '-' . $k;
                if ($policy->limitations === 'notfound') {
                    $return = $this->throwException(new LimitationNotFoundException('notfound'));
                } else {
                    $return = $this->returnValue($policyName);
                    $permissionSet['policies'][] = $policyName;
                }

                $roleDomainMapper
                    ->expects($this->at($count++))
                    ->method('buildDomainPolicyObject')
                    ->with($policy)
                    ->will($return);

                if ($policy->limitations === 'notfound') {
                    break 2;// no more execution after exception
                }
            }
        }

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        $repositoryMock->hasAccess('test-module', 'test-function');
    }

    public function providerForTestHasAccessReturnsPermissionSetsWithRoleLimitation()
    {
        return array(
            array(
                array(
                    32 => $this->createRole(
                        array(
                            array('test-module', 'test-function', 'test-limitation'),
                        ),
                        32
                    ),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 32,
                            'limitationIdentifier' => 'test-role-limitation',
                            'values' => array('test-role-limitation-value'),
                        )
                    ),
                ),
            ),
            array(
                array(
                    33 => $this->createRole(array(array('*', '*', '*')), 33),
                ),
                array(
                    new RoleAssignment(
                        array(
                            'roleId' => 33,
                            'limitationIdentifier' => 'test-role-limitation',
                            'values' => array('test-role-limitation-value'),
                        )
                    ),
                ),
            ),
        );
    }

    /**
     * Test for the hasAccess() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::hasAccess
     * @dataProvider providerForTestHasAccessReturnsPermissionSetsWithRoleLimitation
     */
    public function testHasAccessReturnsPermissionSetsWithRoleLimitation(array $roles, array $roleAssignments)
    {
        /** @var $userHandlerMock \PHPUnit_Framework_MockObject_MockObject */
        $userHandlerMock = $this->getPersistenceMock()->userHandler();
        $limitationTypeMock = $this->getMock('eZ\\Publish\\SPI\\Limitation\\Type');
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('getRoleDomainMapper', 'getCurrentUserReference', 'getLimitationService'),
            array(
                $this->getPersistenceMock(),
                $this->getSPIMockHandler('Search\\Handler'),
            )
        );
        $limitationService = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Helper\\LimitationService',
            array('getLimitationType')
        );
        $roleDomainMapper = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Helper\\RoleDomainMapper',
            array('buildDomainPolicyObject'),
            array(),
            '',
            false
        );

        $repositoryMock
            ->expects($this->once())
            ->method('getRoleDomainMapper')
            ->will($this->returnValue($roleDomainMapper));
        $repositoryMock
            ->expects($this->once())
            ->method('getLimitationService')
            ->will($this->returnValue($limitationService));
        $repositoryMock
            ->expects($this->once())
            ->method('getCurrentUserReference')
            ->will($this->returnValue(new UserReference(14)));

        $userHandlerMock
            ->expects($this->once())
            ->method('loadRoleAssignmentsByGroupId')
            ->with($this->isType('integer'), $this->equalTo(true))
            ->will($this->returnValue($roleAssignments));

        foreach ($roleAssignments as $at => $roleAssignment) {
            $userHandlerMock
                ->expects($this->at($at + 1))
                ->method('loadRole')
                ->with($roleAssignment->roleId)
                ->will($this->returnValue($roles[$roleAssignment->roleId]));
        }

        $permissionSets = array();
        /** @var $roleAssignments \eZ\Publish\SPI\Persistence\User\RoleAssignment[] */
        foreach ($roleAssignments as $i => $roleAssignment) {
            $permissionSet = array();
            foreach ($roles[$roleAssignment->roleId]->policies as $k => $policy) {
                $policyName = "policy-{$i}-{$k}";
                $permissionSet['policies'][] = $policyName;
                $roleDomainMapper
                    ->expects($this->at($k))
                    ->method('buildDomainPolicyObject')
                    ->with($policy)
                    ->will($this->returnValue($policyName));
            }

            $permissionSet['limitation'] = "limitation-{$i}";
            $limitationTypeMock
                ->expects($this->at($i))
                ->method('buildValue')
                ->with($roleAssignment->values)
                ->will($this->returnValue($permissionSet['limitation']));
            $limitationService
                ->expects($this->any())
                ->method('getLimitationType')
                ->with($roleAssignment->limitationIdentifier)
                ->will($this->returnValue($limitationTypeMock));

            $permissionSets[] = $permissionSet;
        }

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        self::assertEquals(
            $permissionSets,
            $repositoryMock->hasAccess('test-module', 'test-function')
        );
    }

    /**
     * Returns Role stub.
     *
     * @param array $policiesData
     * @param mixed $roleId
     *
     * @return \eZ\Publish\SPI\Persistence\User\Role
     */
    private function createRole(array $policiesData, $roleId = null)
    {
        $policies = array();
        foreach ($policiesData as $policyData) {
            $policies[] = new Policy(
                array(
                    'module' => $policyData[0],
                    'function' => $policyData[1],
                    'limitations' => $policyData[2],
                )
            );
        }

        return new Role(
            array(
                'id' => $roleId,
                'policies' => $policies,
            )
        );
    }

    public function providerForTestCanUserSimple()
    {
        return array(
            array(true, true),
            array(false, false),
            array(array(), false),
        );
    }

    /**
     * Test for the canUser() method.
     *
     * Tests execution paths with permission sets equaling to boolean value or empty array.
     *
     * @covers \eZ\Publish\API\Repository\Repository::canUser
     * @dataProvider providerForTestCanUserSimple
     */
    public function testCanUserSimple($permissionSets, $result)
    {
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('hasAccess', 'getCurrentUserReference'),
            array(
                $this->getPersistenceMock(),
                $this->getSPIMockHandler('Search\\Handler'),
            )
        );

        $repositoryMock
            ->expects($this->once())
            ->method('hasAccess')
            ->with($this->equalTo('test-module'), $this->equalTo('test-function'))
            ->will($this->returnValue($permissionSets));

        /** @var $valueObject \eZ\Publish\API\Repository\Values\ValueObject */
        $valueObject = $this->getMockForAbstractClass('eZ\\Publish\\API\\Repository\\Values\\ValueObject');

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        self::assertEquals(
            $result,
            $repositoryMock->canUser('test-module', 'test-function', $valueObject, $valueObject)
        );
    }

    /**
     * Test for the canUser() method.
     *
     * Tests execution path with permission set defining no limitations.
     *
     * @covers \eZ\Publish\API\Repository\Repository::canUser
     */
    public function testCanUserWithoutLimitations()
    {
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('hasAccess', 'getCurrentUserReference'),
            array(
                $this->getPersistenceMock(),
                $this->getSPIMockHandler('Search\\Handler'),
            )
        );

        $policyMock = $this->getMock(
            'eZ\\Publish\\SPI\\Persistence\\User\\Policy',
            array('getLimitations'),
            array(),
            '',
            false
        );
        $policyMock
            ->expects($this->once())
            ->method('getLimitations')
            ->will($this->returnValue('*'));
        $permissionSets = array(
            array(
                'limitation' => null,
                'policies' => array($policyMock),
            ),
        );
        $repositoryMock
            ->expects($this->once())
            ->method('hasAccess')
            ->with($this->equalTo('test-module'), $this->equalTo('test-function'))
            ->will($this->returnValue($permissionSets));

        $repositoryMock
            ->expects($this->once())
            ->method('getCurrentUserReference')
            ->will($this->returnValue(new UserReference(14)));

        /** @var $valueObject \eZ\Publish\API\Repository\Values\ValueObject */
        $valueObject = $this->getMockForAbstractClass('eZ\\Publish\\API\\Repository\\Values\\ValueObject');

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        self::assertTrue($repositoryMock->canUser('test-module', 'test-function', $valueObject, $valueObject));
    }

    /**
     * @return array
     */
    private function getPermissionSetsMock()
    {
        $roleLimitationMock = $this->getMock('eZ\\Publish\\API\\Repository\\Values\\User\\Limitation');
        $roleLimitationMock
            ->expects($this->any())
            ->method('getIdentifier')
            ->will($this->returnValue('test-role-limitation-identifier'));

        $policyLimitationMock = $this->getMock('eZ\\Publish\\API\\Repository\\Values\\User\\Limitation');
        $policyLimitationMock
            ->expects($this->any())
            ->method('getIdentifier')
            ->will($this->returnValue('test-policy-limitation-identifier'));

        $policyMock = $this->getMock(
            'eZ\\Publish\\SPI\\Persistence\\User\\Policy',
            array('getLimitations'),
            array(),
            '',
            false
        );
        $policyMock
            ->expects($this->any())
            ->method('getLimitations')
            ->will($this->returnValue(array($policyLimitationMock, $policyLimitationMock)));

        $permissionSet = array(
            'limitation' => clone $roleLimitationMock,
            'policies' => array($policyMock, $policyMock),
        );
        $permissionSets = array($permissionSet, $permissionSet);

        return $permissionSets;
    }

    /**
     * Provides evaluation results for two permission sets, each with a role limitation and two policies,
     * with two limitations per policy.
     *
     * @return array
     */
    public function providerForTestCanUserComplex()
    {
        return array(
            array(
                array(true, true),
                array(
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                ),
                true,
            ),
            array(
                array(false, false),
                array(
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                ),
                false,
            ),
            array(
                array(false, true),
                array(
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                ),
                true,
            ),
            array(
                array(false, true),
                array(
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                    array(
                        array(true, false),
                        array(true, true),
                    ),
                ),
                true,
            ),
            array(
                array(true, false),
                array(
                    array(
                        array(true, false),
                        array(false, true),
                    ),
                    array(
                        array(true, true),
                        array(true, true),
                    ),
                ),
                false,
            ),
        );
    }

    /**
     * Test for the canUser() method.
     *
     * Tests execution paths with permission sets containing limitations.
     *
     * @covers \eZ\Publish\API\Repository\Repository::canUser
     * @dataProvider providerForTestCanUserComplex
     */
    public function testCanUserComplex(array $roleLimitationEvaluations, array $policyLimitationEvaluations, $userCan)
    {
        /** @var $valueObject \eZ\Publish\API\Repository\Values\ValueObject */
        $valueObject = $this->getMock('eZ\\Publish\\API\\Repository\\Values\\ValueObject');
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('getCurrentUserReference', 'hasAccess', 'getLimitationService'),
            array(),
            '',
            false
        );
        $roleServiceMock = $this->getMock(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            'eZ\\Publish\\Core\\Repository\\RoleService',
            array(),
            array(
                $this->getRepositoryMock(),
                $this->getPersistenceMockHandler('User\\Handler'),
                $limitationService = $this->getMock(
                    'eZ\\Publish\\Core\\Repository\\Helper\\LimitationService',
                    array('getLimitationType')
                ),
                $this->getMock(
                    'eZ\\Publish\\Core\\Repository\\Helper\\RoleDomainMapper',
                    array(),
                    array($limitationService)
                ),
            ),
            '',
            false
        );

        $repositoryMock
            ->expects($this->once())
            ->method('getLimitationService')
            ->will($this->returnValue($limitationService));

        $permissionSets = $this->getPermissionSetsMock();
        $repositoryMock
            ->expects($this->once())
            ->method('hasAccess')
            ->with($this->equalTo('test-module'), $this->equalTo('test-function'))
            ->will($this->returnValue($permissionSets));

        $userRef = new UserReference(14);
        $repositoryMock
            ->expects($this->once())
            ->method('getCurrentUserReference')
            ->will($this->returnValue(new UserReference(14)));

        $invocation = 0;
        for ($i = 0; $i < count($permissionSets); ++$i) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            $limitation = $this->getMock('eZ\\Publish\\SPI\\Limitation\\Type');
            $limitation
                ->expects($this->once())
                ->method('evaluate')
                ->with($permissionSets[$i]['limitation'], $userRef, $valueObject, array($valueObject))
                ->will($this->returnValue($roleLimitationEvaluations[$i]));
            $limitationService
                ->expects($this->at($invocation++))
                ->method('getLimitationType')
                ->with('test-role-limitation-identifier')
                ->will($this->returnValue($limitation));

            if (!$roleLimitationEvaluations[$i]) {
                continue;
            }

            for ($j = 0; $j < count($permissionSets[$i]['policies']); ++$j) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                /** @var $policy \eZ\Publish\API\Repository\Values\User\Policy */
                $policy = $permissionSets[$i]['policies'][$j];
                $limitations = $policy->getLimitations();
                for ($k = 0; $k < count($limitations); ++$k) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    $limitationsPass = true;
                    $limitation = $this->getMock('eZ\\Publish\\SPI\\Limitation\\Type');
                    $limitation
                        ->expects($this->once())
                        ->method('evaluate')
                        ->with($limitations[$k], $userRef, $valueObject, array($valueObject))
                        ->will($this->returnValue($policyLimitationEvaluations[$i][$j][$k]));
                    $limitationService
                        ->expects($this->at($invocation++))
                        ->method('getLimitationType')
                        ->with('test-policy-limitation-identifier')
                        ->will($this->returnValue($limitation));

                    if (!$policyLimitationEvaluations[$i][$j][$k]) {
                        $limitationsPass = false;
                        break;
                    }
                }

                /** @var $limitationsPass */
                if ($limitationsPass) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                    break 2;
                }
            }
        }

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        self::assertEquals(
            $userCan,
            $repositoryMock->canUser('test-module', 'test-function', $valueObject, $valueObject)
        );
    }

    /**
     * Test for the canUser() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::canUser
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     */
    public function testCanUserThrowsInvalidArgumentException()
    {
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('hasAccess'),
            array(),
            '',
            false
        );

        $repositoryMock
            ->expects($this->once())
            ->method('hasAccess')
            ->with($this->equalTo('test-module'), $this->equalTo('test-function'))
            ->will($this->returnValue(array()));

        /** @var $valueObject \eZ\Publish\API\Repository\Values\ValueObject */
        $valueObject = $this->getMockForAbstractClass('eZ\\Publish\\API\\Repository\\Values\\ValueObject');

        /* @var $repositoryMock \eZ\Publish\Core\Repository\Repository */
        $repositoryMock->canUser('test-module', 'test-function', $valueObject, 'This is not a target');
    }

    /**
     * Test for the setCurrentUser() and getCurrentUser() methods.
     *
     * @covers \eZ\Publish\API\Repository\Repository::setCurrentUser
     * @covers \eZ\Publish\API\Repository\Repository::getCurrentUser
     */
    public function testSetAndGetCurrentUser()
    {
        $mockedRepository = $this->getRepository();
        $user = $this->getStubbedUser(42);

        $mockedRepository->setCurrentUser($user);

        self::assertSame(
            $user,
            $mockedRepository->getCurrentUser()
        );
    }

    /**
     * Test for the getCurrentUser() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::getCurrentUser
     */
    public function testGetCurrentUserReturnsAnonymousUser()
    {
        $userServiceMock = $this->getMock('eZ\\Publish\\API\\Repository\\UserService');
        $repositoryMock = $this->getMock(
            'eZ\\Publish\\Core\\Repository\\Repository',
            array('getUserService'),
            array(
                $this->getPersistenceMock(),
                $this->getSPIMockHandler('Search\\Handler'),
                array(
                    'user' => array(
                        'anonymousUserID' => 10,
                    ),
                ),
            )
        );

        $userServiceMock
            ->expects($this->once())
            ->method('loadUser')
            ->with(10)
            ->will($this->returnValue('Anonymous User'));

        $repositoryMock
            ->expects($this->once())
            ->method('getUserService')
            ->will($this->returnValue($userServiceMock));

        /* @var $repositoryMock \eZ\Publish\API\Repository\Repository */
        self::assertEquals(
            'Anonymous User',
            $repositoryMock->getCurrentUser()
        );
    }

    /**
     * Test for the beginTransaction() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::beginTransaction
     */
    public function testBeginTransaction()
    {
        $mockedRepository = $this->getRepository();
        $persistenceHandlerMock = $this->getPersistenceMock();

        $persistenceHandlerMock->expects(
            $this->once()
        )->method(
            'beginTransaction'
        );

        $mockedRepository->beginTransaction();
    }

    /**
     * Test for the commit() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::commit
     */
    public function testCommit()
    {
        $mockedRepository = $this->getRepository();
        $persistenceHandlerMock = $this->getPersistenceMock();

        $persistenceHandlerMock->expects(
            $this->once()
        )->method(
            'commit'
        );

        $mockedRepository->commit();
    }

    /**
     * Test for the commit() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::commit
     * @expectedException \RuntimeException
     */
    public function testCommitThrowsRuntimeException()
    {
        $mockedRepository = $this->getRepository();
        $persistenceHandlerMock = $this->getPersistenceMock();

        $persistenceHandlerMock->expects(
            $this->once()
        )->method(
            'commit'
        )->will(
            $this->throwException(new \Exception())
        );

        $mockedRepository->commit();
    }

    /**
     * Test for the rollback() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::rollback
     */
    public function testRollback()
    {
        $mockedRepository = $this->getRepository();
        $persistenceHandlerMock = $this->getPersistenceMock();

        $persistenceHandlerMock->expects(
            $this->once()
        )->method(
            'rollback'
        );

        $mockedRepository->rollback();
    }

    /**
     * Test for the rollback() method.
     *
     * @covers \eZ\Publish\API\Repository\Repository::rollback
     * @expectedException \RuntimeException
     */
    public function testRollbackThrowsRuntimeException()
    {
        $mockedRepository = $this->getRepository();
        $persistenceHandlerMock = $this->getPersistenceMock();

        $persistenceHandlerMock->expects(
            $this->once()
        )->method(
            'rollback'
        )->will(
            $this->throwException(new \Exception())
        );

        $mockedRepository->rollback();
    }
}

ezsystems / ezpublish-kernel
