Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest Class Reference

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
Mockery LegacyMockInterface	$filesystemMock
ILIAS Filesystem Provider FlySystem FlySystemFileStreamAccess	$subject

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 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(FilesystemOperator::class);
        $this->subject = new FlySystemFileStreamAccess($this->filesystemMock);
    }

testPutStreamWhichShouldSucceed()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testPutStreamWhichShouldSucceed

(

)

Definition at line 213 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 252 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 231 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(UnableToReadFile::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 269 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->updateStream($path, $stream);
    }

Here is the call graph for this function:

testUpdateStreamWithDetachedStreamWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testUpdateStreamWithDetachedStreamWhichShouldFail

(

)

Definition at line 287 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 304 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(UnableToWriteFile::class);

        $this->expectException(IOException::class);
        $this->expectExceptionMessage("Unable to update Stream in \"$path\".");

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

Here is the call graph for this function:

testUpdateStreamWithMissingFileWhichShouldFail()

Filesystem\Provider\FlySystem\FlySystemFileStreamAccessTest::testUpdateStreamWithMissingFileWhichShouldFail

(

)

Definition at line 326 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(UnableToWriteFile::class);

        $this->expectException(\ILIAS\Filesystem\Exception\FileNotFoundException::class);
        $this->expectExceptionMessage("Unable to update Stream in \"$path\".");

        $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('fileExists')
            ->once()
            ->andReturn(false)
            ->getMock()
            ->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 149 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 166 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('fileExists')
            ->once()
            ->andReturn(true);

        $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 187 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('fileExists')
            ->once()
            ->andReturn(false)
            ->getMock()
            ->shouldReceive('writeStream')
            ->once()
            ->withArgs([$path, \resourceValue()])
            ->andThrow(UnableToWriteFile::class);

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

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

Here is the call graph for this function:

Field Documentation

$filesystemMock

Mockery LegacyMockInterface 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