ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest Class Reference

Inheritance diagram for ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest:

Collaboration diagram for ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest:

Public Member Functions
	testConstruct ()
	testIsLoggedIn ()
	testCannotAgree ()
	testNeverAgreed ()
	testWithdrawalRequested ()
	testAgreeDate ()
	testDidNotAcceptCurrentVersion ()
	testNeedsToAcceptNewDocumentWhereNeverAgreed ()
	testNeedsToAcceptNewDocumentReturnsTrue ()
	testNeedsToAcceptNewDocumentReturnsFalse ()
	testDoesntMatch ()
	testMatchingDocument ()
	testAcceptedVersion ()
	testAcceptVersionError ()
	testAcceptMatchingDocument ()
	testIsLDAPUser ()
	testIsExternalUser (int $auth_mode, bool $is_external_account)
	externalAuthModes More...
	testFormat ()
	testRaw ()
	testAcceptAnyDocument ()

Static Public Member Functions
static	externalAuthModes ()

Private Member Functions
	ensureDefined (string $name, $value)

Detailed Description

Definition at line 43 of file UserTest.php.

Member Function Documentation

ensureDefined()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::ensureDefined ( string  $name,   $value  )

private

Definition at line 415 of file UserTest.php.

Referenced by ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\testAcceptedVersion(), ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\testAcceptVersionError(), ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\testCannotAgree(), and ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\testIsLoggedIn().

                                                        : void
    {
        if (!defined($name)) {
            define($name, $value);
        }
    }

Here is the caller graph for this function:

externalAuthModes()

static ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::externalAuthModes ( )

static

Definition at line 406 of file UserTest.php.

References ilAuthUtils\AUTH_ECS, ilAuthUtils\AUTH_LDAP, and ilAuthUtils\AUTH_PROVIDER_LTI.

                                              : array
    {
        return [
            'lti' => [ilAuthUtils::AUTH_PROVIDER_LTI, true],
            'ecs' => [ilAuthUtils::AUTH_ECS, true],
            'ldap' => [ilAuthUtils::AUTH_LDAP, false],
        ];
    }

testAcceptAnyDocument()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testAcceptAnyDocument

(

)

Definition at line 385 of file UserTest.php.

                                           : void
    {
        $user = $this->mock(ilObjUser::class);
        $history = $this->mock(ProvideHistory::class);
        $doc = $this->mock(Document::class);
        $history->expects(self::once())->method('acceptDocument')->with($user, $doc);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mockTree(Provide::class, [
                'document' => ['repository' => ['all' => [$doc]]],
                'history' => $history,
            ]),
            $this->mock(Clock::class)
        );

        $instance->acceptAnyDocument();
    }

testAcceptedVersion()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testAcceptedVersion

(

)

Definition at line 257 of file UserTest.php.

References ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\ensureDefined().

                                         : void
    {
        $this->ensureDefined('ANONYMOUS_USER_ID', 13);
        $this->ensureDefined('SYSTEM_USER_ID', 9);

        $result = $this->mock(Result::class);

        $user = $this->mockTree(ilObjUser::class, ['getId' => 67]);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mockTree(UserSettings::class, ['agreeDate' => ['value' => new DateTimeImmutable()]]),
            $this->mockTree(Provide::class, ['history' => $this->mockMethod(ProvideHistory::class, 'acceptedVersion', [$user], $result)]),
            $this->mock(Clock::class)
        );

        $this->assertSame($result, $instance->acceptedVersion());
    }

Here is the call graph for this function:

testAcceptMatchingDocument()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testAcceptMatchingDocument

(

)

Definition at line 297 of file UserTest.php.

References ILIAS\$setting.

                                                : void
    {
        $user = $this->mock(ilObjUser::class);
        $document = $this->mock(Document::class);
        $date = new DateTimeImmutable();

        $history = $this->mock(ProvideHistory::class);
        $history->expects(self::once())->method('acceptDocument')->with($user, $document);

        $setting = $this->mock(Setting::class);
        $setting->expects(self::once())->method('update')->with($date);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mockTree(UserSettings::class, ['agreeDate' => $setting]),
            $this->mockTree(Provide::class, [
                'document' => $this->mockMethod(ProvideDocument::class, 'chooseDocumentFor', [$user], new Ok($document)),
                'history' => $history,
            ]),
            $this->mockTree(Clock::class, ['now' => $date])
        );

        $instance->acceptMatchingDocument();
    }

testAcceptVersionError()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testAcceptVersionError

(

)

Definition at line 277 of file UserTest.php.

References ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\ensureDefined(), and null.

                                            : void
    {
        $this->ensureDefined('ANONYMOUS_USER_ID', 13);
        $this->ensureDefined('SYSTEM_USER_ID', 9);

        $user = $this->mockTree(ilObjUser::class, ['getId' => 67]);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mockTree(UserSettings::class, ['agreeDate' => ['value' => null]]),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $result = $instance->acceptedVersion();
        $this->assertFalse($result->isOk());
        $this->assertSame('User never agreed.', $result->error());
    }

