Inheritance diagram for ILIAS\MetaData\Manipulator\ManipulatorTest:

Collaboration diagram for ILIAS\MetaData\Manipulator\ManipulatorTest:

Public Member Functions
	getMarkerMock (Action $action, string $data_value='')

	getPathConditionCheckerMock (PathConditionsCollectionInterface $path_conditions_collection)

	getPathFactoryMock ()

	getNavigatorFactoryMock ()

	getDataMock (string $value, Type $type)

	getDefinitionMock (string $name, Type $data_type, bool $is_unique)

	getPathMock (array $steps, bool $is_relative, bool $leads_to_one)

	testPrepareDelete_001 ()

	testPrepareDelete_002 ()

	testPrepareCreateOrUpdate_001 ()

	testPrepareCreateOrUpdate_002 ()

	testPrepareCreateOrUpdate_003 ()

	testPrepareCreateOrUpdate_004 ()

	testPrepareCreateOrUpdate_005 ()

	testPrepareForceCreate01 ()

	testPrepareForceCreate02 ()

Protected Member Functions
	getSetMock (ElementInterface $set_root)

	getScaffoldProviderMock ()

	getMarkerFactoryMock ()

	getPathUtilitiesFactoryMock ()

	getStepMock (string\|StepToken $step_name, array $filter)

	getFilterMock (FilterType $filter_type, array $values)

	createExpectedValuesArray (int $expected_child_count, int\|NoID $expected_id, string $expected_element_data_value, Type $expected_data_type=Type::NULL, ?Action $expected_marker_action=null, string $exptected_marker_value='', array $expected_child_values=[],)

Detailed Description

Definition at line 69 of file ManipulatorTest.php.

Member Function Documentation

◆ createExpectedValuesArray()

ILIAS\MetaData\Manipulator\ManipulatorTest::createExpectedValuesArray	(	int	$expected_child_count,
		int\|NoID	$expected_id,
		string	$expected_element_data_value,
		Type	$expected_data_type = `Type::NULL`,
		?Action	$expected_marker_action = `null`,
		string	$exptected_marker_value = `''`,
		array	$expected_child_values = `[]`
	)

protected

Definition at line 725 of file ManipulatorTest.php.

     : array {
        return [
            'expected_child_count' => $expected_child_count,
            'expected_id' => $expected_id,
            'expected_element_data_value' => $expected_element_data_value,
            'expected_data_type' => $expected_data_type,
            'expected_marker_action' => $expected_marker_action,
            'expected_marker_value' => $exptected_marker_value,
            'children' => $expected_child_values
        ];
    }

◆ getDataMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getDataMock	(	string	$value,
		Type	$type
	)

Definition at line 503 of file ManipulatorTest.php.

                                                          : DataInterface
    {
        return new class ($value, $type) extends NullData {
            public function __construct(protected string $my_value, protected Type $my_type)
            {
            }
 
            public function value(): string
            {
                return $this->my_value;
            }
 
            public function type(): Type
            {
                return $this->my_type;
            }
        };
    }

References ILIAS\GlobalScreen\Provider\__construct().

Here is the call graph for this function:

◆ getDefinitionMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getDefinitionMock	(	string	$name,
		Type	$data_type,
		bool	$is_unique
	)

Definition at line 522 of file ManipulatorTest.php.

     : DefinitionInterface {
        return new class ($name, $data_type, $is_unique) extends NullDefinition {
            public function __construct(
                protected string $my_name,
                protected Type $data_type,
                protected bool $is_unique
            ) {
            }
 
            public function name(): string
            {
                return $this->my_name;
            }
 
            public function dataType(): Type
            {
                return $this->data_type;
            }
 
            public function unique(): bool
            {
                return $this->is_unique;
            }
        };
    }

◆ getFilterMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getFilterMock	(	FilterType	$filter_type,
		array	$values
	)

protected

Definition at line 706 of file ManipulatorTest.php.

                                                                            : FilterInterface
    {
        return new class ($filter_type, $values) extends NullFilter {
            public function __construct(protected FilterType $filter_type, protected array $my_values)
            {
            }
 
            public function type(): FilterType
            {
                return $this->filter_type;
            }
 
            public function values(): \Generator
            {
                yield from $this->my_values;
            }
        };
    }

