ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest Class Reference

Inheritance diagram for ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest:

Collaboration diagram for ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest:

Public Member Functions
	getVocabsWithIDs (bool $active, string ... $ids)
	testVocabularyInvalidVocabID ()
	testVocabularyInvalidVocabIDFromStandardSlot ()
	testVocabularyInvalidVocabIDFromCopyrightSlot ()
	testVocabularyInvalidVocabIDFromControlledVocabulary ()
	testVocabulariesForSlots ()
	testVocabulariesForSlotsNoCopyright ()
	testActiveVocabulariesForSlots ()
	testActiveVocabulariesForSlotsNoCopyright ()
	testActiveVocabulariesForSlotsCopyrightVocabInactive ()

Protected Member Functions
	getVocabulary (bool $active, string $id='', Type $type=Type::NULL)
	getCopyrightBridge (?VocabularyInterface $vocabulary=null)
	getControlledRepo (VocabularyInterface ... $vocabularies)
	getStandardRepo (VocabularyInterface ... $vocabularies)
	assertVocabIDsMatch (array $ids, \Generator $vocabs)

Detailed Description

Definition at line 38 of file ReaderTest.php.

Member Function Documentation

assertVocabIDsMatch()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::assertVocabIDsMatch ( array  $ids, \Generator  $vocabs  )

protected

Parameters

string[]	$ids
VocabularyInterface[]	$vocabs

Definition at line 168 of file ReaderTest.php.

                                                                          : void
    {
        $actual_ids = [];
        foreach ($vocabs as $vocabulary) {
            $actual_ids[] = $vocabulary->id();
        }
        $this->assertSame($ids, $actual_ids);
    }

getControlledRepo()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::getControlledRepo ( VocabularyInterface ...  $vocabularies )

protected

Definition at line 96 of file ReaderTest.php.

                                                                              : ControlledRepo
    {
        return new class ($vocabularies) extends NullControlledRepo {
            public function __construct(protected array $vocabularies)
            {
            }
 
            public function getVocabulary(string $vocab_id): VocabularyInterface
            {
                foreach ($this->vocabularies as $vocabulary) {
                    if ($vocab_id === $vocabulary->id()) {
                        return $vocabulary;
                    }
                }
                return new NullVocabulary();
            }
 
            public function getVocabulariesForSlots(SlotIdentifier ...$slots): \Generator
            {
                yield from $this->vocabularies;
            }
 
            public function getActiveVocabulariesForSlots(SlotIdentifier ...$slots): \Generator
            {
                foreach ($this->vocabularies as $vocabulary) {
                    if (!$vocabulary->isActive()) {
                        continue;
                    }
                    yield $vocabulary;
                }
            }
        };
    }

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

Here is the call graph for this function:

getCopyrightBridge()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::getCopyrightBridge ( ?VocabularyInterface  $vocabulary = null )

protected

Definition at line 82 of file ReaderTest.php.

                                                                                  : CopyrightBridge
    {
        return new class ($vocabulary) extends NullCopyrightBridge {
            public function __construct(protected ?VocabularyInterface $vocabulary)
            {
            }
 
            public function vocabulary(SlotIdentifier $slot): ?VocabularyInterface
            {
                return $this->vocabulary;
            }
        };
    }

References ILIAS\GlobalScreen\Provider\__construct().

Here is the call graph for this function:

getStandardRepo()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::getStandardRepo ( VocabularyInterface ...  $vocabularies )

protected

Definition at line 130 of file ReaderTest.php.

                                                                            : StandardRepo
    {
        return new class ($vocabularies) extends NullStandardRepo {
            public function __construct(protected array $vocabularies)
            {
            }
 
            public function getVocabulary(SlotIdentifier $slot): VocabularyInterface
            {
                foreach ($this->vocabularies as $vocabulary) {
                    if ($slot->value === $vocabulary->id()) {
                        return $vocabulary;
                    }
                }
                return new NullVocabulary();
            }
 
            public function getVocabularies(SlotIdentifier ...$slots): \Generator
            {
                yield from $this->vocabularies;
            }
 
            public function getActiveVocabularies(SlotIdentifier ...$slots): \Generator
            {
                foreach ($this->vocabularies as $vocabulary) {
                    if (!$vocabulary->isActive()) {
                        continue;
                    }
                    yield $vocabulary;
                }
            }
        };
    }

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

