FlySystemDirectoryAccessTest.php

Go to the documentation of this file.

<?php

namespace ILIAS\Filesystem\Provider\FlySystem;

\Hamcrest\Util::registerGlobalFunctions();

use ILIAS\Filesystem\DTO\Metadata;
use ILIAS\Filesystem\Exception\DirectoryNotFoundException;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\MetadataType;
use ILIAS\Filesystem\Visibility;
use League\Flysystem\FilesystemInterface;
use League\Flysystem\RootViolationException;
use Mockery;
use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
use Mockery\MockInterface;
use PHPUnit\Framework\TestCase;

/******************************************************************************
 *
 * This file is part of ILIAS, a powerful learning management system.
 *
 * ILIAS is licensed with the GPL-3.0, you should have received a copy
 * of said license along with the source code.
 *
 * If this is not the case or you just want to try ILIAS, you'll find
 * us at:
 *      https://www.ilias.de
 *      https://github.com/ILIAS-eLearning
 *
 *****************************************************************************/
class FlySystemDirectoryAccessTest extends TestCase
{
    use MockeryPHPUnitIntegration;

    private $subject;
    private $filesystemMock;
    private $fileAccessMock;

    protected function setUp(): void
    {
        parent::setUp();

        $this->filesystemMock = Mockery::mock(FilesystemInterface::class);
        $this->fileAccessMock = Mockery::mock(FlySystemFileAccess::class);

        $this->subject = new FlySystemDirectoryAccess($this->filesystemMock, $this->fileAccessMock);
    }

    public function testHasDirWhichShouldSucceed(): void
    {
        $path = '/path/to/dir';
        $metadata = [
            'type' => 'dir',
            'path' => $path,
            'timestamp' => 10_000_000
        ];

        $this->filesystemMock
            ->shouldReceive('has')
            ->with($path)
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('getMetadata')
            ->once()
            ->andReturn($metadata);

        $exists = $this->subject->hasDir($path);
        $this->assertTrue($exists);
    }

    public function testHasDirWithFileTargetWhichShouldFail(): void
    {
        $path = '/path/to/file';
        $metadata = [
            'type' => 'file',
            'path' => $path,
            'timestamp' => 10_000_000
        ];

        $this->filesystemMock
            ->shouldReceive('has')
            ->with($path)
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('getMetadata')
            ->once()
            ->andReturn($metadata);

        $exists = $this->subject->hasDir($path);
        $this->assertFalse($exists);
    }

    public function testHasDirWithoutTypeInformationWhichShouldFail(): void
    {
        $path = '/path/to/file';
        $metadata = [
            'path' => $path,
            'timestamp' => 10_000_000
        ];

        $this->filesystemMock
            ->shouldReceive('has')
            ->with($path)
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('getMetadata')
            ->once()
            ->andReturn($metadata);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not evaluate path type: \"$path\"");

