ILIAS\Filesystem\Util\LegacyPathHelperTest Class Reference

Inheritance diagram for ILIAS\Filesystem\Util\LegacyPathHelperTest:

Collaboration diagram for ILIAS\Filesystem\Util\LegacyPathHelperTest:

Public Member Functions
	testDeriveFilesystemFromWithWebTargetWhichShouldSucceed ()
	testDeriveFilesystemFromWithStorageTargetWhichShouldSucceed ()
	testDeriveFilesystemFromWithRelativeLibsTargetWhichShouldSucceed ()
	testDeriveFilesystemFromWithAbsoluteLibsTargetWhichShouldSucceed ()
	testDeriveFilesystemFromWithInvalidTargetWhichShouldFail ()
	testCreateRelativePathWithWebTargetWhichShouldSucceed ()
	testCreateRelativePathWithStorageTargetWhichShouldSucceed ()
	testCreateRelativePathWithInvalidTargetWhichShouldFail ()

Protected Member Functions
	setUp ()

Private Attributes
string	$libsPath
string	$storagePath
string	$webPath
Mockery MockInterface ILIAS Filesystem Filesystems	$filesystemsMock

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

disabled disabled disabled

Definition at line 37 of file LegacyPathHelperTest.php.

Member Function Documentation

setUp()

ILIAS\Filesystem\Util\LegacyPathHelperTest::setUp ( )

protected

Definition at line 48 of file LegacyPathHelperTest.php.

References $clientId, $GLOBALS, CLIENT_DATA_DIR, and CLIENT_WEB_DIR.

                              : void
    {
        parent::setUp();

        $iliasAbsolutePath = '/dummy/var/www/html/ilias';
        $dataDir = '/dummy/var/www/ildata';
        $webDir = 'data';
        $clientId = 'default';

        //constants needed for test subject
        define("CLIENT_DATA_DIR", $dataDir . '/' . $clientId);
        define("CLIENT_WEB_DIR", $iliasAbsolutePath . '/' . $webDir . '/' . $clientId);
        define("ILIAS_ABSOLUTE_PATH", $iliasAbsolutePath);
        define("ILIAS_WEB_DIR", $webDir);
        define("CLIENT_ID", 'default');
        $this->libsPath = $iliasAbsolutePath . '/' . 'libs';
        $this->webPath = CLIENT_WEB_DIR;
        $this->storagePath = CLIENT_DATA_DIR;

        //create mock DI container
        $this->filesystemsMock = \Mockery::mock(Filesystems::class);

        $containerMock = Mockery::mock(Container::class);
        $containerMock->shouldReceive('filesystem')
            ->withNoArgs()
            ->zeroOrMoreTimes()
            ->andReturn($this->filesystemsMock);

        $GLOBALS['DIC'] = $containerMock;
    }

testCreateRelativePathWithInvalidTargetWhichShouldFail()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testCreateRelativePathWithInvalidTargetWhichShouldFail

(

)

Definition at line 198 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\createRelativePath().

                                                                            : void
    {
        $target = '/invalid/path/to/target';

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage("Invalid path supplied. Path must start with the web, storage, temp, customizing or libs storage location. Path given: '{$target}'");

        LegacyPathHelper::createRelativePath($target);
    }

Here is the call graph for this function:

testCreateRelativePathWithStorageTargetWhichShouldSucceed()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testCreateRelativePathWithStorageTargetWhichShouldSucceed

(

)

Definition at line 184 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\createRelativePath().

                                                                               : void
    {
        $expectedPath = 'testtarget/subdir';
        $target = $this->storagePath . '/' . $expectedPath;

        $result = LegacyPathHelper::createRelativePath($target);
        $this->assertEquals($expectedPath, $result);
    }

Here is the call graph for this function:

testCreateRelativePathWithWebTargetWhichShouldSucceed()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testCreateRelativePathWithWebTargetWhichShouldSucceed

(

)

