9.5/_file_handling_utility_test_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Extensionmanager\Tests\Unit\Utility;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */

use ‪TYPO3\CMS\Core\Core\Environment;

use ‪TYPO3\CMS\Core\Localization\LanguageService;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException;

use TYPO3\CMS\Extensionmanager\Utility\EmConfUtility;

use ‪TYPO3\CMS\Extensionmanager\Utility\FileHandlingUtility;

use TYPO3\TestingFramework\Core\Unit\UnitTestCase;


class ‪FileHandlingUtilityTest extends UnitTestCase

{

    protected ‪$fakedExtensions = [];


    protected function ‪createFakeExtension($extkeyOnly = false)

    {

        $extKey = strtolower($this->getUniqueId('testing'));

        $absExtPath = ‪Environment::getVarPath() . '/tests/ext-' . $extKey . '/';

        $relPath = 'typo3temp/var/tests/ext-' . $extKey . '/';

        $this->fakedExtensions[$extKey] = [

            'siteRelPath' => $relPath,

            'siteAbsPath' => $absExtPath

        ];

        if ($extkeyOnly === true) {

            return $extKey;

        }

        GeneralUtility::mkdir($absExtPath);

        $this->testFilesToDelete[] = ‪Environment::getVarPath() . '/tests/ext-' . $extKey;

        return $extKey;

    }


    public function ‪makeAndClearExtensionDirRemovesExtensionDirIfAlreadyExists()

    {

        $extKey = $this->‪createFakeExtension();

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['removeDirectory', 'addDirectory', 'getExtensionDir'], [], '', false);

        $fileHandlerMock->expects($this->once())

            ->method('removeDirectory')

            ->with(‪Environment::getVarPath() . '/tests/ext-' . $extKey . '/');

        $fileHandlerMock->expects($this->any())

            ->method('getExtensionDir')

            ->willReturn(‪Environment::getVarPath() . '/tests/ext-' . $extKey . '/');

