eZ\Publish\Core\Repository\Tests\Service\Integration\RoleBase

Complexity

Total Complexity

59

Size/Duplication

Total Lines	901
Duplicated Lines	27.41 %

Coupling/Cohesion

Components	1
Dependencies	18

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	testNewClass()	0	24	1
A	testMissingProperty()	16	16	3
A	testReadOnlyProperty()	16	16	3
A	testIsPropertySet()	16	16	1
A	testUnsetProperty()	0	16	3
A	testCreateRole()	0	38	1
A	testCreateRoleThrowsInvalidArgumentException()	0	12	1
C	testCreateRoleWithPolicies()	24	106	11
A	testUpdateRole()	0	43	1
A	testUpdateRoleThrowsInvalidArgumentException()	0	11	1
A	testAddPolicy()	0	28	2
A	testRemovePolicy()	0	13	1
A	testUpdatePolicy()	0	37	1
A	testLoadRole()	15	15	1
A	testLoadRoleThrowsNotFoundException()	0	6	1
A	testLoadRoleByIdentifier()	15	15	1
A	testLoadRoleByIdentifierThrowsNotFoundException()	0	6	1
A	testLoadRoles()	13	13	2
A	testDeleteRole()	0	16	2
A	testLoadPoliciesByUserId()	14	14	2
A	testLoadPoliciesByNonExistingUserId()	0	6	1
A	testAssignRoleToUserGroup()	13	13	1
A	testUnassignRoleFromUserGroup()	13	13	1
A	testUnassignRoleFromUserGroupUnauthorizedException()	0	15	2
A	testUnassignRoleFromUserGroupThrowsInvalidArgumentException()	9	9	1
A	testAssignRoleToUser()	13	13	1
A	testUnassignRoleFromUser()	0	17	1
A	testUnassignRoleFromUserThrowsInvalidArgumentException()	9	9	1
A	testGetRoleAssignments()	0	15	2
A	testGetRoleAssignmentsForUser()	0	17	2
A	testGetRoleAssignmentsForUserGroup()	0	13	2
A	testNewRoleCreateStruct()	23	23	1
A	testNewPolicyCreateStruct()	19	19	1
A	testNewRoleUpdateStruct()	19	19	1
A	testNewPolicyUpdateStruct()	0	11	1

<?php

/**
 * File contains: eZ\Publish\Core\Repository\Tests\Service\Integration\RoleBase 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\Service\Integration;

use eZ\Publish\Core\Repository\Tests\Service\Integration\Base as BaseServiceTest;
use eZ\Publish\Core\Repository\Values\User\Role;
use eZ\Publish\Core\Repository\Values\User\Policy;
use eZ\Publish\API\Repository\Values\User\Limitation;
use eZ\Publish\API\Repository\Exceptions\PropertyNotFoundException as PropertyNotFound;
use eZ\Publish\API\Repository\Exceptions\PropertyReadOnlyException;
use eZ\Publish\API\Repository\Exceptions\NotFoundException;
use eZ\Publish\API\Repository\Tests\BaseTest as APIBaseTest;
use Exception;

/**
 * Test case for Role Service.
 */
abstract class RoleBase extends BaseServiceTest
{
    /**
     * Test a new class and default values on properties.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\Role::__construct
     * @covers \eZ\Publish\API\Repository\Values\User\Policy::__construct
     */
    public function testNewClass()
    {
        $this->assertPropertiesCorrect(
            array(
                'id' => null,
                'identifier' => null,
                // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
                // 'mainLanguageCode' => null,
                'policies' => array(),
            ),
            new Role()
        );

        $this->assertPropertiesCorrect(
            array(
                'id' => null,
                'roleId' => null,
                'module' => null,
                'function' => null,
                'limitations' => array(),
            ),
            new Policy()
        );
    }

