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

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 59 of file FlySystemFileAccessTestTBD.php.

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

testCopyWhichShouldSucceed()

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

(

)

Definition at line 721 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 742 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 792 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 768 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 555 of file FlySystemFileAccessTestTBD.php.

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

References $path.

testDeleteWithAdapterErrorWhichShouldFail()

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

(

)

Definition at line 569 of file FlySystemFileAccessTestTBD.php.

                                                               : 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);
    }

References $path.

testDeleteWithMissingFileWhichShouldFail()

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

(

)

Definition at line 588 of file FlySystemFileAccessTestTBD.php.

                                                              : 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);
    }

References $path.

testGetMimeTypeWhichShouldSucceed()

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

(

)

Definition at line 127 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 182 of file FlySystemFileAccessTestTBD.php.

                                                                   : 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);
    }

References $path.

testGetMimeTypeWithUnknownMimeTypeWhichShouldFail()

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

(

)

Definition at line 168 of file FlySystemFileAccessTestTBD.php.

                                                                       : 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);
    }

References $path.

testGetSizeWhichShouldSucceed()

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

(

)

Definition at line 251 of file FlySystemFileAccessTestTBD.php.

                                                   : 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(), '');
    }

References ILIAS\Data\DataSize\KiB.

testGetSizeWithMissingFileWhichShouldFail()

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

(

)

Definition at line 279 of file FlySystemFileAccessTestTBD.php.

                                                               : 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);
    }

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

testGetSizeWithUnknownAdapterErrorWhichShouldFail()

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

(

)

Definition at line 264 of file FlySystemFileAccessTestTBD.php.

                                                                       : 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);
    }

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

testGetTimestampWhichShouldSucceed()

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

(

)

Definition at line 196 of file FlySystemFileAccessTestTBD.php.

                                                        : 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);
    }

References $datetime, and $timestamp.

testGetTimestampWithMissingFileWhichShouldFail()

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

(

)

Definition at line 236 of file FlySystemFileAccessTestTBD.php.

                                                                    : 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);
    }

References $path.

testGetTimestampWithUnknownErrorWhichShouldFail()

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

(

)

Definition at line 221 of file FlySystemFileAccessTestTBD.php.

                                                                     : 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);
    }

References $path.

testGetVisibilityWhichShouldSucceed()

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

(

)

Definition at line 370 of file FlySystemFileAccessTestTBD.php.

                                                         : 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);
    }

References $path.

testGetVisibilityWithAdapterErrorWhichShouldFail()

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

(

)

Definition at line 408 of file FlySystemFileAccessTestTBD.php.

                                                                      : 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);
    }

References $path.

testGetVisibilityWithMissingFileWhichShouldFail()

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

(

)

Definition at line 391 of file FlySystemFileAccessTestTBD.php.

                                                                     : 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);
    }

References $path.

testPutContentExistingFile()

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

(

)

Definition at line 138 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 152 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 605 of file FlySystemFileAccessTestTBD.php.

                                                         : 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);
    }

References $path.

testReadWhichShouldSucceed()

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

(

)

Definition at line 68 of file FlySystemFileAccessTestTBD.php.

                                                : 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);
    }

References $path.

testReadWithGeneralFileAccessErrorWhichShouldFail()

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

(

)

Definition at line 88 of file FlySystemFileAccessTestTBD.php.

                                                                       : 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);
    }

References $path.

testReadWithMissingFileWhichShouldFail()

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

(

)

Definition at line 108 of file FlySystemFileAccessTestTBD.php.

                                                            : 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);
    }

References $path.

testRenameWhichShouldSucceed()

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

(

)

Definition at line 628 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 673 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 697 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 649 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 313 of file FlySystemFileAccessTestTBD.php.

                                                                                   : 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);
    }

References $path.

testSetVisibilityWhichShouldSucceed()

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

(

)

Definition at line 294 of file FlySystemFileAccessTestTBD.php.

                                                         : 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);
    }

References $path.

testSetVisibilityWithInvalidAccessModifierWhichShouldFail()

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

(

)

Definition at line 352 of file FlySystemFileAccessTestTBD.php.

                                                                               : 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);
    }

References $path.

testSetVisibilityWithMissingFileWhichShouldFail()

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

(

)

Definition at line 334 of file FlySystemFileAccessTestTBD.php.

                                                                     : 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);
    }

References $path.

testUpdateWhichShouldSucceed()

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

(

)

Definition at line 499 of file FlySystemFileAccessTestTBD.php.

                                                  : 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);
    }

References $path.

testUpdateWithAdapterErrorWhichShouldFail()

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

(

)

Definition at line 514 of file FlySystemFileAccessTestTBD.php.

                                                               : 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);
    }

References $path.

testUpdateWithMissingFileWhichShouldFail()

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

(

)

Definition at line 534 of file FlySystemFileAccessTestTBD.php.

                                                              : 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);
    }

References $path.

testWriteWhichShouldSucceed()

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

(

)

Definition at line 430 of file FlySystemFileAccessTestTBD.php.

                                                 : 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);
    }

References $path.

testWriteWithAdapterErrorWhichShouldFail()

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

(

)

Definition at line 473 of file FlySystemFileAccessTestTBD.php.

                                                              : 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);
    }

References $path.

testWriteWithAlreadyExistingFileWhichShouldFail()

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

(

)

Definition at line 450 of file FlySystemFileAccessTestTBD.php.

                                                                     : 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);
    }

References $path.

Field Documentation

$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