ProvideTest.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\LegalDocuments\test;

use ILIAS\LegalDocuments\ConsumerSlots\PublicApi;
use ILIAS\LegalDocuments\Provide\ProvideHistory;
use ILIAS\LegalDocuments\Provide\ProvidePublicPage;
use ILIAS\LegalDocuments\Provide\ProvideDocument;
use ILIAS\LegalDocuments\Provide\ProvideWithdrawal;
use ILIAS\DI\Container;
use ILIAS\LegalDocuments\Internal;
use PHPUnit\Framework\TestCase;
use ILIAS\LegalDocuments\Provide;
use ilCtrl;
use ilAuthSession;

require_once __DIR__ . '/ContainerMock.php';

class ProvideTest extends TestCase
{
    use ContainerMock;

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

    public function testWithdrawal(): void
    {
        $container = $this->mockTree(Container::class, ['ctrl' => $this->mock(ilCtrl::class)]);
        $container->expects(self::once())->method('offsetGet')->with('ilAuthSession')->willReturn($this->mock(ilAuthSession::class));

        $instance = new Provide('foo', $this->mockMethod(Internal::class, 'get', ['withdraw'], 'foo'), $container);

        $this->assertInstanceOf(ProvideWithdrawal::class, $instance->withdrawal());
    }

    public function testPublicPage(): void
    {
        $container = $this->mockTree(Container::class, ['ctrl' => $this->mock(ilCtrl::class)]);

        $this->assertInstanceOf(ProvidePublicPage::class, (new Provide('foo', $this->mockMethod(
            Internal::class,
            'get',
            ['public-page', 'foo'],
            true
        ), $container))->publicPage());
    }

    public function testDocument(): void
    {
        $document = $this->mock(ProvideDocument::class);
        $internal = $this->mockMethod(Internal::class, 'get', ['document', 'foo'], $document);

        $instance = new Provide('foo', $internal, $this->mock(Container::class));
        $this->assertSame($document, $instance->document());
    }

    public function testHistory(): void
    {
        $history = $this->mock(ProvideHistory::class);
        $internal = $this->mockMethod(Internal::class, 'get', ['history', 'foo'], $history);

        $instance = new Provide('foo', $internal, $this->mock(Container::class));
        $this->assertSame($history, $instance->history());
    }

    public function testAllowEditing(): void
    {
        $document = $this->mock(ProvideDocument::class);

        $internal = $this->mock(Internal::class);
        $consecutive = [
            ['document', 'foo'],
            ['writable-document', 'foo']
        ];
        $internal
            ->expects(self::exactly(2))
            ->method('get')
            ->willReturnCallback(
                function ($a, $b) use (&$consecutive, $document) {
                    [$ea, $eb] = array_shift($consecutive);
                    $this->assertEquals($ea, $a);
                    $this->assertEquals($eb, $b);
                    return $document;
                }
            );

        $instance = new Provide('foo', $internal, $this->mock(Container::class));
        $instance->document();
        $instance->allowEditing()->document();
    }

    public function testPublicApi(): void
    {
        $public_api = $this->mock(PublicApi::class);
        $internal = $this->mockMethod(Internal::class, 'get', ['public-api', 'foo'], $public_api);

        $instance = new Provide('foo', $internal, $this->mock(Container::class));

        $this->assertSame($public_api, $instance->publicApi());
    }

    public function testId(): void
    {
        $this->assertSame('foo', (new Provide('foo', $this->mock(Internal::class), $this->mock(Container::class)))->id());
    }
}