ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest Class Reference

Inheritance diagram for ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest:

Collaboration diagram for ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest:

Public Member Functions
	testReadWhichShouldSucceed ()
	testReadWithGeneralFileAccessErrorWhichShouldFail ()
	testReadWithMissingFileWhichShouldFail ()
	testGetMimeTypeWhichShouldSucceed ()
	testPutContentExistingFile ()
	testPutContentNonExistingFile ()
	testGetMimeTypeWithUnknownMimeTypeWhichShouldFail ()
	testGetMimeTypeWithMissingFileWhichShouldFail ()
	testGetTimestampWhichShouldSucceed ()
	testGetTimestampWithUnknownErrorWhichShouldFail ()
	testGetTimestampWithMissingFileWhichShouldFail ()
	testGetSizeWhichShouldSucceed ()
	testGetSizeWithUnknownAdapterErrorWhichShouldFail ()
	testGetSizeWithMissingFileWhichShouldFail ()
	testSetVisibilityWhichShouldSucceed ()
	testSetVisibilityThatFailedDueToAdapterFailureWhichShouldFail ()
	testSetVisibilityWithMissingFileWhichShouldFail ()
	testSetVisibilityWithInvalidAccessModifierWhichShouldFail ()
	testGetVisibilityWhichShouldSucceed ()
	testGetVisibilityWithMissingFileWhichShouldFail ()
	testGetVisibilityWithAdapterErrorWhichShouldFail ()
	testWriteWhichShouldSucceed ()
	testWriteWithAlreadyExistingFileWhichShouldFail ()
	testWriteWithAdapterErrorWhichShouldFail ()
	testUpdateWhichShouldSucceed ()
	testUpdateWithAdapterErrorWhichShouldFail ()
	testUpdateWithMissingFileWhichShouldFail ()
	testDeleteWhichShouldSucceed ()
	testDeleteWithAdapterErrorWhichShouldFail ()
	testDeleteWithMissingFileWhichShouldFail ()
	testReadAndDeleteWhichShouldSucceed ()
	testRenameWhichShouldSucceed ()
	testRenameWithMissingSourceWhichShouldFail ()
	testRenameWithExistingDestinationWhichShouldFail ()
	testRenameWithGeneralErrorWhichShouldFail ()
	testCopyWhichShouldSucceed ()
	testCopyWithAdapterErrorWhichShouldFail ()
	testCopyWithMissingFileWhichShouldFail ()
	testCopyWithExistingDestinationFileWhichShouldFail ()

Protected Member Functions
	setUp ()
	Sets up the fixture, for example, open a network connection. More...

Private Attributes
FlySystemFileAccess	$subject
Filesystem MockInterface	$filesystemMock
LegacyMockInterface	$adapterMock

Detailed Description

Author

Nicolas Schäfli ns@st.nosp@m.uder.nosp@m.-raim.nosp@m.ann..nosp@m.ch

Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 48 of file FlySystemFileAccessTestTBD.php.

Member Function Documentation

setUp()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::setUp ( )

protected

Sets up the fixture, for example, open a network connection.

This method is called before a test is executed.

Definition at line 63 of file FlySystemFileAccessTestTBD.php.

                              : void
    {
        parent::setUp();

        $this->filesystemMock = Mockery::mock(FilesystemOperator::class);
        $this->adapterMock = Mockery::mock(FilesystemAdapter::class);
        $this->subject = new FlySystemFileAccess($this->filesystemMock);
    }

testCopyWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testCopyWhichShouldSucceed

(

)

Definition at line 725 of file FlySystemFileAccessTestTBD.php.

                                                : void
    {
        $sourcePath = '/path/to/your/source/file';
        $destinationPath = '/path/to/your/destination/file';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destinationPath)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('copy')
            ->once()
            ->withArgs([$sourcePath, $destinationPath])
            ->andReturn(true);

        $this->subject->copy($sourcePath, $destinationPath);
    }

testCopyWithAdapterErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testCopyWithAdapterErrorWhichShouldFail

(

)

Definition at line 746 of file FlySystemFileAccessTestTBD.php.

                                                             : void
    {
        $sourcePath = '/path/to/your/source/file';
        $destinationPath = '/path/to/your/destination/file';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destinationPath)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('copy')
            ->once()
            ->withArgs([$sourcePath, $destinationPath])
            ->andThrow(UnableToCopyFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage(
            "Could not copy file \"$sourcePath\" to destination \"$destinationPath\" because a general IO error occurred. Please check that your destination is writable."
        );

        $this->subject->copy($sourcePath, $destinationPath);
    }

testCopyWithExistingDestinationFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testCopyWithExistingDestinationFileWhichShouldFail

(

)

Definition at line 796 of file FlySystemFileAccessTestTBD.php.

                                                                        : void
    {
        $sourcePath = '/path/to/your/source/file';
        $destinationPath = '/path/to/your/destination/file';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destinationPath)
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('copy')
            ->never()
            ->withArgs([$sourcePath, $destinationPath])
            ->andThrow(UnableToCopyFile::class);

        $this->expectException(FileAlreadyExistsException::class);
        $this->expectExceptionMessage("File \"$destinationPath\" already exists.");

        $this->subject->copy($sourcePath, $destinationPath);
    }

testCopyWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testCopyWithMissingFileWhichShouldFail

(

)

Definition at line 772 of file FlySystemFileAccessTestTBD.php.

                                                            : void
    {
        $sourcePath = '/path/to/your/source/file';
        $destinationPath = '/path/to/your/destination/file';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destinationPath)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('copy')
            ->once()
            ->withArgs([$sourcePath, $destinationPath])
            ->andThrow(UnableToRetrieveMetadata::class);

        $this->expectException(FileNotFoundException::class);
        $this->expectExceptionMessage("File source \"$sourcePath\" was not found copy failed.");

        $this->subject->copy($sourcePath, $destinationPath);
    }

testDeleteWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testDeleteWhichShouldSucceed

(

)

