CollectionTest.php

Go to the documentation of this file.

<?php
 
namespace ILIAS\ResourceStorage\Resource;
 
use ILIAS\ResourceStorage\AbstractBaseResourceBuilderTestCase;
use ILIAS\ResourceStorage\Collection\CollectionBuilder;
use ILIAS\ResourceStorage\Collection\Collections;
use ILIAS\ResourceStorage\Collection\ResourceCollection;
use ILIAS\ResourceStorage\DummyIDGenerator;
use ILIAS\ResourceStorage\Identification\CollectionIdentificationGenerator;
use ILIAS\ResourceStorage\Identification\ResourceCollectionIdentification;
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\ResourceStorage\Preloader\RepositoryPreloader;
use PHPUnit\Framework\MockObject\MockObject;
use ILIAS\ResourceStorage\Events\Subject;
 
class CollectionTest extends AbstractBaseResourceBuilderTestCase
{
    public $collection_builder;
    public MockObject $preloader;
    public $collections;
    public const DUMMY_RCID = 'dummy-rcid';
 
    protected CollectionIdentificationGenerator $rcid_generator;
 
    #[\Override]
    protected function setUp(): void
    {
        parent::setUp();
        $this->rcid_generator = new DummyIDGenerator(self::DUMMY_RCID);
 
        $this->collection_builder = new CollectionBuilder(
            $this->collection_repository,
            new Subject(),
            $this->rcid_generator
        );
 
        $this->preloader = $this->getMockBuilder(RepositoryPreloader::class)
            ->disableOriginalConstructor()
            ->getMock();
 
        $this->resource_builder = new ResourceBuilder(
            $this->storage_handler_factory,
            $this->repositories,
            $this->locking,
            $this->stream_access
        );
 
        $this->collections = new Collections(
            $this->resource_builder,
            $this->collection_builder,
            $this->preloader,
            new Subject()
        );
    }
 
    public function testCreateCollection(): void
    {
        $identifiation = $this->rcid_generator->getUniqueResourceCollectionIdentification();
        $this->collection_repository->method('blank')->with($identifiation)->willReturn(
            new ResourceCollection($identifiation, -1, '')
        );
 
        $id = $this->collections->id();
 
        $this->assertInstanceOf(ResourceCollectionIdentification::class, $id);
        $this->assertNotInstanceOf(MockObject::class, $id);
        $this->assertSame(self::DUMMY_RCID, $id->serialize());
    }
 
    public function testGetCollectionOfUser(): void
    {
        $identifiation = $this->rcid_generator->getUniqueResourceCollectionIdentification();
        $this->collection_repository->method('blank')->with($identifiation)->willReturn(
            new ResourceCollection($identifiation, 42, '')
        );
 
        $id = $this->collections->id($identifiation->serialize());
 
        $this->collection_repository->method('getResourceIdStrings')->with($identifiation)->willReturn(
            $this->arrayAsGenerator([])
        );
 
        $collection = $this->collections->get($id, 42);
 
        $this->assertInstanceOf(ResourceCollection::class, $collection);
        $this->assertNotInstanceOf(MockObject::class, $collection);
        $this->assertSame(self::DUMMY_RCID, $collection->getIdentification()->serialize());
        $this->assertSame([], $collection->getResourceIdentifications());
    }
 
    public function testIsIn(): void
    {
        $collection = new ResourceCollection(new ResourceCollectionIdentification(self::DUMMY_RCID), 42, '');
 
        $this->assertSame(self::DUMMY_RCID, $collection->getIdentification()->serialize());
        $this->assertSame(42, $collection->getOwner());
        $this->assertTrue($collection->hasSpecificOwner());
        $this->assertSame('default', $collection->getTitle());
 
        $rid_one = new ResourceIdentification('rid_one');
        $rid_two = new ResourceIdentification('rid_two');
        $rid_three = new ResourceIdentification('rid_three');
 
        $this->assertSame(0, $collection->count());
 
        $collection->add($rid_one);
        $this->assertTrue($collection->isIn($rid_one));
        $this->assertFalse($collection->isIn($rid_two));
        $this->assertFalse($collection->isIn($rid_three));
        $this->assertSame(1, $collection->count());
 
        $collection->add($rid_two);
        $this->assertTrue($collection->isIn($rid_one));
        $this->assertTrue($collection->isIn($rid_two));
        $this->assertFalse($collection->isIn($rid_three));
        $this->assertSame(2, $collection->count());
 
        $collection->add($rid_three);
        $this->assertTrue($collection->isIn($rid_one));
        $this->assertTrue($collection->isIn($rid_two));
        $this->assertTrue($collection->isIn($rid_three));
        $this->assertSame(3, $collection->count());
 
        $collection->clear();
        $this->assertFalse($collection->isIn($rid_one));
        $this->assertFalse($collection->isIn($rid_two));
        $this->assertFalse($collection->isIn($rid_three));
        $this->assertSame(0, $collection->count());
    }
 
