FlySystemFileStreamAccessTestTBD.php

Go to the documentation of this file.

<?php
 
namespace Filesystem\Provider\FlySystem;
 
use ILIAS\Filesystem\Exception\FileNotFoundException;
use Hamcrest\Util;
use Mockery\LegacyMockInterface;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\Small;
 
Util::registerGlobalFunctions();
 
use ILIAS\Filesystem\Exception\FileAlreadyExistsException;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\Provider\FlySystem\FlySystemFileStreamAccess;
use ILIAS\Filesystem\Stream\Streams;
use League\Flysystem\FilesystemInterface;
use League\Flysystem\FilesystemOperator;
use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
use Mockery\MockInterface;
use PHPUnit\Framework\TestCase;
use League\Flysystem\UnableToReadFile;
use League\Flysystem\UnableToWriteFile;
 
class FlySystemFileStreamAccessTest extends TestCase
{
    use MockeryPHPUnitIntegration;
 
    private LegacyMockInterface $filesystemMock;
    private FlySystemFileStreamAccess $subject;
 
 
    protected function setUp(): void
    {
        parent::setUp();
 
        $this->filesystemMock = \Mockery::mock(FilesystemOperator::class);
        $this->subject = new FlySystemFileStreamAccess($this->filesystemMock);
    }
 
    #[Test]
 
    public function testReadStreamWhichShouldSucceed(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = fopen('data://text/plain,' . $fileContent, $fileContent, 'r');
 
        $this->filesystemMock->shouldReceive('readStream')
            ->once()
            ->with($path)
            ->andReturn($stream);
 
        $wrappedStream = $this->subject->readStream($path);
 
        $this->assertSame($fileContent, $wrappedStream->getContents());
    }
 
    #[Test]
 
    public function testReadStreamWithMissingFileWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
 
        $this->filesystemMock->shouldReceive('readStream')
            ->once()
            ->with($path)
            ->andThrow(UnableToReadFile::class);
 
        $this->expectException(FileNotFoundException::class);
        $this->expectExceptionMessage("File \"$path\" not found.");
 
        $this->subject->readStream($path);
    }
 
    #[Test]
 
    public function testReadStreamWithGeneralFailureWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
 
        $this->filesystemMock->shouldReceive('readStream')
            ->once()
            ->with($path)
            ->andReturn(false);
 
        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not open stream for file \"$path\"");
 
        $this->subject->readStream($path);
    }
 
    #[Test]
 
    public function testWriteStreamWhichShouldSucceed(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock
            ->shouldReceive('fileExists')
            ->once()
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(true);
 
        $this->subject->writeStream($path, $stream);
    }
 
    #[Test]
 
    public function testWriteStreamWithDetachedStreamWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
        $stream->detach();
 
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('The given stream must not be detached.');
 
        $this->subject->writeStream($path, $stream);
    }
 
    #[Test]
 
    public function testWriteStreamWithExistingFileWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock
            ->shouldReceive('fileExists')
            ->once()
            ->andReturn(true);
 
        $this->expectException(FileAlreadyExistsException::class);
        $this->expectExceptionMessage("File \"$path\" already exists.");
 
        $this->subject->writeStream($path, $stream);
    }
 
    #[Test]
 
    public function testWriteStreamWithFailingAdapterWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock
            ->shouldReceive('fileExists')
            ->once()
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andThrow(UnableToWriteFile::class);
 
        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not write stream to file \"$path\"");
 
        $this->subject->writeStream($path, $stream);
    }
 
    #[Test]
 
    public function testPutStreamWhichShouldSucceed(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock->shouldReceive('putStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(true);
 
        $this->subject->putStream($path, $stream);
    }
 
    #[Test]
 
    public function testPutStreamWithGeneralFailureWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock->shouldReceive('putStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(false);
 
        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not put stream content into \"$path\"");
 
        $this->subject->putStream($path, $stream);
    }
 
    #[Test]
 
    public function testPutStreamWithDetachedStreamWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
        $stream->detach();
 
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('The given stream must not be detached.');
 
        $this->subject->putStream($path, $stream);
    }
 
    #[Test]
 
    public function testUpdateStreamWhichShouldSucceed(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(true);
 
        $this->subject->updateStream($path, $stream);
    }
 
    #[Test]
 
    public function testUpdateStreamWithDetachedStreamWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
        $stream->detach();
 
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('The given stream must not be detached.');
 
        $this->subject->updateStream($path, $stream);
    }
 
    #[Test]
 
    public function testUpdateStreamWithGeneralFailureWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock
            ->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andThrow(UnableToWriteFile::class);
 
        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Unable to update Stream in \"$path\".");
 
        $this->subject->updateStream($path, $stream);
    }
 
    #[Test]
 
    public function testUpdateStreamWithMissingFileWhichShouldFail(): void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);
 
        $this->filesystemMock
            ->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andThrow(UnableToWriteFile::class);
 
        $this->expectException(FileNotFoundException::class);
        $this->expectExceptionMessage("Unable to update Stream in \"$path\".");
 
        $this->subject->updateStream($path, $stream);
    }
}