LegacyPathHelperTestTBD.php

Go to the documentation of this file.

<?php
 
namespace ILIAS\Filesystem\Util;
 
use PHPUnit\Framework\Attributes\BackupGlobals;
use PHPUnit\Framework\Attributes\BackupStaticProperties;
use PHPUnit\Framework\Attributes\PreserveGlobalState;
use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\Small;
use ILIAS\DI\Container;
use ILIAS\Filesystem\Filesystem;
use ILIAS\Filesystem\Filesystems;
use Mockery;
use Mockery\MockInterface;
use PHPUnit\Framework\TestCase;
 
#[BackupGlobals(false)]
#[BackupStaticProperties(false)]
#[PreserveGlobalState(false)]
#[RunTestsInSeparateProcesses]
class LegacyPathHelperTest extends TestCase
{
    public $libsPath;
    private string $storagePath;
    private string $webPath;
    private MockInterface|Filesystems $filesystemsMock;
 
 
    protected function setUp(): void
    {
        parent::setUp();
 
        $iliasAbsolutePath = '/dummy/var/www/html/ilias';
        $dataDir = '/dummy/var/www/ildata';
        $webDir = 'public/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 . '/' . 'vendor';
        $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;
    }
 
 
    #[Test]
 
    public function testDeriveFilesystemFromWithWebTargetWhichShouldSucceed(): void
    {
        $target = $this->webPath . '/testtarget';
 
        $this->filesystemsMock
            ->shouldReceive('web')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));
 
        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertInstanceOf(\ILIAS\Filesystem\Filesystem::class, $filesystem, 'Expecting filesystem instance.');
    }
 
 
    #[Test]
 
    public function testDeriveFilesystemFromWithStorageTargetWhichShouldSucceed(): void
    {
        $target = $this->storagePath . '/testtarget';
 
        $this->filesystemsMock
            ->shouldReceive('storage')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));
 
        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertInstanceOf(\ILIAS\Filesystem\Filesystem::class, $filesystem, 'Expecting filesystem instance.');
    }
 
 
    #[Test]
 
    public function testDeriveFilesystemFromWithRelativeLibsTargetWhichShouldSucceed(): void
    {
        $target = './vendor/bower/bower_components/mediaelement/build';
 
        $this->filesystemsMock
            ->shouldReceive('libs')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));
 
        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertInstanceOf(\ILIAS\Filesystem\Filesystem::class, $filesystem, 'Expecting filesystem instance.');
    }
 
    #[Test]
 
    public function testDeriveFilesystemFromWithAbsoluteLibsTargetWhichShouldSucceed(): void
    {
        $target = $this->libsPath . 'vendor/bower/bower_components/mediaelement/build';
 
        $this->filesystemsMock
            ->shouldReceive('libs')
            ->once()
            ->andReturn(Mockery::mock(Filesystem::class));
 
        $filesystem = LegacyPathHelper::deriveFilesystemFrom($target);
        $this->assertInstanceOf(\ILIAS\Filesystem\Filesystem::class, $filesystem, 'Expecting filesystem instance.');
    }
 
 
    #[Test]
 
    public function testDeriveFilesystemFromWithInvalidTargetWhichShouldFail(): 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);
    }
 
 
    #[Test]
 
    public function testCreateRelativePathWithWebTargetWhichShouldSucceed(): void
    {
        $expectedPath = 'testtarget/subdir';
        $target = $this->webPath . '/' . $expectedPath;
 
        $result = LegacyPathHelper::createRelativePath($target);
        $this->assertSame($expectedPath, $result);
    }
 
 
    #[Test]
 
    public function testCreateRelativePathWithStorageTargetWhichShouldSucceed(): void
    {
        $expectedPath = 'testtarget/subdir';
        $target = $this->storagePath . '/' . $expectedPath;
 
        $result = LegacyPathHelper::createRelativePath($target);
        $this->assertSame($expectedPath, $result);
    }
 
 
    #[Test]
 
    public function testCreateRelativePathWithInvalidTargetWhichShouldFail(): 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);
    }
}