    public function testAddAndRemove(): void
    {
        $collection = new ResourceCollection(
            new ResourceCollectionIdentification(self::DUMMY_RCID),
            ResourceCollection::NO_SPECIFIC_OWNER,
            ''
        );
 
        $this->assertSame(self::DUMMY_RCID, $collection->getIdentification()->serialize());
        $this->assertSame(ResourceCollection::NO_SPECIFIC_OWNER, $collection->getOwner());
        $this->assertFalse($collection->hasSpecificOwner());
        $this->assertSame('default', $collection->getTitle());
 
        $rid_one = new ResourceIdentification('rid_one');
        $rid_two = new ResourceIdentification('rid_two');
 
        $this->assertSame(0, $collection->count());
 
        $collection->add($rid_one);
        $this->assertTrue($collection->isIn($rid_one));
        $this->assertSame(1, $collection->count());
 
        $collection->add($rid_two);
        $this->assertTrue($collection->isIn($rid_one));
        $this->assertTrue($collection->isIn($rid_two));
        $this->assertSame(2, $collection->count());
 
        $collection->remove($rid_one);
        $this->assertFalse($collection->isIn($rid_one));
        $this->assertTrue($collection->isIn($rid_two));
        $this->assertSame(1, $collection->count());
 
        $collection->remove($rid_two);
        $this->assertFalse($collection->isIn($rid_one));
        $this->assertFalse($collection->isIn($rid_two));
        $this->assertSame(0, $collection->count());
 
        $collection->clear();
        $this->assertFalse($collection->isIn($rid_one));
        $this->assertFalse($collection->isIn($rid_two));
        $this->assertSame(0, $collection->count());
    }
 
    public function testDuplicates(): void
    {
        $rid = new ResourceIdentification('rid');
        $same_rid = new ResourceIdentification('rid');
 
        $collection = new ResourceCollection(
            new ResourceCollectionIdentification(self::DUMMY_RCID),
            ResourceCollection::NO_SPECIFIC_OWNER,
            ''
        );
        $collection->add($rid);
        $collection->add($same_rid);
 
        $this->assertCount(1, $collection->getResourceIdentifications());
    }
 
 
    public function testRidCache(): void
    {
        $resource_collection_identification = new ResourceCollectionIdentification(self::DUMMY_RCID);
        $rid_one = new ResourceIdentification('rid_one');
        $rid_two = new ResourceIdentification('rid_two');
        $rid_three = new ResourceIdentification('rid_three');
 
        $collections_service = new Collections(
            $this->resource_builder,
            $this->collection_builder,
            $this->preloader,
            new Subject()
        );
 
        $this->collection_repository
            ->expects($this->once())
            ->method('existing')
            ->with($resource_collection_identification)
            ->willReturn(
                new ResourceCollection($resource_collection_identification, -1, 'title')
            );
 
        $collection = $collections_service->get(
            $resource_collection_identification
        );
        $this->assertCount(0, $collection->getResourceIdentifications());
 
        $collection->add($rid_one);
        $collection->add($rid_two);
        $collection->add($rid_three);
 
        $this->assertCount(3, $collection->getResourceIdentifications());
 
        $collections_service->store($collection);
        $consecutive = [
            $rid_one,
            $rid_two,
            $rid_three
        ];
        $this->resource_repository
            ->expects($this->exactly(3))
            ->method('has')
            ->willReturnCallback(
                function ($rid) use (&$consecutive): true {
                    $expected = array_shift($consecutive);
                    $this->assertEquals($expected, $rid);
                    return true;
                }
            );
 
        $collection = $collections_service->get(
            $resource_collection_identification
        );
 
        $this->assertCount(3, $collection->getResourceIdentifications());
    }
 
 
    protected function arrayAsGenerator(array $array): \Generator
    {
        foreach ($array as $item) {
            yield $item;
        }
    }
}