UserBase - Code Metrics - Inspection of "fixup! EZP-24853: Enhance REST output when failing..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — ezp24853-enhance_rest_when_fai... ( e6742d...0714c7 )

unknown
created 2016-08-09 11:19 UTC
UserBase F

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	915
Duplicated Lines	22.62 %
Coupling/Cohesion

Components	1
Dependencies	20
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
dl	207
loc	915
rs	1.7254
c	1
b	0
f	0
wmc	63
lcom	1
cbo	20
41 Methods

Rating	Name	Duplication	Size	Complexity
B	testNewClass()	0	28	1
A	testMissingProperty()	0	16	3
A	testReadOnlyProperty()	0	16	3
A	testIsPropertySet()	16	16	1
A	testUnsetProperty()	0	16	3
A	testCreateUserGroup()	15	15	1
A	testLoadUserGroup()	0	6	1
A	testLoadUserGroupThrowsNotFoundException()	0	5	1
A	testLoadSubUserGroups()	0	18	1
A	testLoadSubUserGroupsThrowsNotFoundException()	18	18	1
A	testDeleteUserGroup()	0	13	2
A	testDeleteUserGroupThrowsNotFoundException()	18	18	1
A	testMoveUserGroup()	0	17	1
B	testMoveUserGroupThrowsNotFoundException()	0	30	1
A	testUpdateUserGroup()	0	18	1
A	testCreateUser()	0	17	1
B	testCreateUserThrowsNotFoundException()	0	24	1
A	testCreateUserThrowsInvalidArgumentException()	11	11	1
A	testLoadUser()	9	9	1
A	testLoadUserThrowsNotFoundException()	0	6	1
A	testLoadAnonymousUser()	9	9	1
A	testLoadUserByCredentials()	20	20	1
A	testLoadUserByCredentialsThrowsNotFoundException()	0	6	1
A	testLoadUserByCredentialsThrowsNotFoundExceptionBadPassword()	0	6	1
B	testUpdateUser()	0	25	1
A	testUpdateUserThrowsContentValidationException()	12	12	1
B	testAssignUserToUserGroup()	6	28	6
A	testAssignUserToUserGroupThrowsInvalidArgumentException()	8	8	1
C	testUnAssignUserFromUserGroup()	6	38	7
A	testUnAssignUserFromUserGroupThrowsBadStateException()	9	9	1
A	testUnAssignUserFromUserGroupThrowsInvalidArgumentException()	8	8	1
B	testLoadUserGroupsOfUser()	0	27	4
A	testLoadUsersOfUserGroup()	0	22	2
A	testNewUserCreateStruct()	19	19	1
A	testNewUserGroupCreateStruct()	0	8	1
B	testNewUserUpdateStruct()	0	24	1
A	testNewUserGroupUpdateStruct()	0	14	1
A	testCreateUserGroupRequiredFieldEmpty()	0	12	1
A	testCreateUserGroupRequiredFieldMissing()	0	9	1
A	testUpdateUserGroupRequiredFieldEmpty()	12	12	1
A	testCreateUserRequiredFieldsEmpty()	11	11	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 UserBase 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 UserBase, and based on these observations, apply Extract Interface, too.
<?php

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

use eZ\Publish\Core\Repository\Tests\Service\Integration\Base as BaseServiceTest;
use eZ\Publish\Core\Repository\Values\User\User;
use eZ\Publish\Core\Repository\Values\User\UserGroup;
use eZ\Publish\Core\Repository\Values\Content\Content;
use eZ\Publish\Core\Repository\Values\Content\VersionInfo;
use eZ\Publish\API\Repository\Values\Content\ContentInfo;
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;

/**
 * Test case for User Service.
 */