Here is the call graph for this function:

testAgreeDate()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testAgreeDate

(

)

Definition at line 138 of file UserTest.php.

References ILIAS\$setting.

                                   : void
    {
        $setting = $this->mock(Setting::class);

        $instance = new User(
            $this->mock(ilObjUser::class),
            $this->mock(Settings::class),
            $this->mockMethod(UserSettings::class, 'agreeDate', [], $setting),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertSame($setting, $instance->agreeDate());
    }

testCannotAgree()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testCannotAgree

(

)

Definition at line 80 of file UserTest.php.

References ANONYMOUS_USER_ID, ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\ensureDefined(), and SYSTEM_USER_ID.

                                     : void
    {
        $this->ensureDefined('ANONYMOUS_USER_ID', 13);
        $this->ensureDefined('SYSTEM_USER_ID', 9);

        $user = $this->mock(ilObjUser::class);
        $user->expects(self::exactly(5))->method('getId')->willReturnOnConsecutiveCalls(0, ANONYMOUS_USER_ID, SYSTEM_USER_ID, 1, 68);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertTrue($instance->cannotAgree());
        $this->assertTrue($instance->cannotAgree());
        $this->assertTrue($instance->cannotAgree());
        $this->assertFalse($instance->cannotAgree());
        $this->assertFalse($instance->cannotAgree());
    }

Here is the call graph for this function:

testConstruct()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testConstruct

(

)

Definition at line 47 of file UserTest.php.

                                   : void
    {
        $this->assertInstanceOf(User::class, new User(
            $this->mock(ilObjUser::class),
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        ));
    }

testDidNotAcceptCurrentVersion()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testDidNotAcceptCurrentVersion

(

)

Definition at line 153 of file UserTest.php.

                                                    : void
    {
        $user = $this->mock(ilObjUser::class);
        $document = $this->mock(Document::class);

        $instance = new User(
            $user,
            $this->mockTree(Settings::class, ['validateOnLogin' => ['value' => true]]),
            $this->mock(UserSettings::class),
            $this->mockTree(Provide::class, [
                'document' => $this->mockMethod(ProvideDocument::class, 'chooseDocumentFor', [$user], new Ok($document)),
                'history' => $this->mockMethod(ProvideHistory::class, 'alreadyAccepted', [$user, $document], false),
            ]),
            $this->mock(Clock::class)
        );

        $this->assertTrue($instance->didNotAcceptCurrentVersion());
    }

testDoesntMatch()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testDoesntMatch

(

)

Definition at line 221 of file UserTest.php.

                                     : void
    {
        $document = $this->mock(Document::class);
        $user = $this->mock(ilObjUser::class);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mockTree(Provide::class, [
                'document' => $this->mockMethod(ProvideDocument::class, 'documentMatches', [$document, $user], true),
            ]),
            $this->mock(Clock::class)
        );

        $this->assertFalse($instance->doesntMatch($document));
    }

testFormat()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testFormat

(

)

