eZ\Publish\API\Repository\Tests\UserServiceTest

Complexity

Total Complexity

142

Size/Duplication

Total Lines	3136
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	32

Importance

Changes

0

103 Methods

Rating	Name	Duplication	Size	Complexity
A	testLoadSubUserGroups()	0	19	2
A	createUserContentTypeWithPasswordExpirationDate()	0	9	1
B	createUserContentTypeWithAccountSettings()	0	97	1
A	testLoadUserGroup()	0	20	1
A	testLoadUserGroupWithNoAccessToParent()	0	29	1
A	testLoadUserGroupThrowsNotFoundException()	0	14	1
A	testLoadSubUserGroupsThrowsNotFoundException()	0	25	1
A	testNewUserGroupCreateStruct()	0	17	1
A	testNewUserGroupCreateStructSetsMainLanguageCode()	0	4	1
A	testNewUserGroupCreateStructSetsContentType()	0	7	1
A	testNewUserGroupCreateStructWithSecondParameter()	0	24	2
A	testCreateUserGroup()	0	18	1
A	testCreateUserGroupSetsExpectedProperties()	0	11	1
A	testCreateUserGroupThrowsInvalidArgumentException()	0	28	1
A	testCreateUserGroupThrowsInvalidArgumentExceptionFieldTypeNotAccept()	0	27	1
A	testCreateUserGroupWhenMissingField()	0	23	1
A	testCreateUserGroupInTransactionWithRollback()	0	43	3
A	testDeleteUserGroup()	0	17	1
A	testDeleteUserGroupThrowsNotFoundException()	0	21	1
A	testMoveUserGroup()	0	39	1
A	testMoveUserGroupThrowsNotFoundException()	0	33	1
A	testNewUserGroupUpdateStruct()	0	18	1
A	testUpdateUserGroup()	0	25	1
A	testUpdateUserGroupWithSubContentUpdateStruct()	0	33	1
A	testUpdateUserGroupWithSubContentMetadataUpdateStruct()	0	36	1
A	testUpdateUserGroupThrowsInvalidArgumentExceptionOnFieldTypeNotAccept()	0	27	1
A	testNewUserCreateStruct()	0	22	1
A	testUpdateUserGroupThrowsContentFieldValidationExceptionOnRequiredFieldEmpty()	0	15	1
A	testNewUserCreateStructSetsExpectedProperties()	0	17	1
A	testNewUserCreateStructWithFifthParameter()	0	25	2
A	testNewUserWithDomainName()	0	12	1
A	testCreateUser()	0	13	1
A	testCreateUserSetsExpectedProperties()	0	15	1
A	testCreateUserWhenMissingField()	0	33	1
A	testCreateUserThrowsInvalidArgumentExceptionOnFieldTypeNotAccept()	0	33	1
A	testCreateUserThrowsInvalidArgumentException()	0	41	2
A	testCreateUserInTransactionWithRollback()	0	28	3
A	testCreateUserThrowsNotFoundException()	0	27	1
A	testCreateUserWithWeakPasswordThrowsUserPasswordValidationException()	0	25	2
A	testCreateUserWithStrongPassword()	0	10	1
A	testLoadUser()	0	19	1
A	testLoadUserThrowsNotFoundException()	0	15	1
A	testLoadUserByCredentials()	0	15	1
A	testLoadUserByCredentialsThrowsNotFoundExceptionForUnknownPassword()	0	16	1
A	testLoadUserByCredentialsThrowsNotFoundExceptionForUnknownPasswordEmtpy()	0	16	1
A	testLoadUserByCredentialsThrowsNotFoundExceptionForUnknownLogin()	0	16	1
A	testLoadUserByCredentialsThrowsInvalidArgumentValueForEmptyLogin()	0	16	1
A	testLoadUserByLogin()	0	29	1
A	testLoadUserByLoginThrowsNotFoundExceptionForUnknownLogin()	0	16	1
A	testLoadUserByLoginWorksForLoginWithWrongCase()	0	29	1
A	testLoadUserByLoginThrowsNotFoundExceptionForUnknownLoginByEmail()	0	15	1
A	testLoadUserByEmail()	0	15	1
A	testLoadUserByEmailReturnsEmptyInUnknownEmail()	0	16	1
A	testDeleteUser()	0	18	1
A	testDeleteUserDeletesRelatedBookmarks()	0	27	1
A	testNewUserUpdateStruct()	0	29	1
A	testUpdateUser()	0	25	1
A	testUpdateUserEmail()	0	23	1
A	testUpdateUserNoPassword()	0	40	1
A	testUpdateUserUpdatesExpectedProperties()	0	17	1
A	testUpdateUserReturnsPublishedVersion()	0	7	1
A	testUpdateUserWithContentMetadataUpdateStruct()	0	31	1
A	testUpdateUserWithContentUpdateStruct()	0	35	1
A	testUpdateUserWhenMissingField()	0	30	1
A	testUpdateUserThrowsInvalidArgumentExceptionOnFieldTypeNotAccept()	0	30	1
A	testUpdateUserWithWeakPasswordThrowsUserPasswordValidationException()	0	29	2
A	testUpdateUserWithStrongPassword()	0	16	1
A	testLoadUserGroupsOfUser()	0	19	2
A	testLoadUsersOfUserGroup()	0	21	2
A	testAssignUserToUserGroup()	0	35	2
A	testAssignUserToUserGroupThrowsInvalidArgumentException()	0	22	1
A	testUnAssignUserFromUserGroup()	0	35	2
A	testUnAssignUserFromUserGroupThrowsInvalidArgumentException()	0	21	1
A	testUnAssignUserFromUserGroupThrowsBadStateArgumentException()	0	20	1
A	testLoadUserGroupWithPrioritizedLanguagesList()	0	23	2
A	testLoadUserGroupWithPrioritizedLanguagesListAfterMainLanguageUpdate()	0	30	2
A	testLoadSubUserGroupsWithPrioritizedLanguagesList()	0	31	3
A	testLoadUserWithPrioritizedLanguagesList()	0	26	3
A	testLoadUserWithPrioritizedLanguagesListAfterMainLanguageUpdate()	0	34	3
A	testLoadUserByLoginWithPrioritizedLanguagesList()	0	26	3
A	testLoadUserByCredentialsWithPrioritizedLanguagesList()	0	30	3
A	testLoadUsersByEmailWithPrioritizedLanguagesList()	0	28	4
A	testLoadUserGroupsOfUserWithPrioritizedLanguagesList()	0	21	2
A	testLoadUsersOfUserGroupWithPrioritizedLanguagesList()	0	32	4
A	getPrioritizedLanguageList()	0	13	1
A	createMultiLanguageUserGroup()	0	18	1
A	createUserGroupVersion1()	0	26	1
A	createMultiLanguageUser()	0	29	2
A	testCreateUserInvalidPasswordHashTypeThrowsException()	0	43	4
A	testLoadUserByToken()	0	18	1
A	testLoadUserByTokenThrowsNotFoundException()	0	17	1
A	testUpdateUserToken()	0	16	1
A	testExpireUserToken()	0	15	1
A	testValidatePasswordWithDefaultContext()	0	10	1
A	testValidatePassword()	0	15	1
A	testValidatePasswordReturnsErrorWhenOldPasswordIsReused()	0	22	1
A	dataProviderForValidatePassword()	0	20	1
A	testGetPasswordInfo()	0	32	2
A	testGetPasswordInfoIfExpirationIsDisabled()	0	13	1
A	testGetPasswordInfoIfExpirationWarningIsDisabled()	0	22	2
A	createTestUser()	0	4	1
A	createTestUserWithPassword()	0	22	1
A	createUserContentTypeWithStrongPassword()	0	13	1

<?php

/**
 * @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\API\Repository\Tests;

use DateInterval;
use DateTime;
use DateTimeImmutable;
use eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException;
use eZ\Publish\API\Repository\Exceptions\InvalidArgumentException;
use eZ\Publish\API\Repository\Exceptions\NotFoundException;
use eZ\Publish\API\Repository\Values\Content\ContentInfo;
use eZ\Publish\API\Repository\Values\Content\Language;
use eZ\Publish\API\Repository\Values\Content\VersionInfo as APIVersionInfo;
use eZ\Publish\API\Repository\Values\ContentType\ContentType;
use eZ\Publish\API\Repository\Values\User\Limitation\SubtreeLimitation;
use eZ\Publish\API\Repository\Values\User\PasswordInfo;
use eZ\Publish\API\Repository\Values\User\PasswordValidationContext;
use eZ\Publish\API\Repository\Values\User\UserGroupUpdateStruct;
use eZ\Publish\API\Repository\Values\User\UserTokenUpdateStruct;
use eZ\Publish\API\Repository\Values\User\UserUpdateStruct;
use eZ\Publish\API\Repository\Values\User\User;
use eZ\Publish\Core\FieldType\ValidationError;
use eZ\Publish\Core\Repository\Values\Content\Content;
use eZ\Publish\Core\Repository\Values\Content\VersionInfo;
use eZ\Publish\Core\Repository\Values\User\UserGroup;
use Exception;

/**
 * Test case for operations in the UserService using in memory storage.
 *
 * @see eZ\Publish\API\Repository\UserService
 * @group integration
 * @group user
 */
class UserServiceTest extends BaseTest
{
    // Example password matching default rules
    private const EXAMPLE_PASSWORD = 'P@ssword123!';

    private const EXAMPLE_PASSWORD_TTL = 30;
    private const EXAMPLE_PASSWORD_TTL_WARNING = 14;

    /**
     * Test for the loadUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserGroup()
     */
    public function testLoadUserGroup()
    {
        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        $userGroup = $userService->loadUserGroup($mainGroupId);
        /* END: Use Case */

        $this->assertInstanceOf(UserGroup::class, $userGroup);

        // User group happens to also be a Content; isUserGroup() should be true and isUser() should be false
        $this->assertTrue($userService->isUserGroup($userGroup), 'isUserGroup() => false on a user group');
        $this->assertFalse($userService->isUser($userGroup), 'isUser() => true on a user group');
        $this->assertSame(0, $userGroup->parentId, 'parentId should be equal `0` because it is top level node');
    }

    /**
     * Test for the loadUserGroup() method to ensure that DomainUserGroupObject is created properly even if a user
     * has no access to parent of UserGroup.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserGroup()
     */
    public function testLoadUserGroupWithNoAccessToParent()
    {
        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        $user = $this->createUserWithPolicies(
            'user',
            [
                ['module' => 'content', 'function' => 'read'],
            ],
            new SubtreeLimitation(['limitationValues' => ['/1/5']])
        );
        $repository->getPermissionResolver()->setCurrentUserReference($user);

        $userGroup = $userService->loadUserGroup($mainGroupId);
        /* END: Use Case */

        $this->assertInstanceOf(UserGroup::class, $userGroup);

        // User group happens to also be a Content; isUserGroup() should be true and isUser() should be false
        $this->assertTrue($userService->isUserGroup($userGroup), 'isUserGroup() => false on a user group');
        $this->assertFalse($userService->isUser($userGroup), 'isUser() => true on a user group');
        $this->assertSame(0, $userGroup->parentId, 'parentId should be equal `0` because it is top level node');
    }