    /**
     * Test retrieving missing property.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\Role::__get
     * @covers \eZ\Publish\API\Repository\Values\User\Policy::__get
     */
    public function testMissingProperty()
    {
        try {
            $role = new Role();
            $value = $role->notDefined;

The property notDefined does not exist on object<eZ\Publish\Core\Repository\Values\User\Role>. Since you implemented __set, maybe consider adding a @property annotation.

$value is not used, you could remove the assignment.

            self::fail('Succeeded getting non existing property');
        } catch (PropertyNotFound $e) {

Consider adding a comment why this CATCH block is empty.

        }

        try {
            $policy = new Policy();
            $value = $policy->notDefined;

The property notDefined does not exist on object<eZ\Publish\Core\Repository\Values\User\Policy>. Since you implemented __set, maybe consider adding a @property annotation.

$value is not used, you could remove the assignment.

            self::fail('Succeeded getting non existing property');
        } catch (PropertyNotFound $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }

    /**
     * Test setting read only property.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\Role::__set
     * @covers \eZ\Publish\API\Repository\Values\User\Policy::__set
     */
    public function testReadOnlyProperty()
    {
        try {
            $role = new Role();
            $role->id = 42;
            self::fail('Succeeded setting read only property');
        } catch (PropertyReadOnlyException $e) {

Consider adding a comment why this CATCH block is empty.

        }

        try {
            $policy = new Policy();
            $policy->id = 42;
            self::fail('Succeeded setting read only property');
        } catch (PropertyReadOnlyException $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }

    /**
     * Test if property exists.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\Role::__isset
     * @covers \eZ\Publish\API\Repository\Values\User\Policy::__isset
     */
    public function testIsPropertySet()
    {
        $role = new Role();
        $value = isset($role->notDefined);
        self::assertEquals(false, $value);

        $value = isset($role->id);
        self::assertEquals(true, $value);

        $policy = new Policy();
        $value = isset($policy->notDefined);
        self::assertEquals(false, $value);

        $value = isset($policy->id);
        self::assertEquals(true, $value);
    }

    /**
     * Test unsetting a property.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\Role::__unset
     * @covers \eZ\Publish\API\Repository\Values\User\Policy::__unset
     */
    public function testUnsetProperty()
    {
        $role = new Role(array('id' => 1));
        try {
            unset($role->id);
            self::fail('Unsetting read-only property succeeded');
        } catch (PropertyReadOnlyException $e) {

Consider adding a comment why this CATCH block is empty.

        }

        $policy = new Policy(array('id' => 1));
        try {
            unset($policy->id);
            self::fail('Unsetting read-only property succeeded');
        } catch (PropertyReadOnlyException $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }

    /**
     * Test creating a role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::createRole
     */
    public function testCreateRole()
    {
        $roleService = $this->repository->getRoleService();
        $roleCreateStruct = $roleService->newRoleCreateStruct('ultimate_permissions');
        // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
        // $roleCreateStruct->mainLanguageCode = 'eng-GB';
        // $roleCreateStruct->names = array( 'eng-GB' => 'Ultimate permissions' );
        // $roleCreateStruct->descriptions = array( 'eng-GB' => 'This is a role with ultimate permissions' );

        $createdRole = $roleService->createRole($roleCreateStruct);

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $createdRole);
        self::assertGreaterThan(0, $createdRole->id);

        /* @todo uncomment when support for multilingual names and descriptions is added EZP-24776
        self::assertEquals(
            array(
                'eng-GB' => $roleCreateStruct->names['eng-GB']
            ),
            $createdRole->getNames()
        );

        self::assertEquals(
            array(
                'eng-GB' => $roleCreateStruct->descriptions['eng-GB']
            ),
            $createdRole->getDescriptions()
        );
        */

        $this->assertPropertiesCorrect(
            array(
                'identifier' => $roleCreateStruct->identifier,
                'policies' => array(),
            ),
            $createdRole
        );
    }

    /**
     * Test creating a role throwing InvalidArgumentException.
     *
     * @expectedException \eZ\Publish\Core\Base\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\RoleService::createRole
     */
    public function testCreateRoleThrowsInvalidArgumentException()
    {
        $roleService = $this->repository->getRoleService();
        $roleCreateStruct = $roleService->newRoleCreateStruct('Anonymous');

        // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
        // $roleCreateStruct->mainLanguageCode = 'eng-GB';
        // $roleCreateStruct->names = array( 'eng-GB' => 'Anonymous' );
        // $roleCreateStruct->descriptions = array( 'eng-GB' => 'Anonymous role' );

        $roleService->createRole($roleCreateStruct);
    }

    /**
     * Test creating a role with policies.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::createRole
     */
    public function testCreateRoleWithPolicies()
    {
        $roleService = $this->repository->getRoleService();

        $limitation1 = new Limitation\ContentTypeLimitation();
        $limitation1->limitationValues = array('1', '3', '13');

        $limitation2 = new Limitation\SectionLimitation();
        $limitation2->limitationValues = array('2', '3');

        $limitation3 = new Limitation\OwnerLimitation();
        $limitation3->limitationValues = array('1', '2');

        $limitation4 = new Limitation\UserGroupLimitation();
        $limitation4->limitationValues = array('1');

        $policyCreateStruct1 = $roleService->newPolicyCreateStruct('content', 'read');
        $policyCreateStruct1->addLimitation($limitation1);
        $policyCreateStruct1->addLimitation($limitation2);

        $policyCreateStruct2 = $roleService->newPolicyCreateStruct('content', 'edit');
        $policyCreateStruct2->addLimitation($limitation3);
        $policyCreateStruct2->addLimitation($limitation4);

        $roleCreateStruct = $roleService->newRoleCreateStruct('ultimate_permissions');

        // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
        // $roleCreateStruct->mainLanguageCode = 'eng-GB';
        // $roleCreateStruct->names = array( 'eng-GB' => 'Ultimate permissions' );
        // $roleCreateStruct->descriptions = array( 'eng-GB' => 'This is a role with ultimate permissions' );

        $roleCreateStruct->addPolicy($policyCreateStruct1);
        $roleCreateStruct->addPolicy($policyCreateStruct2);

        $createdRole = $roleService->createRole($roleCreateStruct);

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $createdRole);
        self::assertGreaterThan(0, $createdRole->id);

        /* @todo uncomment when support for multilingual names and descriptions is added EZP-24776
        self::assertEquals(
            array(
                'eng-GB' => $roleCreateStruct->names['eng-GB']
            ),
            $createdRole->getNames()
        );

        self::assertEquals(
            array(
                'eng-GB' => $roleCreateStruct->descriptions['eng-GB']
            ),
            $createdRole->getDescriptions()
        );
        */

        $this->assertPropertiesCorrect(
            array(
                'identifier' => $roleCreateStruct->identifier,
            ),
            $createdRole
        );

        self::assertCount(2, $createdRole->getPolicies());

        foreach ($createdRole->getPolicies() as $policy) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Policy', $policy);
            self::assertGreaterThan(0, $policy->id);
            self::assertEquals($createdRole->id, $policy->roleId);

            self::assertCount(2, $policy->getLimitations());

            foreach ($policy->getLimitations() as $limitation) {
                self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Limitation', $limitation);

                if ($policy->module == 'content' && $policy->function == 'read') {
                    switch ($limitation->getIdentifier()) {

This code seems to be duplicated across your project.

                        case Limitation::CONTENTTYPE:
                            self::assertEquals($limitation1->limitationValues, $limitation->limitationValues);
                            break;

                        case Limitation::SECTION:
                            self::assertEquals($limitation2->limitationValues, $limitation->limitationValues);
                            break;

                        default:
                            self::fail('Created role contains limitations not defined with create struct');
                    }
                } elseif ($policy->module == 'content' && $policy->function == 'edit') {
                    switch ($limitation->getIdentifier()) {

This code seems to be duplicated across your project.

                        case Limitation::OWNER:
                            self::assertEquals($limitation3->limitationValues, $limitation->limitationValues);
                            break;

                        case Limitation::USERGROUP:
                            self::assertEquals($limitation4->limitationValues, $limitation->limitationValues);
                            break;

                        default:
                            self::fail('Created role contains limitations not defined with create struct');
                    }
                } else {
                    self::fail('Created role contains policy not defined with create struct');
                }
            }
        }
    }