abstract class UserBase extends BaseServiceTest
{
    /**
     * Test a new class and default values on properties.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\User::__construct
     * @covers \eZ\Publish\API\Repository\Values\User\UserGroup::__construct
     */
    public function testNewClass()
    {
        $user = new User();

        $this->assertPropertiesCorrect(
            array(
                'login' => null,
                'email' => null,
                'passwordHash' => null,
                'hashAlgorithm' => null,
                'maxLogin' => null,
                'enabled' => null,
            ),
            $user
        );

        $group = new UserGroup();
        self::assertEquals(null, $group->parentId);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        self::assertEquals(null, $group->subGroupCount);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        $this->assertPropertiesCorrect(
            array(
                'parentId' => null,
                'subGroupCount' => null,
            ),
            $group
        );
    }

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

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

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

        }

        try {
            $userGroup = new UserGroup();
            $value = $userGroup->notDefined;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

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

        }
    }

    /**
     * Test setting read only property.
     *
     * @covers \eZ\Publish\API\Repository\Values\User\User::__set
     * @covers \eZ\Publish\API\Repository\Values\User\UserGroup::__set
     */
    public function testReadOnlyProperty()
    {
        try {
            $user = new User();
            $user->login = 'user';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            self::fail('Succeeded setting read only property');
        } catch (PropertyReadOnlyException $e) {

        }

        try {
            $userGroup = new UserGroup();
            $userGroup->parentId = 42;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            self::fail('Succeeded setting read only property');
        } catch (PropertyReadOnlyException $e) {

        }
    }

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

        $value = isset($user->login);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

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

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

        $value = isset($userGroup->parentId);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

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

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

        }

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

        }
    }

    /**
     * Test creating new user group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::createUserGroup
     */
    public function testCreateUserGroup()
    {
        $userService = $this->repository->getUserService();

        $parentGroup = $userService->loadUserGroup(4);
        $userGroupCreateStruct = $userService->newUserGroupCreateStruct('eng-GB');
        $userGroupCreateStruct->ownerId = 14;
        $userGroupCreateStruct->sectionId = 1;
        $userGroupCreateStruct->setField('name', 'New group');
        $userGroupCreateStruct->setField('description', 'This is a new group');

        $newGroup = $userService->createUserGroup($userGroupCreateStruct, $parentGroup);

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserGroup', $newGroup);
    }

    /**
     * Test creating new user group throwing ContentFieldValidationException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException
     * @covers \eZ\Publish\API\Repository\UserService::createUserGroup
     */
    public function testCreateUserGroupRequiredFieldEmpty()
    {
        $userService = $this->repository->getUserService();

        $parentGroup = $userService->loadUserGroup(4);
        $userGroupCreateStruct = $userService->newUserGroupCreateStruct('eng-GB');
        $userGroupCreateStruct->ownerId = 14;
        $userGroupCreateStruct->sectionId = 1;
        $userGroupCreateStruct->setField('name', '');

        $userService->createUserGroup($userGroupCreateStruct, $parentGroup);
    }

    /**
     * Test creating new user group throwing ContentFieldValidationException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException
     * @covers \eZ\Publish\API\Repository\UserService::createUserGroup
     */
    public function testCreateUserGroupRequiredFieldMissing()
    {
        $userService = $this->repository->getUserService();

        $parentGroup = $userService->loadUserGroup(4);
        $userGroupCreateStruct = $userService->newUserGroupCreateStruct('eng-GB');

        $userService->createUserGroup($userGroupCreateStruct, $parentGroup);
    }

    /**
     * Test loading a group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroup
     */
    public function testLoadUserGroup()
    {
        $userService = $this->repository->getUserService();
        $userGroup = $userService->loadUserGroup(4);
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserGroup', $userGroup);
    }

    /**
     * Test loading a group throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroup
     */
    public function testLoadUserGroupThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();
        $userService->loadUserGroup(APIBaseTest::DB_INT_MAX);
    }

    /**
     * Test loading sub groups.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadSubUserGroups
     */
    public function testLoadSubUserGroups()
    {
        $userService = $this->repository->getUserService();

        $parentGroup = $userService->loadUserGroup(4);
        $userGroupCreateStruct = $userService->newUserGroupCreateStruct('eng-GB');
        $userGroupCreateStruct->ownerId = 14;
        $userGroupCreateStruct->sectionId = 1;
        $userGroupCreateStruct->setField('name', 'New group');
        $userGroupCreateStruct->setField('description', 'This is a new group');

        $userService->createUserGroup($userGroupCreateStruct, $parentGroup);

        $subGroups = $userService->loadSubUserGroups($parentGroup);

        self::assertInternalType('array', $subGroups);
        self::assertNotEmpty($subGroups);
    }

    /**
     * Test loading sub groups throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::loadSubUserGroups
     */
    public function testLoadSubUserGroupsThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();

        $parentGroup = new UserGroup(
            array(
                'content' => new Content(
                    array(
                        'versionInfo' => new VersionInfo(
                            array('contentInfo' => new ContentInfo(array('id' => APIBaseTest::DB_INT_MAX)))
                        ),
                        'internalFields' => array(),
                    )
                ),
            )
        );
        $userService->loadSubUserGroups($parentGroup);
    }

    /**
     * Test deleting user group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::deleteUserGroup
     */
    public function testDeleteUserGroup()
    {
        $userService = $this->repository->getUserService();

        $userGroup = $userService->loadUserGroup(12);
        $userService->deleteUserGroup($userGroup);

        try {
            $userService->loadUserGroup($userGroup->id);
            self::fail('Succeeded loading deleted user group');
        } catch (NotFoundException $e) {

        }
    }

    /**
     * Test deleting user group throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::deleteUserGroup
     */
    public function testDeleteUserGroupThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();

        $userGroup = new UserGroup(
            array(
                'content' => new Content(
                    array(
                        'versionInfo' => new VersionInfo(
                            array('contentInfo' => new ContentInfo(array('id' => APIBaseTest::DB_INT_MAX)))
                        ),
                        'internalFields' => array(),
                    )
                ),
            )
        );
        $userService->deleteUserGroup($userGroup);
    }

    /**
     * Test moving a user group below another group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::moveUserGroup
     */
    public function testMoveUserGroup()
    {
        $userService = $this->repository->getUserService();
        $locationService = $this->repository->getLocationService();

        $userGroupToMove = $userService->loadUserGroup(42);
        $parentUserGroup = $userService->loadUserGroup(12);
        $userService->moveUserGroup($userGroupToMove, $parentUserGroup);

        $movedUserGroup = $userService->loadUserGroup($userGroupToMove->id);

        $newMainLocation = $locationService->loadLocation($movedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId);
        self::assertEquals(
            $parentUserGroup->getVersionInfo()->getContentInfo()->mainLocationId,
            $newMainLocation->parentLocationId
        );
    }

    /**
     * Test moving a user group below another group throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::moveUserGroup
     */
    public function testMoveUserGroupThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();

        $userGroupToMove = new UserGroup(
            array(
                'content' => new Content(
                    array(
                        'versionInfo' => new VersionInfo(
                            array('contentInfo' => new ContentInfo(array('id' => APIBaseTest::DB_INT_MAX)))
                        ),
                        'internalFields' => array(),
                    )
                ),
            )
        );
        $parentUserGroup = new UserGroup(
            array(
                'content' => new Content(
                    array(
                        'versionInfo' => new VersionInfo(
                            array('contentInfo' => new ContentInfo(array('id' => APIBaseTest::DB_INT_MAX)))
                        ),
                        'internalFields' => array(),
                    )
                ),
            )
        );
        $userService->moveUserGroup($userGroupToMove, $parentUserGroup);
    }

    /**
     * Test updating a user group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::updateUserGroup
     */
    public function testUpdateUserGroup()
    {
        $userService = $this->repository->getUserService();
        $contentService = $this->repository->getContentService();

        $userGroupUpdateStruct = $userService->newUserGroupUpdateStruct();
        $userGroupUpdateStruct->contentUpdateStruct = $contentService->newContentUpdateStruct();
        $userGroupUpdateStruct->contentUpdateStruct->setField('name', 'New anonymous group', 'eng-US');

        $userGroup = $userService->loadUserGroup(42);

        $updatedUserGroup = $userService->updateUserGroup($userGroup, $userGroupUpdateStruct);
        self::assertInstanceOf('eZ\\Publish\\API\\Repository\\Values\\User\\UserGroup', $updatedUserGroup);
        self::assertEquals(
            $userGroupUpdateStruct->contentUpdateStruct->fields[0]->value,
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            $updatedUserGroup->getFieldValue('name')
        );
    }

    /**
     * Test updating a user group throwing ContentFieldValidationException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException
     * @covers \eZ\Publish\API\Repository\UserService::updateUserGroup
     */
    public function testUpdateUserGroupRequiredFieldEmpty()
    {
        $userService = $this->repository->getUserService();
        $contentService = $this->repository->getContentService();

        $userGroup = $userService->loadUserGroup(42);
        $userGroupUpdateStruct = $userService->newUserGroupUpdateStruct();
        $userGroupUpdateStruct->contentUpdateStruct = $contentService->newContentUpdateStruct();
        $userGroupUpdateStruct->contentUpdateStruct->setField('name', '', 'eng-US');

        $userService->updateUserGroup($userGroup, $userGroupUpdateStruct);
    }

    /**
     * Test creating a user.
     *
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     */
    public function testCreateUser()
    {
        $userService = $this->repository->getUserService();

        $userCreateStruct = $userService->newUserCreateStruct('new_user', '[email protected]', 'password', 'eng-GB');
        $userCreateStruct->setField('first_name', 'New', 'eng-GB');
        $userCreateStruct->setField('last_name', 'User', 'eng-GB');

        $parentGroup = $userService->loadUserGroup(42);
        $createdUser = $userService->createUser($userCreateStruct, array($parentGroup));

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\User', $createdUser);
        self::assertEquals('New', $createdUser->getFieldValue('first_name'));
        self::assertEquals('User', $createdUser->getFieldValue('last_name'));
        self::assertEquals($userCreateStruct->login, $createdUser->login);
        self::assertEquals($userCreateStruct->email, $createdUser->email);
    }

    /**
     * Test creating a user throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     */
    public function testCreateUserThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();

        $userCreateStruct = $userService->newUserCreateStruct('new_user', '[email protected]', 'password', 'eng-GB');
        $userCreateStruct->setField('first_name', 'New');
        $userCreateStruct->setField('last_name', 'User');

        $parentGroup = new UserGroup(
            array(
                'content' => new Content(
                    array(
                        'versionInfo' => new VersionInfo(
                            array(
                                'contentInfo' => new ContentInfo(array('id' => APIBaseTest::DB_INT_MAX)),
                            )
                        ),
                        'internalFields' => array(),
                    )
                ),
            )
        );
        $userService->createUser($userCreateStruct, array($parentGroup));
    }

    /**
     * Test creating a user throwing ContentFieldValidationException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     */
    public function testCreateUserRequiredFieldsEmpty()
    {
        $userService = $this->repository->getUserService();

        $userCreateStruct = $userService->newUserCreateStruct('new_user', '[email protected]', 'password', 'eng-GB');
        $userCreateStruct->setField('first_name', '', 'eng-GB');
        $userCreateStruct->setField('last_name', '', 'eng-GB');

        $parentGroup = $userService->loadUserGroup(12);
        $userService->createUser($userCreateStruct, array($parentGroup));
    }

    /**
     * Test creating a user throwing InvalidArgumentException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     */
    public function testCreateUserThrowsInvalidArgumentException()
    {
        $userService = $this->repository->getUserService();

        $userCreateStruct = $userService->newUserCreateStruct('admin', '[email protected]', 'password', 'eng-GB');
        $userCreateStruct->setField('first_name', '', 'eng-GB');
        $userCreateStruct->setField('last_name', '', 'eng-GB');

        $parentGroup = $userService->loadUserGroup(12);
        $userService->createUser($userCreateStruct, array($parentGroup));
    }

    /**
     * Test loading a user.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUser
     */
    public function testLoadUser()
    {
        $userService = $this->repository->getUserService();

        $loadedUser = $userService->loadUser(14);

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\User', $loadedUser);
        self::assertEquals(14, $loadedUser->id);
    }

    /**
     * Test loading a user throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::loadUser
     */
    public function testLoadUserThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();

        $userService->loadUser(APIBaseTest::DB_INT_MAX);
    }

    /**
     * Test loading anonymous user.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadAnonymousUser
     */
    public function testLoadAnonymousUser()
    {
        $userService = $this->repository->getUserService();

        $loadedUser = $userService->loadAnonymousUser();


        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\User', $loadedUser);
        self::assertEquals(10, $loadedUser->id);
    }

    /**
     * Test loading a user by credentials.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserByCredentials
     */
    public function testLoadUserByCredentials()
    {
        $userService = $this->repository->getUserService();

        $loadedUser = $userService->loadUserByCredentials('admin', 'publish');
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\User', $loadedUser);

        $this->assertPropertiesCorrect(
            array(
                'id' => 14,
                'login' => 'admin',
                'email' => '[email protected]',
                'passwordHash' => 'c78e3b0f3d9244ed8c6d1c29464bdff9',
                'hashAlgorithm' => User::PASSWORD_HASH_MD5_USER,
                'enabled' => true,
                'maxLogin' => 10,
            ),
            $loadedUser
        );
    }

    /**
     * Test loading a user by credentials throwing NotFoundException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::loadUser
     */
    public function testLoadUserByCredentialsThrowsNotFoundException()
    {
        $userService = $this->repository->getUserService();

        $userService->loadUserByCredentials('non_existing_user', 'invalid_password');
    }

    /**
     * Test loading a user by credentials throwing NotFoundException because of bad password.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\NotFoundException
     * @covers \eZ\Publish\API\Repository\UserService::loadUser
     */
    public function testLoadUserByCredentialsThrowsNotFoundExceptionBadPassword()
    {
        $userService = $this->repository->getUserService();

        $userService->loadUserByCredentials('admin', 'some_password');
    }

    /**
     * Test updating a user.
     *
     * @covers \eZ\Publish\API\Repository\UserService::updateUser
     */
    public function testUpdateUser()
    {
        $userService = $this->repository->getUserService();

        $userUpdateStruct = $userService->newUserUpdateStruct();
        $userUpdateStruct->contentUpdateStruct = $this->repository->getContentService()->newContentUpdateStruct();
        $userUpdateStruct->contentUpdateStruct->setField('first_name', 'New first name', 'eng-US');
        $userUpdateStruct->contentUpdateStruct->setField('last_name', 'New last name', 'eng-US');

        $user = $userService->loadUser(14);

        $userService->updateUser($user, $userUpdateStruct);
        $updatedUser = $userService->loadUser($user->id);

        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\User', $updatedUser);
        self::assertEquals(
            'New first name',
            $updatedUser->getFieldValue('first_name')
        );

        self::assertEquals(
            'New last name',
            $updatedUser->getFieldValue('last_name')
        );
    }

    /**
     * Test updating a user throwing ContentValidationException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\ContentValidationException
     * @covers \eZ\Publish\API\Repository\UserService::updateUser
     */
    public function testUpdateUserThrowsContentValidationException()
    {
        $userService = $this->repository->getUserService();
        $contentService = $this->repository->getContentService();

        $user = $userService->loadUser(14);
        $userUpdateStruct = $userService->newUserUpdateStruct();
        $userUpdateStruct->contentUpdateStruct = $contentService->newContentUpdateStruct();
        $userUpdateStruct->contentUpdateStruct->setField('name', '', 'eng-US');

        $userService->updateUser($user, $userUpdateStruct);
    }

    /**
     * Test assigning a user group to user.
     *
     * @covers \eZ\Publish\API\Repository\UserService::assignUserToUserGroup
     */
    public function testAssignUserToUserGroup()
    {
        $userService = $this->repository->getUserService();
        $locationService = $this->repository->getLocationService();

        $user = $userService->loadUser(14);
        $userGroup = $userService->loadUserGroup(42);

        $userService->assignUserToUserGroup($user, $userGroup);

        $userLocations = $locationService->loadLocations($user->getVersionInfo()->getContentInfo());

        if (!is_array($userLocations) || empty($userLocations)) {
            self::fail('Failed assigning user to user group');
        }

        $hasAddedLocation = false;
        foreach ($userLocations as $location) {

            if ($location->parentLocationId == $userGroup->getVersionInfo()->getContentInfo()->mainLocationId) {
                $hasAddedLocation = true;
                break;
            }
        }

        if (!$hasAddedLocation) {
            self::fail('Failed assigning user to user group');
        }
    }

    /**
     * Test assigning a user group to user throwing InvalidArgumentException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\UserService::assignUserToUserGroup
     */
    public function testAssignUserToUserGroupThrowsInvalidArgumentException()
    {
        $userService = $this->repository->getUserService();

        $user = $userService->loadUser(14);
        $userGroup = $userService->loadUserGroup(12);
        $userService->assignUserToUserGroup($user, $userGroup);
    }

    /**
     * Test removing a user from user group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::unAssignUserFromUserGroup
     * @depends testAssignUserToUserGroup
     */
    public function testUnAssignUserFromUserGroup()
    {
        $userService = $this->repository->getUserService();
        $locationService = $this->repository->getLocationService();

        $user = $userService->loadUser(14);
        $userGroup = $userService->loadUserGroup(12);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        // first assign another user group as we can't remove all users groups
        $userGroup = $userService->loadUserGroup(42);
        $userService->assignUserToUserGroup($user, $userGroup);

        // un-assign original group
        $userService->unAssignUserFromUserGroup($user, $userGroup);

        try {
            $user = $userService->loadUser(14);
        } catch (NotFoundException $e) {
            // user was deleted because the group we assigned him from was his last location
            return;
        }

        $userLocations = $locationService->loadLocations($user->getVersionInfo()->getContentInfo());

        if (is_array($userLocations) && !empty($userLocations)) {
            $hasRemovedLocation = false;
            foreach ($userLocations as $location) {

                if ($location->parentLocationId == $userGroup->getVersionInfo()->getContentInfo()->mainLocationId) {
                    $hasRemovedLocation = true;
                    break;
                }
            }

            if ($hasRemovedLocation) {
                self::fail('Failed removing a user from user group');
            }
        }
    }

    /**
     * Test removing a user from user group throwing BadState for removing last group.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\BadStateException
     * @covers \eZ\Publish\API\Repository\UserService::unAssignUserFromUserGroup
     */
    public function testUnAssignUserFromUserGroupThrowsBadStateException()
    {
        $userService = $this->repository->getUserService();
        $user = $userService->loadUser(14);
        $userGroup = $userService->loadUserGroup(12);

        // un-assign original group, should throw BadState
        $userService->unAssignUserFromUserGroup($user, $userGroup);
    }

    /**
     * Test removing a user from user group throwing InvalidArgumentException.
     *
     * @expectedException \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     * @covers \eZ\Publish\API\Repository\UserService::unAssignUserFromUserGroup
     */
    public function testUnAssignUserFromUserGroupThrowsInvalidArgumentException()
    {
        $userService = $this->repository->getUserService();

        $user = $userService->loadUser(14);
        $userGroup = $userService->loadUserGroup(42);
        $userService->unAssignUserFromUserGroup($user, $userGroup);
    }

    /**
     * Test loading user groups the user belongs to.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroupsOfUser
     */
    public function testLoadUserGroupsOfUser()
    {
        $userService = $this->repository->getUserService();
        $locationService = $this->repository->getLocationService();

        $user = $userService->loadUser(14);
        $userLocations = $locationService->loadLocations(
            $user->getVersionInfo()->getContentInfo()
        );

        $groupLocationIds = array();
        foreach ($userLocations as $userLocation) {
            if ($userLocation->parentLocationId !== null) {
                $groupLocationIds[] = $userLocation->parentLocationId;
            }
        }

        $userGroups = $userService->loadUserGroupsOfUser($user);

        foreach ($userGroups as $userGroup) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserGroup', $userGroup);
            self::assertContains(
                $userGroup->getVersionInfo()->getContentInfo()->mainLocationId,
                $groupLocationIds
            );
        }
    }

    /**
     * Test loading user groups the user belongs to.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUsersOfUserGroup
     */
    public function testLoadUsersOfUserGroup()
    {
        $userService = $this->repository->getUserService();
        $locationService = $this->repository->getLocationService();

        $userGroup = $userService->loadUserGroup(12);
        $users = $userService->loadUsersOfUserGroup($userGroup);

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

        foreach ($users as $user) {
            self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\User', $user);

            $userLocation = $locationService->loadLocation($user->getVersionInfo()->getContentInfo()->mainLocationId);

            self::assertEquals(
                $userGroup->getVersionInfo()->getContentInfo()->mainLocationId,
                $userLocation->parentLocationId
            );
        }
    }

    /**
     * Test creating new UserCreateStruct.
     *
     * @covers \eZ\Publish\API\Repository\UserService::newUserCreateStruct
     */
    public function testNewUserCreateStruct()
    {
        $userService = $this->repository->getUserService();

        $userCreateStruct = $userService->newUserCreateStruct('admin', '[email protected]', 'password', 'eng-GB');
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserCreateStruct', $userCreateStruct);

        $this->assertPropertiesCorrect(
            array(
                'mainLanguageCode' => 'eng-GB',
                'login' => 'admin',
                'email' => '[email protected]',
                'password' => 'password',
                'enabled' => true,
                'fields' => array(),
            ),
            $userCreateStruct
        );
    }

    /**
     * Test creating new UserGroupCreateStruct.
     *
     * @covers \eZ\Publish\API\Repository\UserService::newUserGroupCreateStruct
     */
    public function testNewUserGroupCreateStruct()
    {
        $userService = $this->repository->getUserService();

        $userGroupCreateStruct = $userService->newUserGroupCreateStruct('eng-GB');
        self::assertInstanceOf('\\eZ\\Publish\\API\\Repository\\Values\\User\\UserGroupCreateStruct', $userGroupCreateStruct);
        self::assertEquals('eng-GB', $userGroupCreateStruct->mainLanguageCode);
    }

    /**
     * Test creating new UserUpdateStruct.
     *
     * @covers \eZ\Publish\API\Repository\UserService::newUserUpdateStruct
     */
    public function testNewUserUpdateStruct()
    {
        $userService = $this->repository->getUserService();

        $userUpdateStruct = $userService->newUserUpdateStruct();

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

        self::assertNull($userUpdateStruct->contentUpdateStruct);
        self::assertNull($userUpdateStruct->contentMetadataUpdateStruct);

        $this->assertPropertiesCorrect(
            array(
                'email' => null,
                'password' => null,
                'enabled' => null,
                'maxLogin' => null,
            ),
            $userUpdateStruct
        );
    }

    /**
     * Test creating new UserGroupUpdateStruct.
     *
     * @covers \eZ\Publish\API\Repository\UserService::newUserGroupUpdateStruct
     */
    public function testNewUserGroupUpdateStruct()
    {
        $userService = $this->repository->getUserService();

        $userGroupUpdateStruct = $userService->newUserGroupUpdateStruct();

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

        self::assertNull($userGroupUpdateStruct->contentUpdateStruct);
        self::assertNull($userGroupUpdateStruct->contentMetadataUpdateStruct);
    }
}

ezsystems / ezpublish-kernel