        $fileHandlerMock->_call('makeAndClearExtensionDir', $extKey);

    }


    public function ‪invalidRelativePathDataProvider()

    {

        return [

            ['../../'],

            ['/foo/bar'],

            ['foo//bar'],

            ['foo/bar' . "\0"],

        ];

    }


    public function ‪getAbsolutePathThrowsExceptionForInvalidRelativePaths($invalidRelativePath)

    {

        $this->expectException(ExtensionManagerException::class);

        $this->expectExceptionCode(1350742864);

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['dummy'], []);

        $fileHandlerMock->_call('getAbsolutePath', $invalidRelativePath);

    }


    public function ‪validRelativePathDataProvider()

    {

        return [

            ['foo/../bar', ‪Environment::getPublicPath() . '/bar'],

            ['bas', ‪Environment::getPublicPath() . '/bas'],

        ];

    }


    public function ‪getAbsolutePathReturnsAbsolutePathForValidRelativePaths($validRelativePath, $expectedAbsolutePath)

    {

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['dummy']);

        $this->assertSame($expectedAbsolutePath, $fileHandlerMock->_call('getAbsolutePath', $validRelativePath));

    }


    public function ‪makeAndClearExtensionDirAddsDir()

    {

        $extKey = $this->‪createFakeExtension();

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['removeDirectory', 'addDirectory', 'getExtensionDir']);

        $fileHandlerMock->expects($this->once())

            ->method('addDirectory')

            ->with(‪Environment::getVarPath() . '/tests/ext-' . $extKey . '/');

        $fileHandlerMock->expects($this->any())

            ->method('getExtensionDir')

            ->willReturn(‪Environment::getVarPath() . '/tests/ext-' . $extKey . '/');

        $fileHandlerMock->_call('makeAndClearExtensionDir', $extKey);

    }


    public function ‪makeAndClearExtensionDirThrowsExceptionOnInvalidPath()

    {

        $this->expectException(ExtensionManagerException::class);

        $this->expectExceptionCode(1337280417);

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['removeDirectory', 'addDirectory']);

        $languageServiceMock = $this->getMockBuilder(LanguageService::class)->getMock();

        $fileHandlerMock->_set('languageService', $languageServiceMock);

        $fileHandlerMock->_call('makeAndClearExtensionDir', 'testing123', 'fakepath');

    }


    public function ‪addDirectoryAddsDirectory()

    {

        $extDirPath = ‪Environment::getVarPath() . '/tests/' . $this->getUniqueId('test-extensions-');

        $this->testFilesToDelete[] = $extDirPath;

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['dummy']);

        $fileHandlerMock->_call('addDirectory', $extDirPath);

        $this->assertTrue(is_dir($extDirPath));

    }


    public function ‪removeDirectoryRemovesDirectory()

    {

        $extDirPath = ‪Environment::getVarPath() . '/tests/' . $this->getUniqueId('test-extensions-');

        @mkdir($extDirPath);

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['dummy']);

        $fileHandlerMock->_call('removeDirectory', $extDirPath);

        $this->assertFalse(is_dir($extDirPath));

    }


    public function ‪removeDirectoryRemovesSymlink()

    {

        $absoluteSymlinkPath = ‪Environment::getVarPath() . '/tests/' . $this->getUniqueId('test_symlink_');

        $absoluteFilePath = ‪Environment::getVarPath() . '/tests/' . $this->getUniqueId('test_file_');

        touch($absoluteFilePath);

        $this->testFilesToDelete[] = $absoluteFilePath;

        symlink($absoluteFilePath, $absoluteSymlinkPath);

        $fileHandler = new ‪FileHandlingUtility();

        $fileHandler->removeDirectory($absoluteSymlinkPath);

        $this->assertFalse(is_link($absoluteSymlinkPath));

    }


    public function ‪removeDirectoryDoesNotRemoveContentOfSymlinkedTargetDirectory()

    {

        $absoluteSymlinkPath = ‪Environment::getVarPath() . '/tests/' . $this->getUniqueId('test_symlink_');

        $absoluteDirectoryPath = ‪Environment::getVarPath() . '/tests/' . $this->getUniqueId('test_dir_') . '/';

        $relativeFilePath = $this->getUniqueId('test_file_');


        mkdir($absoluteDirectoryPath);

        touch($absoluteDirectoryPath . $relativeFilePath);


        $this->testFilesToDelete[] = $absoluteDirectoryPath . $relativeFilePath;

        $this->testFilesToDelete[] = $absoluteDirectoryPath;


        symlink($absoluteDirectoryPath, $absoluteSymlinkPath);


        $fileHandler = new ‪FileHandlingUtility();

        $fileHandler->removeDirectory($absoluteSymlinkPath);

        $this->assertTrue(is_file($absoluteDirectoryPath . $relativeFilePath));

    }


    public function ‪unpackExtensionFromExtensionDataArrayCreatesTheExtensionDirectory()

    {

        $extensionData = [

            'extKey' => 'test'

        ];

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, [

            'makeAndClearExtensionDir',

            'writeEmConfToFile',

            'extractFilesArrayFromExtensionData',

            'extractDirectoriesFromExtensionData',

            'createDirectoriesForExtensionFiles',

            'writeExtensionFiles',

            'reloadPackageInformation',

        ]);

        $fileHandlerMock->expects($this->once())->method('extractFilesArrayFromExtensionData')->will($this->returnValue([]));

        $fileHandlerMock->expects($this->once())->method('extractDirectoriesFromExtensionData')->will($this->returnValue([]));

        $fileHandlerMock->expects($this->once())->method('makeAndClearExtensionDir')->with($extensionData['extKey']);

        $fileHandlerMock->_call('unpackExtensionFromExtensionDataArray', $extensionData);

    }


    public function ‪unpackExtensionFromExtensionDataArrayStripsDirectoriesFromFilesArray()

    {

        $extensionData = [

            'extKey' => 'test'

        ];

        $files = [

            'ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

            'doc/' => [

                'name' => 'doc/',

                'size' => 0,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => ''

            ],

            'doc/ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

        ];

        $cleanedFiles = [

            'ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

            'doc/ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

        ];

        $directories = [

            'doc/',

            'mod/doc/'

        ];


        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, [

            'makeAndClearExtensionDir',

            'writeEmConfToFile',

            'extractFilesArrayFromExtensionData',

            'extractDirectoriesFromExtensionData',

            'createDirectoriesForExtensionFiles',

            'writeExtensionFiles',

            'reloadPackageInformation',

        ]);

        $fileHandlerMock->expects($this->once())->method('extractFilesArrayFromExtensionData')->will($this->returnValue($files));

        $fileHandlerMock->expects($this->once())->method('extractDirectoriesFromExtensionData')->will($this->returnValue($directories));

        $fileHandlerMock->expects($this->once())->method('createDirectoriesForExtensionFiles')->with($directories);

        $fileHandlerMock->expects($this->once())->method('writeExtensionFiles')->with($cleanedFiles);

        $fileHandlerMock->expects($this->once())->method('reloadPackageInformation')->with('test');

        $fileHandlerMock->_call('unpackExtensionFromExtensionDataArray', $extensionData);

    }


    public function ‪extractFilesArrayFromExtensionDataReturnsFileArray()

    {

        $extensionData = [

            'key' => 'test',

            'FILES' => [

                'filename1' => 'dummycontent',

                'filename2' => 'dummycontent2'

            ]

        ];

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['makeAndClearExtensionDir']);

        $extractedFiles = $fileHandlerMock->_call('extractFilesArrayFromExtensionData', $extensionData);

        $this->assertArrayHasKey('filename1', $extractedFiles);

        $this->assertArrayHasKey('filename2', $extractedFiles);

    }


    public function ‪writeExtensionFilesWritesFiles()

    {

        $files = [

            'ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

            'README' => [

                'name' => 'README',

                'size' => 4566,

                'mtime' => 1219448533,

                'is_executable' => false,

                'content' => 'FEEL FREE TO ADD SOME DOCUMENTATION HERE'

            ]

        ];

        $rootPath = ($extDirPath = $this->fakedExtensions[$this->‪createFakeExtension()]['siteAbsPath']);

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['makeAndClearExtensionDir']);

        $fileHandlerMock->_call('writeExtensionFiles', $files, $rootPath);

        $this->assertTrue(file_exists($rootPath . 'ChangeLog'));

    }


    public function ‪extractDirectoriesFromExtensionDataExtractsDirectories()

    {

        $files = [

            'ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

            'doc/' => [

                'name' => 'doc/',

                'size' => 0,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => ''

            ],

            'doc/ChangeLog' => [

                'name' => 'ChangeLog',

                'size' => 4559,

                'mtime' => 1219448527,

                'is_executable' => false,

                'content' => 'some content to write'

            ],

            'doc/README' => [

                'name' => 'README',

                'size' => 4566,

                'mtime' => 1219448533,

                'is_executable' => false,

                'content' => 'FEEL FREE TO ADD SOME DOCUMENTATION HERE'

            ],

            'mod/doc/README' => [

                'name' => 'README',

                'size' => 4566,

                'mtime' => 1219448533,

                'is_executable' => false,

                'content' => 'FEEL FREE TO ADD SOME DOCUMENTATION HERE'

            ]

        ];

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['makeAndClearExtensionDir']);

        $extractedDirectories = $fileHandlerMock->_call('extractDirectoriesFromExtensionData', $files);

        $expected = [

            'doc/',

            'mod/doc/'

        ];

        $this->assertSame($expected, array_values($extractedDirectories));

    }


    public function ‪createDirectoriesForExtensionFilesCreatesDirectories()

    {

        $rootPath = $this->fakedExtensions[$this->‪createFakeExtension()]['siteAbsPath'];

        $directories = [

            'doc/',

            'mod/doc/'

        ];

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['makeAndClearExtensionDir']);

        $this->assertFalse(is_dir($rootPath . 'doc/'));

        $this->assertFalse(is_dir($rootPath . 'mod/doc/'));

        $fileHandlerMock->_call('createDirectoriesForExtensionFiles', $directories, $rootPath);

        $this->assertTrue(is_dir($rootPath . 'doc/'));

        $this->assertTrue(is_dir($rootPath . 'mod/doc/'));

    }


    public function ‪writeEmConfWritesEmConfFile()

    {

        $extKey = $this->‪createFakeExtension();

        $extensionData = [

            'extKey' => $extKey,

            'EM_CONF' => [

                'title' => 'Plugin cache engine',

                'description' => 'Provides an interface to cache plugin content elements based on 4.3 caching framework',

                'category' => 'Frontend',

            ]

        ];

        $rootPath = $this->fakedExtensions[$extKey]['siteAbsPath'];

        $emConfUtilityMock = $this->getAccessibleMock(EmConfUtility::class, ['constructEmConf']);

        $emConfUtilityMock->expects($this->once())->method('constructEmConf')->with($extensionData)->will($this->returnValue(var_export($extensionData['EM_CONF'], true)));

        $fileHandlerMock = $this->getAccessibleMock(FileHandlingUtility::class, ['makeAndClearExtensionDir']);

        $fileHandlerMock->_set('emConfUtility', $emConfUtilityMock);

        $fileHandlerMock->_call('writeEmConfToFile', $extensionData, $rootPath);

        $this->assertTrue(file_exists($rootPath . 'ext_emconf.php'));

    }


    protected function ‪getPreparedFileHandlingMockForDirectoryCreationTests()

    {

        $fileHandlerMock = $this->getMockBuilder(FileHandlingUtility::class)

            ->setMethods(['createNestedDirectory', 'getAbsolutePath', 'directoryExists'])

            ->getMock();

        $fileHandlerMock->expects($this->any())

            ->method('getAbsolutePath')

            ->will($this->returnArgument(0));

        return $fileHandlerMock;

    }


    public function ‪uploadFolderIsNotCreatedIfNotRequested()

    {

        $fileHandlerMock = $this->‪getPreparedFileHandlingMockForDirectoryCreationTests();

        $fileHandlerMock->expects($this->never())

            ->method('createNestedDirectory');

        $fileHandlerMock->ensureConfiguredDirectoriesExist(

            [

                'key' => 'foo_bar',

                'uploadfolder' => 0,

            ]

        );

    }


    public function ‪additionalFoldersAreNotCreatedIfNotRequested()

    {

        $fileHandlerMock = $this->‪getPreparedFileHandlingMockForDirectoryCreationTests();

        $fileHandlerMock->expects($this->never())

            ->method('createNestedDirectory');

        $fileHandlerMock->ensureConfiguredDirectoriesExist(

            [

                'key' => 'foo_bar',

                'createDirs' => '',

            ]

        );

    }


    public function ‪configuredUploadFolderIsCreatedIfRequested()

    {

        $fileHandlerMock = $this->‪getPreparedFileHandlingMockForDirectoryCreationTests();

        $fileHandlerMock->expects($this->once())

            ->method('createNestedDirectory')

            ->with('uploads/tx_foobar/');

        $fileHandlerMock->ensureConfiguredDirectoriesExist(

            [

                'key' => 'foo_bar',

                'uploadfolder' => 1,

            ]

        );

    }


    public function ‪configuredAdditionalDirectoriesAreCreatedIfRequested()

    {

        $fileHandlerMock = $this->‪getPreparedFileHandlingMockForDirectoryCreationTests();

        $fileHandlerMock->expects($this->exactly(2))

            ->method('createNestedDirectory')

            ->will(

                $this->returnCallback(function ($path) {

                    if (!\in_array($path, ['foo/bar', 'baz/foo'])) {

                        throw new \Exception('Path "' . $path . '" is not expected to be created', 1476108500);

                    }

                })

            );

        $fileHandlerMock->ensureConfiguredDirectoriesExist(

            [

                'key' => 'foo_bar',

                'createDirs' => 'foo/bar, baz/foo',

            ]

        );

    }


    public function ‪configuredDirectoriesAreNotCreatedIfTheyAlreadyExist()

    {

        $fileHandlerMock = $this->‪getPreparedFileHandlingMockForDirectoryCreationTests();

        $fileHandlerMock->expects($this->exactly(3))

            ->method('directoryExists')

            ->will($this->returnValue(true));

        $fileHandlerMock->expects($this->never())

            ->method('createNestedDirectory');

        $fileHandlerMock->ensureConfiguredDirectoriesExist(

            [

                'key' => 'foo_bar',

                'uploadfolder' => 1,

                'createDirs' => 'foo/bar, baz/foo',

            ]

        );

    }


    public function ‪createZipFileFromExtensionGeneratesCorrectArchive()

    {

        // 42 second of first day in 1970 - used to have achieve stable file names

        ‪$GLOBALS['EXEC_TIME'] = 42;


        // Create extension for testing:

        $extKey = $this->‪createFakeExtension();

        $extensionRoot = $this->fakedExtensions[$extKey]['siteAbsPath'];


        // Build mocked fileHandlingUtility:

        $fileHandlerMock = $this->getAccessibleMock(

            FileHandlingUtility::class,

            ['getAbsoluteExtensionPath', 'getExtensionVersion']

        );

        $fileHandlerMock->expects($this->any())

            ->method('getAbsoluteExtensionPath')

            ->will($this->returnValue($extensionRoot));

        $fileHandlerMock->expects($this->any())

            ->method('getExtensionVersion')

            ->will($this->returnValue('0.0.0'));


        // Add files and directories to extension:

        touch($extensionRoot . 'emptyFile.txt');

        file_put_contents($extensionRoot . 'notEmptyFile.txt', 'content');

        touch($extensionRoot . '.hiddenFile');

        mkdir($extensionRoot . 'emptyDir');

        mkdir($extensionRoot . 'notEmptyDir');

        touch($extensionRoot . 'notEmptyDir/file.txt');


        // Create zip-file from extension

        $filename = $fileHandlerMock->_call('createZipFileFromExtension', $extKey);


        $expectedFilename = ‪Environment::getVarPath() . '/transient/' . $extKey . '_0.0.0_' . date('YmdHi', 42) . '.zip';

        $this->testFilesToDelete[] = $filename;

        $this->assertEquals($expectedFilename, $filename, 'Archive file name differs from expectation');


        // File was created

        $this->assertTrue(file_exists($filename), 'Zip file not created');


        // Read archive and check its contents

        $archive = new \ZipArchive();

        $this->assertTrue($archive->open($filename), 'Unable to open archive');

        $this->assertEquals($archive->statName('emptyFile.txt')['size'], 0, 'Empty file not in archive');

        $this->assertEquals($archive->getFromName('notEmptyFile.txt'), 'content', 'Expected content not found');

        $this->assertFalse($archive->statName('.hiddenFile'), 'Hidden file not in archive');

        $this->assertTrue(is_array($archive->statName('emptyDir/')), 'Empty directory not in archive');

        $this->assertTrue(is_array($archive->statName('notEmptyDir/')), 'Not empty directory not in archive');

        $this->assertTrue(is_array($archive->statName('notEmptyDir/file.txt')), 'File within directory not in archive');


        // Check that the archive has no additional content

        $this->assertEquals($archive->numFiles, 5, 'Too many or too less files in archive');

    }

}