    /**
     * Test updating role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::updateRole
     */
    public function testUpdateRole()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRoleByIdentifier('Anonymous');

        $roleUpdateStruct = $roleService->newRoleUpdateStruct();
        $roleUpdateStruct->identifier = 'Anonymous 2';

        // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
        // $roleUpdateStruct->mainLanguageCode = 'eng-US';
        // $roleUpdateStruct->names['eng-US'] = 'Anonymous 2';
        // $roleUpdateStruct->descriptions['eng-US'] = 'Anonymous 2 role';

        $updatedRole = $roleService->updateRole($role, $roleUpdateStruct);

The method eZ\Publish\API\Repository\RoleService::updateRole() has been deprecated with message: since 6.0, use {@see updateRoleDraft}

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $updatedRole);

        // @todo: enable
        /*
                self::assertEquals(
                    array(
                        'eng-US' => $roleUpdateStruct->names['eng-US']
                    ),
                    $updatedRole->getNames()
                );

                self::assertEquals(
                    array(
                        'eng-US' => $roleUpdateStruct->descriptions['eng-US']
                    ),
                    $updatedRole->getDescriptions()
                );
        */
        $this->assertPropertiesCorrect(
            array(
                'id' => $role->id,
                'identifier' => $roleUpdateStruct->identifier,
                'policies' => $role->getPolicies(),
            ),
            $updatedRole
        );
    }

    /**
     * Test updating role throwing InvalidArgumentException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\RoleService::updateRole
     */
    public function testUpdateRoleThrowsInvalidArgumentException()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRoleByIdentifier('Anonymous');

        $roleUpdateStruct = $roleService->newRoleUpdateStruct();
        $roleUpdateStruct->identifier = 'Administrator';

        $roleService->updateRole($role, $roleUpdateStruct);

