public static function tearDownAfterClass()
{
foreach (self::$testDirs as $dir) {
chmod($dir, 0777);
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir($dir, TRUE);
}
}
/**
* Unset all additional properties of test classes to help PHP
* garbage collection. This reduces memory footprint with lots
* of tests.
*
* If owerwriting tearDown() in test classes, please call
* parent::tearDown() at the end. Unsetting of own properties
* is not needed this way.
*
* @throws \RuntimeException
* @return void
*/
protected function tearDown()
{
// Unset properties of test classes to safe memory
$reflection = new \ReflectionObject($this);
foreach ($reflection->getProperties() as $property) {
$declaringClass = $property->getDeclaringClass()->getName();
if (!$property->isStatic() && $declaringClass !== \TYPO3\CMS\Core\Tests\UnitTestCase::class && $declaringClass !== \TYPO3\CMS\Core\Tests\BaseTestCase::class && strpos($property->getDeclaringClass()->getName(), 'PHPUnit_') !== 0) {
$propertyName = $property->getName();
unset($this->{$propertyName});
}
}
unset($reflection);
// Delete registered test files and directories
foreach ($this->testFilesToDelete as $absoluteFileName) {
$absoluteFileName = GeneralUtility::fixWindowsFilePath(PathUtility::getCanonicalPath($absoluteFileName));
if (!GeneralUtility::validPathStr($absoluteFileName)) {
throw new \RuntimeException('tearDown() cleanup: Filename contains illegal characters', 1410633087);
}
if (!StringUtility::beginsWith($absoluteFileName, PATH_site . 'typo3temp/')) {
throw new \RuntimeException('tearDown() cleanup: Files to delete must be within typo3temp/', 1410633412);
}
// file_exists returns false for links pointing to not existing targets, so handle links before next check.
if (@is_link($absoluteFileName) || @is_file($absoluteFileName)) {
unlink($absoluteFileName);
} elseif (@is_dir($absoluteFileName)) {
GeneralUtility::rmdir($absoluteFileName, true);
} else {
throw new \RuntimeException('tearDown() cleanup: File, link or directory does not exist', 1410633510);
}
}
$this->testFilesToDelete = array();
}
/**
* Flush all processed files to be used for debugging mainly.
*
* @return void
*/
public function flushProcessedFilesCommand()
{
foreach ($this->getStorageRepository()->findAll() as $storage) {
// This only works for local driver
if ($storage->getDriverType() === 'Local') {
$this->outputLine();
$this->outputLine(sprintf('%s (%s)', $storage->getName(), $storage->getUid()));
$this->outputLine('--------------------------------------------');
$this->outputLine();
#$storage->getProcessingFolder()->delete(TRUE); // will not work
// Well... not really FAL friendly but straightforward for Local drivers.
$processedDirectoryPath = PATH_site . $storage->getProcessingFolder()->getPublicUrl();
$fileIterator = new FilesystemIterator($processedDirectoryPath, FilesystemIterator::SKIP_DOTS);
$numberOfProcessedFiles = iterator_count($fileIterator);
GeneralUtility::rmdir($processedDirectoryPath, TRUE);
GeneralUtility::mkdir($processedDirectoryPath);
// recreate the directory.
$message = sprintf('Done! Removed %s processed file(s).', $numberOfProcessedFiles);
$this->outputLine($message);
// Remove the record as well.
$record = $this->getDatabaseConnection()->exec_SELECTgetSingleRow('count(*) AS numberOfProcessedFiles', 'sys_file_processedfile', 'storage = ' . $storage->getUid());
$this->getDatabaseConnection()->exec_DELETEquery('sys_file_processedfile', 'storage = ' . $storage->getUid());
$message = sprintf('Done! Removed %s records from "sys_file_processedfile".', $record['numberOfProcessedFiles']);
$this->outputLine($message);
}
}
// Remove possible remaining "sys_file_processedfile"
$query = 'TRUNCATE sys_file_processedfile';
$this->getDatabaseConnection()->sql_query($query);
}
/**
* This clear cache implementation follows a pretty brutal approach.
* Goal is to reliably get rid of cache entries, even if some broken
* extension is loaded that would kill the backend 'clear cache' action.
*
* Therefor this method "knows" implementation details of the cache
* framework and uses them to clear all file based cache (typo3temp/Cache)
* and database caches (tables prefixed with cf_) manually.
*
* After that ext_tables and ext_localconf of extensions are loaded, those
* may register additional caches in the caching framework with different
* backend, and will then clear them with the usual flush() method.
*
* @return void
*/
public function clearAll()
{
// Delete typo3temp/Cache
GeneralUtility::rmdir(PATH_site . 'typo3temp/Cache', TRUE);
$bootstrap = \TYPO3\CMS\Core\Core\Bootstrap::getInstance();
$bootstrap->unregisterClassLoader();
\TYPO3\CMS\Core\Cache\Cache::flagCachingFrameworkForReinitialization();
$bootstrap->initializeClassLoader()->initializeCachingFramework()->initializeClassLoaderCaches()->initializePackageManagement('TYPO3\\CMS\\Core\\Package\\PackageManager');
// Get all table names starting with 'cf_' and truncate them
$database = $this->getDatabaseConnection();
$tables = $database->admin_get_tables();
foreach ($tables as $table) {
$tableName = $table['Name'];
if (substr($tableName, 0, 3) === 'cf_') {
$database->exec_TRUNCATEquery($tableName);
}
}
// From this point on, the code may fatal, if some broken extension is loaded.
// Use bootstrap to load all ext_localconf and ext_tables
$bootstrap->loadTypo3LoadedExtAndExtLocalconf(FALSE)->applyAdditionalConfigurationSettings()->initializeTypo3DbGlobal()->loadExtensionTables(FALSE);
// The cache manager is already instantiated in the install tool
// with some hacked settings to disable caching of extbase and fluid.
// We want a "fresh" object here to operate on a different cache setup.
// cacheManager implements SingletonInterface, so the only way to get a "fresh"
// instance is by circumventing makeInstance and/or the objectManager and
// using new directly!
$cacheManager = new \TYPO3\CMS\Core\Cache\CacheManager();
$cacheManager->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
// Cache manager needs cache factory. cache factory injects itself to manager in __construct()
new \TYPO3\CMS\Core\Cache\CacheFactory('production', $cacheManager);
$cacheManager->flushCaches();
}
/**
* @return void
*/
public function tearDown()
{
foreach ($this->fakedExtensions as $extension => $dummy) {
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir(PATH_site . 'typo3temp/' . $extension, TRUE);
}
parent::tearDown();
}
protected function tearDown()
{
if (!empty($this->extension) && $this->extension->getExtensionKey() != null) {
GeneralUtility::rmdir($this->extension->getExtensionDir(), true);
}
parent::tearDown();
}
/**
*
* @param string $params
* @param type $pObj
*
* @todo add typehinting
*/
function clearCachePostProc($params, &$pObj)
{
if (isset($params['cacheCmd']) && ($params['cacheCmd'] = 'pages')) {
GeneralUtility::rmdir(PATH_site . 'typo3temp/Cache/Data/DynCss', TRUE);
GeneralUtility::rmdir(PATH_site . 'typo3temp/DynCss', TRUE);
}
}
/**
* Tear down
*/
public function tearDown()
{
foreach ($this->testDirs as $dir) {
chmod($dir, 0777);
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir($dir, TRUE);
}
parent::tearDown();
}
/**
* Clean up
* Warning: Since phpunit itself is php and we are fiddling with php
* autoloader code here, the tests are a bit fragile. This tearDown
* method ensures that all main classes are available again during
* tear down of a testcase.
* This construct will fail if the class under test is changed and
* not compatible anymore. Make sure to always run the whole test
* suite if fiddling with the autoloader unit tests to ensure that
* there is no fatal error thrown in other unit test classes triggered
* by errors in this one.
*/
public function tearDown()
{
$GLOBALS['typo3CacheManager'] = $this->typo3CacheManager;
\TYPO3\CMS\Core\Core\ClassLoader::unregisterAutoloader();
\TYPO3\CMS\Core\Core\ClassLoader::registerAutoloader();
foreach ($this->fakedExtensions as $extension) {
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir(PATH_site . 'typo3temp/' . $extension, TRUE);
}
}
/**
* Tear down
*/
public function tearDown()
{
foreach ($this->testNodesToDelete as $node) {
if (\TYPO3\CMS\Core\Utility\GeneralUtility::isFirstPartOfStr($node, PATH_site . 'typo3temp/')) {
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir($node, TRUE);
}
}
parent::tearDown();
}
/**
* Execute signalSlot 'afterExtensionUninstall'
*
* @param string $extensionName
*/
public static function executeOnSignal($extensionName = null)
{
if ($extensionName !== 'lib_js_analytics') {
return;
}
// Cleanup uploads-folder (containing downloaded analytics.js) and extension-configuration
GeneralUtility::rmdir(GeneralUtility::getFileAbsFileName('uploads/tx_libjsanalytics/'), true);
$objectManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
$configurationManager = $objectManager->get('TYPO3\\CMS\\Core\\Configuration\\ConfigurationManager');
$configurationManager->removeLocalConfigurationKeysByPath(['EXT/extConf/lib_js_analytics']);
}
/**
* Clear all caches.
*
* @param bool $hard
* @return void
*/
public function clearAllCaches($hard = FALSE)
{
if (!$hard) {
$this->dataHandler->clear_cacheCmd('all');
} else {
GeneralUtility::rmdir(PATH_site . 'typo3temp/Cache', TRUE);
$cacheManager = new \TYPO3\CMS\Core\Cache\CacheManager();
$cacheManager->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
new \TYPO3\CMS\Core\Cache\CacheFactory('production', $cacheManager);
$cacheManager->flushCaches();
}
}
/**
* Deletes DynCss folders inside typo3temp/.
*
* @param array $params
* @param \TYPO3\CMS\Core\DataHandling\DataHandler $pObj
*/
public function clearCachePostProc(array $params, DataHandler &$pObj)
{
if (!isset($params['cacheCmd'])) {
return;
}
switch ($params['cacheCmd']) {
case 'dyncss':
GeneralUtility::rmdir(PATH_site . 'typo3temp/Cache/Data/DynCss', true);
GeneralUtility::rmdir(PATH_site . 'typo3temp/DynCss', true);
break;
default:
}
}
/**
* Remove all directory and files within the test instance folder.
*
* @return void
*/
protected function removeOldInstanceIfExists()
{
$dir = scandir($this->instancePath);
foreach ($dir as $entry) {
if (is_dir($this->instancePath . '/' . $entry) && $entry != '..' && $entry != '.') {
GeneralUtility::rmdir($this->instancePath . '/' . $entry, TRUE);
} else {
if (is_file($this->instancePath . '/' . $entry)) {
unlink($this->instancePath . '/' . $entry);
}
}
}
}
/**
* @return void
*/
public function tearDown()
{
foreach ($this->fakedExtensions as $extension => $dummy) {
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir(PATH_site . 'typo3conf/ext/' . $extension, TRUE);
}
foreach ($this->resourcesToRemove as $resource) {
if (file_exists($resource) && is_file($resource)) {
unlink($resource);
} elseif (file_exists($resource) && is_dir($resource)) {
rmdir($resource);
}
}
parent::tearDown();
}
public function tearDown()
{
ExtensionManagementUtility::clearExtensionKeyMap();
foreach ($this->testFilesToDelete as $absoluteFileName) {
\TYPO3\CMS\Core\Utility\GeneralUtility::unlink_tempfile($absoluteFileName);
}
if (file_exists(PATH_site . 'typo3temp/test_ext/')) {
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir(PATH_site . 'typo3temp/test_ext/', TRUE);
}
ExtensionManagementUtilityAccessibleProxy::setPackageManager($this->backUpPackageManager);
ExtensionManagementUtilityAccessibleProxy::setCacheManager(NULL);
$GLOBALS['TYPO3_LOADED_EXT'] = new \TYPO3\CMS\Core\Compatibility\LoadedExtensionsArray($this->backUpPackageManager);
\TYPO3\CMS\Core\Utility\GeneralUtility::resetSingletonInstances($this->singletonInstances);
parent::tearDown();
}
/**
* clear Cache ajax handler
*
* @param array $ajaxParams
* @param AjaxRequestHandler $ajaxObj
*/
public function clear($ajaxParams, AjaxRequestHandler $ajaxObj)
{
if ($this->isProduction() || !$this->isAdmin()) {
return;
}
/** @var \TYPO3\CMS\Core\Cache\CacheManager $cacheManager */
$cacheManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager');
$cacheManager->getCache('autoloader')->flush();
// clear autoload folder
if (GeneralUtility::compat_version('7.0')) {
$autoloadFolder = GeneralUtility::getFileAbsFileName('typo3temp/autoload/');
if (is_dir($autoloadFolder)) {
GeneralUtility::rmdir($autoloadFolder, true);
}
}
}
/**
* Render a CSV export request.
*
* @return boolean
*/
public function render()
{
$objects = $this->templateVariableContainer->get('objects');
// Make sure we have something to process...
if (!empty($objects)) {
// Initialization step.
$this->initializeEnvironment($objects);
$this->exportFileNameAndPath .= '.csv';
// add extension to the file.
// Write the exported data to a CSV file.
$this->writeCsvFile($objects);
// We must generate a zip archive since there are files included.
if ($this->hasCollectedFiles()) {
$this->writeZipFile();
$this->sendZipHttpHeaders();
readfile($this->zipFileNameAndPath);
} else {
$this->sendCsvHttpHeaders();
readfile($this->exportFileNameAndPath);
}
GeneralUtility::rmdir($this->temporaryDirectory, TRUE);
}
}
/**
* Install translations for all selected languages for an extension
*
* @param string $extensionKey The extension key to install the translations for
* @param string $language Language code of translation to fetch
* @param string $mirrorUrl Mirror URL to fetch data from
* @return boolean TRUE on success, error string on fauilure
*/
public function updateTranslation($extensionKey, $language, $mirrorUrl)
{
$result = FALSE;
try {
$l10n = $this->fetchTranslation($extensionKey, $language, $mirrorUrl);
if (is_array($l10n)) {
$file = PATH_site . 'typo3temp' . DIRECTORY_SEPARATOR . $extensionKey . '-l10n-' . $language . '.zip';
$path = 'l10n' . DIRECTORY_SEPARATOR . $language . DIRECTORY_SEPARATOR . $extensionKey . DIRECTORY_SEPARATOR;
if (!is_dir(PATH_typo3conf . $path)) {
\TYPO3\CMS\Core\Utility\GeneralUtility::mkdir_deep(PATH_typo3conf, $path);
}
\TYPO3\CMS\Core\Utility\GeneralUtility::writeFile($file, $l10n[0]);
\TYPO3\CMS\Core\Utility\GeneralUtility::rmdir(PATH_typo3conf . $path . $extensionKey, TRUE);
if ($this->unzipTranslationFile($file, PATH_typo3conf . $path)) {
$result = TRUE;
}
}
} catch (\TYPO3\CMS\Core\Exception $exception) {
// @todo logging
}
return $result;
}
/**
* @test
*/
public function getAllFilesAndFoldersInPathReturnsArrayWithMd5Keys()
{
$directory = PATH_site . 'typo3temp/' . $this->getUniqueId('directory_');
mkdir($directory);
$filesAndDirectories = GeneralUtility::getAllFilesAndFoldersInPath(array(), $directory, '', true);
$check = true;
foreach ($filesAndDirectories as $md5 => $path) {
if (!preg_match('/^[a-f0-9]{32}$/', $md5)) {
$check = false;
}
}
GeneralUtility::rmdir($directory);
$this->assertTrue($check);
}
/**
* Install translations for all selected languages for an extension
*
* @param string $extensionKey The extension key to install the translations for
* @param string $language Language code of translation to fetch
* @param string $mirrorUrl Mirror URL to fetch data from
* @return bool TRUE on success, error string on failure
*/
public function updateTranslation($extensionKey, $language, $mirrorUrl)
{
$result = FALSE;
try {
$l10n = $this->fetchTranslation($extensionKey, $language, $mirrorUrl);
if (is_array($l10n)) {
$absolutePathToZipFile = GeneralUtility::getFileAbsFileName('typo3temp/' . $extensionKey . '-l10n-' . $language . '.zip');
$relativeLanguagePath = 'l10n' . '/' . $language . '/';
$absoluteLanguagePath = GeneralUtility::getFileAbsFileName(PATH_typo3conf . $relativeLanguagePath);
$absoluteExtensionLanguagePath = GeneralUtility::getFileAbsFileName(PATH_typo3conf . $relativeLanguagePath . $extensionKey . '/');
if (empty($absolutePathToZipFile) || empty($absoluteLanguagePath) || empty($absoluteExtensionLanguagePath)) {
throw new \TYPO3\CMS\Lang\Exception\Language('Given path is invalid.', 1352565336);
}
if (!is_dir($absoluteLanguagePath)) {
GeneralUtility::mkdir_deep(PATH_typo3conf, $relativeLanguagePath);
}
GeneralUtility::writeFile($absolutePathToZipFile, $l10n[0]);
if (is_dir($absoluteExtensionLanguagePath)) {
GeneralUtility::rmdir($absoluteExtensionLanguagePath, TRUE);
}
if ($this->unzipTranslationFile($absolutePathToZipFile, $absoluteLanguagePath)) {
$result = TRUE;
}
}
} catch (\TYPO3\CMS\Core\Exception $exception) {
// @todo logging
}
return $result;
}
/**
* Removes a folder from this storage.
*
* @param \TYPO3\CMS\Core\Resource\Folder $folder
* @param bool $deleteRecursively
* @return boolean
*/
public function deleteFolder(\TYPO3\CMS\Core\Resource\Folder $folder, $deleteRecursively = FALSE)
{
$folderPath = $this->getAbsolutePath($folder);
$result = \TYPO3\CMS\Core\Utility\GeneralUtility::rmdir($folderPath, $deleteRecursively);
if ($result === FALSE) {
throw new \TYPO3\CMS\Core\Resource\Exception\FileOperationErrorException('Deleting folder "' . $folder->getIdentifier() . '" failed.', 1330119451);
}
return $result;
}
/**
* @test
*/
public function fixPermissionsCorrectlySetsPermissionsRecursive()
{
if (TYPO3_OS == 'WIN') {
$this->markTestSkipped('fixPermissions() tests not available on Windows');
}
// Create and prepare test directory and file structure
$baseDirectory = PATH_site . 'typo3temp/' . uniqid('test_');
Utility\GeneralUtility::mkdir($baseDirectory);
chmod($baseDirectory, 1751);
Utility\GeneralUtility::writeFileToTypo3tempDir($baseDirectory . '/file', '42');
chmod($baseDirectory . '/file', 482);
Utility\GeneralUtility::mkdir($baseDirectory . '/foo');
chmod($baseDirectory . '/foo', 1751);
Utility\GeneralUtility::writeFileToTypo3tempDir($baseDirectory . '/foo/file', '42');
chmod($baseDirectory . '/foo/file', 482);
Utility\GeneralUtility::mkdir($baseDirectory . '/.bar');
chmod($baseDirectory . '/.bar', 1751);
// Use this if writeFileToTypo3tempDir is fixed to create hidden files in subdirectories
// t3lib_div::writeFileToTypo3tempDir($baseDirectory . '/.bar/.file', '42');
// t3lib_div::writeFileToTypo3tempDir($baseDirectory . '/.bar/..file2', '42');
touch($baseDirectory . '/.bar/.file', '42');
chmod($baseDirectory . '/.bar/.file', 482);
touch($baseDirectory . '/.bar/..file2', '42');
chmod($baseDirectory . '/.bar/..file2', 482);
// Set target permissions and run method
$GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask'] = '0660';
$GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask'] = '0770';
$fixPermissionsResult = Utility\GeneralUtility::fixPermissions($baseDirectory, TRUE);
// Get actual permissions
clearstatcache();
$resultBaseDirectoryPermissions = substr(decoct(fileperms($baseDirectory)), 1);
$resultBaseFilePermissions = substr(decoct(fileperms($baseDirectory . '/file')), 2);
$resultFooDirectoryPermissions = substr(decoct(fileperms($baseDirectory . '/foo')), 1);
$resultFooFilePermissions = substr(decoct(fileperms($baseDirectory . '/foo/file')), 2);
$resultBarDirectoryPermissions = substr(decoct(fileperms($baseDirectory . '/.bar')), 1);
$resultBarFilePermissions = substr(decoct(fileperms($baseDirectory . '/.bar/.file')), 2);
$resultBarFile2Permissions = substr(decoct(fileperms($baseDirectory . '/.bar/..file2')), 2);
// Clean up
unlink($baseDirectory . '/file');
unlink($baseDirectory . '/foo/file');
unlink($baseDirectory . '/.bar/.file');
unlink($baseDirectory . '/.bar/..file2');
Utility\GeneralUtility::rmdir($baseDirectory . '/foo');
Utility\GeneralUtility::rmdir($baseDirectory . '/.bar');
Utility\GeneralUtility::rmdir($baseDirectory);
// Test if everything was ok
$this->assertTrue($fixPermissionsResult);
$this->assertEquals($resultBaseDirectoryPermissions, '0770');
$this->assertEquals($resultBaseFilePermissions, '0660');
$this->assertEquals($resultFooDirectoryPermissions, '0770');
$this->assertEquals($resultFooFilePermissions, '0660');
$this->assertEquals($resultBarDirectoryPermissions, '0770');
$this->assertEquals($resultBarFilePermissions, '0660');
$this->assertEquals($resultBarFile2Permissions, '0660');
}
/**
* Remove specified directory
*
* @param string $extDirPath
* @throws \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException
* @return void
*/
public function removeDirectory($extDirPath)
{
$res = GeneralUtility::rmdir($extDirPath, TRUE);
if ($res === FALSE) {
throw new \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException(sprintf($GLOBALS['LANG']->getLL('clearMakeExtDir_could_not_remove_dir'), $this->getRelativePath($extDirPath)), 1337280415);
}
}
/**
* Remove specified directory
*
* @param string $extDirPath
* @throws ExtensionManagerException
* @return void
*/
public function removeDirectory($extDirPath)
{
$extDirPath = GeneralUtility::fixWindowsFilePath($extDirPath);
$extensionPathWithoutTrailingSlash = rtrim($extDirPath, '/');
if (is_link($extensionPathWithoutTrailingSlash) && TYPO3_OS !== 'WIN') {
$result = unlink($extensionPathWithoutTrailingSlash);
} else {
$result = GeneralUtility::rmdir($extDirPath, true);
}
if ($result === false) {
throw new ExtensionManagerException(sprintf($this->languageService->getLL('fileHandling.couldNotRemoveDirectory'), $this->getRelativePath($extDirPath)), 1337280415);
}
}
/**
* @test
*/
public function rmdirRemovesDeadLinkToFile()
{
if (TYPO3_OS === 'WIN') {
$this->markTestSkipped('Test not available on Windows OS.');
}
$notExistingFile = PATH_site . 'typo3temp/' . $this->getUniqueId('notExists_');
$symlinkName = PATH_site . 'typo3temp/' . $this->getUniqueId('link_');
symlink($notExistingFile, $symlinkName);
Utility\GeneralUtility::rmdir($symlinkName, TRUE);
$this->assertFalse(is_link($symlinkName));
}
/**
* Deletes the dummy folder specified in the first parameter $folderName.
* The folder must be empty (no files or subfolders).
*
* @param string $folderName
* the path to the folder to delete relative to
* $this->uploadFolderPath, must not be empty
*
* @return void
*
* @throws \InvalidArgumentException
* @throws Exception
*/
public function deleteDummyFolder($folderName)
{
$absolutePathToFolder = $this->uploadFolderPath . $folderName;
if (!is_dir($absolutePathToFolder)) {
throw new \InvalidArgumentException('The folder "' . $absolutePathToFolder . '" which you are trying to delete does not exist.', 1334439343);
}
if (!isset($this->dummyFolders[$folderName])) {
throw new \InvalidArgumentException('The folder "' . $absolutePathToFolder . '" which you are trying to delete was not created by this instance of ' . 'the testing framework.', 1334439387);
}
if (!GeneralUtility::rmdir($absolutePathToFolder)) {
throw new Exception('The folder "' . $absolutePathToFolder . '" could not be deleted.', 1334439393);
}
unset($this->dummyFolders[$folderName]);
}
/**
* Removes a folder from this storage.
*
* @param string $folderIdentifier
* @param bool $deleteRecursively
* @return bool
* @throws Exception\FileOperationErrorException
* @throws Exception\InvalidPathException
*/
public function deleteFolder($folderIdentifier, $deleteRecursively = false)
{
$folderPath = $this->getAbsolutePath($folderIdentifier);
$result = GeneralUtility::rmdir($folderPath, $deleteRecursively);
if ($result === false) {
throw new Exception\FileOperationErrorException('Deleting folder "' . $folderIdentifier . '" failed.', 1330119451);
}
return $result;
}
/**
* @test
*/
public function constructorCreatesLockDirectoryIfNotExisting()
{
GeneralUtility::rmdir(PATH_site . SimpleLockStrategy::FILE_LOCK_FOLDER, true);
new SimpleLockStrategy('999999999');
$this->assertTrue(is_dir(PATH_site . SimpleLockStrategy::FILE_LOCK_FOLDER));
}
/**
* Removes the backup folder in typo3temp
* @return void
*/
protected function removeBackupFolder()
{
if (!empty($this->extensionBackupPath)) {
GeneralUtility::rmdir($this->extensionBackupPath, true);
$this->extensionBackupPath = '';
}
}
