Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest Class Reference

Class FlySystemFileStreamAccessTest. More...

Inheritance diagram for Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest:

Collaboration diagram for Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest:

Public Member Functions
	testReadStreamWhichShouldSucceed ()
	testReadStreamWithMissingFileWhichShouldFail ()
	testReadStreamWithGeneralFailureWhichShouldFail ()
	testWriteStreamWhichShouldSucceed ()
	testWriteStreamWithDetachedStreamWhichShouldFail ()
	testWriteStreamWithExistingFileWhichShouldFail ()
	testWriteStreamWithFailingAdapterWhichShouldFail ()
	testPutStreamWhichShouldSucceed ()
	testPutStreamWithGeneralFailureWhichShouldFail ()
	testPutStreamWithDetachedStreamWhichShouldFail ()
	testUpdateStreamWhichShouldSucceed ()
	testUpdateStreamWithDetachedStreamWhichShouldFail ()
	testUpdateStreamWithGeneralFailureWhichShouldFail ()
	testUpdateStreamWithMissingFileWhichShouldFail ()

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

Private Attributes
	$filesystemMock
ILIAS Filesystem Provider FlySystem FlySystemFileStreamAccess	$subject

Detailed Description

Class FlySystemFileStreamAccessTest.

Author

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

disabled disabled disabled

Definition at line 41 of file FlySystemFileStreamAccessTest.php.

Member Function Documentation

setUp()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::setUp ( )

protected

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

This method is called before a test is executed.

Definition at line 56 of file FlySystemFileStreamAccessTest.php.

                              : void
    {
        parent::setUp();

        $this->filesystemMock = \Mockery::mock(FilesystemInterface::class);
        $this->subject = new FlySystemFileStreamAccess($this->filesystemMock);
    }

testPutStreamWhichShouldSucceed()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testPutStreamWhichShouldSucceed

(

)

Definition at line 203 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

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

Here is the call graph for this function:

testPutStreamWithDetachedStreamWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testPutStreamWithDetachedStreamWhichShouldFail

(

)

Definition at line 242 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

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

Here is the call graph for this function:

testPutStreamWithGeneralFailureWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testPutStreamWithGeneralFailureWhichShouldFail

(

)

Definition at line 221 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

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

Here is the call graph for this function:

testReadStreamWhichShouldSucceed()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testReadStreamWhichShouldSucceed

(

)

Definition at line 68 of file FlySystemFileStreamAccessTest.php.

References $path.

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

testReadStreamWithGeneralFailureWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testReadStreamWithGeneralFailureWhichShouldFail

(

)

Definition at line 107 of file FlySystemFileStreamAccessTest.php.

References $path.

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

testReadStreamWithMissingFileWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testReadStreamWithMissingFileWhichShouldFail

(

)

Definition at line 88 of file FlySystemFileStreamAccessTest.php.

References $path.

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

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

        $this->expectException(\ILIAS\Filesystem\Exception\FileNotFoundException::class);
        $this->expectExceptionMessage("File \"$path\" not found.");

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

testUpdateStreamWhichShouldSucceed()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testUpdateStreamWhichShouldSucceed

(

)

Definition at line 259 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

                                                        : void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);

        $this->filesystemMock->shouldReceive('updateStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(true);

        $this->subject->updateStream($path, $stream);
    }

Here is the call graph for this function:

testUpdateStreamWithDetachedStreamWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testUpdateStreamWithDetachedStreamWhichShouldFail

(

)

Definition at line 277 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

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

Here is the call graph for this function:

testUpdateStreamWithGeneralFailureWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testUpdateStreamWithGeneralFailureWhichShouldFail

(

)

Definition at line 294 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

                                                                       : void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);

        $this->filesystemMock->shouldReceive('updateStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(false);

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

        $this->subject->updateStream($path, $stream);
    }

Here is the call graph for this function:

testUpdateStreamWithMissingFileWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testUpdateStreamWithMissingFileWhichShouldFail

(

)

Definition at line 315 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

                                                                    : void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);

        $this->filesystemMock->shouldReceive('updateStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andThrow(FileNotFoundException::class);

        $this->expectException(\ILIAS\Filesystem\Exception\FileNotFoundException::class);
        $this->expectExceptionMessage("File \"$path\" not found.");

        $this->subject->updateStream($path, $stream);
    }

Here is the call graph for this function:

testWriteStreamWhichShouldSucceed()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testWriteStreamWhichShouldSucceed

(

)

Definition at line 126 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

                                                       : 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->writeStream($path, $stream);
    }

Here is the call graph for this function:

testWriteStreamWithDetachedStreamWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testWriteStreamWithDetachedStreamWhichShouldFail

(

)

Definition at line 144 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

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

Here is the call graph for this function:

testWriteStreamWithExistingFileWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testWriteStreamWithExistingFileWhichShouldFail

(

)

Definition at line 161 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

                                                                    : void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);

        $this->filesystemMock->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andThrow(FileExistsException::class);

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

        $this->subject->writeStream($path, $stream);
    }

Here is the call graph for this function:

testWriteStreamWithFailingAdapterWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testWriteStreamWithFailingAdapterWhichShouldFail

(

)

Definition at line 182 of file FlySystemFileStreamAccessTest.php.

References $path, and ILIAS\Filesystem\Stream\Streams\ofString().

                                                                      : void
    {
        $path = '/path/to/your/file';
        $fileContent = 'Awesome file content';
        $stream = Streams::ofString($fileContent);

        $this->filesystemMock->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andReturn(false);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Could not write stream to file \"$path\"");

        $this->subject->writeStream($path, $stream);
    }

Here is the call graph for this function:

Field Documentation

$filesystemMock

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::$filesystemMock

private

Definition at line 48 of file FlySystemFileStreamAccessTest.php.

$subject

ILIAS Filesystem Provider FlySystem FlySystemFileStreamAccess Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::$subject

private

Definition at line 49 of file FlySystemFileStreamAccessTest.php.

---

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

• tests/Filesystem/Provider/FlySystem/FlySystemFileStreamAccessTest.php