The method eZ\Publish\API\Repository\RoleService::updateRole() has been deprecated with message: since 6.0, use {@see updateRoleDraft}

    }

    /**
     * Test adding policy to role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::addPolicy
     */
    public function testAddPolicy()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        $policyCount = count($role->getPolicies());

        $limitation1 = new Limitation\ContentTypeLimitation();
        $limitation1->limitationValues = array('1', '3', '13');

        $limitation2 = new Limitation\SectionLimitation();
        $limitation2->limitationValues = array('2', '3');

        $policyCreateStruct = $roleService->newPolicyCreateStruct('content', 'read');
        $policyCreateStruct->addLimitation($limitation1);
        $policyCreateStruct->addLimitation($limitation2);

        $updatedRole = $roleService->addPolicy($role, $policyCreateStruct);

The method eZ\Publish\API\Repository\RoleService::addPolicy() has been deprecated with message: since 6.0, use {@see addPolicyByRoleDraft}

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $updatedRole);
        self::assertCount($policyCount + 1, $updatedRole->getPolicies());

        foreach ($updatedRole->getPolicies() as $policy) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Policy', $policy);
            self::assertGreaterThan(0, $policy->id);
            self::assertEquals($role->id, $policy->roleId);
        }
    }

    /**
     * Test removing policy from the role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::removePolicy
     */
    public function testRemovePolicy()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        $policies = $role->getPolicies();
        $policyCount = count($policies);

        self::assertGreaterThan(0, $policyCount);

        $updatedRole = $roleService->removePolicy($role, $policies[0]);

The method eZ\Publish\API\Repository\RoleService::removePolicy() has been deprecated with message: since 5.3, use {@link removePolicyByRoleDraft()} instead.

        self::assertCount($policyCount - 1, $updatedRole->getPolicies());
    }

    /**
     * Test updating policies of a role, depends on proper eZ Publish clean data
     * which has a number of policies and limitations applied to Anonymous role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::updatePolicy
     */
    public function testUpdatePolicy()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        $policies = $role->getPolicies();
        $policy = $policies[0];

        // Verify we get correct data from backend
        self::assertEquals('content', $policy->module);
        self::assertEquals('read', $policy->function);

        $limitation = new Limitation\ContentTypeLimitation();
        $limitation->limitationValues = array('1', '3', '13');

        $policyUpdateStruct = $roleService->newPolicyUpdateStruct();
        $policyUpdateStruct->addLimitation($limitation);

        $updatedPolicy = $roleService->updatePolicy($policy, $policyUpdateStruct);

