ILIAS\LegalDocuments\test\ConductorTest Class Reference

Inheritance diagram for ILIAS\LegalDocuments\test\ConductorTest:

Collaboration diagram for ILIAS\LegalDocuments\test\ConductorTest:

Public Member Functions
	testConstruct ()
	testProvide ()
	testLoginPageHTML ()
	testLogoutText ()
	testModifyFooter ()
	testAgree (string $gui, string $key)
	testAgreeContent (string $gui, string $key)
	testRedirectAgreeContent ()
	testWithdraw ()
	testUsersWithHiddenOnlineStatus ()
	testUserCanReadInternalMail ()
	testCanUseSoapApi ()
	testAfterLogin ()
	testFindGotoLink ()
	testIntercepting ()
	testSelfRegistration ()
	testUserManagementFields ()

Static Public Member Functions
static	agreeTypes ()

Private Member Functions
	agreement (string $method, string $gui, string $key, ?ilGlobalTemplateInterface $main_template=null)

Detailed Description

Definition at line 54 of file ConductorTest.php.

Member Function Documentation

agreement()

ILIAS\LegalDocuments\test\ConductorTest::agreement ( string  $method, string  $gui, string  $key, ?ilGlobalTemplateInterface  $main_template = null  )

private

Definition at line 318 of file ConductorTest.php.

References $container.

Referenced by ILIAS\LegalDocuments\test\ConductorTest\testAgree(), ILIAS\LegalDocuments\test\ConductorTest\testAgreeContent(), and ILIAS\LegalDocuments\test\ConductorTest\testWithdraw().

    {
        $constraint = $this->mock(Constraint::class);

        $ctrl = $this->mock(ilCtrl::class);
        $ctrl->expects(self::once())->method('setParameterByClass')->with($gui, 'id', 'foo');

        $container = $this->mockTree(Container::class, [
            'refinery' => ['to' => ['string' => $constraint]],
            'http' => ['wrapper' => ['query' => $this->mockMethod(ArrayBasedRequestWrapper::class, 'retrieve', ['id', $constraint], 'foo')]],
            'ui' => [
                'mainTemplate' => $main_template ?? $this->mock(ilGlobalTemplateInterface::class),
                'renderer' => $this->mock(Renderer::class),
            ],
            'ctrl' => $ctrl,
        ]);

        $fragment = $this->mockMethod(PageFragment::class, 'render', [$container->ui()->mainTemplate(), $container->ui()->renderer()], 'rendered');

        $internal = $this->mockMethod(Internal::class, 'get', [$key, 'foo'], function (string $g, string $cmd) use ($fragment, $gui): Result {
            $this->assertSame($gui, $g);
            $this->assertSame('some cmd', $cmd);
            return new Ok($fragment);
        });

        $instance = new Conductor($container, $internal, $this->mock(Routing::class));

        return $instance->$method($gui, 'some cmd');
    }

Here is the caller graph for this function:

agreeTypes()

static ILIAS\LegalDocuments\test\ConductorTest::agreeTypes ( )

static

Definition at line 310 of file ConductorTest.php.

                                       : array
    {
        return [
            'Form type' => [ilLegalDocumentsAgreementGUI::class, 'agreement-form'],
            'Public type' => ['foo', 'public-page'],
        ];
    }

testAfterLogin()

ILIAS\LegalDocuments\test\ConductorTest::testAfterLogin

(

)

Definition at line 234 of file ConductorTest.php.

                                    : void
    {
        $called = [false, false];

        $internal = $this->mockMethod(Internal::class, 'all', ['after-login'], [
            function () use (&$called): void {
                $called[0] = true;
            },
            function () use (&$called): void {
                $called[1] = true;
            }
        ]);

        $instance = new Conductor($this->mock(Container::class), $internal, $this->mock(Routing::class));

        $instance->afterLogin();

        $this->assertSame([true, true], $called);
    }

testAgree()

ILIAS\LegalDocuments\test\ConductorTest::testAgree	(	string	$gui,
		string	$key
	)

Definition at line 141 of file ConductorTest.php.

References ILIAS\LegalDocuments\test\ConductorTest\agreement().

                                                       : void
    {
        $main_template = $this->mock(ilGlobalTemplateInterface::class);
        $main_template->expects(self::once())->method('setContent')->with('rendered');
        $this->agreement('agree', $gui, $key, $main_template);
    }

Here is the call graph for this function:

testAgreeContent()

ILIAS\LegalDocuments\test\ConductorTest::testAgreeContent	(	string	$gui,
		string	$key
	)

Definition at line 149 of file ConductorTest.php.

References ILIAS\LegalDocuments\test\ConductorTest\agreement().

                                                              : void
    {
        $this->assertSame('rendered', $this->agreement('agreeContent', $gui, $key));
    }

Here is the call graph for this function:

testCanUseSoapApi()

ILIAS\LegalDocuments\test\ConductorTest::testCanUseSoapApi

(

)

