ILIAS\MetaData\Elements\ElementTest Class Reference

Inheritance diagram for ILIAS\MetaData\Elements\ElementTest:

Collaboration diagram for ILIAS\MetaData\Elements\ElementTest:

Public Member Functions
	testSubAndSuperElements ()
	testGetData ()
	testIsScaffold ()
	testGetMarkerAndIsMarked ()
	testMarkerTrail ()
	testMarkTwice ()
	testMarkWithScaffolds ()
	testUnmark ()
	testAddScaffolds ()
	testAddScaffoldByName ()
	testAddScaffoldByNameWithGap ()
	testAddScaffoldsWithSubElementsException ()
	testAddScaffoldByNameWithSubElementsException ()

Protected Member Functions
	getDefinition (string $name)
	getMarkerFactory ()
	getScaffoldProvider (bool $broken=false)
	getElement (int|NoID $id, Element ... $elements)
	getElementWithName (int|NoID $id, string $name, Element ... $elements)

Detailed Description

Definition at line 38 of file ElementTest.php.

Member Function Documentation

getDefinition()

ILIAS\MetaData\Elements\ElementTest::getDefinition ( string  $name )

protected

Definition at line 40 of file ElementTest.php.

                                                  : DefinitionInterface
    {
        return new class ($name) extends NullDefinition {
            public function __construct(protected string $name)
            {
            }
 
            public function name(): string
            {
                return $this->name;
            }
        };
    }

References ILIAS\__construct().

Here is the call graph for this function:

getElement()

ILIAS\MetaData\Elements\ElementTest::getElement ( int|NoID  $id, Element ...  $elements  )

protected

Definition at line 165 of file ElementTest.php.

     : Element {
        return new Element(
            $id,
            $this->getDefinition('name'),
            new NullData(),
            ...$elements
        );
    }

getElementWithName()

ILIAS\MetaData\Elements\ElementTest::getElementWithName ( int|NoID  $id, string  $name, Element ...  $elements  )

protected

Definition at line 177 of file ElementTest.php.

     : Element {
        return new Element(
            $id,
            $this->getDefinition($name),
            new NullData(),
            ...$elements
        );
    }

getMarkerFactory()

ILIAS\MetaData\Elements\ElementTest::getMarkerFactory ( )

protected

Definition at line 54 of file ElementTest.php.

                                         : MarkerFactoryInterface
    {
        return new class () extends NullMarkerFactory {
            public function marker(Action $action, string $data_value = ''): MarkerInterface
            {
                return new class ($action) extends NullMarker {
                    protected Action $action;
 
                    public function __construct(Action $action)
                    {
                        $this->action = $action;
                    }
 
                    public function action(): Action
                    {
                        return $this->action;
                    }
 
                    public function dataValue(): string
                    {
                        return '';
                    }
                };
            }
        };
    }

References ILIAS\__construct().

Here is the call graph for this function:

getScaffoldProvider()

ILIAS\MetaData\Elements\ElementTest::getScaffoldProvider ( bool  $broken = false )

protected

Definition at line 81 of file ElementTest.php.

                                                                : ScaffoldProviderInterface
    {
        return new class ($broken) extends NullScaffoldProvider {
            public function __construct(protected bool $broken)
            {
            }
 
            protected function getScaffold(string $name, ElementInterface ...$elements): ElementInterface
            {
                $definition = new class ($name) implements DefinitionInterface {
                    protected string $name;
 
                    public function __construct(string $name)
                    {
                        $this->name = $name;
                    }
 
                    public function name(): string
                    {
                        return $this->name;
                    }
 
                    public function unique(): bool
                    {
                        return false;
                    }
 
                    public function dataType(): Type
                    {
                        return Type::NULL;
                    }
                };
 
                $data = new class () extends NullData {
                    public function type(): Type
                    {
                        return Type::STRING;
                    }
 
                    public function value(): string
                    {
                        return 'value';
                    }
                };
 
                return new Element(
                    NoID::SCAFFOLD,
                    $definition,
                    $data,
                    ...$elements
                );
            }
 
            public function getScaffoldsForElement(ElementInterface $element): \Generator
            {
                if ($this->broken) {
                    $sub = $this->getScaffold('name');
                    $with_sub = $this->getScaffold('with sub', $sub);
 
                    yield '' => $with_sub;
                    return;
                }
 
                $first = $this->getScaffold('first');
                $second = $this->getScaffold('second');
                $third = $this->getScaffold('third');
                $fourth = $this->getScaffold('fourth');
 
                yield $first;
                yield $second;
                yield $third;
                yield $fourth;
            }
 
            public function getPossibleSubElementNamesForElementInOrder(ElementInterface $element): \Generator
            {
                yield 'first';
                yield 'second';
                yield 'third';
                yield 'fourth';
            }
        };
    }

References $data, ILIAS\__construct(), and ILIAS\Data\Description\NULL.

Here is the call graph for this function:

testAddScaffoldByName()

ILIAS\MetaData\Elements\ElementTest::testAddScaffoldByName

(

)

Definition at line 343 of file ElementTest.php.

                                           : void
    {
        $second = $this->getElementWithName(6, 'second');
        $third = $this->getElementWithName(17, 'third');
        $el = $this->getElement(13, $second, $third);
 
        $el->addScaffoldToSubElements($this->getScaffoldProvider(), 'second');
 
        $subs = $el->getSubElements();
        $this->assertSame($second, $subs->current());
        $subs->next();
        $this->assertTrue($subs->current()->isScaffold());
        $this->assertSame('second', $subs->current()->getDefinition()->name());
        $subs->next();
        $this->assertSame($third, $subs->current());
        $subs->next();
        $this->assertNull($subs->current());
    }

testAddScaffoldByNameWithGap()

ILIAS\MetaData\Elements\ElementTest::testAddScaffoldByNameWithGap

(

)

Definition at line 364 of file ElementTest.php.

                                                  : void
    {
        $second = $this->getElementWithName(6, 'second');
        $fourth = $this->getElementWithName(17, 'fourth');
        $el = $this->getElement(13, $second, $fourth);
 
        $el->addScaffoldToSubElements($this->getScaffoldProvider(), 'second');
 
        $subs = $el->getSubElements();
        $this->assertSame($second, $subs->current());
        $subs->next();
        $this->assertTrue($subs->current()->isScaffold());
        $this->assertSame('second', $subs->current()->getDefinition()->name());
        $subs->next();
        $this->assertSame($fourth, $subs->current());
        $subs->next();
        $this->assertNull($subs->current());
    }

testAddScaffoldByNameWithSubElementsException()

ILIAS\MetaData\Elements\ElementTest::testAddScaffoldByNameWithSubElementsException

(

)

Definition at line 391 of file ElementTest.php.

                                                                   : void
    {
        $el = $this->getElement(37);
 
        $this->expectException(\ilMDElementsException::class);
        $el->addScaffoldToSubElements($this->getScaffoldProvider(true), 'with sub');
    }

testAddScaffolds()

ILIAS\MetaData\Elements\ElementTest::testAddScaffolds

(

)

Definition at line 315 of file ElementTest.php.

                                      : void
    {
        $second = $this->getElementWithName(6, 'second');
        $fourth = $this->getElementWithName(6, 'fourth');
        $el = $this->getElement(13, $second, $fourth);
 
        $el->addScaffoldsToSubElements($this->getScaffoldProvider());
 
        $subs = $el->getSubElements();
        $this->assertTrue($subs->current()->isScaffold());
        $this->assertSame('first', $subs->current()->getDefinition()->name());
        $subs->next();
        $this->assertSame($second, $subs->current());
        $subs->next();
        $this->assertTrue($subs->current()->isScaffold());
        $this->assertSame('second', $subs->current()->getDefinition()->name());
        $subs->next();
        $this->assertTrue($subs->current()->isScaffold());
        $this->assertSame('third', $subs->current()->getDefinition()->name());
        $subs->next();
        $this->assertSame($fourth, $subs->current());
        $subs->next();
        $this->assertTrue($subs->current()->isScaffold());
        $this->assertSame('fourth', $subs->current()->getDefinition()->name());
        $subs->next();
        $this->assertNull($subs->current());
    }

testAddScaffoldsWithSubElementsException()

ILIAS\MetaData\Elements\ElementTest::testAddScaffoldsWithSubElementsException

(

)

Definition at line 383 of file ElementTest.php.

                                                              : void
    {
        $el = $this->getElement(37);
 
        $this->expectException(\ilMDElementsException::class);
        $el->addScaffoldsToSubElements($this->getScaffoldProvider(true));
    }

testGetData()

ILIAS\MetaData\Elements\ElementTest::testGetData

(

)

Definition at line 208 of file ElementTest.php.

                                 : void
    {
        $data = new NullData();
        $el = new Element(
            7,
            $this->getDefinition('name'),
            $data
        );
 
        $this->assertSame($data, $el->getData());
    }

References $data.

testGetMarkerAndIsMarked()

ILIAS\MetaData\Elements\ElementTest::testGetMarkerAndIsMarked

(

)

Definition at line 229 of file ElementTest.php.

                                              : void
    {
        $mark_me = $this->getElement(13);
        $stay_away = $this->getElement(7);
        $mark_me->mark($this->getMarkerFactory(), Action::NEUTRAL);
 
        $this->assertTrue($mark_me->isMarked());
        $this->assertInstanceOf(MarkerInterface::class, $mark_me->getMarker());
        $this->assertFalse($stay_away->isMarked());
        $this->assertNull($stay_away->getMarker());
    }

testIsScaffold()

ILIAS\MetaData\Elements\ElementTest::testIsScaffold

(

)