The method eZ\Publish\API\Repository\RoleService::updatePolicy() has been deprecated with message: since 6.0, use {@link updatePolicyByRoleDraft()} instead.

        $this->assertPropertiesCorrect(
            array(
                'id' => $policy->id,
                'roleId' => $policy->roleId,
                'module' => $policy->module,
                'function' => $policy->function,
            ),
            $updatedPolicy
        );

        $limitations = $updatedPolicy->getLimitations();

        self::assertCount(1, $limitations);
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Limitation', $limitations[0]);
        self::assertEquals(Limitation::CONTENTTYPE, $limitations[0]->getIdentifier());
        self::assertEquals($limitation->limitationValues, $limitations[0]->limitationValues);
    }

    /**
     * Test loading role by id.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::loadRole
     */
    public function testLoadRole()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $role);

        $this->assertPropertiesCorrect(
            array(
                'id' => 1,
                'identifier' => 'Anonymous',
            ),
            $role
        );
    }

    /**
     * Test loading role by id throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\RoleService::loadRole
     */
    public function testLoadRoleThrowsNotFoundException()
    {
        $roleService = $this->repository->getRoleService();

        $roleService->loadRole(APIBaseTest::DB_INT_MAX);
    }

    /**
     * Test loading role by identifier.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::loadRoleByIdentifier
     */
    public function testLoadRoleByIdentifier()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRoleByIdentifier('Anonymous');
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $role);

        $this->assertPropertiesCorrect(
            array(
                'id' => 1,
                'identifier' => 'Anonymous',
            ),
            $role
        );
    }

    /**
     * Test loading role by identifier throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\RoleService::loadRoleByIdentifier
     */
    public function testLoadRoleByIdentifierThrowsNotFoundException()
    {
        $roleService = $this->repository->getRoleService();

        $roleService->loadRoleByIdentifier('non-existing');
    }

    /**
     * Test loading all roles.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::loadRoles
     */
    public function testLoadRoles()
    {
        $roleService = $this->repository->getRoleService();

        $roles = $roleService->loadRoles();
        self::assertInternalType('array', $roles);
        self::assertGreaterThan(0, count($roles));

        foreach ($roles as $role) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $role);
            self::assertGreaterThan(0, $role->id);
        }
    }

    /**
     * Test deleting a role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::deleteRole
     */
    public function testDeleteRole()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Role', $role);

        $roleService->deleteRole($role);

        try {
            $roleService->loadRole(1);
            self::fail('Succeeded loading role after deleting it');
        } catch (NotFoundException $e) {
            // Do nothing
        }
    }

    /**
     * Test loading policies by user ID.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::loadPoliciesByUserId
     */
    public function testLoadPoliciesByUserId()
    {
        $roleService = $this->repository->getRoleService();

        $policies = $roleService->loadPoliciesByUserId(10);
        self::assertInternalType('array', $policies);
        self::assertNotEmpty($policies);

        foreach ($policies as $policy) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\Policy', $policy);
            self::assertGreaterThan(0, $policy->id);
            self::assertGreaterThan(0, $policy->roleId);
        }
    }

    /**
     * Test loading policies by non existing user ID.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\RoleService::loadPoliciesByUserId
     */
    public function testLoadPoliciesByNonExistingUserId()
    {
        $roleService = $this->repository->getRoleService();

        $roleService->loadPoliciesByUserId(APIBaseTest::DB_INT_MAX);
    }

    /**
     * Test assigning role to user group.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::assignRoleToUserGroup
     */
    public function testAssignRoleToUserGroup()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        $userGroup = $this->repository->getUserService()->loadUserGroup(12);

        $originalAssignmentCount = count($roleService->getRoleAssignmentsForUserGroup($userGroup));

        $roleService->assignRoleToUserGroup($role, $userGroup);
        $newAssignmentCount = count($roleService->getRoleAssignmentsForUserGroup($userGroup));
        self::assertEquals($originalAssignmentCount + 1, $newAssignmentCount);
    }

    /**
     * Test unassigning role from user group.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::unassignRoleFromUserGroup
     */
    public function testUnassignRoleFromUserGroup()
    {
        $roleService = $this->repository->getRoleService();

        $anonymousRole = $roleService->loadRole(1);
        $anonymousUserGroup = $this->repository->getUserService()->loadUserGroup(42);

        $originalAssignmentCount = count($roleService->getRoleAssignmentsForUserGroup($anonymousUserGroup));

        $roleService->unassignRoleFromUserGroup($anonymousRole, $anonymousUserGroup);

The method eZ\Publish\API\Repository\RoleService::unassignRoleFromUserGroup() has been deprecated with message: since 6.0, use {@see removeRoleAssignment} instead.

        $newAssignmentCount = count($roleService->getRoleAssignmentsForUserGroup($anonymousUserGroup));
        self::assertEquals($originalAssignmentCount - 1, $newAssignmentCount);
    }

    /**
     * Test unassigning role from user group.
     *
     * But on current admin user so he lacks access to read roles.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::unassignRoleFromUserGroup
     * @expectedException \eZ\Publish\API\Repository\Exceptions\UnauthorizedException
     */
    public function testUnassignRoleFromUserGroupUnauthorizedException()
    {
        $roleService = $this->repository->getRoleService();

        try {
            $adminRole = $roleService->loadRole(2);
            $adminUserGroup = $this->repository->getUserService()->loadUserGroup(12);
            $roleService->getRoleAssignmentsForUserGroup($adminUserGroup);
            $roleService->unassignRoleFromUserGroup($adminRole, $adminUserGroup);

The method eZ\Publish\API\Repository\RoleService::unassignRoleFromUserGroup() has been deprecated with message: since 6.0, use {@see removeRoleAssignment} instead.

        } catch (Exception $e) {
            self::fail('Unexpected exception: ' . $e->getMessage() . " \n[" . $e->getFile() . ' (' . $e->getLine() . ')]');
        }

        $roleService->getRoleAssignmentsForUserGroup($adminUserGroup);

The variable $adminUserGroup does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * Test unassigning role from user group which is not already assigned to the group.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\RoleService::unassignRoleFromUserGroup
     */
    public function testUnassignRoleFromUserGroupThrowsInvalidArgumentException()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(1);
        $userGroup = $this->repository->getUserService()->loadUserGroup(12);

        $roleService->unassignRoleFromUserGroup($role, $userGroup);

The method eZ\Publish\API\Repository\RoleService::unassignRoleFromUserGroup() has been deprecated with message: since 6.0, use {@see removeRoleAssignment} instead.

    }

    /**
     * Test assigning role to user.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::assignRoleToUser
     */
    public function testAssignRoleToUser()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(2);
        $user = $this->repository->getUserService()->loadUser(14);

        $originalAssignmentCount = count($roleService->getRoleAssignmentsForUser($user));

        $roleService->assignRoleToUser($role, $user);
        $newAssignmentCount = count($roleService->getRoleAssignmentsForUser($user));
        self::assertEquals($originalAssignmentCount + 1, $newAssignmentCount);
    }

    /**
     * Test unassigning role from user.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::unassignRoleFromUser
     */
    public function testUnassignRoleFromUser()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(2);
        $user = $this->repository->getUserService()->loadUser(14);

        $originalAssignmentCount = count($roleService->getRoleAssignmentsForUser($user));

        $roleService->assignRoleToUser($role, $user);
        $newAssignmentCount = count($roleService->getRoleAssignmentsForUser($user));
        self::assertEquals($originalAssignmentCount + 1, $newAssignmentCount);

        $roleService->unassignRoleFromUser($role, $user);