Definition at line 559 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                  : void
    {
        $path = '/path/to/your/file';

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

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

testDeleteWithAdapterErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testDeleteWithAdapterErrorWhichShouldFail

(

)

Definition at line 573 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                               : void
    {
        $path = '/path/to/your/file';

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

        $this->expectException(IOException::class);
        $this->expectExceptionMessage(
            "Could not delete file \"$path\" because a general IO error occurred. Please check that your target is writable."
        );

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

testDeleteWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testDeleteWithMissingFileWhichShouldFail

(

)

Definition at line 592 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                              : void
    {
        $path = '/path/to/your/file';

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

        $this->expectException(FileNotFoundException::class);
        $this->expectExceptionMessage("File \"$path\" was not found delete operation failed.");

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

testGetMimeTypeWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetMimeTypeWhichShouldSucceed

(

)

Definition at line 131 of file FlySystemFileAccessTestTBD.php.

                                                       : void
    {
        $mimeType = 'image/jpeg';
        $this->filesystemMock->shouldReceive('mimeType')
                             ->once()
                             ->andReturn($mimeType);

        $actualMimeType = $this->subject->getMimeType('/path/to/your/file');
        $this->assertSame($mimeType, $actualMimeType);
    }

testGetMimeTypeWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetMimeTypeWithMissingFileWhichShouldFail

(

)

Definition at line 186 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                   : void
    {
        $path = '/path/to/your/file';
        $this->filesystemMock->shouldReceive('mimeType')
                             ->once()
                             ->with($path)
                             ->andThrow(UnableToRetrieveMetadata::class);

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

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

testGetMimeTypeWithUnknownMimeTypeWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetMimeTypeWithUnknownMimeTypeWhichShouldFail

(

)

Definition at line 172 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                       : void
    {
        $path = '/path/to/your/file';
        $this->filesystemMock->shouldReceive('mimeType')
                             ->with($path)
                             ->once()
                             ->andReturn('');

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not determine the MIME type of the file \"$path\".");

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

testGetSizeWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetSizeWhichShouldSucceed

(

)

Definition at line 255 of file FlySystemFileAccessTestTBD.php.

References ILIAS\Data\DataSize\KiB.

                                                   : void
    {
        $rawSize = 1024;
        $size = new DataSize($rawSize, DataSize::KiB); //floating point is never that precise.

        $this->filesystemMock->shouldReceive('fileSize')
                             ->once()
                             ->andReturn($rawSize);

        $actualSize = $this->subject->getSize('/path/to/your/file', DataSize::KiB);
        $this->assertSame($size->getSize(), $actualSize->getSize(), '');
    }

testGetSizeWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetSizeWithMissingFileWhichShouldFail

(

)

Definition at line 283 of file FlySystemFileAccessTestTBD.php.

References $path, and ILIAS\Data\DataSize\GiB.

                                                               : void
    {
        $path = '/path/to/your/file';
        $this->filesystemMock
            ->shouldReceive('fileSize')
            ->once()
            ->with($path)
            ->andThrow(UnableToRetrieveMetadata::class);

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

        $this->subject->getSize($path, DataSize::GiB);
    }

testGetSizeWithUnknownAdapterErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetSizeWithUnknownAdapterErrorWhichShouldFail

(

)

Definition at line 268 of file FlySystemFileAccessTestTBD.php.

References $path, and ILIAS\Data\DataSize\MiB.

                                                                       : void
    {
        $path = '/path/to/your/file';
        $this->filesystemMock
            ->shouldReceive('fileSize')
            ->with($path)
            ->once()
            ->andThrow(UnableToRetrieveMetadata::class);

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

        $this->subject->getSize($path, DataSize::MiB);
    }

testGetTimestampWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetTimestampWhichShouldSucceed

(

)

Definition at line 200 of file FlySystemFileAccessTestTBD.php.

References $datetime, and $timestamp.

                                                        : void
    {
        $datetime = '2012-02-06';
        $timestamp = strtotime($datetime);
        $this->filesystemMock
            ->shouldReceive('lastModified')
            ->once()
            ->andReturn($timestamp);

        $actualTimestamp = $this->subject->getTimestamp('/path/to/your/file');

        /*
         * needs to be equals instead of same because == checks if the object content is the same and === seems to check the reference too
         * eg.
         * $a == $b => true
         * $a === $b => false
         * $a === $a => true
         * $b === $b => true
         *
         * Danger; this is only the observed behaviour and was not documented at least the part with the === operator.
         * Tested with DateTime objects (PHP 7.1.6)
         */
        $this->assertEquals(new \DateTime($datetime), $actualTimestamp);
    }

testGetTimestampWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetTimestampWithMissingFileWhichShouldFail

(

)

Definition at line 240 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                    : void
    {
        $path = '/path/to/your/file';
        $this->filesystemMock
            ->shouldReceive('lastModified')
            ->once()
            ->with($path)
            ->andThrow(UnableToReadFile::class);

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

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

testGetTimestampWithUnknownErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetTimestampWithUnknownErrorWhichShouldFail

(

)

Definition at line 225 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                     : void
    {
        $path = '/path/to/your/file';
        $this->filesystemMock
            ->shouldReceive('lastModified')
            ->with($path)
            ->once()
            ->andThrow(UnableToRetrieveMetadata::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not lookup timestamp of the file \"$path\".");

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

testGetVisibilityWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetVisibilityWhichShouldSucceed

(

)

Definition at line 374 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                         : void
    {
        $path = '/path/to/your/file';
        $visibility = "private";

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

        $this->filesystemMock->shouldReceive('getVisibility')
                             ->once()
                             ->with($path)
                             ->andReturn($visibility);

        $actualVisibility = $this->subject->getVisibility($path);
        $this->assertSame($visibility, $actualVisibility);
    }

testGetVisibilityWithAdapterErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetVisibilityWithAdapterErrorWhichShouldFail

(

)

Definition at line 412 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                      : void
    {
        $path = '/path/to/your/file';

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

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

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not determine visibility for path '$path'.");

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

testGetVisibilityWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testGetVisibilityWithMissingFileWhichShouldFail

(

)

Definition at line 395 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                     : void
    {
        $path = '/path/to/your/file';

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

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

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

testPutContentExistingFile()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testPutContentExistingFile

(

)

Definition at line 142 of file FlySystemFileAccessTestTBD.php.

                                                : void
    {
        $content = 'Test file content.';
        $this->filesystemMock->shouldReceive('has')
                             ->once()
                             ->andReturn(true);
        $this->filesystemMock->shouldReceive('write')
                             ->with('/path/to/your/file', $content)
                             ->once()
                             ->andReturn(true);

        $this->subject->put('/path/to/your/file', $content);
    }

testPutContentNonExistingFile()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testPutContentNonExistingFile

(

)

Definition at line 156 of file FlySystemFileAccessTestTBD.php.

                                                   : void
    {
        $content = 'Test file content.';
        $this->filesystemMock->shouldReceive('has')
                             ->twice()
                             ->andReturn(false);

        $this->filesystemMock->shouldReceive('write')
                             ->with('/path/to/your/file', $content)
                             ->once()
                             ->andReturn(true);

        $this->subject->put('/path/to/your/file', $content);
    }

testReadAndDeleteWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testReadAndDeleteWhichShouldSucceed

(

)

Definition at line 609 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                         : void
    {
        $path = '/path/to/your/file';
        $content = "awesome content";

        //partially mock the subject to intercept the method calls of the own object.
        $this->subject = Mockery::mock(FlySystemFileAccess::class, [$this->filesystemMock])->makePartial();

        $this->subject
            ->shouldReceive('read')
            ->once()
            ->with($path)
            ->andReturn($content)
            ->getMock()
            ->shouldReceive('delete')
            ->once()
            ->with($path);

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

testReadWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testReadWhichShouldSucceed

(

)

Definition at line 72 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                : void
    {
        $file_content = 'Test file content.';
        $path = '/path/to/your/file';

        $this->filesystemMock->shouldReceive('has')
                             ->once()
                             ->with(ltrim($path, '/'))
                             ->andReturn(true);

        $this->filesystemMock->shouldReceive('read')
                             ->with(ltrim($path, '/'))
                             ->once()
                             ->andReturn($file_content);


        $actualContent = $this->subject->read($path);
        $this->assertSame($file_content, $actualContent);
    }

testReadWithGeneralFileAccessErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testReadWithGeneralFileAccessErrorWhichShouldFail

(

)

Definition at line 92 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                       : void
    {
        $path = '/path/to/your/file';

        $this->filesystemMock->shouldReceive('has')
                             ->once()
                             ->with(ltrim($path, '/'))
                             ->andReturn(true);

        $this->filesystemMock->shouldReceive('read')
                             ->with(ltrim($path, '/'))
                             ->once()
                             ->andReturn(false);


        $this->expectException(IOException::class);
        $this->expectExceptionMessage('File "' . ltrim($path, '/') . '" not found.');
        $actualContent = $this->subject->read($path);
    }

testReadWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testReadWithMissingFileWhichShouldFail

(

)

Definition at line 112 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                            : void
    {

        $path = '/path/to/your/file';

        $this->filesystemMock->shouldReceive('has')
                             ->once()
                             ->with(ltrim($path, '/'))
                             ->andReturn(false);

        $this->filesystemMock->shouldReceive('read')
                             ->never();


        $this->expectException(IOException::class);
        $this->expectExceptionMessage('File "' . ltrim($path, '/') . '" not found.');
        $actualContent = $this->subject->read($path);
    }

testRenameWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testRenameWhichShouldSucceed

(

)

Definition at line 632 of file FlySystemFileAccessTestTBD.php.

                                                  : void
    {
        $source = '/source/path';
        $destination = '/dest/path';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destination)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('move')
            ->once()
            ->withArgs([$source, $destination])
            ->andReturn(true);

        $this->subject->rename($source, $destination);
    }

testRenameWithExistingDestinationWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testRenameWithExistingDestinationWhichShouldFail

(

)

Definition at line 677 of file FlySystemFileAccessTestTBD.php.

                                                                      : void
    {
        $source = '/source/path';
        $destination = '/dest/path';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destination)
            ->andReturn(true)
            ->getMock()
            ->shouldReceive('move')
            ->never()
            ->withArgs([$source, $destination])
            ->andThrow(UnableToMoveFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("File \"$destination\" already exists.");

        $this->subject->rename($source, $destination);
    }

testRenameWithGeneralErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testRenameWithGeneralErrorWhichShouldFail

(

)

Definition at line 701 of file FlySystemFileAccessTestTBD.php.

                                                               : void
    {
        $source = '/source/path';
        $destination = '/dest/path';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destination)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('move')
            ->once()
            ->withArgs([$source, $destination])
            ->andThrow(UnableToMoveFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not move file from \"$source\" to \"$destination\".");

        $this->subject->rename($source, $destination);
    }

testRenameWithMissingSourceWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testRenameWithMissingSourceWhichShouldFail

(

)

Definition at line 653 of file FlySystemFileAccessTestTBD.php.

                                                                : void
    {
        $source = '/source/path';
        $destination = '/dest/path';

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($destination)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('move')
            ->once()
            ->withArgs([$source, $destination])
            ->andThrow(UnableToRetrieveMetadata::class);

        $this->expectException(FileNotFoundException::class);
        $this->expectExceptionMessage("File \"$source\" not found.");

        $this->subject->rename($source, $destination);
    }

testSetVisibilityThatFailedDueToAdapterFailureWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testSetVisibilityThatFailedDueToAdapterFailureWhichShouldFail

(

)

Definition at line 317 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                                   : void
    {
        $path = '/path/to/your/file';
        $visibility = "private";

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

        $this->filesystemMock->shouldReceive('setVisibility')
                             ->once()
                             ->withArgs([$path, $visibility])
                             ->andThrow(UnableToSetVisibility::class);

        $operationSuccessful = $this->subject->setVisibility($path, $visibility);
        $this->assertFalse($operationSuccessful);
    }

testSetVisibilityWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testSetVisibilityWhichShouldSucceed

(

)

Definition at line 298 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                         : void
    {
        $path = '/path/to/your/file';
        $visibility = "private";

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

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

        $operationSuccessful = $this->subject->setVisibility($path, $visibility);
        $this->assertTrue($operationSuccessful);
    }

testSetVisibilityWithInvalidAccessModifierWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testSetVisibilityWithInvalidAccessModifierWhichShouldFail

(

)

Definition at line 356 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                               : void
    {
        $path = '/path/to/your/file';
        $visibility = "not valid";

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

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage("The access must be 'public' or 'private' but '$visibility' was given.");

        $this->subject->setVisibility($path, $visibility);
    }

testSetVisibilityWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testSetVisibilityWithMissingFileWhichShouldFail

(

)

Definition at line 338 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                     : void
    {
        $path = '/path/to/your/file';
        $visibility = "private";

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

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

        $this->subject->setVisibility($path, $visibility);
    }

testUpdateWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testUpdateWhichShouldSucceed

(

)

Definition at line 503 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                  : void
    {
        $path = '/path/to/your/file';
        $content = "some awesome content";

        $this->filesystemMock->shouldReceive('write')
                             ->once()
                             ->withArgs([$path, $content])
                             ->andReturn(true);

        $this->subject->update($path, $content);
    }

testUpdateWithAdapterErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testUpdateWithAdapterErrorWhichShouldFail

(

)

Definition at line 518 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                               : void
    {
        $path = '/path/to/your/file';
        $content = "some awesome content";

        $this->filesystemMock->shouldReceive('write')
                             ->once()
                             ->withArgs([$path, $content])
                             ->andThrow(UnableToWriteFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage(
            "Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable."
        );

        $this->subject->update($path, $content);
    }

testUpdateWithMissingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testUpdateWithMissingFileWhichShouldFail

(

)

Definition at line 538 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                              : void
    {
        $path = '/path/to/your/file';
        $content = "some awesome content";

        $this->filesystemMock
            ->shouldReceive('write')
            ->once()
            ->withArgs([$path, $content])
            ->andThrow(UnableToWriteFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage(
            "Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable."
        );

        $this->subject->update($path, $content);
    }

testWriteWhichShouldSucceed()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testWriteWhichShouldSucceed

(

)

Definition at line 434 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                 : void
    {
        $path = '/path/to/your/file';
        $content = "some awesome content";

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($path)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('write')
            ->once()
            ->withArgs([$path, $content]);

        $this->subject->write($path, $content);
    }

testWriteWithAdapterErrorWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testWriteWithAdapterErrorWhichShouldFail

(

)

Definition at line 477 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                              : void
    {
        $path = '/path/to/your/file';
        $content = "some awesome content";

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($path)
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('write')
            ->once()
            ->withArgs([$path, $content])
            ->andThrow(UnableToWriteFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage(
            "Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable."
        );

        $this->subject->write($path, $content);
    }

testWriteWithAlreadyExistingFileWhichShouldFail()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::testWriteWithAlreadyExistingFileWhichShouldFail

(

)

Definition at line 454 of file FlySystemFileAccessTestTBD.php.

References $path.

                                                                     : void
    {
        $path = '/path/to/your/file';
        $content = "some awesome content";

        $this->filesystemMock
            ->shouldReceive('has')
            ->once()
            ->with($path)
            ->andReturn(true)
            ->shouldReceive('write')
            ->never()
            ->withArgs([$path, $content])
            ->andThrow(UnableToWriteFile::class);

        $this->expectException(FileAlreadyExistsException::class);
        $this->expectExceptionMessage("File \"$path\" already exists.");

        $this->subject->write($path, $content);
    }

Field Documentation

$adapterMock

LegacyMockInterface ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::$adapterMock

private

Definition at line 57 of file FlySystemFileAccessTestTBD.php.

$filesystemMock

Filesystem MockInterface ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::$filesystemMock

private

Definition at line 53 of file FlySystemFileAccessTestTBD.php.

$subject

FlySystemFileAccess ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccessTest::$subject

private

Definition at line 52 of file FlySystemFileAccessTestTBD.php.

---

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

• components/ILIAS/Filesystem/tests/Provider/FlySystem/FlySystemFileAccessTestTBD.php