Inheritance diagram for ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest:

Collaboration diagram for ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest:

Public Member Functions
	testConstruct ()

	testTableReadOnly ()

	testTableEditable ()

	testChooseDocumentFor ()

	testDocumentMatches ()

	testRepository ()

	testHash ()

	testToCondition ()

	testConditionGroupsWithoutContent ()

	testConditionGroups ()

	testValidateCriteriaContent ()

	testDuplicateCriteriaContent ()

	testNeverMatchingCriteriaContent ()

	testContentAsComponent ()

Detailed Description

Definition at line 56 of file ProvideDocumentTest.php.

Member Function Documentation

◆ testChooseDocumentFor()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testChooseDocumentFor ( )

Definition at line 117 of file ProvideDocumentTest.php.

                                           : void
    {
        $document = $this->mockMethod(Document::class, 'criteria', [], []);
        $user = $this->mock(ilObjUser::class);
 
        $criterion = $this->mockTree(Criterion::class, ['content' => ['type' => 'bar']]);
 
        $repository = $this->mockMethod(DocumentRepository::class, 'all', [], [
            $this->mockMethod(Document::class, 'criteria', [], [$criterion]),
            $document,
        ]);
 
        $instance = new ProvideDocument('foo', $repository, new SelectionMap([
            'bar' => $this->mockMethod(ConditionDefinition::class, 'withCriterion', [$criterion->content()], $this->mockMethod(
                Condition::class,
                'eval',
                [$user],
                false
            )),
        ]), [], $this->mock(Container::class));
        $result = $instance->chooseDocumentFor($user);
        $this->assertTrue($result->isOk());
        $this->assertSame($document, $result->value());
    }

◆ testConditionGroups()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testConditionGroups ( )

Definition at line 199 of file ProvideDocumentTest.php.

                                         : void
    {
        $group = $this->mock(Group::class);
        $content = $this->mockTree(CriterionContent::class, [
            'type' => 'baz',
            'arguments' => ['a', 'b', 'c'],
        ]);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap([
            'bar' => $this->mockMethod(ConditionDefinition::class, 'formGroup', [[]], $group),
            'baz' => $this->mockMethod(ConditionDefinition::class, 'formGroup', [$content->arguments()], $group),
        ]), [], $this->mock(Container::class));
 
        $this->assertSame(['bar' => $group, 'baz' => $group], $instance->conditionGroups($content)->choices());
    }

◆ testConditionGroupsWithoutContent()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testConditionGroupsWithoutContent ( )

Definition at line 187 of file ProvideDocumentTest.php.

                                                       : void
    {
        $group = $this->mock(Group::class);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap([
            'bar' => $this->mockMethod(ConditionDefinition::class, 'formGroup', [[]], $group),
            'baz' => $this->mockMethod(ConditionDefinition::class, 'formGroup', [[]], $group),
        ]), [], $this->mock(Container::class));
 
        $this->assertSame(['bar' => $group, 'baz' => $group], $instance->conditionGroups()->choices());
    }

◆ testConstruct()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testConstruct ( )

Definition at line 60 of file ProvideDocumentTest.php.

                                   : void
    {
        $this->assertInstanceOf(ProvideDocument::class, new ProvideDocument(
            'foo',
            $this->mock(DocumentRepository::class),
            new SelectionMap(),
            [],
            $this->mockTree(Container::class, ['user' => ['getTimeZone' => 'europe/berlin']])
        ));
    }

◆ testContentAsComponent()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testContentAsComponent ( )

Definition at line 278 of file ProvideDocumentTest.php.

                                            : void
    {
        $content = $this->mockTree(DocumentContent::class, ['type' => 'html']);
        $component = $this->mock(Component::class);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap(), [
            'html' => function (DocumentContent $c) use ($content, $component): Component {
                $this->assertSame($content, $c);
                return $component;
            }
        ], $this->mock(Container::class));
 
        $this->assertSame($component, $instance->contentAsComponent($content));
    }

References $c.

◆ testDocumentMatches()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testDocumentMatches ( )

Definition at line 142 of file ProvideDocumentTest.php.

                                         : void
    {
        $criterion = $this->mockTree(Criterion::class, ['content' => ['type' => 'bar']]);
        $document = $this->mockMethod(Document::class, 'criteria', [], [$criterion]);
        $user = $this->mock(ilObjUser::class);
 
        $instance = new ProvideDocument('doo', $this->mock(DocumentRepository::class), new SelectionMap([
            'bar' => $this->mockMethod(ConditionDefinition::class, 'withCriterion', [$criterion->content()], $this->mockMethod(
                Condition::class,
                'eval',
                [$user],
                true
            )),
        ]), [], $this->mock(Container::class));
 
        $this->assertTrue($instance->documentMatches($document, $user));
    }

◆ testDuplicateCriteriaContent()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testDuplicateCriteriaContent ( )

Definition at line 246 of file ProvideDocumentTest.php.

                                                  : void
    {
        $content = new CriterionContent('foo', ['bar']);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap(), [], $this->mock(Container::class));
        $result = $instance->validateCriteriaContent([
            $this->mockTree(Criterion::class, ['content' => new CriterionContent('foo', ['bar'])])
        ], $content);
        $this->assertFalse($result->isOk());
        $this->assertSame(ProvideDocument::CRITERION_ALREADY_EXISTS, $result->error());
    }

References ILIAS\LegalDocuments\Provide\ProvideDocument\CRITERION_ALREADY_EXISTS.

◆ testHash()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testHash ( )

Definition at line 167 of file ProvideDocumentTest.php.

                              : void
    {
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap(), [], $this->mock(Container::class));
        $hash = $instance->hash();
        $this->assertTrue(is_string($hash));
        $this->assertSame(254, strlen($hash));
    }