    /**
     * Test for the loadUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroup
     */
    public function testLoadUserGroupThrowsNotFoundException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $nonExistingGroupId = $this->generateId('group', self::DB_INT_MAX);
        /* BEGIN: Use Case */
        $userService = $repository->getUserService();

        // This call will fail with a NotFoundException
        $userService->loadUserGroup($nonExistingGroupId);
        /* END: Use Case */
    }

    /**
     * Test for the loadSubUserGroups() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadSubUserGroups()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroup
     */
    public function testLoadSubUserGroups()
    {
        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

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

        $subUserGroups = $userService->loadSubUserGroups($userGroup);
        foreach ($subUserGroups as $subUserGroup) {
            // Do something with the $subUserGroup
            $this->assertInstanceOf(UserGroup::class, $subUserGroup);
        }
        /* END: Use Case */
    }

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

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $parentGroup = new UserGroup(
            [
                'content' => new Content(
                    [
                        'versionInfo' => new VersionInfo(
                            [
                                'contentInfo' => new ContentInfo(
                                    ['id' => 123456]
                                ),
                            ]
                        ),
                        'internalFields' => [],
                    ]
                ),
            ]
        );
        $userService->loadSubUserGroups($parentGroup);
    }

    /**
     * Test for the newUserGroupCreateStruct() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserGroupCreateStruct
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserGroupCreateStruct()
     * @depends eZ\Publish\API\Repository\Tests\ContentTypeServiceTest::testLoadContentTypeByIdentifier
     */
    public function testNewUserGroupCreateStruct()
    {
        $repository = $this->getRepository();

        /* BEGIN: Use Case */
        $userService = $repository->getUserService();

        $groupCreate = $userService->newUserGroupCreateStruct('eng-US');
        /* END: Use Case */

        $this->assertInstanceOf(
            '\\eZ\\Publish\\API\\Repository\\Values\\User\\UserGroupCreateStruct',
            $groupCreate
        );

        return $groupCreate;
    }

    /**
     * Test for the newUserGroupCreateStruct() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\UserGroupCreateStruct $groupCreate
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserGroupCreateStruct()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserGroupCreateStruct
     */
    public function testNewUserGroupCreateStructSetsMainLanguageCode($groupCreate)
    {
        $this->assertEquals('eng-US', $groupCreate->mainLanguageCode);
    }

    /**
     * Test for the newUserGroupCreateStruct() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\UserGroupCreateStruct $groupCreate
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserGroupCreateStruct()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserGroupCreateStruct
     */
    public function testNewUserGroupCreateStructSetsContentType($groupCreate)
    {
        $this->assertInstanceOf(
            '\\eZ\\Publish\\API\\Repository\\Values\\ContentType\\ContentType',
            $groupCreate->contentType
        );
    }

    /**
     * Test for the newUserGroupCreateStruct() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserGroupCreateStruct($mainLanguageCode, $contentType)
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserGroupCreateStruct
     * @depends eZ\Publish\API\Repository\Tests\ContentTypeServiceTest::testLoadContentTypeByIdentifier
     */
    public function testNewUserGroupCreateStructWithSecondParameter()
    {
        if ($this->isVersion4()) {
            $this->markTestSkipped('This test is only relevant for eZ Publish versions > 4');
        }

        $repository = $this->getRepository();

        /* BEGIN: Use Case */
        $contentTypeService = $repository->getContentTypeService();
        $userService = $repository->getUserService();

        // Load the default ContentType for user groups
        $groupType = $contentTypeService->loadContentTypeByIdentifier('user_group');

        // Instantiate a new group create struct
        $groupCreate = $userService->newUserGroupCreateStruct(
            'eng-US',
            $groupType
        );
        /* END: Use Case */

        $this->assertSame($groupType, $groupCreate->contentType);
    }

    /**
     * Test for the createUserGroup() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserGroup
     *
     * @see \eZ\Publish\API\Repository\UserService::createUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserGroupCreateStruct
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroup
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testCreateContent
     */
    public function testCreateUserGroup()
    {
        /* BEGIN: Use Case */
        $userGroup = $this->createUserGroupVersion1();
        /* END: Use Case */

        $this->assertInstanceOf(
            UserGroup::class,
            $userGroup
        );

        $versionInfo = $userGroup->getVersionInfo();

        $this->assertEquals(APIVersionInfo::STATUS_PUBLISHED, $versionInfo->status);
        $this->assertEquals(1, $versionInfo->versionNo);

        return $userGroup;
    }

    /**
     * Test for the createUserGroup() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup
     *
     * @see \eZ\Publish\API\Repository\UserService::createUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     */
    public function testCreateUserGroupSetsExpectedProperties($userGroup)
    {
        $this->assertEquals(
            [
                'parentId' => $this->generateId('group', 4),
            ],
            [
                'parentId' => $userGroup->parentId,
            ]
        );
    }

    /**
     * Test for the createUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::createUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     */
    public function testCreateUserGroupThrowsInvalidArgumentException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);

        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        // Load main group
        $parentUserGroup = $userService->loadUserGroup($mainGroupId);

        // Instantiate a new create struct
        $userGroupCreate = $userService->newUserGroupCreateStruct('eng-US');
        $userGroupCreate->setField('name', 'Example Group');
        $userGroupCreate->remoteId = '5f7f0bdb3381d6a461d8c29ff53d908f';

        // This call will fail with an "InvalidArgumentException", because the
        // specified remoteId is already used for the "Members" user group.
        $userService->createUserGroup(
            $userGroupCreate,
            $parentUserGroup
        );
        /* END: Use Case */
    }

    /**
     * Test for the createUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::createUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     */
    public function testCreateUserGroupThrowsInvalidArgumentExceptionFieldTypeNotAccept()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);

        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        // Load main group
        $parentUserGroup = $userService->loadUserGroup($mainGroupId);

        // Instantiate a new create struct
        $userGroupCreate = $userService->newUserGroupCreateStruct('eng-US');
        $userGroupCreate->setField('name', new \stdClass());

        // This call will fail with an "InvalidArgumentException", because the
        // specified remoteId is already used for the "Members" user group.
        $userService->createUserGroup(
            $userGroupCreate,
            $parentUserGroup
        );
        /* END: Use Case */
    }

    /**
     * Test for the createUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::createUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     */
    public function testCreateUserGroupWhenMissingField()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException::class);

        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        // Load main group
        $parentUserGroup = $userService->loadUserGroup($mainGroupId);

        // Instantiate a new create struct
        $userGroupCreate = $userService->newUserGroupCreateStruct('eng-US');

        // This call will fail with a "ContentFieldValidationException", because the
        // only mandatory field "name" is not set.
        $userService->createUserGroup($userGroupCreate, $parentUserGroup);
        /* END: Use Case */
    }

    /**
     * Test for the createUserGroup() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserGroup
     *
     * @see \eZ\Publish\API\Repository\UserService::createUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserGroupCreateStruct
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroup
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testCreateContent
     */
    public function testCreateUserGroupInTransactionWithRollback()
    {
        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Use Case */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        $repository->beginTransaction();

        try {
            // Load main group
            $parentUserGroup = $userService->loadUserGroup($mainGroupId);

            // Instantiate a new create struct
            $userGroupCreate = $userService->newUserGroupCreateStruct('eng-US');
            $userGroupCreate->setField('name', 'Example Group');

            // Create the new user group
            $createdUserGroupId = $userService->createUserGroup(
                $userGroupCreate,
                $parentUserGroup
            )->id;
        } catch (Exception $e) {
            // Cleanup hanging transaction on error
            $repository->rollback();
            throw $e;
        }

        $repository->rollback();

        try {
            // Throws exception since creation of user group was rolled back
            $loadedGroup = $userService->loadUserGroup($createdUserGroupId);

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

        } catch (NotFoundException $e) {
            return;
        }
        /* END: Use Case */

        $this->fail('User group object still exists after rollback.');
    }

    /**
     * Test for the deleteUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::deleteUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     */
    public function testDeleteUserGroup()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $userGroup = $this->createUserGroupVersion1();

        // Delete the currently created user group again
        $userService->deleteUserGroup($userGroup);
        /* END: Use Case */

        // We use the NotFoundException here for verification
        $userService->loadUserGroup($userGroup->id);
    }

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

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $userGroup = new UserGroup(
            [
                'content' => new Content(
                    [
                        'versionInfo' => new VersionInfo(
                            ['contentInfo' => new ContentInfo(['id' => 123456])]
                        ),
                        'internalFields' => [],
                    ]
                ),
            ]
        );
        $userService->deleteUserGroup($userGroup);
    }

    /**
     * Test for the moveUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::moveUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadSubUserGroups
     */
    public function testMoveUserGroup()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $membersGroupId = $this->generateId('group', 13);
        /* BEGIN: Use Case */
        // $membersGroupId is the ID of the "Members" user group in an eZ
        // Publish demo installation

        $userGroup = $this->createUserGroupVersion1();

        // Load the new parent group
        $membersUserGroup = $userService->loadUserGroup($membersGroupId);

        // Move user group from "Users" to "Members"
        $userService->moveUserGroup($userGroup, $membersUserGroup);

        // Reload the user group to get an updated $parentId
        $userGroup = $userService->loadUserGroup($userGroup->id);

        $this->refreshSearch($repository);

        // The returned array will no contain $userGroup
        $subUserGroups = $userService->loadSubUserGroups(
            $membersUserGroup
        );
        /* END: Use Case */

        $subUserGroupIds = array_map(
            function ($content) {
                return $content->id;
            },
            $subUserGroups
        );

        $this->assertEquals($membersGroupId, $userGroup->parentId);
        $this->assertEquals([$userGroup->id], $subUserGroupIds);
    }

    /**
     * Test moving a user group below another group throws NotFoundException.
     *
     * @covers \eZ\Publish\API\Repository\UserService::moveUserGroup
     */
    public function testMoveUserGroupThrowsNotFoundException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $userGroupToMove = new UserGroup(
            [
                'content' => new Content(
                    [
                        'versionInfo' => new VersionInfo(
                            ['contentInfo' => new ContentInfo(['id' => 123456])]
                        ),
                        'internalFields' => [],
                    ]
                ),
            ]
        );
        $parentUserGroup = new UserGroup(
            [
                'content' => new Content(
                    [
                        'versionInfo' => new VersionInfo(
                            ['contentInfo' => new ContentInfo(['id' => 123455])]
                        ),
                        'internalFields' => [],
                    ]
                ),
            ]
        );
        $userService->moveUserGroup($userGroupToMove, $parentUserGroup);
    }

    /**
     * Test for the newUserGroupUpdateStruct() method.
     *
     * @covers \eZ\Publish\API\Repository\UserService::newUserGroupUpdateStruct
     */
    public function testNewUserGroupUpdateStruct()
    {
        $repository = $this->getRepository();

        /* BEGIN: Use Case */
        $userService = $repository->getUserService();

        $groupUpdate = $userService->newUserGroupUpdateStruct();
        /* END: Use Case */

        $this->assertInstanceOf(
            UserGroupUpdateStruct::class,
            $groupUpdate
        );

        $this->assertNull($groupUpdate->contentUpdateStruct);
        $this->assertNull($groupUpdate->contentMetadataUpdateStruct);
    }

    /**
     * Test for the updateUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserGroupUpdateStruct
     */
    public function testUpdateUserGroup()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $userGroup = $this->createUserGroupVersion1();

        // Create a group update struct and change nothing
        $groupUpdate = $userService->newUserGroupUpdateStruct();

        // This update will do nothing
        $userGroup = $userService->updateUserGroup(
            $userGroup,
            $groupUpdate
        );
        /* END: Use Case */

        $this->assertInstanceOf(
            UserGroup::class,
            $userGroup
        );

        $this->assertEquals(1, $userGroup->getVersionInfo()->versionNo);
    }

    /**
     * Test for the updateUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUserGroup
     */
    public function testUpdateUserGroupWithSubContentUpdateStruct()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $userGroup = $this->createUserGroupVersion1();

        // Load the content service
        $contentService = $repository->getContentService();

        // Create a content update struct and update the group name
        $contentUpdate = $contentService->newContentUpdateStruct();
        $contentUpdate->setField('name', 'Sindelfingen', 'eng-US');

        // Create a group update struct and set content update struct
        $groupUpdate = $userService->newUserGroupUpdateStruct();
        $groupUpdate->contentUpdateStruct = $contentUpdate;

        // This will update the name and the increment the group version number
        $userGroup = $userService->updateUserGroup(
            $userGroup,
            $groupUpdate
        );
        /* END: Use Case */

        $this->assertEquals('Sindelfingen', $userGroup->getFieldValue('name', 'eng-US'));

        $versionInfo = $userGroup->getVersionInfo();

        $this->assertEquals(APIVersionInfo::STATUS_PUBLISHED, $versionInfo->status);
        $this->assertEquals(2, $versionInfo->versionNo);
    }

    /**
     * Test for the updateUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUserGroup
     */
    public function testUpdateUserGroupWithSubContentMetadataUpdateStruct()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $userGroup = $this->createUserGroupVersion1();

        // Load the content service
        $contentService = $repository->getContentService();

        // Create a metadata update struct and change the remoteId
        $metadataUpdate = $contentService->newContentMetadataUpdateStruct();
        $metadataUpdate->remoteId = '3c61299780663bafa3af2101e52125da';

        // Create a group update struct and set content update struct
        $groupUpdate = $userService->newUserGroupUpdateStruct();
        $groupUpdate->contentMetadataUpdateStruct = $metadataUpdate;

        // This will update the name and the increment the group version number
        $userGroup = $userService->updateUserGroup(
            $userGroup,
            $groupUpdate
        );
        /* END: Use Case */

        $this->assertEquals(
            '3c61299780663bafa3af2101e52125da',
            $userGroup->contentInfo->remoteId
        );

        $versionInfo = $userGroup->getVersionInfo();

        $this->assertEquals(APIVersionInfo::STATUS_PUBLISHED, $versionInfo->status);
        $this->assertEquals(1, $versionInfo->versionNo);
    }

    /**
     * Test for the updateUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUserGroup
     */
    public function testUpdateUserGroupThrowsInvalidArgumentExceptionOnFieldTypeNotAccept()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $userGroup = $this->createUserGroupVersion1();

        // Load the content service
        $contentService = $repository->getContentService();

        // Create a content update struct and update the group name
        $contentUpdate = $contentService->newContentUpdateStruct();
        // An object of stdClass is not accepted as a value by the field "name"
        $contentUpdate->setField('name', new \stdClass(), 'eng-US');

        // Create a group update struct and set content update struct
        $groupUpdate = $userService->newUserGroupUpdateStruct();
        $groupUpdate->contentUpdateStruct = $contentUpdate;

        // This call will fail with an InvalidArgumentException, because the
        // field "name" does not accept the given value
        $userService->updateUserGroup($userGroup, $groupUpdate);
        /* END: Use Case */
    }

    /**
     * Test for the newUserCreateStruct() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserCreateStruct()
     */
    public function testNewUserCreateStruct()
    {
        $repository = $this->getRepository();

        /* BEGIN: Use Case */
        $userService = $repository->getUserService();

        $userCreate = $userService->newUserCreateStruct(
            'user',
            'user@example.com',
            'secret',
            'eng-US'
        );
        /* END: Use Case */

        $this->assertInstanceOf(
            '\\eZ\\Publish\\API\\Repository\\Values\\User\\UserCreateStruct',
            $userCreate
        );

        return $userCreate;
    }

    /**
     * Test updating a user group throws ContentFieldValidationException.
     *
     * @covers \eZ\Publish\API\Repository\UserService::updateUserGroup
     */
    public function testUpdateUserGroupThrowsContentFieldValidationExceptionOnRequiredFieldEmpty()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException::class);

        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $contentService = $repository->getContentService();

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

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

    /**
     * Test for the newUserCreateStruct() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\UserCreateStruct $userCreate
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserCreateStruct()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserCreateStruct
     */
    public function testNewUserCreateStructSetsExpectedProperties($userCreate)
    {
        $this->assertEquals(
            [
                'login' => 'user',
                'email' => 'user@example.com',
                'password' => 'secret',
                'mainLanguageCode' => 'eng-US',
            ],
            [
                'login' => $userCreate->login,
                'email' => $userCreate->email,
                'password' => $userCreate->password,
                'mainLanguageCode' => $userCreate->mainLanguageCode,
            ]
        );
    }

    /**
     * Test for the newUserCreateStruct() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserCreateStruct($login, $email, $password, $mainLanguageCode, $contentType)
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserCreateStruct
     * @depends eZ\Publish\API\Repository\Tests\ContentTypeServiceTest::testLoadContentTypeByIdentifier
     */
    public function testNewUserCreateStructWithFifthParameter()
    {
        if ($this->isVersion4()) {
            $this->markTestSkipped('This test is only relevant for eZ Publish versions > 4');
        }

        $repository = $this->getRepository();

        /* BEGIN: Use Case */
        $contentTypeService = $repository->getContentTypeService();
        $userService = $repository->getUserService();

        $userType = $contentTypeService->loadContentTypeByIdentifier('user');

        $userCreate = $userService->newUserCreateStruct(
            'user',
            'user@example.com',
            'secret',
            'eng-US',
            $userType
        );
        /* END: Use Case */

        $this->assertSame($userType, $userCreate->contentType);
    }

    /**
     * Test for creating user with Active Directory login name.
     */
    public function testNewUserWithDomainName()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $createdUser = $this->createUserVersion1(
            'ez-user-Domain\username-by-login',
            'username-by-login@ez-user-Domain.com'
        );
        $loadedUser = $userService->loadUserByLogin('ez-user-Domain\username-by-login', Language::ALL);

        $this->assertEquals($createdUser, $loadedUser);
    }

    /**
     * Test for the createUser() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     *
     * @see \eZ\Publish\API\Repository\UserService::createUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserCreateStruct
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testCreateContent
     */
    public function testCreateUser()
    {
        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();
        /* END: Use Case */

        $this->assertInstanceOf(
            '\\eZ\\Publish\\API\\Repository\\Values\\User\\User',
            $user
        );

        return $user;
    }

    /**
     * Test for the createUser() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\User $user
     *
     * @see \eZ\Publish\API\Repository\UserService::createUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testCreateUserSetsExpectedProperties(User $user)
    {
        $this->assertEquals(
            [
                'login' => 'user',
                'email' => 'user@example.com',
                'mainLanguageCode' => 'eng-US',
            ],
            [
                'login' => $user->login,
                'email' => $user->email,
                'mainLanguageCode' => $user->contentInfo->mainLanguageCode,
            ]
        );
    }

    /**
     * Test for the createUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::createUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testCreateUserWhenMissingField()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException::class);

        $repository = $this->getRepository();

        $editorsGroupId = $this->generateId('group', 13);
        /* BEGIN: Use Case */
        // $editorsGroupId is the ID of the "Editors" user group in an eZ
        // Publish demo installation

        $userService = $repository->getUserService();

        // Instantiate a create struct with mandatory properties
        $userCreate = $userService->newUserCreateStruct(
            'user',
            'user@example.com',
            'secret',
            'eng-US'
        );

        // Do not set the mandatory fields "first_name" and "last_name"
        //$userCreate->setField( 'first_name', 'Example' );
        //$userCreate->setField( 'last_name', 'User' );

        // Load parent group for the user
        $group = $userService->loadUserGroup($editorsGroupId);

        // This call will fail with a "ContentFieldValidationException", because the
        // mandatory fields "first_name" and "last_name" are not set.
        $userService->createUser($userCreate, [$group]);
        /* END: Use Case */
    }

    /**
     * Test for the createUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::createUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testCreateUserThrowsInvalidArgumentExceptionOnFieldTypeNotAccept()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);

        $repository = $this->getRepository();

        $editorsGroupId = $this->generateId('group', 13);
        /* BEGIN: Use Case */
        // $editorsGroupId is the ID of the "Editors" user group in an eZ
        // Publish demo installation

        $userService = $repository->getUserService();

        // Instantiate a create struct with mandatory properties
        $userCreate = $userService->newUserCreateStruct(
            'user',
            'user@example.com',
            'secret',
            'eng-US'
        );

        // An object of stdClass is not a valid value for the field first_name
        $userCreate->setField('first_name', new \stdClass());
        $userCreate->setField('last_name', 'User');

        // Load parent group for the user
        $group = $userService->loadUserGroup($editorsGroupId);

        // This call will fail with an "InvalidArgumentException", because the
        // value for the firled "first_name" is not accepted by the field type.
        $userService->createUser($userCreate, [$group]);
        /* END: Use Case */
    }

    /**
     * Test for the createUser() method.
     *
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testCreateUserThrowsInvalidArgumentException()
    {
        $repository = $this->getRepository();

        $editorsGroupId = $this->generateId('group', 13);
        /* BEGIN: Use Case */
        // $editorsGroupId is the ID of the "Editors" user group in an eZ
        // Publish demo installation

        $userService = $repository->getUserService();

        // Instantiate a create struct with mandatory properties
        $userCreate = $userService->newUserCreateStruct(
            // admin is an existing login
            'admin',
            'user@example.com',
            'secret',
            'eng-US'
        );

        $userCreate->setField('first_name', 'Example');
        $userCreate->setField('last_name', 'User');

        // Load parent group for the user
        $group = $userService->loadUserGroup($editorsGroupId);

        try {
            // This call will fail with a "InvalidArgumentException", because the
            // user with "admin" login already exists.
            $userService->createUser($userCreate, [$group]);
            /* END: Use Case */
        } catch (ContentFieldValidationException $e) {
            // Exception is caught, as there is no other way to check exception properties.
            $this->assertValidationErrorOccurs($e, 'The user login \'%login%\' is used by another user. You must enter a unique login.');

            /* END: Use Case */
            return;
        }

        $this->fail('Expected ValidationError messages did not occur.');
    }

    /**
     * Test for the createUser() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     *
     * @see \eZ\Publish\API\Repository\UserService::createUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserCreateStruct
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testCreateContent
     */
    public function testCreateUserInTransactionWithRollback()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $repository->beginTransaction();

        try {
            $user = $this->createUserVersion1();
        } catch (Exception $e) {
            // Cleanup hanging transaction on error
            $repository->rollback();
            throw $e;
        }

        $repository->rollback();

        try {
            // Throws exception since creation of user was rolled back
            $loadedUser = $userService->loadUser($user->id);

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

        } catch (NotFoundException $e) {
            return;
        }
        /* END: Use Case */

        $this->fail('User object still exists after rollback.');
    }

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

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $userCreateStruct = $userService->newUserCreateStruct('new_user', 'new_user@ez.no', 'password', 'eng-GB');
        $userCreateStruct->setField('first_name', 'New');
        $userCreateStruct->setField('last_name', 'User');

        $parentGroup = new UserGroup(
            [
                'content' => new Content(
                    [
                        'versionInfo' => new VersionInfo(
                            [
                                'contentInfo' => new ContentInfo(['id' => 123456]),
                            ]
                        ),
                        'internalFields' => [],
                    ]
                ),
            ]
        );
        $userService->createUser($userCreateStruct, [$parentGroup]);
    }

    /**
     * Test creating a user throwing UserPasswordValidationException when password doesn't follow specific rules.
     *
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     */
    public function testCreateUserWithWeakPasswordThrowsUserPasswordValidationException()
    {
        $userContentType = $this->createUserContentTypeWithStrongPassword();

        try {
            // This call will fail with a "UserPasswordValidationException" because the
            // the password does not follow specified rules.
            $this->createTestUserWithPassword('pass', $userContentType);
        } catch (ContentFieldValidationException $e) {
            // Exception is caught, as there is no other way to check exception properties.
            $this->assertAllValidationErrorsOccur(
                $e,
                [
                    'User password must include at least one special character',
                    'User password must be at least %length% characters long',
                    'User password must include at least one upper case letter',
                    'User password must include at least one number',
                ]
            );

            return;
        }

        $this->fail('Expected ValidationError messages did not occur.');
    }

    /**
     * Opposite test case for testCreateUserWithWeakPasswordThrowsUserPasswordValidationException.
     *
     * @covers \eZ\Publish\API\Repository\UserService::createUser
     */
    public function testCreateUserWithStrongPassword()
    {
        $userContentType = $this->createUserContentTypeWithStrongPassword();

        /* BEGIN: Use Case */
        $user = $this->createTestUserWithPassword('H@xxi0r!', $userContentType);
        /* END: Use Case */

        $this->assertInstanceOf(User::class, $user);
    }

    /**
     * Test for the loadUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testLoadUser()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Load the newly created user
        $userReloaded = $userService->loadUser($user->id, Language::ALL);
        /* END: Use Case */

        $this->assertEquals($user, $userReloaded);

        // User happens to also be a Content; isUser() should be true and isUserGroup() should be false
        $this->assertTrue($userService->isUser($user), 'isUser() => false on a user');
        $this->assertFalse($userService->isUserGroup($user), 'isUserGroup() => true on a user group');
    }

    /**
     * Test for the loadUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUser
     */
    public function testLoadUserThrowsNotFoundException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $nonExistingUserId = $this->generateId('user', self::DB_INT_MAX);
        /* BEGIN: Use Case */
        $userService = $repository->getUserService();

        // This call will fail with a "NotFoundException", because no user with
        // an id equal to self::DB_INT_MAX should exist.
        $userService->loadUser($nonExistingUserId);
        /* END: Use Case */
    }

    /**
     * Test for the loadUserByCredentials() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByCredentials()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testLoadUserByCredentials()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Load the newly created user
        $userReloaded = $userService->loadUserByCredentials('user', 'secret', Language::ALL);
        /* END: Use Case */

        $this->assertEquals($user, $userReloaded);
    }

    /**
     * Test for the loadUserByCredentials() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByCredentials()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByCredentials
     */
    public function testLoadUserByCredentialsThrowsNotFoundExceptionForUnknownPassword()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        // This call will fail with a "NotFoundException", because the given
        // login/password combination does not exist.
        $userService->loadUserByCredentials('user', 'SeCrEt');
        /* END: Use Case */
    }

    /**
     * Test for the loadUserByCredentials() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByCredentials()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByCredentials
     */
    public function testLoadUserByCredentialsThrowsNotFoundExceptionForUnknownPasswordEmtpy()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        // This call will fail with a "NotFoundException", because the given
        // login/password combination does not exist.
        $userService->loadUserByCredentials('user', '');
        /* END: Use Case */
    }

    /**
     * Test for the loadUserByCredentials() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByCredentials()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByCredentials
     */
    public function testLoadUserByCredentialsThrowsNotFoundExceptionForUnknownLogin()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        // This call will fail with a "NotFoundException", because the given
        // login/password combination does not exist.
        $userService->loadUserByCredentials('üser', 'secret');
        /* END: Use Case */
    }

    /**
     * Test for the loadUserByCredentials() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByCredentials()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByCredentials
     */
    public function testLoadUserByCredentialsThrowsInvalidArgumentValueForEmptyLogin()
    {
        $this->expectException(\eZ\Publish\Core\Base\Exceptions\InvalidArgumentValue::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        // This call will fail with a "InvalidArgumentValue", because the given
        // login is empty.
        $userService->loadUserByCredentials('', 'secret');
        /* END: Use Case */
    }

    /**
     * Test for the loadUserByLogin() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByLogin()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testLoadUserByLogin()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1('User');

        // Load the newly created user
        $userReloaded = $userService->loadUserByLogin('User');
        /* END: Use Case */

        $this->assertPropertiesCorrect(
            [
                'login' => $user->login,
                'email' => $user->email,
                'passwordHash' => $user->passwordHash,
                'hashAlgorithm' => $user->hashAlgorithm,
                'enabled' => $user->enabled,
                'maxLogin' => $user->maxLogin,
                'id' => $user->id,
                'contentInfo' => $user->contentInfo,
                'versionInfo' => $user->versionInfo,
                'fields' => $user->fields,
            ],
            $userReloaded
        );
    }

    /**
     * Test for the loadUserByLogin() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByLogin()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByLogin
     */
    public function testLoadUserByLoginThrowsNotFoundExceptionForUnknownLogin()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        // This call will fail with a "NotFoundException", because the given
        // login/password combination does not exist.
        $userService->loadUserByLogin('user42');
        /* END: Use Case */
    }

    /**
     * Test for the loadUserByLogin() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByLogin()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByLogin
     */
    public function testLoadUserByLoginWorksForLoginWithWrongCase()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Lookup by user login should ignore casing
        $userReloaded = $userService->loadUserByLogin('USER');
        /* END: Use Case */

        $this->assertPropertiesCorrect(
            [
                'login' => $user->login,
                'email' => $user->email,
                'passwordHash' => $user->passwordHash,
                'hashAlgorithm' => $user->hashAlgorithm,
                'enabled' => $user->enabled,
                'maxLogin' => $user->maxLogin,
                'id' => $user->id,
                'contentInfo' => $user->contentInfo,
                'versionInfo' => $user->versionInfo,
                'fields' => $user->fields,
            ],
            $userReloaded
        );
    }

    /**
     * Test for the loadUserByLogin() method.
     *
     * In some cases people use email as login name, make sure system works as exepcted when asking for user by email.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUserByLogin()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByLogin
     */
    public function testLoadUserByLoginThrowsNotFoundExceptionForUnknownLoginByEmail()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

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

        // Lookup by user login by email should behave as normal
        $userService->loadUserByLogin('user@example.com');
        /* END: Use Case */
    }

    /**
     * Test for the loadUsersByEmail() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUsersByEmail()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testLoadUserByEmail()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Load the newly created user
        $usersReloaded = $userService->loadUsersByEmail('user@example.com', Language::ALL);
        /* END: Use Case */

        $this->assertEquals([$user], $usersReloaded);
    }

    /**
     * Test for the loadUsersByEmail() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::loadUsersByEmail()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserByEmail
     */
    public function testLoadUserByEmailReturnsEmptyInUnknownEmail()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        // This call will return empty array, because the given
        // login/password combination does not exist.
        $emptyUserList = $userService->loadUsersByEmail('user42@example.com');
        /* END: Use Case */

        $this->assertEquals([], $emptyUserList);
    }

    /**
     * Test for the deleteUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::deleteUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUser
     */
    public function testDeleteUser()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\NotFoundException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Delete the currently created user
        $userService->deleteUser($user);
        /* END: Use Case */

        // We use the NotFoundException here to verify that the user not exists
        $userService->loadUser($user->id);
    }

    /**
     * Test for the deleteUser() method.
     *
     * @covers \eZ\Publish\API\Repository\UserService::deleteUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUser
     */
    public function testDeleteUserDeletesRelatedBookmarks()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();
        $locationService = $repository->getLocationService();
        $bookmarkService = $repository->getBookmarkService();
        /* BEGIN: Use Case */
        $admin = $repository->getPermissionResolver()->getCurrentUserReference();

        $user = $this->createUserVersion1();

        $repository->getPermissionResolver()->setCurrentUserReference($user);

        $bookmarkService->createBookmark(
            $locationService->loadLocation($this->generateId('location', 43))
        );

        $repository->getPermissionResolver()->setCurrentUserReference($admin);
        // Delete the currently created user
        $userService->deleteUser($user);

        $repository->getPermissionResolver()->setCurrentUserReference($user);
        /* END: Use Case */

        $this->assertEquals(0, $bookmarkService->loadBookmarks(0, 9999)->totalCount);
    }

    /**
     * Test for the newUserUpdateStruct() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::newUserUpdateStruct()
     */
    public function testNewUserUpdateStruct()
    {
        $repository = $this->getRepository();

        /* BEGIN: Use Case */
        $userService = $repository->getUserService();

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();
        /* END: Use Case */

        $this->assertInstanceOf(
            UserUpdateStruct::class,
            $userUpdate
        );

        $this->assertNull($userUpdate->contentUpdateStruct);
        $this->assertNull($userUpdate->contentMetadataUpdateStruct);

        $this->assertPropertiesCorrect(
            [
                'email' => null,
                'password' => null,
                'enabled' => null,
                'maxLogin' => null,
            ],
            $userUpdate
        );
    }

    /**
     * Test for the updateUser() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserUpdateStruct
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testUpdateContent
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testUpdateContentMetadata
     */
    public function testUpdateUser()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();

        // Set new values for password and maxLogin
        $userUpdate->password = 'my-new-password';
        $userUpdate->maxLogin = 42;
        $userUpdate->enabled = false;

        // Updated the user record.
        $userVersion2 = $userService->updateUser($user, $userUpdate);
        /* END: Use Case */

        $this->assertInstanceOf(User::class, $userVersion2);

        return $userVersion2;
    }

    /**
     * Test for the updateUser() and loadUsersByEmail() method on change to email.
     */
    public function testUpdateUserEmail(): void
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        // Create a user
        $user = $this->createUserVersion1();

        // Check we get what we expect (and implicit warmup any kind of cache)
        $users = $userService->loadUsersByEmail('user2@example.com');
        $this->assertCount(0, $users);

        // Update user with the given email address
        $userUpdate = $userService->newUserUpdateStruct();
        $userUpdate->email = 'user2@example.com';
        $updatedUser = $userService->updateUser($user, $userUpdate);
        $this->assertInstanceOf(User::class, $updatedUser);

        // Check that we can load user by email
        $users = $userService->loadUsersByEmail('user2@example.com');
        $this->assertCount(1, $users);
        $this->assertInstanceOf(User::class, $users[0]);
    }

    /**
     * Test for the updateUser() method.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testNewUserUpdateStruct
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testUpdateContent
     * @depends eZ\Publish\API\Repository\Tests\ContentServiceTest::testUpdateContentMetadata
     */
    public function testUpdateUserNoPassword()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();

        // Set new values for maxLogin, don't change password
        $userUpdate->maxLogin = 43;
        $userUpdate->enabled = false;

        // Updated the user record.
        $userVersion2 = $userService->updateUser($user, $userUpdate);
        /* END: Use Case */

        $this->assertInstanceOf(User::class, $user);

        $this->assertEquals(
            [
                'login' => $user->login,
                'email' => $user->email,
                'passwordHash' => $user->passwordHash,
                'hashAlgorithm' => $user->hashAlgorithm,
                'maxLogin' => 43,
                'enabled' => false,
            ],
            [
                'login' => $userVersion2->login,
                'email' => $userVersion2->email,
                'passwordHash' => $userVersion2->passwordHash,
                'hashAlgorithm' => $userVersion2->hashAlgorithm,
                'maxLogin' => $userVersion2->maxLogin,
                'enabled' => $userVersion2->enabled,
            ]
        );
    }

    /**
     * Test for the updateUser() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\User $user
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUser
     */
    public function testUpdateUserUpdatesExpectedProperties(User $user)
    {
        $this->assertEquals(
            [
                'login' => 'user',
                'email' => 'user@example.com',
                'maxLogin' => 42,
                'enabled' => false,
            ],
            [
                'login' => $user->login,
                'email' => $user->email,
                'maxLogin' => $user->maxLogin,
                'enabled' => $user->enabled,
            ]
        );
    }

    /**
     * Test for the updateUser() method.
     *
     * @param \eZ\Publish\API\Repository\Values\User\User $user
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUser
     */
    public function testUpdateUserReturnsPublishedVersion(User $user)
    {
        $this->assertEquals(
            APIVersionInfo::STATUS_PUBLISHED,
            $user->getVersionInfo()->status
        );
    }

    /**
     * Test for the updateUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUser
     */
    public function testUpdateUserWithContentMetadataUpdateStruct()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Get the ContentService implementation
        $contentService = $repository->getContentService();

        // Create a metadata update struct and change the remote id.
        $metadataUpdate = $contentService->newContentMetadataUpdateStruct();
        $metadataUpdate->remoteId = '85e10037d1ac0a00aa75443ced483e08';

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();

        // Set the metadata update struct.
        $userUpdate->contentMetadataUpdateStruct = $metadataUpdate;

        // Updated the user record.
        $userVersion2 = $userService->updateUser($user, $userUpdate);

        // The contentInfo->remoteId will be changed now.
        $remoteId = $userVersion2->contentInfo->remoteId;
        /* END: Use Case */

        $this->assertEquals('85e10037d1ac0a00aa75443ced483e08', $remoteId);
    }

    /**
     * Test for the updateUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUser
     */
    public function testUpdateUserWithContentUpdateStruct()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Get the ContentService implementation
        $contentService = $repository->getContentService();

        // Create a content update struct and change the remote id.
        $contentUpdate = $contentService->newContentUpdateStruct();
        $contentUpdate->setField('first_name', 'Hello', 'eng-US');
        $contentUpdate->setField('last_name', 'World', 'eng-US');

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();

        // Set the content update struct.
        $userUpdate->contentUpdateStruct = $contentUpdate;

        // Updated the user record.
        $userVersion2 = $userService->updateUser($user, $userUpdate);

        $name = sprintf(
            '%s %s',
            $userVersion2->getFieldValue('first_name'),
            $userVersion2->getFieldValue('last_name')
        );
        /* END: Use Case */

        $this->assertEquals('Hello World', $name);
    }

    /**
     * Test for the updateUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUser
     */
    public function testUpdateUserWhenMissingField()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Get the ContentService implementation
        $contentService = $repository->getContentService();

        // Create a content update struct and change the remote id.
        $contentUpdate = $contentService->newContentUpdateStruct();
        $contentUpdate->setField('first_name', null, 'eng-US');

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();

        // Set the content update struct.
        $userUpdate->contentUpdateStruct = $contentUpdate;

        // This call will fail with a "ContentFieldValidationException" because the
        // mandatory field "first_name" is set to an empty value.
        $userService->updateUser($user, $userUpdate);

        /* END: Use Case */
    }

    /**
     * Test for the updateUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::updateUser()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUpdateUser
     */
    public function testUpdateUserThrowsInvalidArgumentExceptionOnFieldTypeNotAccept()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);

        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // Get the ContentService implementation
        $contentService = $repository->getContentService();

        $contentUpdate = $contentService->newContentUpdateStruct();
        // An object of stdClass is not valid for the field first_name
        $contentUpdate->setField('first_name', new \stdClass(), 'eng-US');

        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();

        // Set the content update struct.
        $userUpdate->contentUpdateStruct = $contentUpdate;

        // This call will fail with a "InvalidArgumentException" because the
        // the field "first_name" does not accept the given value.
        $userService->updateUser($user, $userUpdate);

        /* END: Use Case */
    }

    /**
     * Test updating a user throwing UserPasswordValidationException when password doesn't follow specified rules.
     *
     * @covers \eZ\Publish\API\Repository\UserService::updateUser
     */
    public function testUpdateUserWithWeakPasswordThrowsUserPasswordValidationException()
    {
        $userService = $this->getRepository()->getUserService();

        $user = $this->createTestUserWithPassword('H@xxxiR!_1', $this->createUserContentTypeWithStrongPassword());

        /* BEGIN: Use Case */
        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();
        $userUpdate->password = 'pass';

        try {
            // This call will fail with a "UserPasswordValidationException" because the
            // the password does not follow specified rules
            $userService->updateUser($user, $userUpdate);
            /* END: Use Case */
        } catch (ContentFieldValidationException $e) {
            // Exception is caught, as there is no other way to check exception properties.
            $this->assertValidationErrorOccurs($e, 'User password must include at least one special character');
            $this->assertValidationErrorOccurs($e, 'User password must be at least %length% characters long');
            $this->assertValidationErrorOccurs($e, 'User password must include at least one upper case letter');
            $this->assertValidationErrorOccurs($e, 'User password must include at least one number');

            /* END: Use Case */
            return;
        }

        $this->fail('Expected ValidationError messages did not occur.');
    }

    /**
     * Opposite test case for testUpdateUserWithWeakPasswordThrowsUserPasswordValidationException.
     *
     * @covers \eZ\Publish\API\Repository\UserService::updateUser
     */
    public function testUpdateUserWithStrongPassword()
    {
        $userService = $this->getRepository()->getUserService();

        $user = $this->createTestUserWithPassword('H@xxxiR!_1', $this->createUserContentTypeWithStrongPassword());

        /* BEGIN: Use Case */
        // Create a new update struct instance
        $userUpdate = $userService->newUserUpdateStruct();
        $userUpdate->password = 'H@xxxiR!_2';

        $user = $userService->updateUser($user, $userUpdate);
        /* END: Use Case */

        $this->assertInstanceOf(User::class, $user);
    }

    /**
     * Test for the loadUserGroupsOfUser() method.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroupsOfUser
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testLoadUserGroupsOfUser()
    {
        $repository = $this->getRepository();

        $userService = $repository->getUserService();

        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // This array will contain the "Editors" user group name
        $userGroupNames = [];
        foreach ($userService->loadUserGroupsOfUser($user) as $userGroup) {
            $this->assertInstanceOf(UserGroup::class, $userGroup);
            $userGroupNames[] = $userGroup->getFieldValue('name');
        }
        /* END: Use Case */

        $this->assertEquals(['Editors'], $userGroupNames);
    }

    /**
     * Test for the loadUsersOfUserGroup() method.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUsersOfUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testCreateUser
     */
    public function testLoadUsersOfUserGroup()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $group = $userService->loadUserGroup($this->generateId('group', 13));

        /* BEGIN: Use Case */
        $this->createUserVersion1();

        $this->refreshSearch($repository);

        // This array will contain the email of the newly created "Editor" user
        $email = [];
        foreach ($userService->loadUsersOfUserGroup($group) as $user) {
            $this->assertInstanceOf(User::class, $user);
            $email[] = $user->email;
        }
        /* END: Use Case */
        $this->assertEquals(['user@example.com'], $email);
    }

    /**
     * Test for the assignUserToUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::assignUserToUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroupsOfUser
     */
    public function testAssignUserToUserGroup()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $administratorGroupId = $this->generateId('group', 12);
        /* BEGIN: Use Case */
        // $administratorGroupId is the ID of the "Administrator" group in an
        // eZ Publish demo installation

        $user = $this->createUserVersion1();

        // Assign group to newly created user
        $userService->assignUserToUserGroup(
            $user,
            $userService->loadUserGroup($administratorGroupId)
        );

        // This array will contain "Editors" and "Administrator users"
        $userGroupNames = [];
        foreach ($userService->loadUserGroupsOfUser($user) as $userGroup) {
            $userGroupNames[] = $userGroup->getFieldValue('name');
        }
        /* END: Use Case */

        sort($userGroupNames, SORT_STRING);

        $this->assertEquals(
            [
                'Administrator users',
                'Editors',
            ],
            $userGroupNames
        );
    }

    /**
     * Test for the assignUserToUserGroup() method.
     *
     * @covers \eZ\Publish\API\Repository\UserService::assignUserToUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testAssignUserToUserGroup
     */
    public function testAssignUserToUserGroupThrowsInvalidArgumentException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);
        $this->expectExceptionMessage('Argument \'user\' is invalid: User is already in the given User Group');

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $editorsGroupId = $this->generateId('group', 13);
        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();
        // $editorsGroupId is the ID of the "Editors" group in an
        // eZ Publish demo installation

        // This call will fail with an "InvalidArgumentException", because the
        // user is already assigned to the "Editors" group
        $userService->assignUserToUserGroup(
            $user,
            $userService->loadUserGroup($editorsGroupId)
        );
        /* END: Use Case */
    }

    /**
     * Test for the unAssignUssrFromUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::unAssignUssrFromUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testLoadUserGroupsOfUser
     */
    public function testUnAssignUserFromUserGroup()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $editorsGroupId = $this->generateId('group', 13);
        $anonymousGroupId = $this->generateId('group', 42);

        /* BEGIN: Use Case */
        // $anonymousGroupId is the ID of the "Anonymous Users" group in an eZ
        // Publish demo installation

        $user = $this->createUserVersion1();

        // Assign group to newly created user
        $userService->assignUserToUserGroup(
            $user,
            $userService->loadUserGroup($anonymousGroupId)
        );

        // Unassign user from "Editors" group
        $userService->unAssignUserFromUserGroup(
            $user,
            $userService->loadUserGroup($editorsGroupId)
        );

        // This array will contain "Anonymous Users"
        $userGroupNames = [];
        foreach ($userService->loadUserGroupsOfUser($user) as $userGroup) {
            $userGroupNames[] = $userGroup->getFieldValue('name');
        }
        /* END: Use Case */

        $this->assertEquals(['Anonymous Users'], $userGroupNames);
    }

    /**
     * Test for the unAssignUserFromUserGroup() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::unAssignUserFromUserGroup()
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUnAssignUserFromUserGroup
     */
    public function testUnAssignUserFromUserGroupThrowsInvalidArgumentException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException::class);

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $administratorGroupId = $this->generateId('group', 12);
        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();
        // $administratorGroupId is the ID of the "Administrator" group in an
        // eZ Publish demo installation

        // This call will fail with an "InvalidArgumentException", because the
        // user is not assigned to the "Administrator" group
        $userService->unAssignUserFromUserGroup(
            $user,
            $userService->loadUserGroup($administratorGroupId)
        );
        /* END: Use Case */
    }

    /**
     * Test for the unAssignUserFromUserGroup() method removing user from the last group.
     *
     * @covers \eZ\Publish\API\Repository\UserService::unAssignUserFromUserGroup
     * @depends eZ\Publish\API\Repository\Tests\UserServiceTest::testUnAssignUserFromUserGroup
     */
    public function testUnAssignUserFromUserGroupThrowsBadStateArgumentException()
    {
        $this->expectException(\eZ\Publish\API\Repository\Exceptions\BadStateException::class);
        $this->expectExceptionMessage('Argument \'user\' has a bad state: User only has one User Group, cannot unassign from last group');

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $editorsGroupId = $this->generateId('group', 13);
        /* BEGIN: Use Case */
        $user = $this->createUserVersion1();

        // This call will fail with an "BadStateException", because the
        // user has to be assigned to at least one group
        $userService->unAssignUserFromUserGroup(
            $user,
            $userService->loadUserGroup($editorsGroupId)
        );
        /* END: Use Case */
    }

    /**
     * Test that multi-language logic for the loadUserGroup method respects prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroup
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserGroupWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $userGroup = $this->createMultiLanguageUserGroup();
        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = $userGroup->contentInfo->mainLanguageCode;
        }

        $loadedUserGroup = $userService->loadUserGroup($userGroup->id, $prioritizedLanguages);

        self::assertEquals(
            $loadedUserGroup->getName($expectedLanguageCode),
            $loadedUserGroup->getName()
        );
        self::assertEquals(
            $loadedUserGroup->getFieldValue('description', $expectedLanguageCode),
            $loadedUserGroup->getFieldValue('description')
        );
    }

    /**
     * Test that multi-language logic works correctly after updating user group main language.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroup
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserGroupWithPrioritizedLanguagesListAfterMainLanguageUpdate(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $contentService = $repository->getContentService();

        $userGroup = $this->createMultiLanguageUserGroup();

        $userGroupUpdateStruct = $userService->newUserGroupUpdateStruct();
        $userGroupUpdateStruct->contentMetadataUpdateStruct = $contentService->newContentMetadataUpdateStruct();
        $userGroupUpdateStruct->contentMetadataUpdateStruct->mainLanguageCode = 'eng-GB';
        $userService->updateUserGroup($userGroup, $userGroupUpdateStruct);

        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = 'eng-GB';
        }

        $loadedUserGroup = $userService->loadUserGroup($userGroup->id, $prioritizedLanguages);

        self::assertEquals(
            $loadedUserGroup->getName($expectedLanguageCode),
            $loadedUserGroup->getName()
        );
        self::assertEquals(
            $loadedUserGroup->getFieldValue('description', $expectedLanguageCode),
            $loadedUserGroup->getFieldValue('description')
        );
    }

    /**
     * Test that multi-language logic for the loadSubUserGroups method respects prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadSubUserGroups
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadSubUserGroupsWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        // create main group for subgroups
        $userGroup = $this->createMultiLanguageUserGroup(4);
        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = $userGroup->contentInfo->mainLanguageCode;
        }

        // create subgroups
        $this->createMultiLanguageUserGroup($userGroup->id);
        $this->createMultiLanguageUserGroup($userGroup->id);

        $userGroup = $userService->loadUserGroup($userGroup->id, $prioritizedLanguages);

        $subUserGroups = $userService->loadSubUserGroups($userGroup, 0, 2, $prioritizedLanguages);
        foreach ($subUserGroups as $subUserGroup) {
            self::assertEquals(
                $subUserGroup->getName($expectedLanguageCode),
                $subUserGroup->getName()
            );
            self::assertEquals(
                $subUserGroup->getFieldValue('description', $expectedLanguageCode),
                $subUserGroup->getFieldValue('description')
            );
        }
    }

    /**
     * Test that multi-language logic for the loadUser method respects prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUser
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $user = $this->createMultiLanguageUser();
        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = $user->contentInfo->mainLanguageCode;
        }

        $loadedUser = $userService->loadUser($user->id, $prioritizedLanguages);

        self::assertEquals(
            $loadedUser->getName($expectedLanguageCode),
            $loadedUser->getName()
        );

        foreach (['fist_name', 'last_name', 'signature'] as $fieldIdentifier) {
            self::assertEquals(
                $loadedUser->getFieldValue($fieldIdentifier, $expectedLanguageCode),
                $loadedUser->getFieldValue($fieldIdentifier)
            );
        }
    }

    /**
     * Test that multi-language logic for the loadUser method works correctly after updating
     * user content main language.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroup
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserWithPrioritizedLanguagesListAfterMainLanguageUpdate(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $contentService = $repository->getContentService();

        $user = $this->createMultiLanguageUser();
        // sanity check
        self::assertEquals($user->contentInfo->mainLanguageCode, 'eng-US');

        $userUpdateStruct = $userService->newUserUpdateStruct();
        $userUpdateStruct->contentMetadataUpdateStruct = $contentService->newContentMetadataUpdateStruct();
        $userUpdateStruct->contentMetadataUpdateStruct->mainLanguageCode = 'eng-GB';
        $userService->updateUser($user, $userUpdateStruct);
        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = 'eng-GB';
        }

        $loadedUser = $userService->loadUser($user->id, $prioritizedLanguages);

        self::assertEquals(
            $loadedUser->getName($expectedLanguageCode),
            $loadedUser->getName()
        );

        foreach (['fist_name', 'last_name', 'signature'] as $fieldIdentifier) {
            self::assertEquals(
                $loadedUser->getFieldValue($fieldIdentifier, $expectedLanguageCode),
                $loadedUser->getFieldValue($fieldIdentifier)
            );
        }
    }

    /**
     * Test that multi-language logic for the loadUserByLogin method respects prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserByLogin
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserByLoginWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $user = $this->createMultiLanguageUser();

        // load, with prioritized languages, the newly created user
        $loadedUser = $userService->loadUserByLogin($user->login, $prioritizedLanguages);
        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = $loadedUser->contentInfo->mainLanguageCode;
        }

        self::assertEquals(
            $loadedUser->getName($expectedLanguageCode),
            $loadedUser->getName()
        );

        foreach (['first_name', 'last_name', 'signature'] as $fieldIdentifier) {
            self::assertEquals(
                $loadedUser->getFieldValue($fieldIdentifier, $expectedLanguageCode),
                $loadedUser->getFieldValue($fieldIdentifier)
            );
        }
    }

    /**
     * Test that multi-language logic for the loadUserByCredentials method respects
     * prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserByCredentials
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserByCredentialsWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $user = $this->createMultiLanguageUser();

        // load, with prioritized languages, the newly created user
        $loadedUser = $userService->loadUserByCredentials(
            $user->login,
            'secret',
            $prioritizedLanguages
        );
        if ($expectedLanguageCode === null) {
            $expectedLanguageCode = $loadedUser->contentInfo->mainLanguageCode;
        }

        self::assertEquals(
            $loadedUser->getName($expectedLanguageCode),
            $loadedUser->getName()
        );

        foreach (['first_name', 'last_name', 'signature'] as $fieldIdentifier) {
            self::assertEquals(
                $loadedUser->getFieldValue($fieldIdentifier, $expectedLanguageCode),
                $loadedUser->getFieldValue($fieldIdentifier)
            );
        }
    }

    /**
     * Test that multi-language logic for the loadUsersByEmail method respects
     * prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUsersByEmail
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUsersByEmailWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $user = $this->createMultiLanguageUser();

        // load, with prioritized languages, users by email
        $loadedUsers = $userService->loadUsersByEmail($user->email, $prioritizedLanguages);

        foreach ($loadedUsers as $loadedUser) {
            if ($expectedLanguageCode === null) {
                $expectedLanguageCode = $loadedUser->contentInfo->mainLanguageCode;
            }
            self::assertEquals(
                $loadedUser->getName($expectedLanguageCode),
                $loadedUser->getName()
            );

            foreach (['first_name', 'last_name', 'signature'] as $fieldIdentifier) {
                self::assertEquals(
                    $loadedUser->getFieldValue($fieldIdentifier, $expectedLanguageCode),
                    $loadedUser->getFieldValue($fieldIdentifier)
                );
            }
        }
    }

    /**
     * Test that multi-language logic for the loadUserGroupsOfUser method respects
     * prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserGroupsOfUser
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUserGroupsOfUserWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();
        $userGroup = $this->createMultiLanguageUserGroup();
        $user = $this->createMultiLanguageUser($userGroup->id);

        $userGroups = $userService->loadUserGroupsOfUser($user, 0, 25, $prioritizedLanguages);
        foreach ($userGroups as $userGroup) {
            self::assertEquals(
                $userGroup->getName($expectedLanguageCode),
                $userGroup->getName()
            );
            self::assertEquals(
                $userGroup->getFieldValue('description', $expectedLanguageCode),
                $userGroup->getFieldValue('description')
            );
        }
    }

    /**
     * Test that multi-language logic for the loadUsersOfUserGroup method respects
     * prioritized language list.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUsersOfUserGroup
     * @dataProvider getPrioritizedLanguageList
     * @param string[] $prioritizedLanguages
     * @param string|null $expectedLanguageCode language code of expected translation
     */
    public function testLoadUsersOfUserGroupWithPrioritizedLanguagesList(
        array $prioritizedLanguages,
        $expectedLanguageCode
    ) {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        // create parent user group
        $userGroup = $this->createMultiLanguageUserGroup();
        // add two users to the created parent user group
        $this->createMultiLanguageUser($userGroup->id);
        $this->createMultiLanguageUser($userGroup->id);

        // test loading of users via user group with prioritized languages list
        $users = $userService->loadUsersOfUserGroup($userGroup, 0, 25, $prioritizedLanguages);
        foreach ($users as $user) {
            if ($expectedLanguageCode === null) {
                $expectedLanguageCode = $user->contentInfo->mainLanguageCode;
            }
            self::assertEquals(
                $user->getName($expectedLanguageCode),
                $user->getName()
            );

            foreach (['first_name', 'last_name', 'signature'] as $fieldIdentifier) {
                self::assertEquals(
                    $user->getFieldValue($fieldIdentifier, $expectedLanguageCode),
                    $user->getFieldValue($fieldIdentifier)
                );
            }
        }
    }

    /**
     * Get prioritized languages list data.
     *
     * Test cases using this data provider should expect the following arguments:
     * <code>
     *   array $prioritizedLanguagesList
     *   string $expectedLanguage (if null - use main language)
     * </code>
     *
     * @return array
     */
    public function getPrioritizedLanguageList()
    {
        return [
            [[], null],
            [['eng-US'], 'eng-US'],
            [['eng-GB'], 'eng-GB'],
            [['eng-US', 'eng-GB'], 'eng-US'],
            [['eng-GB', 'eng-US'], 'eng-GB'],
            // use non-existent group as the first one
            [['ger-DE'], null],
            [['ger-DE', 'eng-GB'], 'eng-GB'],
        ];
    }

    /**
     * @param int $parentGroupId
     * @return \eZ\Publish\API\Repository\Values\User\UserGroup
     */
    private function createMultiLanguageUserGroup($parentGroupId = 4)
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        // create user group with multiple translations
        $parentGroupId = $this->generateId('group', $parentGroupId);
        $parentGroup = $userService->loadUserGroup($parentGroupId);

        $userGroupCreateStruct = $userService->newUserGroupCreateStruct('eng-US');
        $userGroupCreateStruct->setField('name', 'US user group', 'eng-US');
        $userGroupCreateStruct->setField('name', 'GB user group', 'eng-GB');
        $userGroupCreateStruct->setField('description', 'US user group description', 'eng-US');
        $userGroupCreateStruct->setField('description', 'GB user group description', 'eng-GB');
        $userGroupCreateStruct->alwaysAvailable = true;

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

    /**
     * Create a user group fixture in a variable named <b>$userGroup</b>,.
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserGroup
     */
    private function createUserGroupVersion1()
    {
        $repository = $this->getRepository();

        $mainGroupId = $this->generateId('group', 4);
        /* BEGIN: Inline */
        // $mainGroupId is the ID of the main "Users" group

        $userService = $repository->getUserService();

        // Load main group
        $parentUserGroup = $userService->loadUserGroup($mainGroupId);

        // Instantiate a new create struct
        $userGroupCreate = $userService->newUserGroupCreateStruct('eng-US');
        $userGroupCreate->setField('name', 'Example Group');

        // Create the new user group
        $userGroup = $userService->createUserGroup(
            $userGroupCreate,
            $parentUserGroup
        );
        /* END: Inline */

        return $userGroup;
    }

    /**
     * Create user with multiple translations of User Content fields.
     *
     * @param int $userGroupId User group ID (default 13 - Editors)
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    private function createMultiLanguageUser($userGroupId = 13)
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        // Instantiate a create struct with mandatory properties
        $randomLogin = md5(mt_rand() . time());
        $userCreateStruct = $userService->newUserCreateStruct(
            $randomLogin,
            "{$randomLogin}@example.com",
            'secret',
            'eng-US'
        );
        $userCreateStruct->enabled = true;
        $userCreateStruct->alwaysAvailable = true;

        // set field for each language
        foreach (['eng-US', 'eng-GB'] as $languageCode) {
            $userCreateStruct->setField('first_name', "{$languageCode} Example", $languageCode);
            $userCreateStruct->setField('last_name', "{$languageCode} User", $languageCode);
            $userCreateStruct->setField('signature', "{$languageCode} signature", $languageCode);
        }

        // Load parent group for the user
        $group = $userService->loadUserGroup($userGroupId);

        // Create a new user
        return $userService->createUser($userCreateStruct, [$group]);
    }

    /**
     * Test for the createUser() method.
     *
     * @see \eZ\Publish\API\Repository\UserService::createUser()
     */
    public function testCreateUserInvalidPasswordHashTypeThrowsException()
    {
        $repository = $this->getRepository();
        $eventUserService = $repository->getUserService();

        // Instantiate a create struct with mandatory properties.
        $createStruct = $eventUserService->newUserCreateStruct(
            'user',
            'user@example.com',
            'secret',
            'eng-US'
        );

        // Set some fields required by the user ContentType.
        $createStruct->setField('first_name', 'Example');
        $createStruct->setField('last_name', 'User');

        // Get User fieldType.
        $userFieldDef = null;
        foreach ($createStruct->fields as $field) {
            if ($field->fieldTypeIdentifier === 'ezuser') {
                $userFieldDef = $field;
                break;
            }
        }

        if (!$userFieldDef) {
            $this->fail('User FieldType not found in userCreateStruct!');
        }

        /** @var \eZ\Publish\Core\FieldType\User\Value $userValue */
        $userValue = $userFieldDef->value;

        // Set not supported hash type.
        $userValue->passwordHashType = 42424242;

        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("Argument 'hashType' is invalid: Password hash type '42424242' is not recognized");

        // Create a new user instance.
        // 13 is ID of the "Editors" user group in an eZ Publish demo installation.
        $eventUserService->createUser($createStruct, [$eventUserService->loadUserGroup(13)]);
    }

    /**
     * Test loading User by Token.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserByToken
     */
    public function testLoadUserByToken()
    {
        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $user = $this->createUserVersion1();

        $userTokenUpdateStruct = new UserTokenUpdateStruct();
        $userTokenUpdateStruct->hashKey = md5('hash');
        $userTokenUpdateStruct->time = new DateTime();

        $userService->updateUserToken($user, $userTokenUpdateStruct);

        $loadedUser = $userService->loadUserByToken($userTokenUpdateStruct->hashKey, Language::ALL);
        self::assertEquals($user, $loadedUser);

        return $userTokenUpdateStruct->hashKey;
    }

    /**
     * Test trying to load User by invalid Token.
     *
     * @covers \eZ\Publish\API\Repository\UserService::loadUserByToken
     */
    public function testLoadUserByTokenThrowsNotFoundException()
    {
        $this->expectException(NotFoundException::class);

        $repository = $this->getRepository();
        $userService = $repository->getUserService();

        $user = $this->createUserVersion1();

        $userTokenUpdateStruct = new UserTokenUpdateStruct();
        $userTokenUpdateStruct->hashKey = md5('hash');
        $userTokenUpdateStruct->time = new DateTime();

        $userService->updateUserToken($user, $userTokenUpdateStruct);

        $userService->loadUserByToken('not_existing_token');
    }

    /**
     * Test updating User Token.
     *
     * @covers \eZ\Publish\API\Repository\UserService::updateUserToken()
     *
     * @depends testLoadUserByToken
     *
     * @param string $originalUserToken
     */
    public function testUpdateUserToken($originalUserToken)
    {
        $repository = $this->getRepository(false);
        $userService = $repository->getUserService();

        $user = $userService->loadUserByToken($originalUserToken);

        $userTokenUpdateStruct = new UserTokenUpdateStruct();
        $userTokenUpdateStruct->hashKey = md5('my_updated_hash');
        $userTokenUpdateStruct->time = new DateTime();

        $userService->updateUserToken($user, $userTokenUpdateStruct);

        $loadedUser = $userService->loadUserByToken($userTokenUpdateStruct->hashKey);
        self::assertEquals($user, $loadedUser);
    }

    /**
     * Test invalidating (expiring) User Token.
     *
     * @covers \eZ\Publish\API\Repository\UserService::expireUserToken()
     *
     * @depends testLoadUserByToken
     *
     * @param string $userToken
     */
    public function testExpireUserToken($userToken)
    {
        $this->expectException(NotFoundException::class);

        $repository = $this->getRepository(false);
        $userService = $repository->getUserService();

        // sanity check
        $userService->loadUserByToken($userToken);

        $userService->expireUserToken($userToken);

        // should throw NotFoundException now
        $userService->loadUserByToken($userToken);
    }

    /**
     * @covers \eZ\Publish\API\Repository\UserService::validatePassword()
     */
    public function testValidatePasswordWithDefaultContext()
    {
        $userService = $this->getRepository()->getUserService();

        /* BEGIN: Use Case */
        $errors = $userService->validatePassword('pass');
        /* END: Use Case */

        $this->assertEmpty($errors);
    }

    /**
     * @covers \eZ\Publish\API\Repository\UserService::validatePassword()
     * @dataProvider dataProviderForValidatePassword
     */
    public function testValidatePassword(string $password, array $expectedErrors)
    {
        $userService = $this->getRepository()->getUserService();
        $contentType = $this->createUserContentTypeWithStrongPassword();

        /* BEGIN: Use Case */
        $context = new PasswordValidationContext([
            'contentType' => $contentType,
        ]);

        $actualErrors = $userService->validatePassword($password, $context);
        /* END: Use Case */

        $this->assertEquals($expectedErrors, $actualErrors);
    }

    public function testValidatePasswordReturnsErrorWhenOldPasswordIsReused(): void
    {
        $password = 'P@blish123!';

        $userService = $this->getRepository()->getUserService();
        // Password expiration needs to be enabled
        $contentType = $this->createUserContentTypeWithPasswordExpirationDate();

        $user = $this->createTestUserWithPassword($password, $contentType);

        $context = new PasswordValidationContext([
            'contentType' => $contentType,
            'user' => $user,
        ]);

        $actualErrors = $userService->validatePassword($password, $context);

        $this->assertEquals(
            [new ValidationError('New password cannot be the same as old password', null, [], 'password')],
            $actualErrors
        );
    }

    /**
     * Data provider for testValidatePassword.
     *
     * @return array
     */
    public function dataProviderForValidatePassword(): array
    {
        return [
            [
                'pass',
                [
                    new ValidationError('User password must be at least %length% characters long', null, [
                        '%length%' => 8,
                    ], 'password'),
                    new ValidationError('User password must include at least one upper case letter', null, [], 'password'),
                    new ValidationError('User password must include at least one number', null, [], 'password'),
                    new ValidationError('User password must include at least one special character', null, [], 'password'),
                ],
            ],
            [
                'H@xxxi0R!!!',
                [],
            ],
        ];
    }

    public function testGetPasswordInfo(): void
    {
        $userService = $this->getRepository()->getUserService();
        $contentType = $this->createUserContentTypeWithPasswordExpirationDate(
            self::EXAMPLE_PASSWORD_TTL,
            self::EXAMPLE_PASSWORD_TTL_WARNING
        );

        $user = $this->createTestUser($contentType);

        /* BEGIN: Use Case */
        $passwordInfo = $userService->getPasswordInfo($user);
        /* END: Use Case */

        $passwordUpdatedAt = $user->passwordUpdatedAt;
        if ($passwordUpdatedAt instanceof DateTime) {
            $passwordUpdatedAt = DateTimeImmutable::createFromFormat(DateTime::ATOM, $passwordUpdatedAt->format(DateTime::ATOM));
        }

        $expectedPasswordExpirationDate = $passwordUpdatedAt->add(
            new DateInterval(sprintf('P%dD', self::EXAMPLE_PASSWORD_TTL))
        );

        $expectedPasswordExpirationWarningDate = $passwordUpdatedAt->add(
            new DateInterval(sprintf('P%dD', self::EXAMPLE_PASSWORD_TTL - self::EXAMPLE_PASSWORD_TTL_WARNING))
        );

        $this->assertEquals(new PasswordInfo(
            $expectedPasswordExpirationDate,
            $expectedPasswordExpirationWarningDate
        ), $passwordInfo);
    }

    public function testGetPasswordInfoIfExpirationIsDisabled(): void
    {
        $userService = $this->getRepository()->getUserService();
        $contentType = $this->createUserContentTypeWithPasswordExpirationDate(null, null);

        $user = $this->createTestUser($contentType);

        /* BEGIN: Use Case */
        $passwordInfo = $userService->getPasswordInfo($user);
        /* END: Use Case */

        $this->assertEquals(new PasswordInfo(), $passwordInfo);
    }

    public function testGetPasswordInfoIfExpirationWarningIsDisabled(): void
    {
        $userService = $this->getRepository()->getUserService();
        $contentType = $this->createUserContentTypeWithPasswordExpirationDate(self::EXAMPLE_PASSWORD_TTL, null);

        $user = $this->createTestUser($contentType);

        /* BEGIN: Use Case */
        $passwordInfo = $userService->getPasswordInfo($user);
        /* END: Use Case */

        $passwordUpdatedAt = $user->passwordUpdatedAt;
        if ($passwordUpdatedAt instanceof DateTime) {
            $passwordUpdatedAt = DateTimeImmutable::createFromFormat(DateTime::ATOM, $passwordUpdatedAt->format(DateTime::ATOM));
        }

        $expectedPasswordExpirationDate = $passwordUpdatedAt->add(
            new DateInterval(sprintf('P%dD', self::EXAMPLE_PASSWORD_TTL))
        );

        $this->assertEquals(new PasswordInfo($expectedPasswordExpirationDate, null), $passwordInfo);
    }

    public function createTestUser(ContentType $contentType): User
    {
        return $this->createTestUserWithPassword(self::EXAMPLE_PASSWORD, $contentType);
    }

    /**
     * Creates a user with given password.
     *
     * @param string $password
     * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    private function createTestUserWithPassword(string $password, ContentType $contentType): User
    {
        $userService = $this->getRepository()->getUserService();
        // ID of the "Editors" user group in an eZ Publish demo installation
        $editorsGroupId = 13;

        // Instantiate a create struct with mandatory properties
        $userCreate = $userService->newUserCreateStruct(
            'johndoe',
            'johndoe@example.com',
            $password,
            'eng-US',
            $contentType
        );
        $userCreate->enabled = true;
        $userCreate->setField('first_name', 'John');
        $userCreate->setField('last_name', 'Doe');

        return $userService->createUser($userCreate, [
            $userService->loadUserGroup($editorsGroupId),
        ]);
    }

    /**
     * Creates the User Content Type with password constraints.
     *
     * @return \eZ\Publish\API\Repository\Values\ContentType\ContentType
     */
    private function createUserContentTypeWithStrongPassword(): ContentType
    {
        return $this->createUserContentTypeWithAccountSettings('user-with-strong-password', null, [
            'PasswordValueValidator' => [
                'requireAtLeastOneUpperCaseCharacter' => 1,
                'requireAtLeastOneLowerCaseCharacter' => 1,
                'requireAtLeastOneNumericCharacter' => 1,
                'requireAtLeastOneNonAlphanumericCharacter' => 1,
                'requireNewPassword' => 1,
                'minLength' => 8,
            ],
        ]);
    }

    private function createUserContentTypeWithPasswordExpirationDate(
        ?int $passwordTTL = self::EXAMPLE_PASSWORD_TTL,
        ?int $passwordTTLWarning = self::EXAMPLE_PASSWORD_TTL_WARNING
    ): ContentType {
        return $this->createUserContentTypeWithAccountSettings('password-expiration', [
            'PasswordTTL' => $passwordTTL,
            'PasswordTTLWarning' => $passwordTTLWarning,
        ]);
    }

    private function createUserContentTypeWithAccountSettings(
        string $identifier,
        ?array $fieldSetting = null,
        ?array $validatorConfiguration = null
    ): ContentType {
        $repository = $this->getRepository();

        $contentTypeService = $repository->getContentTypeService();
        $permissionResolver = $repository->getPermissionResolver();

        $typeCreate = $contentTypeService->newContentTypeCreateStruct($identifier);
        $typeCreate->mainLanguageCode = 'eng-GB';
        $typeCreate->urlAliasSchema = 'url|scheme';
        $typeCreate->nameSchema = 'name|scheme';
        $typeCreate->names = [
            'eng-GB' => 'User: ' . $identifier,
        ];
        $typeCreate->descriptions = [
            'eng-GB' => '',
        ];
        $typeCreate->creatorId = $this->generateId('user', $permissionResolver->getCurrentUserReference()->getUserId());
        $typeCreate->creationDate = $this->createDateTime();

        $firstNameFieldCreate = $contentTypeService->newFieldDefinitionCreateStruct('first_name', 'ezstring');
        $firstNameFieldCreate->names = [
            'eng-GB' => 'First name',
        ];
        $firstNameFieldCreate->descriptions = [
            'eng-GB' => '',
        ];
        $firstNameFieldCreate->fieldGroup = 'default';
        $firstNameFieldCreate->position = 1;
        $firstNameFieldCreate->isTranslatable = false;
        $firstNameFieldCreate->isRequired = true;
        $firstNameFieldCreate->isInfoCollector = false;
        $firstNameFieldCreate->validatorConfiguration = [
            'StringLengthValidator' => [
                'minStringLength' => 0,
                'maxStringLength' => 0,
            ],
        ];
        $firstNameFieldCreate->fieldSettings = [];
        $firstNameFieldCreate->isSearchable = true;
        $firstNameFieldCreate->defaultValue = '';

        $typeCreate->addFieldDefinition($firstNameFieldCreate);

        $lastNameFieldCreate = $contentTypeService->newFieldDefinitionCreateStruct('last_name', 'ezstring');
        $lastNameFieldCreate->names = [
            'eng-GB' => 'Last name',
        ];
        $lastNameFieldCreate->descriptions = [
            'eng-GB' => '',
        ];
        $lastNameFieldCreate->fieldGroup = 'default';
        $lastNameFieldCreate->position = 2;
        $lastNameFieldCreate->isTranslatable = false;
        $lastNameFieldCreate->isRequired = true;
        $lastNameFieldCreate->isInfoCollector = false;
        $lastNameFieldCreate->validatorConfiguration = [
            'StringLengthValidator' => [
                'minStringLength' => 0,
                'maxStringLength' => 0,
            ],
        ];
        $lastNameFieldCreate->fieldSettings = [];
        $lastNameFieldCreate->isSearchable = true;
        $lastNameFieldCreate->defaultValue = '';

        $typeCreate->addFieldDefinition($lastNameFieldCreate);

        $accountFieldCreateStruct = $contentTypeService->newFieldDefinitionCreateStruct('account', 'ezuser');
        $accountFieldCreateStruct->names = [
            'eng-GB' => 'User account',
        ];
        $accountFieldCreateStruct->descriptions = [
            'eng-GB' => '',
        ];
        $accountFieldCreateStruct->fieldGroup = 'default';
        $accountFieldCreateStruct->position = 3;
        $accountFieldCreateStruct->isTranslatable = false;
        $accountFieldCreateStruct->isRequired = true;
        $accountFieldCreateStruct->isInfoCollector = false;
        $accountFieldCreateStruct->validatorConfiguration = $validatorConfiguration;
        $accountFieldCreateStruct->fieldSettings = $fieldSetting;
        $accountFieldCreateStruct->isSearchable = false;
        $accountFieldCreateStruct->defaultValue = null;

        $typeCreate->addFieldDefinition($accountFieldCreateStruct);

        $contentTypeDraft = $contentTypeService->createContentType($typeCreate, [
            $contentTypeService->loadContentTypeGroupByIdentifier('Users'),
        ]);
        $contentTypeService->publishContentTypeDraft($contentTypeDraft);

        return $contentTypeService->loadContentTypeByIdentifier($identifier);
    }
}