Definition at line 352 of file UserTest.php.

                                : void
    {
        $instance = new User(
            $this->mockTree(ilObjUser::class, [
                'getFullname' => 'foo',
                'getLogin' => 'bar',
                'getExternalAccount' => 'baz',
            ]),
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertSame('', $instance->format(''));
        $this->assertSame("hej foo bar\nbaz", $instance->format('hej %s %s[BR]%s'));
    }

testIsExternalUser()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testIsExternalUser	(	int	$auth_mode,
		bool	$is_external_account
	)

externalAuthModes

Definition at line 339 of file UserTest.php.

                                                                                 : void
    {
        $instance = new User(
            $this->mockTree(ilObjUser::class, ['getAuthMode' => 'default']),
            $this->mockTree(Settings::class, ['authMode' => ['value' => (string) $auth_mode]]),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertSame($is_external_account, $instance->isExternalAccount());
    }

testIsLDAPUser()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testIsLDAPUser

(

)

Definition at line 323 of file UserTest.php.

References ilAuthUtils\AUTH_LDAP.

                                    : void
    {
        $instance = new User(
            $this->mockTree(ilObjUser::class, ['getAuthMode' => 'default']),
            $this->mockTree(Settings::class, ['authMode' => ['value' => (string) ilAuthUtils::AUTH_LDAP]]),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertTrue($instance->isLDAPUser());
    }

testIsLoggedIn()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testIsLoggedIn

(

)

Definition at line 58 of file UserTest.php.

References ANONYMOUS_USER_ID, and ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest\ensureDefined().

                                    : void
    {
        $this->ensureDefined('ANONYMOUS_USER_ID', 13);

        $user = $this->mock(ilObjUser::class);
        $user->expects(self::exactly(5))->method('getId')->willReturnOnConsecutiveCalls(0, ANONYMOUS_USER_ID, 9, 1, 68);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertFalse($instance->isLoggedIn());
        $this->assertFalse($instance->isLoggedIn());
        $this->assertTrue($instance->isLoggedIn());
        $this->assertTrue($instance->isLoggedIn());
        $this->assertTrue($instance->isLoggedIn());
    }

Here is the call graph for this function:

testMatchingDocument()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testMatchingDocument

(

)

Definition at line 239 of file UserTest.php.

                                          : void
    {
        $user = $this->mock(ilObjUser::class);
        $result = $this->mock(Result::class);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mockTree(Provide::class, [
                'document' => $this->mockMethod(ProvideDocument::class, 'chooseDocumentFor', [$user], $result),
            ]),
            $this->mock(Clock::class)
        );

        $this->assertSame($result, $instance->matchingDocument());
    }

testNeedsToAcceptNewDocumentReturnsFalse()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testNeedsToAcceptNewDocumentReturnsFalse

(

)

Definition at line 201 of file UserTest.php.

                                                              : void
    {
        $user = $this->mock(ilObjUser::class);
        $document = $this->mock(Document::class);
        $history = $this->mockMethod(ProvideHistory::class, 'currentDocumentOfAcceptedVersion', [$user], new Ok($document));

        $instance = new User(
            $user,
            $this->mockTree(Settings::class, ['validateOnLogin' => ['value' => true]]),
            $this->mockTree(UserSettings::class, ['agreeDate' => ['value' => new DateTimeImmutable()]]),
            $this->mockTree(Provide::class, [
                'document' => $this->mockMethod(ProvideDocument::class, 'documentMatches', [$document, $user], true),
                'history' => $history,
            ]),
            $this->mock(Clock::class)
        );

        $this->assertFalse($instance->needsToAcceptNewDocument());
    }

testNeedsToAcceptNewDocumentReturnsTrue()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testNeedsToAcceptNewDocumentReturnsTrue

(

)

Definition at line 185 of file UserTest.php.

                                                             : void
    {
        $user = $this->mock(ilObjUser::class);
        $history = $this->mockMethod(ProvideHistory::class, 'currentDocumentOfAcceptedVersion', [$user], new Error('Not found.'));

        $instance = new User(
            $user,
            $this->mockTree(Settings::class, ['validateOnLogin' => ['value' => true]]),
            $this->mockTree(UserSettings::class, ['agreeDate' => ['value' => new DateTimeImmutable()]]),
            $this->mockTree(Provide::class, ['history' => $history]),
            $this->mock(Clock::class)
        );

        $this->assertTrue($instance->needsToAcceptNewDocument());
    }

testNeedsToAcceptNewDocumentWhereNeverAgreed()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testNeedsToAcceptNewDocumentWhereNeverAgreed

(

)

Definition at line 172 of file UserTest.php.

References null.

                                                                  : void
    {
        $instance = new User(
            $this->mock(ilObjUser::class),
            $this->mock(Settings::class),
            $this->mockTree(UserSettings::class, ['agreeDate' => ['value' => null]]),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertTrue($instance->needsToAcceptNewDocument());
    }

testNeverAgreed()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testNeverAgreed

(

)

Definition at line 103 of file UserTest.php.

References ILIAS\$setting, and null.

                                     : void
    {
        $setting = $this->mock(Setting::class);
        $setting->expects(self::exactly(2))->method('value')->willReturnOnConsecutiveCalls(null, new DateTimeImmutable());

        $user_settings = $this->mock(UserSettings::class);
        $user_settings->expects(self::exactly(2))->method('agreeDate')->willReturn($setting);

        $instance = new User(
            $this->mock(ilObjUser::class),
            $this->mock(Settings::class),
            $user_settings,
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertTrue($instance->neverAgreed());
        $this->assertFalse($instance->neverAgreed());
    }

testRaw()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testRaw

(

)

Definition at line 370 of file UserTest.php.

                             : void
    {
        $user = $this->mock(ilObjUser::class);

        $instance = new User(
            $user,
            $this->mock(Settings::class),
            $this->mock(UserSettings::class),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertSame($user, $instance->raw());
    }

testWithdrawalRequested()

ILIAS\LegalDocuments\test\ConsumerToolbox\UserTest::testWithdrawalRequested

(

)

Definition at line 123 of file UserTest.php.

References ILIAS\$setting.

                                             : void
    {
        $setting = $this->mock(Setting::class);

        $instance = new User(
            $this->mock(ilObjUser::class),
            $this->mock(Settings::class),
            $this->mockMethod(UserSettings::class, 'withdrawalRequested', [], $setting),
            $this->mock(Provide::class),
            $this->mock(Clock::class)
        );

        $this->assertSame($setting, $instance->withdrawalRequested());
    }

---

The documentation for this class was generated from the following file:

• components/ILIAS/LegalDocuments/tests/ConsumerToolbox/UserTest.php