Definition at line 220 of file ElementTest.php.

                                    : void
    {
        $scaffold = $this->getElement(NoID::SCAFFOLD);
        $not_scaffold = $this->getElement(5);
 
        $this->assertTrue($scaffold->isScaffold());
        $this->assertFalse($not_scaffold->isScaffold());
    }

testMarkerTrail()

ILIAS\MetaData\Elements\ElementTest::testMarkerTrail

(

)

Definition at line 241 of file ElementTest.php.

                                     : void
    {
        $el111 = $this->getElement(111);
        $el11 = $this->getElement(11, $el111);
        $el12 = $this->getElement(12);
        $el1 = $this->getElement(1, $el11, $el12);
        $el2 = $this->getElement(2);
        $root = $this->getElement(NoID::ROOT, $el1, $el2);
 
        $el11->mark($this->getMarkerFactory(), Action::CREATE_OR_UPDATE);
 
        $this->assertTrue($el11->isMarked());
        $this->assertSame(Action::CREATE_OR_UPDATE, $el11->getMarker()->action());
        $this->assertTrue($el1->isMarked());
        $this->assertSame(Action::NEUTRAL, $el1->getMarker()->action());
        $this->assertTrue($root->isMarked());
        $this->assertSame(Action::NEUTRAL, $root->getMarker()->action());
 
        $this->assertFalse($el111->isMarked());
        $this->assertFalse($el12->isMarked());
        $this->assertFalse($el2->isMarked());
    }

testMarkTwice()

ILIAS\MetaData\Elements\ElementTest::testMarkTwice

(

)

Definition at line 264 of file ElementTest.php.

                                   : void
    {
        $marker_factory = $this->getMarkerFactory();
        $sub = $this->getElement(11);
        $el = $this->getElement(1, $sub);
 
        $el->mark($marker_factory, Action::CREATE_OR_UPDATE);
        $this->assertSame(Action::CREATE_OR_UPDATE, $el->getMarker()->action());
 
        $sub->mark($marker_factory, Action::DELETE);
        $this->assertSame(Action::DELETE, $sub->getMarker()->action());
        $this->assertSame(Action::CREATE_OR_UPDATE, $el->getMarker()->action());
 
        $el->mark($marker_factory, Action::DELETE);
        $this->assertSame(Action::DELETE, $el->getMarker()->action());
    }

References ILIAS\MetaData\Elements\Markers\DELETE.

testMarkWithScaffolds()

ILIAS\MetaData\Elements\ElementTest::testMarkWithScaffolds

(

)

Definition at line 281 of file ElementTest.php.

                                           : void
    {
        $marker_factory = $this->getMarkerFactory();
        $sub = $this->getElement(NoID::SCAFFOLD);
        $el = $this->getElement(NoID::SCAFFOLD, $sub);
 
        $sub->mark($marker_factory, Action::CREATE_OR_UPDATE);
        $this->assertSame(Action::CREATE_OR_UPDATE, $sub->getMarker()->action());
        $this->assertSame(Action::CREATE_OR_UPDATE, $el->getMarker()->action());
 
        $sub = $this->getElement(NoID::SCAFFOLD);
        $el = $this->getElement(NoID::SCAFFOLD, $sub);
 
        $sub->mark($marker_factory, Action::DELETE);
        $this->assertSame(Action::DELETE, $sub->getMarker()->action());
        $this->assertSame(Action::NEUTRAL, $el->getMarker()->action());
    }

References ILIAS\MetaData\Elements\Markers\DELETE.

testSubAndSuperElements()

ILIAS\MetaData\Elements\ElementTest::testSubAndSuperElements

(

)

Definition at line 190 of file ElementTest.php.

                                             : void
    {
        $el11 = $this->getElement(11);
        $el1 = $this->getElement(1, $el11);
        $el2 = $this->getElement(2);
        $root = $this->getElement(NoID::ROOT, $el1, $el2);
 
        $subs = $root->getSubElements();
        $this->assertSame($el1, $subs->current());
        $subs->next();
        $this->assertSame($el2, $subs->current());
        $subs->next();
        $this->assertNull($subs->current());
 
        $this->assertSame($root, $el1->getSuperElement());
        $this->assertSame($el11, $el1->getSubElements()->current());
    }

testUnmark()

ILIAS\MetaData\Elements\ElementTest::testUnmark

(

)

Definition at line 299 of file ElementTest.php.

                                : void
    {
        $el111 = $this->getElement(111);
        $el11 = $this->getElement(11, $el111);
        $el1 = $this->getElement(1, $el11);
        $root = $this->getElement(NoID::ROOT, $el1);
 
        $el111->mark($this->getMarkerFactory(), Action::CREATE_OR_UPDATE);
        $el11->unmark();
 
        $this->assertTrue($root->isMarked());
        $this->assertTrue($el1->isMarked());
        $this->assertFalse($el11->isMarked());
        $this->assertFalse($el111->isMarked());
    }

---

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

• components/ILIAS/MetaData/tests/Elements/ElementTest.php