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.

References ILIAS\MetaData\Elements\ElementInterface\getData(), ILIAS\MetaData\Elements\Markers\MarkableInterface\getMarker(), ILIAS\MetaData\Elements\Base\BaseElementInterface\getMDID(), ILIAS\MetaData\Elements\ElementInterface\getSubElements(), and null.

      : 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
         ];
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDataMock()

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

Definition at line 503 of file ManipulatorTest.php.

References ILIAS\__construct().

                                                           : 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;
             }
         };
     }

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.

References $data, ILIAS\__construct(), ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\MetaData\Elements\Markers\MarkerFactoryInterface\marker(), and null.

      : 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;
             }
         };
     }

Here is the call graph for this function:

◆ getFilterMock()

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

protected

Definition at line 706 of file ManipulatorTest.php.

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

                                                                             : 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;
             }
         };
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getMarkerFactoryMock()

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

protected

Definition at line 119 of file ManipulatorTest.php.

References $path, ILIAS\__construct(), ILIAS\MetaData\Paths\Filters\DATA, ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\MetaData\Manipulator\ManipulatorTest\getPathMock(), ILIAS\Repository\int(), null, ILIAS\MetaData\Paths\PathInterface\steps(), and ILIAS\MetaData\Paths\Steps\SUPER.

                                              : 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);
             }
         };
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getMarkerMock()

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

Definition at line 100 of file ManipulatorTest.php.

References ILIAS\__construct().

                                                                           : 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;
             }
         };
     }

Here is the call graph for this function:

◆ getNavigatorFactoryMock()

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

Definition at line 466 of file ManipulatorTest.php.

References ILIAS\__construct().

                                              : 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);
             }
         };
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPathConditionCheckerMock()

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

Definition at line 347 of file ManipulatorTest.php.

References ILIAS\__construct(), ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\MetaData\Manipulator\ManipulatorTest\getNavigatorFactoryMock(), and ILIAS\MetaData\Paths\Steps\StepInterface\name().

      : 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;
             }
         };
     }

Here is the call graph for this function:

◆ getPathFactoryMock()

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

Definition at line 408 of file ManipulatorTest.php.

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

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

Here is the call graph for this function:

Here is the caller 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.

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

                                                                                     : 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;
             }
         };
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPathUtilitiesFactoryMock()

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

protected

Definition at line 480 of file ManipulatorTest.php.

References ILIAS\__construct().

Referenced by ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_001(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_002(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_003(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_004(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_005(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareForceCreate01(), and ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareForceCreate02().

                                                     : 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);
             }
         };
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getScaffoldProviderMock()

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

protected

Definition at line 90 of file ManipulatorTest.php.

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

Referenced by ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_001(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_002(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_003(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_004(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareCreateOrUpdate_005(), ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareForceCreate01(), and ILIAS\MetaData\Manipulator\ManipulatorTest\testPrepareForceCreate02().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSetMock()

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

protected

Definition at line 71 of file ManipulatorTest.php.

References ILIAS\__construct().

                                                              : 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;
             }
         };
     }

Here is the call graph for this function:

Here is the caller 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.

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

                                                                               : 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;
             }
         };
     }

Here is the call graph for this function:

Here is the caller 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);
     }

Here is the call graph for this function:

◆ 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);
     }

Here is the call graph for this function:

◆ 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);
     }

Here is the call graph for this function:

◆ 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);
     }

Here is the call graph for this function:

◆ 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);
     }

Here is the call graph for this function:

◆ testPrepareDelete_001()

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

Definition at line 797 of file ManipulatorTest.php.

References Vendor\Package\$e, ILIAS\MetaData\Manipulator\ManipulatorTest\createExpectedValuesArray(), ILIAS\MetaData\Paths\Filters\DATA, ILIAS\MetaData\Elements\Markers\DELETE, ILIAS\MetaData\Manipulator\ManipulatorTest\getFilterMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getMarkerFactoryMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getNavigatorFactoryMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getPathFactoryMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getPathMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getSetMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getStepMock(), and null.

                                            : 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);
     }

Here is the call graph for this function:

◆ testPrepareDelete_002()

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

Definition at line 920 of file ManipulatorTest.php.

References Vendor\Package\$e, ILIAS\MetaData\Manipulator\ManipulatorTest\createExpectedValuesArray(), ILIAS\MetaData\Paths\Filters\DATA, ILIAS\MetaData\Manipulator\ManipulatorTest\getFilterMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getMarkerFactoryMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getNavigatorFactoryMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getPathFactoryMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getPathMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getSetMock(), ILIAS\MetaData\Manipulator\ManipulatorTest\getStepMock(), and null.

                                            : 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);
     }

Here is the call graph for this function:

◆ 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);
     }

Here is the call graph for this function:

◆ 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);
     }

Here is the call graph for this function:

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()