◆ testNeverMatchingCriteriaContent()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testNeverMatchingCriteriaContent ( )

Definition at line 258 of file ProvideDocumentTest.php.

                                                      : void
    {
        $content = new CriterionContent('foo', ['bar']);
        $existing_content = new CriterionContent('hoo', ['haz']);
 
        $condition = $this->mock(Condition::class);
        $condition->expects(self::once())->method('knownToNeverMatchWith')->with($condition)->willReturn(true);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap([
            'hoo' => $this->mockMethod(ConditionDefinition::class, 'withCriterion', [$existing_content], $condition),
            'foo' => $this->mockMethod(ConditionDefinition::class, 'withCriterion', [$content], $condition),
        ]), [], $this->mock(Container::class));
 
        $result = $instance->validateCriteriaContent([
            $this->mockTree(Criterion::class, ['content' => $existing_content]),
        ], $content);
        $this->assertFalse($result->isOk());
        $this->assertSame(ProvideDocument::CRITERION_WOULD_NEVER_MATCH, $result->error());
    }

References ILIAS\LegalDocuments\Provide\ProvideDocument\CRITERION_WOULD_NEVER_MATCH.

◆ testRepository()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testRepository ( )

Definition at line 160 of file ProvideDocumentTest.php.

                                    : void
    {
        $repository = $this->mock(DocumentRepository::class);
        $instance = new ProvideDocument('foo', $repository, new SelectionMap(), [], $this->mock(Container::class));
        $this->assertSame($repository, $instance->repository());
    }

◆ testTableEditable()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testTableEditable ( )

Definition at line 92 of file ProvideDocumentTest.php.

                                       : void
    {
        if (!defined('ILIAS_HTTP_PATH')) {
            define('ILIAS_HTTP_PATH', 'http://localhost');
        }
 
        $dummy_gui = new stdClass();
 
        $uri = 'http://myIlias/ilias.php?baseClass=iladministrationgui&cmdNode=2g:qo:gq&cmdClass=ilLegalDocumentsAdministrationGUI&cmd=documents&ref_id=50';
 
        $container = $this->mockTree(Container::class, [
            'ui' => [
                'factory' => ['table' => ['action' => ['multi' => []]]],
                'mainTemplate' => [],
            ],
            'language' => [],
            'http' => ['request' => ['getUri' => ['__toString' => $uri]]],
            'ctrl' => [],
            'user' => ['getTimeZone' => 'europe/berlin'],
        ]);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap(), [], $container);
        $this->assertInstanceOf(DocumentTable::class, $instance->table($dummy_gui, $this->mock(EditLinks::class)));
    }

References $container.

◆ testTableReadOnly()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testTableReadOnly ( )

Definition at line 71 of file ProvideDocumentTest.php.

                                       : void
    {
        $dummy_gui = new stdClass();
 
        $uri = 'http://myIlias/ilias.php?baseClass=iladministrationgui&cmdNode=2g:qo:gq&cmdClass=ilLegalDocumentsAdministrationGUI&cmd=documents&ref_id=50';
 
        $container = $this->mockTree(Container::class, [
            'ui' => [
                'factory' => [],
                'mainTemplate' => [],
            ],
            'language' => [],
            'http' => ['request' => ['getUri' => ['__toString' => $uri]]],
            'ctrl' => [],
            'user' => ['getTimeZone' => 'europe/berlin'],
        ]);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap(), [], $container);
        $this->assertInstanceOf(DocumentTable::class, $instance->table($dummy_gui));
    }

References $container.

◆ testToCondition()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testToCondition ( )

Definition at line 175 of file ProvideDocumentTest.php.

                                     : void
    {
        $condition = $this->mock(Condition::class);
        $content = $this->mockMethod(CriterionContent::class, 'type', [], 'bar');
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap([
            'bar' => $this->mockMethod(ConditionDefinition::class, 'withCriterion', [$content], $condition),
        ]), [], $this->mock(Container::class));
 
        $this->assertSame($condition, $instance->toCondition($content));
    }

◆ testValidateCriteriaContent()

ILIAS\LegalDocuments\test\Provide\ProvideDocumentTest::testValidateCriteriaContent ( )

Definition at line 215 of file ProvideDocumentTest.php.

                                                 : void
    {
        $content = new CriterionContent('foo', ['bar']);
        $existing_content = new CriterionContent('hoo', ['haz']);
        $other_existing_content = new CriterionContent('foo', ['baz']);
 
        $condition = $this->mock(Condition::class);
        $condition->expects(self::exactly(2))->method('knownToNeverMatchWith')->with($condition)->willReturn(false);
 
        $definition = $this->mock(ConditionDefinition::class);
        $consecutive = [$content, $other_existing_content, $content];
        $definition->expects(self::exactly(3))->method('withCriterion')->with(
            $this->callback(function ($value) use (&$consecutive) {
                $this->assertSame(array_shift($consecutive), $value);
                return true;
            })
        )->willReturn($condition);
 
        $instance = new ProvideDocument('foo', $this->mock(DocumentRepository::class), new SelectionMap([
            'hoo' => $this->mockMethod(ConditionDefinition::class, 'withCriterion', [$existing_content], $condition),
            'foo' => $definition,
        ]), [], $this->mock(Container::class));
 
        $result = $instance->validateCriteriaContent([
            $this->mockTree(Criterion::class, ['content' => $existing_content]),
            $this->mockTree(Criterion::class, ['content' => $other_existing_content]),
        ], $content);
        $this->assertTrue($result->isOk());
        $this->assertSame($content, $result->value());
    }

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

components/ILIAS/LegalDocuments/tests/Provide/ProvideDocumentTest.php

Public Member Functions