Definition at line 217 of file ConductorTest.php.

References $container.

                                       : void
    {
        $constraints = [
            'foo' => $this->mock(Constraint::class),
            'bar' => $this->mock(Constraint::class),
        ];

        $container = $this->mockTree(Container::class, [
            'refinery' => ['in' => $this->mockMethod(InGroup::class, 'series', [array_values($constraints)], $this->mock(Transformation::class))]
        ]);

        $internal = $this->mockMethod(Internal::class, 'all', ['use-soap-api'], $constraints);

        $instance = new Conductor($container, $internal, $this->mock(Routing::class));
        $this->assertInstanceOf(Transformation::class, $instance->canUseSoapApi());
    }

testConstruct()

ILIAS\LegalDocuments\test\ConductorTest::testConstruct

(

)

Definition at line 58 of file ConductorTest.php.

                                   : void
    {
        $this->assertInstanceOf(Conductor::class, new Conductor($this->mock(Container::class), $this->mock(Internal::class), $this->mock(Routing::class)));
    }

testFindGotoLink()

ILIAS\LegalDocuments\test\ConductorTest::testFindGotoLink

(

)

Definition at line 254 of file ConductorTest.php.

References Vendor\Package\$foo.

                                      : void
    {
        $foo = $this->mock(Target::class);
        $internal = $this->mockMethod(Internal::class, 'all', ['goto'], [
            $this->mockTree(GotoLink::class, ['name' => 'bar']),
            $this->mockTree(GotoLink::class, ['name' => 'foo', 'target' => $foo]),
        ]);

        $instance = new Conductor($this->mock(Container::class), $internal, $this->mock(Routing::class));

        $target = $instance->findGotoLink('foo');
        $this->assertTrue($target->isOk());
        $this->assertSame($foo, $target->value());
    }

testIntercepting()

ILIAS\LegalDocuments\test\ConductorTest::testIntercepting

(

)

Definition at line 270 of file ConductorTest.php.

                                      : void
    {
        $intercepting = [
            'foo' => $this->mock(Intercept::class),
            'bar' => $this->mock(Intercept::class)
        ];

        $internal = $this->mockMethod(Internal::class, 'all', ['intercept'], $intercepting);

        $instance = new Conductor($this->mock(Container::class), $internal, $this->mock(Routing::class));
        $this->assertSame($intercepting, $instance->intercepting());
    }

testLoginPageHTML()

ILIAS\LegalDocuments\test\ConductorTest::testLoginPageHTML

(

)

Definition at line 69 of file ConductorTest.php.

References $components, $container, and $space.

                                       : void
    {
        $components = [
            $this->mock(Component::class),
            $this->mock(Component::class),
        ];

        $space = $this->mock(Content::class);

        $container = $this->mockTree(Container::class, [
            'ui' => [
                'renderer' => $this->mockMethod(Renderer::class, 'render', [
                    $components,
                ], 'rendered'),
            ],
        ]);

        $internal = $this->mockMethod(Internal::class, 'get', ['show-on-login-page', 'foo'], fn() => $components);

        $instance = new Conductor($container, $internal, $this->mock(Routing::class));

        $this->assertSame('rendered', $instance->loginPageHTML('foo'));
    }

testLogoutText()

ILIAS\LegalDocuments\test\ConductorTest::testLogoutText

(

)

Definition at line 93 of file ConductorTest.php.

References $container, and null.

                                    : void
    {
        $constraint = $this->mock(Constraint::class);
        $component = $this->mock(Component::class);

        $container = $this->mockTree(Container::class, [
            'refinery' => ['to' => ['string' => $constraint]],
            'http' => ['wrapper' => ['query' => $this->mockMethod(ArrayBasedRequestWrapper::class, 'retrieve', ['withdraw_consent', $constraint], 'foo')]],
            'ui' => ['renderer' => $this->mockMethod(Renderer::class, 'render', [$component], 'rendered')],
        ]);


        $internal = $this->mock(Internal::class);
        $internal->method('get')->willReturnCallback(function ($param1, $param2) use (&$called, $component) {
            if ($param1 === 'logout-text' && $param2 === 'foo') {
                return static function () use ($component): Component {
                    return $component;
                };
            }

            return null;
        });

        $instance = new Conductor($container, $internal, $this->mock(Routing::class));

        $logoutText = $instance->logoutText();

        $this->assertSame('rendered', $logoutText);
    }

testModifyFooter()

ILIAS\LegalDocuments\test\ConductorTest::testModifyFooter

(

)

Definition at line 123 of file ConductorTest.php.

References Vendor\Package\$f, and null.

                                      : void
    {
        $footer = fn() => null;

        $modify_footer = function (Closure $f) use ($footer) {
            $this->assertSame($footer, $f);
            return $f;
        };

        $instance = new Conductor($this->mock(Container::class), $this->mockMethod(Internal::class, 'all', ['footer'], [
            $modify_footer,
            $modify_footer,
        ]), $this->mock(Routing::class));

        $this->assertSame($footer, $instance->modifyFooter($footer));
    }