References ILIAS\GlobalScreen\Provider\__construct(), and ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from().

Here is the call graph for this function:

◆ getMarkerFactoryMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getMarkerFactoryMock ( )

protected

Definition at line 119 of file ManipulatorTest.php.

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

References ILIAS\__construct().

Here is the call graph for this function:

◆ getMarkerMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getMarkerMock	(	Action	$action,
		string	$data_value = `''`
	)

Definition at line 100 of file ManipulatorTest.php.

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

References ILIAS\__construct().

Here is the call graph for this function:

◆ getNavigatorFactoryMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getNavigatorFactoryMock ( )

Definition at line 466 of file ManipulatorTest.php.

                                             : NavigatorFactoryInterface
    {
        return new class ($this) extends NullNavigatorFactory {
            public function __construct(protected ManipulatorTest $test)
            {
            }
 
            public function navigator(PathInterface $path, ElementInterface $start_element): NavigatorInterface
            {
                return $this->test->getNavigatorMock($path, $start_element);
            }
        };
    }

References $path, and ILIAS\GlobalScreen\Provider\__construct().

Here is the call graph for this function:

◆ getPathConditionCheckerMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getPathConditionCheckerMock ( PathConditionsCollectionInterface $path_conditions_collection )

Definition at line 347 of file ManipulatorTest.php.

     : PathConditionsCheckerInterface {
        return new class (
            $path_conditions_collection,
            $this->getNavigatorFactoryMock()
        ) extends NullPathConditionsChecker {
            public function __construct(
                protected PathConditionsCollectionInterface $path_conditions_collection,
                protected NavigatorFactoryInterface $navigator_factory
            ) {
            }
 
            public function isPathConditionMet(StepInterface $step, ElementInterface $root): bool
            {
                $navigator = $this->navigator_factory->navigator(
                    $this->path_conditions_collection->getConditionPathByStepName($step->name()),
                    $root
                );
                while (!is_null($navigator)) {
                    if (!$navigator->hasElements()) {
                        return false;
                    }
                    $navigator = $navigator->nextStep();
                }
                return true;
            }
 
            public function allPathConditionsAreMet(StepInterface $step, ElementInterface ...$roots): bool
            {
                foreach ($roots as $root) {
                    if (!$this->isPathConditionMet($step, $root)) {
                        return false;
                    }
                }
                return true;
            }
 
            public function atLeastOnePathConditionIsMet(StepInterface $step, ElementInterface ...$roots): bool
            {
                foreach ($roots as $root) {
                    if ($this->isPathConditionMet($step, $root)) {
                        return true;
                    }
                }
                return false;
            }
 
            public function getRootsThatMeetPathCondition(StepInterface $step, ElementInterface ...$roots): \Generator
            {
                $elements = [];
                foreach ($roots as $root) {
                    if ($this->isPathConditionMet($step, $root)) {
                        $elements[] = $root;
                    }
                }
                yield from $elements;
            }
        };
    }

◆ getPathFactoryMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getPathFactoryMock ( )

Definition at line 408 of file ManipulatorTest.php.

                                        : PathFactoryInterface
    {
        return new class ($this) extends NullFactory {
            public function __construct(protected ManipulatorTest $test)
            {
            }
 
            public function custom(): BuilderInterface
            {
                return $this->test->getPathBuilderMock();
            }
        };
    }

References ILIAS\GlobalScreen\Provider\__construct(), and ILIAS\UI\examples\Chart\Bar\Horizontal\custom().

Here is the call graph for this function:

◆ getPathMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getPathMock	(	array	$steps,
		bool	$is_relative,
		bool	$leads_to_one
	)

Parameters

StepInterface[] $steps

Parameters

StepInterface[] $my_steps

Definition at line 654 of file ManipulatorTest.php.

                                                                                    : PathInterface
    {
        return new class ($steps, $is_relative, $leads_to_one) extends NullPath {
            public function __construct(
                protected array $my_steps,
                protected bool $is_relative,
                protected bool $leads_to_one
            ) {
            }
 
            public function leadsToExactlyOneElement(): bool
            {
                return $this->leads_to_one;
            }
 
            public function isRelative(): bool
            {
                return $this->is_relative;
            }
 
            public function steps(): \Generator
            {
                yield from $this->my_steps;
            }
        };
    }

