FlavourTest.php

Go to the documentation of this file.

<?php
 
namespace ILIAS\ResourceStorage\Flavours;
 
use PHPUnit\Framework\MockObject\MockObject;
use ILIAS\Filesystem\Stream\Streams;
use ILIAS\ResourceStorage\AbstractTestBase;
use ILIAS\ResourceStorage\Consumer\StreamAccess\StreamAccess;
use ILIAS\ResourceStorage\Flavour\Definition\FlavourDefinition;
use ILIAS\ResourceStorage\Flavour\Flavour;
use ILIAS\ResourceStorage\Flavour\FlavourBuilder;
use ILIAS\ResourceStorage\Flavour\Machine\Factory;
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\ResourceStorage\Information\FileInformation;
use ILIAS\ResourceStorage\Resource\Repository\FlavourRepository;
use ILIAS\ResourceStorage\Resource\ResourceBuilder;
use ILIAS\ResourceStorage\Resource\StorableResource;
use ILIAS\ResourceStorage\Revision\FileRevision;
use ILIAS\ResourceStorage\StorageHandler\StorageHandler;
use ILIAS\ResourceStorage\StorageHandler\StorageHandlerFactory;
use ILIAS\ResourceStorage\Consumer\StreamAccess\StreamResolver;
use ILIAS\ResourceStorage\Events\Subject;
 
require_once __DIR__ . '/../AbstractTestBase.php';
 
class FlavourTest extends AbstractTestBase
{
    public MockObject $resource_builder;
    private const string BASE_DIR = '/var';
    private Factory $machine_factory;
    protected $storage_handler_factory;
    private MockObject $flavour_repo;
    private StreamAccess $stream_access;
 
    #[\Override]
    protected function setUp(): void
    {
        $this->machine_factory = new Factory(new \ILIAS\ResourceStorage\Flavour\Engine\Factory());
        $storage_handler_mock = $this->createMock(StorageHandler::class);
        $storage_handler_mock->method('isPrimary')->willReturn(true);
        $this->storage_handler_factory = new StorageHandlerFactory([
            $storage_handler_mock
        ], self::BASE_DIR);
        $this->flavour_repo = $this->createMock(FlavourRepository::class);
        $this->resource_builder = $this->createMock(ResourceBuilder::class);
        $this->stream_access = new StreamAccess(self::BASE_DIR, $this->storage_handler_factory);
    }
 
 
    public function testDefinitionVariantNameLengths(): void
    {
        $flavour_builder = new FlavourBuilder(
            $this->flavour_repo,
            $this->machine_factory,
            $this->resource_builder,
            $this->storage_handler_factory,
            $this->stream_access,
            new Subject()
        );
 
        // Length OK
        $flavour_definition = $this->createMock(FlavourDefinition::class);
        $flavour_definition->expects($this->exactly(2))
            ->method('getVariantName')
            ->willReturn(str_repeat('a', 768));
 
        $flavour_builder->has(
            new ResourceIdentification('1'),
            $flavour_definition
        );
        $this->assertTrue(true); // no exception thrown
 
        // Too long
        $flavour_definition = $this->createMock(FlavourDefinition::class);
        $flavour_definition->expects($this->exactly(2))
            ->method('getVariantName')
            ->willReturn(str_repeat('a', 769));
 
        $this->expectException(\InvalidArgumentException::class);
        $flavour_builder->has(
            new ResourceIdentification('1'),
            $flavour_definition
        );
    }
 
    public function testHasFlavour(): void
    {
        // Data
        $rid_one = new ResourceIdentification('1');
        $rid_two = new ResourceIdentification('2');
        $flavour_builder = new FlavourBuilder(
            $this->flavour_repo,
            $this->machine_factory,
            $this->resource_builder,
            $this->storage_handler_factory,
            $this->stream_access,
            new Subject()
        );
 
        // Expectations
        $flavour_definition = $this->createMock(FlavourDefinition::class);
        $flavour_definition->expects($this->exactly(4))
            ->method('getVariantName')
            ->willReturn('short');
 
 
        $consecutive = [
                [[$rid_one, 0, $flavour_definition], false],
                [[$rid_two, 0, $flavour_definition], true],
        ];
        $this->flavour_repo
            ->expects($this->exactly(2))
            ->method('has')
            ->willReturnCallback(
                function ($rid, $mid, $def) use (&$consecutive) {
                    [$expected, $ret] = array_shift($consecutive);
                    $this->assertEquals($expected, [$rid, $mid, $def]);
                    return $ret;
                }
            );
 
        // Assertions
        $this->assertFalse(
            $flavour_builder->has(
                $rid_one,
                $flavour_definition
            )
        );
        $this->assertTrue(
            $flavour_builder->has(
                $rid_two,
                $flavour_definition
            )
        );
    }
 
    public function testNewFlavour(): void
    {
        // Data
        $rid_one = new ResourceIdentification('1');
        $flavour_builder = new FlavourBuilder(
            $this->flavour_repo,
            $this->machine_factory,
            $this->resource_builder,
            $this->storage_handler_factory,
            $this->stream_access,
            new Subject()
        );
 
        // Expectations
        $flavour_definition = $this->createMock(FlavourDefinition::class);
        $flavour_definition
            ->method('getVariantName')
            ->willReturn('short');
 
        $this->flavour_repo->expects($this->once())
            ->method('has')
            ->with($rid_one, 0, $flavour_definition)
            ->willReturn(false);
 
        $this->resource_builder->expects($this->once())
            ->method('has')
            ->with($rid_one)
            ->willReturn(true);
 
        $revision = $this->createMock(FileRevision::class);
 
        $revision->expects($this->once())
            ->method('getInformation')
            ->willReturn($this->createMock(FileInformation::class));
 
        $stream = Streams::ofString('test');
 
        $resource = $this->createMock(StorableResource::class);
 
        $this->resource_builder->expects($this->once())
            ->method('get')
            ->with($rid_one)
            ->willReturn($resource);
 
        $resource
            ->method('getCurrentRevision')
            ->willReturn($revision);
 
 
        $this->resource_builder->expects($this->once())
            ->method('extractStream')
            ->with($revision)
            ->willReturn($stream);
 
 
        // Assertions
        $flavour = $flavour_builder->get(
            $rid_one,
            $flavour_definition
        );
        $this->assertInstanceOf(Flavour::class, $flavour);
        $stream_resolvers = $flavour->getStreamResolvers();
        $this->assertCount(1, $stream_resolvers);
        $first_stream_access = $stream_resolvers[0];
        $this->assertInstanceOf(StreamResolver::class, $first_stream_access);
        $resolved_stream = $first_stream_access->getStream();
        $this->assertSame('empty', (string) $resolved_stream);
    }
}