Definition at line 170 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\createRelativePath().

                                                                           : void
    {
        $expectedPath = 'testtarget/subdir';
        $target = $this->webPath . '/' . $expectedPath;

        $result = LegacyPathHelper::createRelativePath($target);
        $this->assertEquals($expectedPath, $result);
    }

Here is the call graph for this function:

testDeriveFilesystemFromWithAbsoluteLibsTargetWhichShouldSucceed()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testDeriveFilesystemFromWithAbsoluteLibsTargetWhichShouldSucceed

(

)

Definition at line 137 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\deriveFilesystemFrom().

                                                                                      : void
    {
        $target = $this->libsPath . 'libs/bower/bower_components/mediaelement/build';

        $this->filesystemsMock
            ->shouldReceive('libs')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));

        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertTrue($filesystem instanceof Filesystem, 'Expecting filesystem instance.');
    }

Here is the call graph for this function:

testDeriveFilesystemFromWithInvalidTargetWhichShouldFail()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testDeriveFilesystemFromWithInvalidTargetWhichShouldFail

(

)

Definition at line 155 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\deriveFilesystemFrom().

                                                                              : void
    {
        $target = '/invalid/path/to/testtarget';

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage("Invalid path supplied. Path must start with the web, storage, temp, customizing or libs storage location. Path given: '{$target}'");

        LegacyPathHelper::deriveFilesystemFrom($target);
    }

Here is the call graph for this function:

testDeriveFilesystemFromWithRelativeLibsTargetWhichShouldSucceed()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testDeriveFilesystemFromWithRelativeLibsTargetWhichShouldSucceed

(

)

Definition at line 120 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\deriveFilesystemFrom().

                                                                                      : void
    {
        $target = './libs/bower/bower_components/mediaelement/build';

        $this->filesystemsMock
            ->shouldReceive('libs')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));

        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertTrue($filesystem instanceof Filesystem, 'Expecting filesystem instance.');
    }

Here is the call graph for this function:

testDeriveFilesystemFromWithStorageTargetWhichShouldSucceed()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testDeriveFilesystemFromWithStorageTargetWhichShouldSucceed

(

)

Definition at line 102 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\deriveFilesystemFrom().

                                                                                 : void
    {
        $target = $this->storagePath . '/testtarget';

        $this->filesystemsMock
            ->shouldReceive('storage')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));

        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertTrue($filesystem instanceof Filesystem, 'Expecting filesystem instance.');
    }

Here is the call graph for this function:

testDeriveFilesystemFromWithWebTargetWhichShouldSucceed()

ILIAS\Filesystem\Util\LegacyPathHelperTest::testDeriveFilesystemFromWithWebTargetWhichShouldSucceed

(

)

Definition at line 84 of file LegacyPathHelperTest.php.

References ILIAS\Filesystem\Util\LegacyPathHelper\deriveFilesystemFrom().

                                                                             : void
    {
        $target = $this->webPath . '/testtarget';

        $this->filesystemsMock
            ->shouldReceive('web')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));

        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertTrue($filesystem instanceof Filesystem, 'Expecting filesystem instance.');
    }

Here is the call graph for this function:

Field Documentation

$filesystemsMock

Mockery MockInterface ILIAS Filesystem Filesystems ILIAS\Filesystem\Util\LegacyPathHelperTest::$filesystemsMock

private

Definition at line 42 of file LegacyPathHelperTest.php.

$libsPath

string ILIAS\Filesystem\Util\LegacyPathHelperTest::$libsPath

private

Definition at line 39 of file LegacyPathHelperTest.php.

$storagePath

string ILIAS\Filesystem\Util\LegacyPathHelperTest::$storagePath

private

Definition at line 40 of file LegacyPathHelperTest.php.

$webPath

string ILIAS\Filesystem\Util\LegacyPathHelperTest::$webPath

private

Definition at line 41 of file LegacyPathHelperTest.php.

---

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

• tests/Filesystem/Util/LegacyPathHelperTest.php