References ILIAS\GlobalScreen\Provider\__construct(), and ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from().

Here is the call graph for this function:

◆ getPathUtilitiesFactoryMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getPathUtilitiesFactoryMock ( )

protected

Definition at line 480 of file ManipulatorTest.php.

                                                    : PathUtilitiesFactoryInterface
    {
        return new class (
            $this
        ) extends NullPathUtilitiesFactory {
            public function __construct(
                protected ManipulatorTest $test
            ) {
            }
 
            public function pathConditionChecker(
                PathConditionsCollectionInterface $path_conditions_collection
            ): PathConditionsCheckerInterface {
                return $this->test->getPathConditionCheckerMock($path_conditions_collection);
            }
 
            public function pathConditionsCollection(PathInterface $path): PathConditionsCollectionInterface
            {
                return $this->test->getPathConditionCollectionMock($path);
            }
        };
    }

References $path, and ILIAS\GlobalScreen\Provider\__construct().

Here is the call graph for this function:

◆ getScaffoldProviderMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getScaffoldProviderMock ( )

protected

Definition at line 90 of file ManipulatorTest.php.

                                                : ScaffoldProviderInterface
    {
        return new class () extends NullScaffoldProvider {
            public function getScaffoldsForElement(ElementInterface $element): \Generator
            {
                yield from [];
            }
        };
    }

References ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from().

Here is the call graph for this function:

◆ getSetMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getSetMock ( ElementInterface $set_root )

protected

Definition at line 71 of file ManipulatorTest.php.

                                                             : SetInterface
    {
        return new class ($set_root) extends NullSet {
            public function __construct(protected ElementInterface $set_root)
            {
            }
 
            public function getRessourceID(): RessourceIDInterface
            {
                return new NullRessourceID();
            }
 
            public function getRoot(): ElementInterface
            {
                return $this->set_root;
            }
        };
    }

References ILIAS\__construct().

Here is the call graph for this function:

◆ getStepMock()

ILIAS\MetaData\Manipulator\ManipulatorTest::getStepMock	(	string\|StepToken	$step_name,
		array	$filter
	)

protected

Parameters

FilterInterface[] $filter

Definition at line 687 of file ManipulatorTest.php.

                                                                              : StepInterface
    {
        return new class ($step_name, $filter) extends NullStep {
            public function __construct(protected string|StepToken $step_name, protected array $my_filter)
            {
            }
 
            public function name(): string|StepToken
            {
                return $this->step_name;
            }
 
            public function filters(): \Generator
            {
                yield from $this->my_filter;
            }
        };
    }

References ILIAS\GlobalScreen\Provider\__construct(), and ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from().

Here is the call graph for this function:

◆ testPrepareCreateOrUpdate_001()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareCreateOrUpdate_001 ( )

