ElementTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\MetaData\Elements;
 
use PHPUnit\Framework\TestCase;
use ILIAS\MetaData\Elements\NoID;
use ILIAS\MetaData\Elements\Markers\MarkerFactoryInterface;
use ILIAS\MetaData\Elements\Markers\Action;
use ILIAS\MetaData\Elements\Markers\MarkerInterface;
use ILIAS\MetaData\Manipulator\ScaffoldProvider\ScaffoldProviderInterface;
use ILIAS\MetaData\Structure\Definitions\DefinitionInterface;
use ILIAS\MetaData\Elements\Data\Type;
use ILIAS\MetaData\Elements\Data\DataInterface;
use ILIAS\MetaData\Elements\Data\NullData;
use ILIAS\MetaData\Structure\Definitions\NullDefinition;
use ILIAS\MetaData\Elements\Markers\NullMarkerFactory;
use ILIAS\MetaData\Elements\Markers\NullMarker;
use ILIAS\MetaData\Manipulator\ScaffoldProvider\NullScaffoldProvider;
 
class ElementTest extends TestCase
{
    protected function getDefinition(string $name): DefinitionInterface
    {
        return new class ($name) extends NullDefinition {
            public function __construct(protected string $name)
            {
            }
 
            public function name(): string
            {
                return $this->name;
            }
        };
    }
 
    protected function getMarkerFactory(): 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 '';
                    }
                };
            }
        };
    }
 
    protected function getScaffoldProvider(bool $broken = false): 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';
            }
        };
    }
 
    protected function getElement(
        int|NoID $id,
        Element ...$elements
    ): Element {
        return new Element(
            $id,
            $this->getDefinition('name'),
            new NullData(),
            ...$elements
        );
    }
 
    protected function getElementWithName(
        int|NoID $id,
        string $name,
        Element ...$elements
    ): Element {
        return new Element(
            $id,
            $this->getDefinition($name),
            new NullData(),
            ...$elements
        );
    }
 
    public function testSubAndSuperElements(): 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());
    }
 
    public function testGetData(): void
    {
        $data = new NullData();
        $el = new Element(
            7,
            $this->getDefinition('name'),
            $data
        );
 
        $this->assertSame($data, $el->getData());
    }
 
    public function testIsScaffold(): void
    {
        $scaffold = $this->getElement(NoID::SCAFFOLD);
        $not_scaffold = $this->getElement(5);
 
        $this->assertTrue($scaffold->isScaffold());
        $this->assertFalse($not_scaffold->isScaffold());
    }
 
    public function testGetMarkerAndIsMarked(): 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());
    }
 
    public function testMarkerTrail(): 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());
    }
 
    public function testMarkTwice(): 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());
    }
 
    public function testMarkWithScaffolds(): 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());
    }
 
    public function testUnmark(): 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());
    }
 
    public function testAddScaffolds(): 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());
    }
 
    public function testAddScaffoldByName(): 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());
    }
 
 
 
    public function testAddScaffoldByNameWithGap(): 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());
    }
 
    public function testAddScaffoldsWithSubElementsException(): void
    {
        $el = $this->getElement(37);
 
        $this->expectException(\ilMDElementsException::class);
        $el->addScaffoldsToSubElements($this->getScaffoldProvider(true));
    }
 
    public function testAddScaffoldByNameWithSubElementsException(): void
    {
        $el = $this->getElement(37);
 
        $this->expectException(\ilMDElementsException::class);
        $el->addScaffoldToSubElements($this->getScaffoldProvider(true), 'with sub');
    }
}