ProvideHistoryTest.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\LegalDocuments\test\Provide;

use ILIAS\Data\Result;
use ILIAS\UI\Component\Legacy;
use ILIAS\LegalDocuments\Legacy\Table as LegacyTable;
use ILIAS\LegalDocuments\Table as TableInterface;
use ILIAS\LegalDocuments\Table\HistoryTable;
use ILIAS\UI\Factory as UIFactory;
use ILIAS\LegalDocuments\Repository\HistoryRepository;
use ILIAS\LegalDocuments\Value\Document;
use ILIAS\LegalDocuments\test\ContainerMock;
use ILIAS\DI\Container;
use ILIAS\LegalDocuments\Provide\ProvideDocument;
use PHPUnit\Framework\TestCase;
use ILIAS\LegalDocuments\Provide\ProvideHistory;
use ilObjUser;
use ilGlobalTemplateInterface;
use ilLanguage;
use stdClass;
use ilCtrl;

require_once __DIR__ . '/../ContainerMock.php';

class ProvideHistoryTest extends TestCase
{
    use ContainerMock;

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

    public function testTable(): void
    {
        $dummy_gui = new stdClass();
        $legacy = $this->mock(Legacy\Content::class);
        $legacy_factory = $this->mock(Legacy\Factory::class);
        $legacy_factory
            ->expects($this->once())
            ->method('content')
            ->willReturn($legacy);

        $table = $this->mockMethod(LegacyTable::class, 'getHTML', [], 'table html');

        $container = $this->mockTree(Container::class, [
            'ctrl' => $this->mock(ilCtrl::class),
            'language' => $this->mock(ilLanguage::class),
            'ui' => [
                'factory' => $this->mockMethod(UIFactory::class, 'legacy', [], $legacy_factory),
                'mainTemplate' => $this->mock(ilGlobalTemplateInterface::class)
            ],
        ]);

        $create_table_gui = function (object $gui, string $command, TableInterface $t) use ($dummy_gui, $table): LegacyTable {
            $this->assertSame($dummy_gui, $gui);
            $this->assertSame('dummy command', $command);
            $this->assertInstanceOf(HistoryTable::class, $t);
            return $table;
        };

        $instance = new ProvideHistory('foo', $this->mock(HistoryRepository::class), $this->mock(ProvideDocument::class), $container, $create_table_gui);

        $this->assertSame($legacy, $instance->table($dummy_gui, 'dummy command', 'reset command', 'auto complete command'));
    }

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

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

        $instance = new ProvideHistory('foo', $repository, $this->mock(ProvideDocument::class), $this->mock(Container::class));
        $instance->acceptDocument($user, $document);
    }

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

        $repository = $this->mockMethod(HistoryRepository::class, 'alreadyAccepted', [$user, $document], true);

        $instance = new ProvideHistory('foo', $repository, $this->mock(ProvideDocument::class), $this->mock(Container::class));
        $this->assertTrue($instance->alreadyAccepted($user, $document));
    }

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

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

        $repository = $this->mockMethod(HistoryRepository::class, 'acceptedVersion', [$user], $result);

        $instance = new ProvideHistory('foo', $repository, $this->mock(ProvideDocument::class), $this->mock(Container::class));
        $this->assertSame($result, $instance->acceptedVersion($user));
    }

    public function testCurrentDocumentOfAcceptedVersion(): void
    {
        $user = $this->mock(ilObjUser::class);
        $result = $this->mock(Result::class);
        $repository = $this->mockMethod(HistoryRepository::class, 'currentDocumentOfAcceptedVersion', [$user], $result);
        $instance = new ProvideHistory('foo', $repository, $this->mock(ProvideDocument::class), $this->mock(Container::class));

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