Here is the call graph for this function:

getVocabsWithIDs()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::getVocabsWithIDs	(	bool	$active,
		string ...	$ids
	)

Returns

VocabularyInterface[]

Definition at line 73 of file ReaderTest.php.

                                                                  : array
    {
        $result = [];
        foreach ($ids as $id) {
            $result[] = $this->getVocabulary($active, $id);
        }
        return $result;
    }

References $id.

getVocabulary()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::getVocabulary ( bool  $active, string  $id = '', Type  $type = Type::NULL  )

protected

Definition at line 40 of file ReaderTest.php.

     : VocabularyInterface {
        return new class ($active, $type, $id) extends NullVocabulary {
            public function __construct(
                protected bool $active,
                protected Type $type,
                protected string $id
            ) {
            }
 
            public function isActive(): bool
            {
                return $this->active;
            }
 
            public function type(): Type
            {
                return $this->type;
            }
 
            public function id(): string
            {
                return $this->id;
            }
        };
    }

testActiveVocabulariesForSlots()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testActiveVocabulariesForSlots

(

)

Definition at line 307 of file ReaderTest.php.

                                                    : void
    {
        $cp_vocab = $this->getVocabulary(true, 'cp');
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, 'stand active 1', 'stand active 2');
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, 'stand inactive 1', 'stand inactive 2');
 
        $reader = new Reader(
            $this->getCopyrightBridge($cp_vocab),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $this->assertVocabIDsMatch(
            [
                'cp',
                'contr active 1',
                'contr active 2',
                'stand active 1',
                'stand active 2'
            ],
            $reader->activeVocabulariesForSlots(SlotIdentifier::RIGHTS_COST)
        );
    }

testActiveVocabulariesForSlotsCopyrightVocabInactive()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testActiveVocabulariesForSlotsCopyrightVocabInactive

(

)

Definition at line 357 of file ReaderTest.php.

                                                                          : void
    {
        $cp_vocab = $this->getVocabulary(false, 'cp');
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, 'stand active 1', 'stand active 2');
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, 'stand inactive 1', 'stand inactive 2');
 
        $reader = new Reader(
            $this->getCopyrightBridge($cp_vocab),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $this->assertVocabIDsMatch(
            [
                'contr active 1',
                'contr active 2',
                'stand active 1',
                'stand active 2'
            ],
            $reader->activeVocabulariesForSlots(SlotIdentifier::RIGHTS_COST)
        );
    }

testActiveVocabulariesForSlotsNoCopyright()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testActiveVocabulariesForSlotsNoCopyright

(

)

Definition at line 333 of file ReaderTest.php.

                                                               : void
    {
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, 'stand active 1', 'stand active 2');
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, 'stand inactive 1', 'stand inactive 2');
 
        $reader = new Reader(
            $this->getCopyrightBridge(),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $this->assertVocabIDsMatch(
            [
                'contr active 1',
                'contr active 2',
                'stand active 1',
                'stand active 2'
            ],
            $reader->activeVocabulariesForSlots(SlotIdentifier::RIGHTS_COST)
        );
    }

testVocabulariesForSlots()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testVocabulariesForSlots

(

)

Definition at line 249 of file ReaderTest.php.

                                              : void
    {
        $cp_vocab = $this->getVocabulary(true, 'cp');
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, 'stand active 1', 'stand active 2');
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, 'stand inactive 1', 'stand inactive 2');
 
        $reader = new Reader(
            $this->getCopyrightBridge($cp_vocab),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $this->assertVocabIDsMatch(
            [
                'cp',
                'contr active 1',
                'contr active 2',
                'contr inactive 1',
                'contr inactive 2',
                'stand active 1',
                'stand active 2',
                'stand inactive 1',
                'stand inactive 2'
            ],
            $reader->vocabulariesForSlots(SlotIdentifier::RIGHTS_COST)
        );
    }