The method eZ\Publish\API\Repository\RoleService::unassignRoleFromUser() has been deprecated with message: since 6.0, use {@see removeRoleAssignment} instead.

        $finalAssignmentCount = count($roleService->getRoleAssignmentsForUser($user));
        self::assertEquals($newAssignmentCount - 1, $finalAssignmentCount);
    }

    /**
     * Test unassigning role from user which is not already assigned to the user.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\RoleService::unassignRoleFromUser
     */
    public function testUnassignRoleFromUserThrowsInvalidArgumentException()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(2);
        $user = $this->repository->getUserService()->loadUser(14);

        $roleService->unassignRoleFromUser($role, $user);

The method eZ\Publish\API\Repository\RoleService::unassignRoleFromUser() has been deprecated with message: since 6.0, use {@see removeRoleAssignment} instead.

    }

    /**
     * Test fetching all role assignments for specified role.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::getRoleAssignments
     */
    public function testGetRoleAssignments()
    {
        $roleService = $this->repository->getRoleService();

        $role = $roleService->loadRole(2);

        $roleAssignments = $roleService->getRoleAssignments($role);

        self::assertInternalType('array', $roleAssignments);
        self::assertNotEmpty($roleAssignments);

        foreach ($roleAssignments as $assignment) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\RoleAssignment', $assignment);
        }
    }

    /**
     * Test fetching role assignments for specified user.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::getRoleAssignmentsForUser
     */
    public function testGetRoleAssignmentsForUser()
    {
        $roleService = $this->repository->getRoleService();

        $user = $this->repository->getUserService()->loadUser(14);
        $role = $roleService->loadRole(2);
        $roleService->assignRoleToUser($role, $user);

        $userAssignments = $roleService->getRoleAssignmentsForUser($user);

        self::assertInternalType('array', $userAssignments);
        self::assertNotEmpty($userAssignments);

        foreach ($userAssignments as $assignment) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserRoleAssignment', $assignment);
        }
    }

    /**
     * Test fetching role assignments for specified user group.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::getRoleAssignmentsForUserGroup
     */
    public function testGetRoleAssignmentsForUserGroup()
    {
        $userGroup = $this->repository->getUserService()->loadUserGroup(12);

        $userGroupAssignments = $this->repository->getRoleService()->getRoleAssignmentsForUserGroup($userGroup);

        self::assertInternalType('array', $userGroupAssignments);
        self::assertNotEmpty($userGroupAssignments);

        foreach ($userGroupAssignments as $assignment) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserGroupRoleAssignment', $assignment);
        }
    }

    /**
     * Test creating new RoleCreateStruct.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::newRoleCreateStruct
     */
    public function testNewRoleCreateStruct()
    {
        $roleService = $this->repository->getRoleService();

        $roleCreateStruct = $roleService->newRoleCreateStruct('Ultimate permissions');

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\RoleCreateStruct', $roleCreateStruct);

        $this->assertPropertiesCorrect(
            array(
                'identifier' => 'Ultimate permissions',
                // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
                // 'mainLanguageCode' => null,
                // 'names' => null,
                // 'descriptions' => null
            ),
            $roleCreateStruct
        );

        self::assertEquals('Ultimate permissions', $roleCreateStruct->identifier);
        self::assertInternalType('array', $roleCreateStruct->getPolicies());
        self::assertEmpty($roleCreateStruct->getPolicies());
    }

    /**
     * Test creating new PolicyCreateStruct.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::newPolicyCreateStruct
     */
    public function testNewPolicyCreateStruct()
    {
        $roleService = $this->repository->getRoleService();

        $policyCreateStruct = $roleService->newPolicyCreateStruct('content', 'read');

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\PolicyCreateStruct', $policyCreateStruct);

        $this->assertPropertiesCorrect(
            array(
                'module' => 'content',
                'function' => 'read',
            ),
            $policyCreateStruct
        );

        self::assertInternalType('array', $policyCreateStruct->getLimitations());
        self::assertEmpty($policyCreateStruct->getLimitations());
    }

    /**
     * Test creating new RoleUpdateStruct.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::newRoleUpdateStruct
     */
    public function testNewRoleUpdateStruct()
    {
        $roleService = $this->repository->getRoleService();

        $roleUpdateStruct = $roleService->newRoleUpdateStruct();

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\RoleUpdateStruct', $roleUpdateStruct);

        $this->assertPropertiesCorrect(
            array(
                'identifier' => null,
                // @todo uncomment when support for multilingual names and descriptions is added EZP-24776
                // 'mainLanguageCode' => null,
                // 'names' => null,
                // 'descriptions' => null
            ),
            $roleUpdateStruct
        );
    }

    /**
     * Test creating new PolicyUpdateStruct.
     *
     * @covers \eZ\Publish\API\Repository\RoleService::newPolicyUpdateStruct
     */
    public function testNewPolicyUpdateStruct()
    {
        $roleService = $this->repository->getRoleService();

        $policyUpdateStruct = $roleService->newPolicyUpdateStruct();

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\PolicyUpdateStruct', $policyUpdateStruct);

        self::assertInternalType('array', $policyUpdateStruct->getLimitations());
        self::assertEmpty($policyUpdateStruct->getLimitations());
    }
}