Definition at line 1019 of file ManipulatorTest.php.

                                                   : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::NULL, [])
            ])
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
 
        try {
            $manipulator->prepareCreateOrUpdate($this->getSetMock($element_root), $path, 'test');
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_general = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'general',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test',
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            1,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, $path, and ILIAS\Data\Description\NULL.

◆ testPrepareCreateOrUpdate_002()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareCreateOrUpdate_002 ( )

Definition at line 1067 of file ManipulatorTest.php.

                                                   : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $add_path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::DATA, ['general'])
            ]),
            $this->getStepMock('tags', [
                $this->getFilterMock(FilterType::DATA, ['tags'])
            ]),
            $this->getStepMock('tag', [
                $this->getFilterMock(FilterType::DATA, ['tag']),
                $this->getFilterMock(FilterType::INDEX, [0, 1])
            ]),
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
        $element_general = $this->getElementMock(0, 'general', Type::NULL, true);
        $element_special = $this->getElementMock(1, 'special', Type::NULL, true);
 
        $element_root->addChildren($element_general, $element_special);
 
        try {
            $manipulator->prepareCreateOrUpdate($this->getSetMock($element_root), $add_path, 'test1', 'test2');
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_tag_1 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test2',
        );
 
        $expected_element_tag_0 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test1',
        );
 
        $expected_element_tags = $this->createExpectedValuesArray(
            2,
            NoID::SCAFFOLD,
            'tags',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'tags',
            [
                $expected_element_tag_0,
                $expected_element_tag_1
            ]
        );
 
        $expected_element_special = $this->createExpectedValuesArray(
            0,
            1,
            'special',
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            1,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tags
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            2,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general,
                $expected_element_special
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, and ILIAS\Data\Description\NULL.

◆ testPrepareCreateOrUpdate_003()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareCreateOrUpdate_003 ( )

Definition at line 1167 of file ManipulatorTest.php.

                                                   : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $add_path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::DATA, ['general'])
            ]),
            $this->getStepMock('tags', [
                $this->getFilterMock(FilterType::DATA, ['tags'])
            ]),
            $this->getStepMock('tag', [
                $this->getFilterMock(FilterType::DATA, ['tag']),
                $this->getFilterMock(FilterType::INDEX, [0, 2])
            ]),
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
        $element_general = $this->getElementMock(0, 'general', Type::NULL, true);
        $element_special = $this->getElementMock(1, 'special', Type::NULL, true);
        $element_tags = $this->getElementMock(2, 'tags', Type::NULL, true);
        $element_tag_0 = $this->getElementMock(3, 'tag', Type::STRING);
        $element_tag_1 = $this->getElementMock(4, 'tag', Type::STRING);
        $element_tag_2 = $this->getElementMock(5, 'tag', Type::STRING);
        $element_tag_3 = $this->getElementMock(6, 'tag', Type::STRING);
 
        $element_root->addChildren($element_general, $element_special);
        $element_general->addChildren($element_tags);
        $element_tags->addChildren($element_tag_0, $element_tag_1, $element_tag_2, $element_tag_3);
 
        try {
            $manipulator->prepareCreateOrUpdate($this->getSetMock($element_root), $add_path, 'test1', 'test2');
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_tag_3 = $this->createExpectedValuesArray(
            0,
            6,
            'tag',
            Type::STRING
        );
 
        $expected_element_tag_2 = $this->createExpectedValuesArray(
            0,
            5,
            'tag',
            Type::STRING,
            Action::CREATE_OR_UPDATE,
            'test2'
        );
 
        $expected_element_tag_1 = $this->createExpectedValuesArray(
            0,
            4,
            'tag',
            Type::STRING
        );
 
        $expected_element_tag_0 = $this->createExpectedValuesArray(
            0,
            3,
            'tag',
            Type::STRING,
            Action::CREATE_OR_UPDATE,
            'test1'
        );
 
        $expected_element_tags = $this->createExpectedValuesArray(
            4,
            2,
            'tags',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tag_0,
                $expected_element_tag_1,
                $expected_element_tag_2,
                $expected_element_tag_3
            ]
        );
 
        $expected_element_special = $this->createExpectedValuesArray(
            0,
            1,
            'special'
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            1,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tags
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            2,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general,
                $expected_element_special
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, and ILIAS\Data\Description\NULL.

◆ testPrepareCreateOrUpdate_004()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareCreateOrUpdate_004 ( )

Definition at line 1290 of file ManipulatorTest.php.

                                                   : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $add_path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::DATA, ['general'])
            ]),
            $this->getStepMock('general_condition', [
                $this->getFilterMock(FilterType::DATA, ['general_condition'])
            ]),
            $this->getStepMock(StepToken::SUPER, []),
            $this->getStepMock('tags', [
                $this->getFilterMock(FilterType::DATA, ['tags'])
            ]),
            $this->getStepMock('tag', [
                $this->getFilterMock(FilterType::DATA, ['tag']),
                $this->getFilterMock(FilterType::INDEX, [0, 2])
            ]),
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
        $element_general = $this->getElementMock(0, 'general', Type::NULL, true);
        $element_special = $this->getElementMock(1, 'special', Type::NULL, true);
        $element_general_condition = $this->getElementMock(2, 'general_condition', Type::NULL);
        $element_tags = $this->getElementMock(3, 'tags', Type::NULL, true);
        $element_tag_0 = $this->getElementMock(4, 'tag', Type::STRING);
        $element_tag_1 = $this->getElementMock(5, 'tag', Type::STRING);
        $element_tag_2 = $this->getElementMock(6, 'tag', Type::STRING);
        $element_tag_3 = $this->getElementMock(7, 'tag', Type::STRING);
 
        $element_root->addChildren($element_general, $element_special);
        $element_general->addChildren($element_general_condition, $element_tags);
        $element_tags->addChildren($element_tag_0, $element_tag_1, $element_tag_2, $element_tag_3);
 
        try {
            $manipulator->prepareCreateOrUpdate($this->getSetMock($element_root), $add_path, 'test1', 'test2');
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_tag_3 = $this->createExpectedValuesArray(
            0,
            7,
            'tag',
            Type::STRING
        );
 
        $expected_element_tag_2 = $this->createExpectedValuesArray(
            0,
            6,
            'tag',
            Type::STRING,
            Action::CREATE_OR_UPDATE,
            'test2'
        );
 
        $expected_element_tag_1 = $this->createExpectedValuesArray(
            0,
            5,
            'tag',
            Type::STRING
        );
 
        $expected_element_tag_0 = $this->createExpectedValuesArray(
            0,
            4,
            'tag',
            Type::STRING,
            Action::CREATE_OR_UPDATE,
            'test1'
        );
 
        $expected_element_tags = $this->createExpectedValuesArray(
            4,
            3,
            'tags',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tag_0,
                $expected_element_tag_1,
                $expected_element_tag_2,
                $expected_element_tag_3
            ]
        );
 
        $expected_element_general_condition = $this->createExpectedValuesArray(
            0,
            2,
            'general_condition'
        );
 
        $expected_element_special = $this->createExpectedValuesArray(
            0,
            1,
            'special'
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            2,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general_condition,
                $expected_element_tags
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            2,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general,
                $expected_element_special
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, ILIAS\Data\Description\NULL, and ILIAS\MetaData\Paths\Steps\SUPER.

◆ testPrepareCreateOrUpdate_005()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareCreateOrUpdate_005 ( )

Definition at line 1425 of file ManipulatorTest.php.

                                                   : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $add_path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::DATA, ['general'])
            ]),
            $this->getStepMock('tags', [
                $this->getFilterMock(FilterType::DATA, ['tags'])
            ]),
            $this->getStepMock('tags_condition', [
                $this->getFilterMock(FilterType::DATA, ['tags_condition'])
            ]),
            $this->getStepMock(StepToken::SUPER, []),
            $this->getStepMock('tag', [
                $this->getFilterMock(FilterType::DATA, ['tag'])
            ]),
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
        $element_general = $this->getElementMock(0, 'general', Type::NULL, true);
        $element_special = $this->getElementMock(1, 'special', Type::NULL, true);
        $element_general_condition = $this->getElementMock(2, 'general_condition', Type::NULL);
        $element_tags = $this->getElementMock(3, 'tags', Type::NULL, true);
        $element_tag_0 = $this->getElementMock(4, 'tag', Type::STRING);
 
        $element_root->addChildren($element_general, $element_special);
        $element_general->addChildren($element_general_condition, $element_tags);
        $element_tags->addChildren($element_tag_0);
 
        try {
            $manipulator->prepareCreateOrUpdate(
                $this->getSetMock($element_root),
                $add_path,
                'test1',
                'test2',
                'test3'
            );
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_tag_3 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test3'
        );
 
        $expected_element_tag_2 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test2'
        );
 
        $expected_element_tag_1 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test1'
        );
 
        $expected_element_tag_0 = $this->createExpectedValuesArray(
            0,
            4,
            'tag',
            Type::STRING
        );
 
        $expected_element_tags_condition = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tags_condition',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'tags_condition'
        );
 
        $expected_element_tags_created = $this->createExpectedValuesArray(
            4,
            NoID::SCAFFOLD,
            'tags',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'tags',
            [
                $expected_element_tags_condition,
                $expected_element_tag_1,
                $expected_element_tag_2,
                $expected_element_tag_3
            ]
        );
 
        $expected_element_tags = $this->createExpectedValuesArray(
            1,
            3,
            'tags',
            Type::NULL,
            null,
            '',
            [
                $expected_element_tag_0
            ]
        );
 
        $expected_element_general_condition = $this->createExpectedValuesArray(
            0,
            2,
            'general_condition'
        );
 
        $expected_element_special = $this->createExpectedValuesArray(
            0,
            1,
            'special'
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            3,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general_condition,
                $expected_element_tags,
                $expected_element_tags_created
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            2,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general,
                $expected_element_special
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, ILIAS\Data\Description\NULL, and ILIAS\MetaData\Paths\Steps\SUPER.

◆ testPrepareDelete_001()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareDelete_001 ( )

Definition at line 797 of file ManipulatorTest.php.

                                           : void
    {
        $manipulator = new Manipulator(
            new NullScaffoldProvider(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            new NullPathUtilitiesFactory()
        );
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL);
        $element_general = $this->getElementMock(0, 'general', Type::NULL);
        $element_subsection_1_0 = $this->getElementMock(1, 'subsection_1', Type::NULL);
        $element_subsection_1_1 = $this->getElementMock(2, 'subsection_1', Type::NULL);
        $element_target_0 = $this->getElementMock(3, 'target', Type::STRING);
        $element_target_1 = $this->getElementMock(4, 'target', Type::STRING);
        $element_target_2 = $this->getElementMock(5, 'target', Type::STRING);
 
        $element_root->addChildren($element_general);
        $element_general->addChildren($element_subsection_1_0, $element_subsection_1_1);
        $element_subsection_1_0->addChildren($element_target_0);
        $element_subsection_1_1->addChildren($element_target_1, $element_target_2);
 
        $set = $this->getSetMock($element_root);
        $delete_path = $this->getPathMock(
            [
                $this->getStepMock('general', [
                    $this->getFilterMock(FilterType::DATA, ['general'])
                ]),
                $this->getStepMock('subsection_1', [
                    $this->getFilterMock(FilterType::DATA, ['subsection_1']),
                    $this->getFilterMock(FilterType::MDID, [2])
                ]),
                $this->getStepMock('target', [
                    $this->getFilterMock(FilterType::DATA, ['target'])
                ])
            ],
            false,
            false
        );
 
        try {
            $manipulator->prepareDelete($set, $delete_path);
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_target_2 = $this->createExpectedValuesArray(
            0,
            5,
            'target',
            Type::STRING,
            Action::DELETE
        );
 
        $expected_element_target_1 = $this->createExpectedValuesArray(
            0,
            4,
            'target',
            Type::STRING,
            Action::DELETE
        );
 
        $expected_element_target_0 = $this->createExpectedValuesArray(
            0,
            3,
            'target',
            Type::STRING
        );
 
        $expected_element_subsection_1_1 = $this->createExpectedValuesArray(
            2,
            2,
            'subsection_1',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_target_1,
                $expected_element_target_2
            ]
        );
 
        $expected_element_subsection_1_0 = $this->createExpectedValuesArray(
            1,
            1,
            'subsection_1',
            Type::NULL,
            null,
            '',
            [
                $expected_element_target_0
            ]
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            2,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_subsection_1_0,
                $expected_element_subsection_1_1
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            1,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, ILIAS\MetaData\Elements\Markers\DELETE, and ILIAS\Data\Description\NULL.

◆ testPrepareDelete_002()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareDelete_002 ( )

Definition at line 920 of file ManipulatorTest.php.

                                           : void
    {
        $manipulator = new Manipulator(
            new NullScaffoldProvider(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            new NullPathUtilitiesFactory()
        );
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL);
        $element_general = $this->getElementMock(0, 'general', Type::NULL);
        $element_subsection_1_0 = $this->getElementMock(1, 'subsection_1', Type::NULL);
        $element_subsection_1_1 = $this->getElementMock(2, 'subsection_1', Type::NULL);
        $element_target = $this->getElementMock(3, 'target', Type::STRING);
 
        $element_root->addChildren($element_general);
        $element_general->addChildren($element_subsection_1_0, $element_subsection_1_1);
        $element_subsection_1_0->addChildren($element_target);
 
        $set = $this->getSetMock($element_root);
        $delete_path = $this->getPathMock(
            [
                $this->getStepMock('general', [
                    $this->getFilterMock(FilterType::DATA, ['general'])
                ]),
                $this->getStepMock('subsection_1', [
                    $this->getFilterMock(FilterType::DATA, ['subsection_1'])
                ]),
                $this->getStepMock('i_do_not_exist_one', [
                    $this->getFilterMock(FilterType::DATA, ['i_do_not_exist_one'])
                ]),
                $this->getStepMock('i_do_not_exist_two', [
                    $this->getFilterMock(FilterType::DATA, ['i_do_not_exist_two'])
                ])
            ],
            false,
            false
        );
 
        try {
            $manipulator->prepareDelete($set, $delete_path);
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_target = $this->createExpectedValuesArray(
            0,
            3,
            'target',
            Type::STRING
        );
 
        $expected_element_subsection_1_1 = $this->createExpectedValuesArray(
            0,
            2,
            'subsection_1'
        );
 
        $expected_element_subsection_1_0 = $this->createExpectedValuesArray(
            1,
            1,
            'subsection_1',
            Type::NULL,
            null,
            '',
            [
                $expected_element_target
            ]
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            2,
            0,
            'general',
            Type::NULL,
            null,
            '',
            [
                $expected_element_subsection_1_0,
                $expected_element_subsection_1_1
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            1,
            NoID::ROOT,
            'root',
            Type::NULL,
            null,
            '',
            [
                $expected_element_general
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, and ILIAS\Data\Description\NULL.

◆ testPrepareForceCreate01()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareForceCreate01 ( )

Definition at line 1586 of file ManipulatorTest.php.

                                              : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $add_path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::DATA, ['general'])
            ]),
            $this->getStepMock('tags', [
                $this->getFilterMock(FilterType::DATA, ['tags'])
            ]),
            $this->getStepMock('tags_condition', [
                $this->getFilterMock(FilterType::DATA, ['tags_condition'])
            ]),
            $this->getStepMock(StepToken::SUPER, []),
            $this->getStepMock('tag', [
                $this->getFilterMock(FilterType::DATA, ['tag'])
            ]),
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
        $element_general = $this->getElementMock(0, 'general', Type::NULL, true);
        $element_special = $this->getElementMock(1, 'special', Type::NULL, true);
        $element_general_condition = $this->getElementMock(2, 'general_condition', Type::NULL);
        $element_tags = $this->getElementMock(3, 'tags', Type::NULL, true);
        $element_tag_0 = $this->getElementMock(4, 'tag', Type::STRING);
        $element_tags_condition = $this->getElementMock(5, 'tags_condition', Type::NULL, true);
 
        $element_root->addChildren($element_general, $element_special);
        $element_general->addChildren($element_general_condition, $element_tags);
        $element_tags->addChildren($element_tag_0, $element_tags_condition);
 
        try {
            $manipulator->prepareForceCreate(
                $this->getSetMock($element_root),
                $add_path,
                'test1',
                'test2',
                'test3'
            );
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_tag_3 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test3'
        );
 
        $expected_element_tag_2 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test2'
        );
 
        $expected_element_tag_1 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test1'
        );
 
        $expected_element_tag_0 = $this->createExpectedValuesArray(
            0,
            4,
            'tag',
            Type::STRING
        );
 
        $expected_element_tags_condition = $this->createExpectedValuesArray(
            0,
            5,
            'tags_condition',
            Type::NULL
        );
 
        $expected_element_tags = $this->createExpectedValuesArray(
            5,
            3,
            'tags',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tag_0,
                $expected_element_tags_condition,
                $expected_element_tag_1,
                $expected_element_tag_2,
                $expected_element_tag_3
            ]
        );
 
        $expected_element_general_condition = $this->createExpectedValuesArray(
            0,
            2,
            'general_condition'
        );
 
        $expected_element_special = $this->createExpectedValuesArray(
            0,
            1,
            'special'
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            2,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general_condition,
                $expected_element_tags
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            2,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general,
                $expected_element_special
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, ILIAS\Data\Description\NULL, and ILIAS\MetaData\Paths\Steps\SUPER.

◆ testPrepareForceCreate02()

ILIAS\MetaData\Manipulator\ManipulatorTest::testPrepareForceCreate02 ( )

Definition at line 1734 of file ManipulatorTest.php.

                                              : void
    {
        $manipulator = new Manipulator(
            $this->getScaffoldProviderMock(),
            $this->getMarkerFactoryMock(),
            $this->getNavigatorFactoryMock(),
            $this->getPathFactoryMock(),
            $this->getPathUtilitiesFactoryMock()
        );
 
        $add_path = $this->getPathMock([
            $this->getStepMock('general', [
                $this->getFilterMock(FilterType::DATA, ['general'])
            ]),
            $this->getStepMock('tags', [
                $this->getFilterMock(FilterType::DATA, ['tags'])
            ]),
            $this->getStepMock('tag', [
                $this->getFilterMock(FilterType::DATA, ['tag'])
            ]),
        ], false, false);
 
        $element_root = $this->getElementMock(NoID::ROOT, 'root', Type::NULL, true);
        $element_general = $this->getElementMock(0, 'general', Type::NULL, true);
        $element_tags = $this->getElementMock(1, 'tags', Type::NULL, true);
        $element_tag_0 = $this->getElementMock(2, 'tag', Type::STRING);
 
        $element_root->addChildren($element_general);
        $element_general->addChildren($element_tags);
        $element_tags->addChildren($element_tag_0);
 
        try {
            $manipulator->prepareForceCreate(
                $this->getSetMock($element_root),
                $add_path,
                'test1',
                'test2',
                'test3'
            );
        } catch (\ilMDPathException $e) {
            $this->fail($e->getMessage());
        }
 
        $expected_element_tag_3 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test3'
        );
 
        $expected_element_tag_2 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test2'
        );
 
        $expected_element_tag_1 = $this->createExpectedValuesArray(
            0,
            NoID::SCAFFOLD,
            'tag',
            Type::NULL,
            Action::CREATE_OR_UPDATE,
            'test1'
        );
 
        $expected_element_tag_0 = $this->createExpectedValuesArray(
            0,
            2,
            'tag',
            Type::STRING
        );
 
        $expected_element_tags = $this->createExpectedValuesArray(
            4,
            1,
            'tags',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tag_0,
                $expected_element_tag_1,
                $expected_element_tag_2,
                $expected_element_tag_3
            ]
        );
 
        $expected_element_general = $this->createExpectedValuesArray(
            1,
            0,
            'general',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_tags
            ]
        );
 
        $expected_element_root = $this->createExpectedValuesArray(
            1,
            NoID::ROOT,
            'root',
            Type::NULL,
            Action::NEUTRAL,
            '',
            [
                $expected_element_general
            ]
        );
 
        $this->myAssertTree($element_root, $expected_element_root);
    }

References Vendor\Package\$e, ILIAS\MetaData\Paths\Filters\DATA, and ILIAS\Data\Description\NULL.

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

components/ILIAS/MetaData/tests/Manipulator/ManipulatorTest.php

Public Member Functions

Protected Member Functions

Detailed Description

Member Function Documentation

◆ createExpectedValuesArray()

◆ getDataMock()

◆ getDefinitionMock()

◆ getFilterMock()

◆ getMarkerFactoryMock()

◆ getMarkerMock()

◆ getNavigatorFactoryMock()

◆ getPathConditionCheckerMock()

◆ getPathFactoryMock()

◆ getPathMock()

◆ getPathUtilitiesFactoryMock()

◆ getScaffoldProviderMock()

◆ getSetMock()

◆ getStepMock()

◆ testPrepareCreateOrUpdate_001()

◆ testPrepareCreateOrUpdate_002()

◆ testPrepareCreateOrUpdate_003()

◆ testPrepareCreateOrUpdate_004()

◆ testPrepareCreateOrUpdate_005()

◆ testPrepareDelete_001()

◆ testPrepareDelete_002()

◆ testPrepareForceCreate01()

◆ testPrepareForceCreate02()