testVocabulariesForSlotsNoCopyright()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testVocabulariesForSlotsNoCopyright

(

)

Definition at line 279 of file ReaderTest.php.

                                                         : void
    {
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, 'stand active 1', 'stand active 2');
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, 'stand inactive 1', 'stand inactive 2');
 
        $reader = new Reader(
            $this->getCopyrightBridge(),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $this->assertVocabIDsMatch(
            [
                'contr active 1',
                'contr active 2',
                'contr inactive 1',
                'contr inactive 2',
                'stand active 1',
                'stand active 2',
                'stand inactive 1',
                'stand inactive 2'
            ],
            $reader->vocabulariesForSlots(SlotIdentifier::RIGHTS_COST)
        );
    }

testVocabularyInvalidVocabID()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testVocabularyInvalidVocabID

(

)

Definition at line 177 of file ReaderTest.php.

                                                  : void
    {
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, SlotIdentifier::GENERAL_COVERAGE->value);
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, SlotIdentifier::RIGHTS_COST->value);
 
        $reader = new Reader(
            $this->getCopyrightBridge(),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $vocab = $reader->vocabulary('something entirely different');
 
        $this->assertInstanceOf(NullVocabulary::class, $vocab);
    }

References $vocab.

testVocabularyInvalidVocabIDFromControlledVocabulary()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testVocabularyInvalidVocabIDFromControlledVocabulary

(

)

Definition at line 231 of file ReaderTest.php.

                                                                          : void
    {
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, SlotIdentifier::GENERAL_COVERAGE->value);
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, SlotIdentifier::RIGHTS_COST->value);
 
        $reader = new Reader(
            $this->getCopyrightBridge(),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $vocab = $reader->vocabulary('contr active 1');
 
        $this->assertSame('contr active 1', $vocab->id());
    }

References $vocab.

testVocabularyInvalidVocabIDFromCopyrightSlot()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testVocabularyInvalidVocabIDFromCopyrightSlot

(

)

Definition at line 212 of file ReaderTest.php.

                                                                   : void
    {
        $cp_vocab = $this->getVocabulary(true, SlotIdentifier::RIGHTS_DESCRIPTION->value);
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, SlotIdentifier::GENERAL_COVERAGE->value);
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, SlotIdentifier::RIGHTS_COST->value);
 
        $reader = new Reader(
            $this->getCopyrightBridge($cp_vocab),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $vocab = $reader->vocabulary(SlotIdentifier::RIGHTS_DESCRIPTION->value);
 
        $this->assertSame(SlotIdentifier::RIGHTS_DESCRIPTION->value, $vocab->id());
    }

References $vocab.

testVocabularyInvalidVocabIDFromStandardSlot()

ILIAS\MetaData\Vocabularies\Dispatch\ReaderTest::testVocabularyInvalidVocabIDFromStandardSlot

(

)

Definition at line 195 of file ReaderTest.php.

                                                                  : void
    {
        $active_controlled_vocabs = $this->getVocabsWithIDs(true, 'contr active 1', 'contr active 2');
        $inactive_controlled_vocabs = $this->getVocabsWithIDs(false, 'contr inactive 1', 'contr inactive 2');
        $active_standard_vocabs = $this->getVocabsWithIDs(true, SlotIdentifier::GENERAL_COVERAGE->value);
        $inactive_standard_vocabs = $this->getVocabsWithIDs(false, SlotIdentifier::RIGHTS_COST->value);
 
        $reader = new Reader(
            $this->getCopyrightBridge(),
            $this->getControlledRepo(...$active_controlled_vocabs, ...$inactive_controlled_vocabs),
            $this->getStandardRepo(...$active_standard_vocabs, ...$inactive_standard_vocabs)
        );
 
        $vocab = $reader->vocabulary(SlotIdentifier::RIGHTS_COST->value);
 
        $this->assertSame(SlotIdentifier::RIGHTS_COST->value, $vocab->id());
    }

References $vocab.

---

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

• components/ILIAS/MetaData/tests/Vocabularies/Dispatch/ReaderTest.php