ConductorTest.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\LegalDocuments\test;

use ILIAS\LegalDocuments\ConsumerSlots\SelfRegistration\Bundle;
use ILIAS\LegalDocuments\ConsumerSlots\SelfRegistration;
use ILIAS\LegalDocuments\Intercept;
use ILIAS\LegalDocuments\Value\Target;
use ILIAS\LegalDocuments\GotoLink;
use ILIAS\Refinery\Constraint;
use ILIAS\Refinery\In\Group as InGroup;
use ILIAS\Refinery\Transformation;
use ILIAS\Data\Result;
use ILIAS\Data\Result\Ok;
use ILIAS\LegalDocuments\PageFragment;
use ILIAS\UI\Renderer;
use ILIAS\UI\Component\Component;
use ILIAS\UI\Component\Legacy\Content;
use ILIAS\HTTP\Wrapper\ArrayBasedRequestWrapper;
use ILIAS\LegalDocuments\Provide;
use ILIAS\LegalDocuments\Internal;
use ILIAS\DI\Container;
use PHPUnit\Framework\TestCase;
use ILIAS\LegalDocuments\Conductor;
use ilCtrl;
use ilLegalDocumentsAgreementGUI;
use ilGlobalTemplateInterface;
use ilObjUser;
use ILIAS\LegalDocuments\ConsumerToolbox\Routing;
use ILIAS\Data\Result\Error;
use Closure;
use PHPUnit\Framework\Attributes\DataProvider;

require_once __DIR__ . '/ContainerMock.php';

class ConductorTest extends TestCase
{
    use ContainerMock;

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

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

    public function testLoginPageHTML(): 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'));
    }

    public function testLogoutText(): 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);
    }

    public function testModifyFooter(): 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));
    }

    #[DataProvider('agreeTypes')]
    public function testAgree(string $gui, string $key): void
    {
        $main_template = $this->mock(ilGlobalTemplateInterface::class);
        $main_template->expects(self::once())->method('setContent')->with('rendered');
        $this->agreement('agree', $gui, $key, $main_template);
    }

    #[DataProvider('agreeTypes')]
    public function testAgreeContent(string $gui, string $key): void
    {
        $this->assertSame('rendered', $this->agreement('agreeContent', $gui, $key));
    }

    public function testRedirectAgreeContent(): 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');
    }

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

    public function testUsersWithHiddenOnlineStatus(): 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])
        );
    }

    public function testUserCanReadInternalMail(): 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());
    }

    public function testCanUseSoapApi(): 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());
    }

    public function testAfterLogin(): 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);
    }

    public function testFindGotoLink(): 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());
    }


    public function testIntercepting(): 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());
    }

    public function testSelfRegistration(): 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());
    }

    public function testUserManagementFields(): 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)));
    }

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

    private function agreement(string $method, string $gui, string $key, ?ilGlobalTemplateInterface $main_template = null)
    {
        $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');
    }
}