testProvide()

ILIAS\LegalDocuments\test\ConductorTest::testProvide

(

)

Definition at line 63 of file ConductorTest.php.

                                 : void
    {
        $instance = new Conductor($this->mock(Container::class), $this->mock(Internal::class), $this->mock(Routing::class));
        $this->assertInstanceOf(Provide::class, $instance->provide('foo'));
    }

testRedirectAgreeContent()

ILIAS\LegalDocuments\test\ConductorTest::testRedirectAgreeContent

(

)

Definition at line 154 of file ConductorTest.php.

References $container.

                                              : void
    {
        $this->expectExceptionMessage('Not available.');
        $routing = $this->mock(Routing::class);
        $routing->expects(self::once())->method('redirectToOriginalTarget');
        $constraint = $this->mock(Constraint::class);
        $container = $this->mockTree(Container::class, [
            'refinery' => ['to' => ['string' => $constraint]],
            'http' => ['wrapper' => ['query' => $this->mockMethod(ArrayBasedRequestWrapper::class, 'retrieve', ['id', $constraint], 'foo')]],
        ]);
        $internal = $this->mock(Internal::class);
        $internal = $this->mockMethod(Internal::class, 'get', ['agreement-form', 'foo'], function (string $g, string $cmd): Result {
            return new Error('Not available.');
        });
        $instance = new Conductor($container, $internal, $routing);
        $instance->agreeContent(ilLegalDocumentsAgreementGUI::class, 'foo');
    }

testSelfRegistration()

ILIAS\LegalDocuments\test\ConductorTest::testSelfRegistration

(

)

Definition at line 283 of file ConductorTest.php.

                                          : void
    {
        $internal = $this->mockMethod(Internal::class, 'all', ['self-registration'], [
            $this->mock(SelfRegistration::class),
        ]);

        $instance = new Conductor($this->mock(Container::class), $internal, $this->mock(Routing::class));

        $this->assertInstanceOf(Bundle::class, $instance->selfRegistration());
    }

testUserCanReadInternalMail()

ILIAS\LegalDocuments\test\ConductorTest::testUserCanReadInternalMail

(

)

Definition at line 193 of file ConductorTest.php.

References $container.

                                                 : void
    {
        $constraints = [
            'foo' => $this->mock(Constraint::class),
            'bar' => $this->mock(Constraint::class),
        ];

        $series = $this->mock(Transformation::class);

        $container = $this->mockTree(Container::class, [
            'refinery' => ['in' => $this->mockMethod(
                InGroup::class,
                'series',
                [array_values($constraints)],
                $series
            )],
        ]);

        $internal = $this->mockMethod(Internal::class, 'all', ['constrain-internal-mail'], $constraints);

        $instance = new Conductor($container, $internal, $this->mock(Routing::class));
        $this->assertSame($series, $instance->userCanReadInternalMail());
    }

testUserManagementFields()

ILIAS\LegalDocuments\test\ConductorTest::testUserManagementFields

(

)

Definition at line 294 of file ConductorTest.php.

                                              : void
    {
        $internal = $this->mockMethod(Internal::class, 'all', ['user-management-fields'], [
            fn() => ['foo' => 'bar', 'baz' => 'hej'],
            fn() => ['hoo' => 'har'],
        ]);

        $instance = new Conductor($this->mock(Container::class), $internal, $this->mock(Routing::class));

        $this->assertSame([
            'foo' => 'bar',
            'baz' => 'hej',
            'hoo' => 'har',
        ], $instance->userManagementFields($this->mock(ilObjUser::class)));
    }

testUsersWithHiddenOnlineStatus()

ILIAS\LegalDocuments\test\ConductorTest::testUsersWithHiddenOnlineStatus

(

)

Definition at line 179 of file ConductorTest.php.

                                                     : void
    {
        $internal = $this->mockMethod(Internal::class, 'all', ['filter-online-users'], [
            fn() => [4, 5, 6],
            fn() => [5, 6],
        ]);
        $instance = new Conductor($this->mock(Container::class), $internal, $this->mock(Routing::class));

        $this->assertSame(
            [1, 2, 3, 4, 7, 8, 9],
            $instance->usersWithHiddenOnlineStatus([1, 2, 3, 4, 5, 6, 7, 8, 9])
        );
    }

testWithdraw()

ILIAS\LegalDocuments\test\ConductorTest::testWithdraw

(

)

Definition at line 172 of file ConductorTest.php.

References ILIAS\LegalDocuments\test\ConductorTest\agreement().

                                  : void
    {
        $main_template = $this->mock(ilGlobalTemplateInterface::class);
        $main_template->expects(self::once())->method('setContent')->with('rendered');
        $this->agreement('withdraw', 'foo', 'withdraw', $main_template);
    }

Here is the call graph for this function:

---

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

• components/ILIAS/LegalDocuments/tests/ConductorTest.php