        $exists = $this->subject->hasDir($path);
        $this->assertFalse($exists);
    }

    public function testHasDirWithMissingDirWhichShouldSucceed(): void
    {
        $path = '/path/to/dir';

        $this->filesystemMock
            ->shouldReceive('has')
            ->with($path)
            ->andReturn(false);

        $exists = $this->subject->hasDir($path);
        $this->assertFalse($exists);
    }

    public function testListContentsWhichShouldSucceed(): void
    {
        $path = '/path/to/dir';
        $file = ['type' => 'file', 'path' => $path];
        $dir = ['type' => 'dir', 'path' => $path];

        $contentList = [
            $file,
            $dir
        ];

        $this->filesystemMock
            ->shouldReceive('listContents')
            ->once()
            ->withArgs([$path, \boolValue()])
            ->andReturn($contentList)
            ->getMock()
            ->shouldReceive('has')
            ->once()
            ->with($path)
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('getMetadata')
            ->once()
            ->with($path)
            ->andReturn($dir);

        $content = $this->subject->listContents($path);

        $this->assertSame($contentList[0]['type'], $content[0]->getType());
        $this->assertSame($contentList[0]['path'], $content[0]->getPath());
        $this->assertTrue($content[0]->isFile());
        $this->assertFalse($content[0]->isDir());
        $this->assertSame($contentList[1]['type'], $content[1]->getType());
        $this->assertSame($contentList[1]['path'], $content[1]->getPath());
        $this->assertTrue($content[1]->isDir());
        $this->assertFalse($content[1]->isFile());
    }

    public function testListContentsWithMissingRootDirectoryWhichShouldFail(): void
    {
        $path = '/path/to/dir';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->andReturn(false);

        $this->expectException(DirectoryNotFoundException::class);
        $this->expectExceptionMessage("Directory \"$path\" not found.");

        $this->subject->listContents($path);
    }

    public function testListContentsWithInvalidMetadataWhichShouldFail(): void
    {
        $path = '/path/to/dir';
        $file = ['type' => 'file', 'path' => $path];
        $dir = ['type' => 'dir'];

        $contentList = [
            $file,
            $dir,
            $file
        ];

        $this->filesystemMock
            ->shouldReceive('listContents')
            ->once()
            ->andReturn($contentList)
            ->getMock()
            ->shouldReceive('has')
            ->once()
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('getMetadata')
            ->once()
            ->andReturn($dir);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Invalid metadata received for path \"$path\"");

        $this->subject->listContents($path);
    }

    public function testCreateDirWhichShouldSucceed(): void
    {
        $path = '/path/to/dir';
        $access = Visibility::PRIVATE_ACCESS;

        $this->filesystemMock
            ->shouldReceive('createDir')
            ->once()
            ->withArgs([$path, ['visibility' => $access]])
            ->andReturn(true);

        $this->subject->createDir($path, $access);
    }

    public function testCreateDirWithGeneralErrorWhichShouldFail(): void
    {
        $path = '/path/to/dir';
        $access = Visibility::PRIVATE_ACCESS;

        $this->filesystemMock
            ->shouldReceive('createDir')
            ->once()
            ->withArgs([$path, ['visibility' => $access]])
            ->andReturn(false);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not create directory \"$path\"");

        $this->subject->createDir($path, $access);
    }

    public function testCreateDirWithInvalidVisibilityWhichShouldFail(): void
    {
        $path = '/path/to/dir';
        $access = 'invalid';

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage("Invalid visibility expected public or private but got \"$access\".");

        $this->subject->createDir($path, $access);
    }

    public function testCopyDirWhichShouldSucceed(): void
    {
        $srcPath = '/source/path/to/dir';
        $destPath = '/dest/path/to/dir';

        $fileSourceList = [
            new Metadata("$srcPath/hello1", MetadataType::FILE),
            new Metadata("$srcPath/helloDir", MetadataType::DIRECTORY),
            new Metadata("$srcPath/hello2", MetadataType::FILE),
            new Metadata("$srcPath/hello/subhello1", MetadataType::FILE),
            new Metadata("$srcPath/helloDir2", MetadataType::DIRECTORY),
            new Metadata("$srcPath/hello3", MetadataType::FILE),
            new Metadata("$srcPath/hello/subhello2", MetadataType::FILE),
        ];

        $fileDestinationList = [];

        $subjectMock = Mockery::mock(
            FlySystemDirectoryAccess::class . '[listContents, hasDir]',
            [$this->filesystemMock, $this->fileAccessMock]
        );
        $subjectMock
            ->shouldReceive('listContents')
            ->withArgs([$srcPath, true])
            ->once()
            ->andReturn($fileSourceList)
            ->getMock()
            ->shouldReceive('listContents')
            ->withArgs([$destPath, true])
            ->once()
            ->andReturn($fileDestinationList);

        $subjectMock
            ->shouldReceive('hasDir')
            ->with($srcPath)
            ->once()
            ->andReturn(true);

        $this->fileAccessMock
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[0]->getPath(), "$destPath/hello1"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[2]->getPath(), "$destPath/hello2"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[3]->getPath(), "$destPath/hello/subhello1"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[5]->getPath(), "$destPath/hello3"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[6]->getPath(), "$destPath/hello/subhello2"])
            ->once()
            ->getMock();

        $subjectMock->copyDir($srcPath, $destPath);
    }

    public function testCopyDirWithDestinationListContentErrorWhichShouldSucceed(): void
    {
        $srcPath = '/source/path/to/dir';
        $destPath = '/dest/path/to/dir';

        $fileSourceList = [
            new Metadata("$srcPath/hello1", MetadataType::FILE),
            new Metadata("$srcPath/helloDir", MetadataType::DIRECTORY),
            new Metadata("$srcPath/hello2", MetadataType::FILE),
            new Metadata("$srcPath/hello/subhello1", MetadataType::FILE),
            new Metadata("$srcPath/helloDir2", MetadataType::DIRECTORY),
            new Metadata("$srcPath/hello3", MetadataType::FILE),
            new Metadata("$srcPath/hello/subhello2", MetadataType::FILE),
        ];

        $subjectMock = Mockery::mock(
            FlySystemDirectoryAccess::class . '[listContents, hasDir]',
            [$this->filesystemMock, $this->fileAccessMock]
        );
        $subjectMock
            ->shouldReceive('listContents')
            ->withArgs([$srcPath, true])
            ->once()
            ->andReturn($fileSourceList)
            ->getMock()
            ->shouldReceive('listContents')
            ->withArgs([$destPath, true])
            ->once()
            ->andThrow(DirectoryNotFoundException::class);

        $subjectMock
            ->shouldReceive('hasDir')
            ->with($srcPath)
            ->once()
            ->andReturn(true);

        $this->fileAccessMock
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[0]->getPath(), "$destPath/hello1"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[2]->getPath(), "$destPath/hello2"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[3]->getPath(), "$destPath/hello/subhello1"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[5]->getPath(), "$destPath/hello3"])
            ->once()
            ->getMock()
            ->shouldReceive('copy')
            ->withArgs([$fileSourceList[6]->getPath(), "$destPath/hello/subhello2"])
            ->once()
            ->getMock();

        $subjectMock->copyDir($srcPath, $destPath);
    }

    public function testCopyDirWithFullDestinationDirWhichShouldFail(): void
    {
        $srcPath = '/source/path/to/dir';
        $destPath = '/dest/path/to/dir';

        $fileDestinationList = [
            new Metadata("$srcPath/hello1", MetadataType::FILE),
            new Metadata("$srcPath/helloDir", MetadataType::DIRECTORY),
            new Metadata("$srcPath/hello2", MetadataType::FILE),
            new Metadata("$srcPath/hello/subhello1", MetadataType::FILE),
            new Metadata("$srcPath/helloDir2", MetadataType::DIRECTORY),
            new Metadata("$srcPath/hello3", MetadataType::FILE),
            new Metadata("$srcPath/hello/subhello2", MetadataType::FILE),
        ];

        $subjectMock = Mockery::mock(
            FlySystemDirectoryAccess::class . '[listContents, hasDir]',
            [$this->filesystemMock, $this->fileAccessMock]
        );
        $subjectMock
            ->shouldReceive('listContents')
            ->withArgs([$destPath, true])
            ->once()
            ->andReturn($fileDestinationList);

        $subjectMock
            ->shouldReceive('hasDir')
            ->with($srcPath)
            ->once()
            ->andReturn(true);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Destination \"$destPath\" is not empty can not copy files.");

        $subjectMock->copyDir($srcPath, $destPath);
    }

    public function testCopyDirWithMissingSourceDirWhichShouldFail(): void
    {
        $srcPath = '/source/path/to/dir';
        $destPath = '/dest/path/to/dir';

        $subjectMock = Mockery::mock(
            FlySystemDirectoryAccess::class . '[hasDir]',
            [$this->filesystemMock, $this->fileAccessMock]
        );
        $subjectMock
            ->shouldReceive('hasDir')
            ->with($srcPath)
            ->once()
            ->andReturn(false);

        $this->expectException(DirectoryNotFoundException::class);
        $this->expectExceptionMessage("Directory \"$srcPath\" not found");

        $subjectMock->copyDir($srcPath, $destPath);
    }

    public function testDeleteDirWhichShouldSucceed(): void
    {
        $path = '/directory/which/should/be/removed';

        $this->filesystemMock
            ->shouldReceive('deleteDir')
            ->once()
            ->with($path)
            ->andReturn(true);

        $this->subject->deleteDir($path);
    }

    public function testDeleteDirWithRootViolationWhichShouldFail(): void
    {
        $path = '';

        $this->filesystemMock
            ->shouldReceive('deleteDir')
            ->once()
            ->with($path)
            ->andThrow(RootViolationException::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage('The filesystem root must not be deleted.');

        $this->subject->deleteDir($path);
    }

    public function testDeleteDirWithGeneralErrorWhichShouldFail(): void
    {
        $path = '/directory/which/should/be/removed';

        $this->filesystemMock
            ->shouldReceive('deleteDir')
            ->once()
            ->with($path)
            ->andReturn(false);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not delete directory \"$path\".");

        $this->subject->deleteDir($path);
    }
}