FileBackendTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Tests\Unit\Cache\Backend;
 
use org\bovigo\vfs\vfsStreamDirectory;
use org\bovigo\vfs\vfsStreamWrapper;
use ‪TYPO3\CMS\Core\Cache\Backend\FileBackend;
use ‪TYPO3\CMS\Core\Cache\Exception;
use ‪TYPO3\CMS\Core\Cache\Exception\InvalidDataException;
use ‪TYPO3\CMS\Core\Cache\Frontend\AbstractFrontend;
use ‪TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
use ‪TYPO3\CMS\Core\Core\Environment;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪FileBackendTest extends UnitTestCase
{
    protected ‪$resetSingletonInstances = true;
 
    protected function ‪setUp(): void
    {
        parent::setUp();
        vfsStreamWrapper::register();
        vfsStreamWrapper::setRoot(new vfsStreamDirectory('Foo'));
    }
 
    public function ‪setCacheDirectoryThrowsExceptionOnNonWritableDirectory(): void
    {
        $this->expectException(Exception::class);
        $this->expectExceptionCode(1303669848);
 
        $mockCache = $this->createMock(AbstractFrontend::class);
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('http://localhost/');
 
        $backend->setCache($mockCache);
    }
 
    public function ‪setCacheDirectoryAllowsAbsolutePathWithoutTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('/tmp/foo');
        self::assertEquals('/tmp/foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsAbsolutePathWithTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('/tmp/foo/');
        self::assertEquals('/tmp/foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsRelativePathWithoutTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('tmp/foo');
        $path = ‪Environment::getProjectPath();
        self::assertEquals($path . '/tmp/foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsRelativePathWithTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('tmp/foo/');
        $path = ‪Environment::getProjectPath();
        self::assertEquals($path . '/tmp/foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsRelativeDottedPathWithoutTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('../tmp/foo');
        $path = ‪Environment::getProjectPath();
        self::assertEquals($path . '/../tmp/foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsRelativeDottedPathWithTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('../tmp/foo/');
        $path = ‪Environment::getProjectPath();
        self::assertEquals($path . '/../tmp/foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsAbsoluteDottedPathWithoutTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('/tmp/../foo');
        self::assertEquals('/tmp/../foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪setCacheDirectoryAllowsAbsoluteDottedPathWithTrailingSlash(): void
    {
        $backend = $this->getAccessibleMock(FileBackend::class, ['dummy'], [], '', false);
        $backend->setCacheDirectory('/tmp/../foo/');
        self::assertEquals('/tmp/../foo/', $backend->_get('temporaryCacheDirectory'));
    }
 
    public function ‪getCacheDirectoryReturnsTheCurrentCacheDirectory(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::any())->method('getIdentifier')->willReturn('SomeCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        self::assertEquals('vfs://Foo/cache/data/SomeCache/', $backend->getCacheDirectory());
    }
 
    public function ‪aDedicatedCacheDirectoryIsUsedForCodeCaches(): void
    {
        $mockCache = $this->createMock(PhpFrontend::class);
        $mockCache->expects(self::any())->method('getIdentifier')->willReturn('SomeCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        self::assertEquals('vfs://Foo/cache/code/SomeCache/', $backend->getCacheDirectory());
    }
 
    public function ‪setThrowsExceptionIfDataIsNotAString(): void
    {
        $this->expectException(InvalidDataException::class);
        $this->expectExceptionCode(1204481674);
 
        $mockCache = $this->createMock(AbstractFrontend::class);
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set('some identifier', ['not a string']);
    }
 
    public function ‪setReallySavesToTheSpecifiedDirectory(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $data = 'some data' . microtime();
        $entryIdentifier = 'BackendFileTest';
        $pathAndFilename = 'vfs://Foo/cache/data/UnitTestCache/' . $entryIdentifier;
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set($entryIdentifier, $data);
 
        self::assertFileExists($pathAndFilename);
        $retrievedData = file_get_contents($pathAndFilename, false, null, 0, \strlen($data));
        self::assertEquals($data, $retrievedData);
    }
 
    public function ‪setOverwritesAnAlreadyExistingCacheEntryForTheSameIdentifier(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $data1 = 'some data' . microtime();
        $data2 = 'some data' . microtime();
        $entryIdentifier = 'BackendFileRemoveBeforeSetTest';
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set($entryIdentifier, $data1, [], 500);
        $backend->set($entryIdentifier, $data2, [], 200);
 
        $pathAndFilename = 'vfs://Foo/cache/data/UnitTestCache/' . $entryIdentifier;
        self::assertFileExists($pathAndFilename);
        $retrievedData = file_get_contents($pathAndFilename, false, null, 0, \strlen($data2));
        self::assertEquals($data2, $retrievedData);
    }
 
    public function ‪setAlsoSavesSpecifiedTags(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $data = 'some data' . microtime();
        $entryIdentifier = 'BackendFileRemoveBeforeSetTest';
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set($entryIdentifier, $data, ['Tag1', 'Tag2']);
 
        $pathAndFilename = 'vfs://Foo/cache/data/UnitTestCache/' . $entryIdentifier;
        self::assertFileExists($pathAndFilename);
        $retrievedData = file_get_contents(
            $pathAndFilename,
            false,
            null,
            \strlen($data) + ‪FileBackend::EXPIRYTIME_LENGTH,
            9
        );
        self::assertEquals('Tag1 Tag2', $retrievedData);
    }
 
    public function ‪setCacheDetectsAndLoadsAFrozenCache(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $data = 'some data' . microtime();
        $entryIdentifier = 'BackendFileTest';
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set($entryIdentifier, $data, ['Tag1', 'Tag2']);
 
        $backend->freeze();
 
        unset($backend);
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        self::assertTrue($backend->isFrozen());
        self::assertEquals($data, $backend->get($entryIdentifier));
    }
 
    public function ‪getReturnsContentOfTheCorrectCacheFile(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['setTag'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $entryIdentifier = 'BackendFileTest';
 
        $data = 'some data' . microtime();
        $backend->set($entryIdentifier, $data, [], 500);
 
        $data = 'some other data' . microtime();
        $backend->set($entryIdentifier, $data, [], 100);
 
        $loadedData = $backend->get($entryIdentifier);
        self::assertEquals($data, $loadedData);
    }
 
    public function ‪getReturnsFalseForExpiredEntries(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->expects(self::once())->method('isCacheFileExpired')->with('vfs://Foo/cache/data/UnitTestCache/ExpiredEntry')->willReturn(true);
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        self::assertFalse($backend->get('ExpiredEntry'));
    }
 
    public function ‪getDoesNotCheckIfAnEntryIsExpiredIfTheCacheIsFrozen(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->expects(self::once())->method('isCacheFileExpired');
 
        $backend->set('foo', 'some data');
        $backend->freeze();
        self::assertEquals('some data', $backend->get('foo'));
        self::assertFalse($backend->get('bar'));
    }
 
    public function ‪hasReturnsTrueIfAnEntryExists(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $entryIdentifier = 'BackendFileTest';
 
        $data = 'some data' . microtime();
        $backend->set($entryIdentifier, $data);
 
        self::assertTrue($backend->has($entryIdentifier), 'has() did not return TRUE.');
        self::assertFalse($backend->has($entryIdentifier . 'Not'), 'has() did not return FALSE.');
    }
 
    public function ‪hasReturnsFalseForExpiredEntries(): void
    {
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->expects(self::exactly(2))->method('isCacheFileExpired')->will(self::onConsecutiveCalls(
            true,
            false
        ));
 
        self::assertFalse($backend->has('foo'));
        self::assertTrue($backend->has('bar'));
    }
 
    public function ‪hasDoesNotCheckIfAnEntryIsExpiredIfTheCacheIsFrozen(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->expects(self::once())->method('isCacheFileExpired'); // Indirectly called by freeze() -> get()
 
        $backend->set('foo', 'some data');
        $backend->freeze();
        self::assertTrue($backend->has('foo'));
        self::assertFalse($backend->has('bar'));
    }
 
    public function ‪removeReallyRemovesACacheEntry(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $data = 'some data' . microtime();
        $entryIdentifier = 'BackendFileTest';
        $pathAndFilename = 'vfs://Foo/cache/data/UnitTestCache/' . $entryIdentifier;
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set($entryIdentifier, $data);
        self::assertFileExists($pathAndFilename);
 
        $backend->remove($entryIdentifier);
        // @todo remove condition and else branch as soon as phpunit v8 goes out of support
        if (method_exists($this, 'assertFileDoesNotExist')) {
            self::assertFileDoesNotExist($pathAndFilename);
        } else {
            self::assertFileNotExists($pathAndFilename);
        }
    }
 
    public function ‪invalidEntryIdentifiers(): array
    {
        return [
            'trailing slash' => ['/myIdentifier'],
            'trailing dot and slash' => ['./myIdentifier'],
            'trailing two dots and slash' => ['../myIdentifier'],
            'trailing with multiple dots and slashes' => ['.././../myIdentifier'],
            'slash in middle part' => ['my/Identifier'],
            'dot and slash in middle part' => ['my./Identifier'],
            'two dots and slash in middle part' => ['my../Identifier'],
            'multiple dots and slashes in middle part' => ['my.././../Identifier'],
            'pending slash' => ['myIdentifier/'],
            'pending dot and slash' => ['myIdentifier./'],
            'pending dots and slash' => ['myIdentifier../'],
            'pending multiple dots and slashes' => ['myIdentifier.././../'],
        ];
    }
 
    public function ‪setThrowsExceptionForInvalidIdentifier(string $identifier): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1282073032);
 
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->setConstructorArgs(['test'])
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->set($identifier, 'cache data', []);
    }
 
    public function ‪getThrowsExceptionForInvalidIdentifier(string $identifier): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1282073033);
 
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->get($identifier);
    }
 
    public function ‪hasThrowsExceptionForInvalidIdentifier(string $identifier): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1282073034);
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
 
        $backend->has($identifier);
    }
 
    public function ‪removeThrowsExceptionForInvalidIdentifier(string $identifier): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1282073035);
 
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->remove($identifier);
    }
 
    public function ‪requireOnceThrowsExceptionForInvalidIdentifier(string $identifier): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1282073036);
 
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->requireOnce($identifier);
    }
 
    public function ‪requireOnceIncludesAndReturnsResultOfIncludedPhpFile(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $entryIdentifier = 'SomePhpEntry';
 
        $data = '<?php return "foo"; ?>';
        $backend->set($entryIdentifier, $data);
 
        $loadedData = $backend->requireOnce($entryIdentifier);
        self::assertEquals('foo', $loadedData);
    }
 
    public function ‪requireOnceDoesNotCheckExpiryTimeIfBackendIsFrozen(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->expects(self::once())->method('isCacheFileExpired'); // Indirectly called by freeze() -> get()
 
        $data = '<?php return "foo"; ?>';
        $backend->set('FooEntry', $data);
 
        $backend->freeze();
 
        $loadedData = $backend->requireOnce('FooEntry');
        self::assertEquals('foo', $loadedData);
    }
 
    public function ‪requireThrowsExceptionForInvalidIdentifier(string $identifier): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1532528246);
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->require($identifier);
    }
 
    public function ‪requireIncludesAndReturnsResultOfIncludedPhpFile(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $entryIdentifier = 'SomePhpEntry2';
 
        $data = '<?php return "foo2"; ?>';
        $backend->set($entryIdentifier, $data);
 
        $loadedData = $backend->require($entryIdentifier);
        self::assertEquals('foo2', $loadedData);
    }
 
    public function ‪requireDoesNotCheckExpiryTimeIfBackendIsFrozen(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->expects(self::once())->method('isCacheFileExpired'); // Indirectly called by freeze() -> get()
 
        $data = '<?php return "foo"; ?>';
        $backend->set('FooEntry2', $data);
 
        $backend->freeze();
 
        $loadedData = $backend->require('FooEntry2');
        self::assertEquals('foo', $loadedData);
    }
 
    public function ‪requireCanLoadSameEntryMultipleTimes(): void
    {
        $frontendProphecy = $this->prophesize(AbstractFrontend::class);
        $frontendProphecy->getIdentifier()->willReturn('UnitTestCache');
        $subject = new ‪FileBackend('Testing');
        $subject->setCacheDirectory('vfs://Foo/');
        $subject->setCache($frontendProphecy->reveal());
        $subject->set('BarEntry', '<?php return "foo"; ?>');
        $loadedData = $subject->require('BarEntry');
        self::assertEquals('foo', $loadedData);
        $loadedData = $subject->require('BarEntry');
        self::assertEquals('foo', $loadedData);
    }
 
    public function ‪findIdentifiersByTagFindsCacheEntriesWithSpecifiedTag(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $data = 'some data' . microtime();
        $backend->set('BackendFileTest1', $data, ['UnitTestTag%test', 'UnitTestTag%boring']);
        $backend->set('BackendFileTest2', $data, ['UnitTestTag%test', 'UnitTestTag%special']);
        $backend->set('BackendFileTest3', $data, ['UnitTestTag%test']);
 
        $expectedEntry = 'BackendFileTest2';
 
        $actualEntries = $backend->findIdentifiersByTag('UnitTestTag%special');
        self::assertIsArray($actualEntries);
        self::assertEquals($expectedEntry, array_pop($actualEntries));
    }
 
    public function ‪findIdentifiersByTagDoesNotReturnExpiredEntries(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $data = 'some data';
        $backend->set('BackendFileTest1', $data, ['UnitTestTag%test', 'UnitTestTag%boring']);
        $backend->set('BackendFileTest2', $data, ['UnitTestTag%test', 'UnitTestTag%special'], -100);
        $backend->set('BackendFileTest3', $data, ['UnitTestTag%test']);
 
        self::assertSame([], $backend->findIdentifiersByTag('UnitTestTag%special'));
        self::assertSame(['BackendFileTest1', 'BackendFileTest3'], $backend->findIdentifiersByTag('UnitTestTag%test'));
    }
 
    public function ‪flushRemovesAllCacheEntries(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $data = 'some data';
        $backend->set('BackendFileTest1', $data);
        $backend->set('BackendFileTest2', $data);
 
        self::assertFileExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest1');
        self::assertFileExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest2');
 
        $backend->flush();
 
        // @todo remove condition and else branch as soon as phpunit v8 goes out of support
        if (method_exists($this, 'assertFileDoesNotExist')) {
            self::assertFileDoesNotExist('vfs://Foo/cache/data/UnitTestCache/BackendFileTest1');
            self::assertFileDoesNotExist('vfs://Foo/cache/data/UnitTestCache/BackendFileTest2');
        } else {
            self::assertFileNotExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest1');
            self::assertFileNotExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest2');
        }
    }
 
    public function ‪flushCreatesCacheDirectoryAgain(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->flush();
        self::assertFileExists('vfs://Foo/cache/data/UnitTestCache/');
    }
 
    public function ‪flushByTagRemovesCacheEntriesWithSpecifiedTag(): void
    {
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['findIdentifiersByTag', 'remove'])
            ->disableOriginalConstructor()
            ->getMock();
 
        $backend->expects(self::once())->method('findIdentifiersByTag')->with('UnitTestTag%special')->willReturn([
            'foo',
            'bar',
            'baz'
        ]);
        $backend->expects(self::exactly(3))->method('remove')->withConsecutive(['foo'], ['bar'], ['baz']);
 
        $backend->flushByTag('UnitTestTag%special');
    }
 
    public function ‪collectGarbageRemovesExpiredCacheEntries(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['isCacheFileExpired'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->expects(self::exactly(2))->method('isCacheFileExpired')->will(self::onConsecutiveCalls(
            true,
            false
        ));
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $data = 'some data';
        $backend->set('BackendFileTest1', $data);
        $backend->set('BackendFileTest2', $data);
 
        self::assertFileExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest1');
        self::assertFileExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest2');
 
        $backend->collectGarbage();
 
        // @todo remove condition and else branch as soon as phpunit v8 goes out of support
        if (method_exists($this, 'assertFileDoesNotExist')) {
            self::assertFileDoesNotExist('vfs://Foo/cache/data/UnitTestCache/BackendFileTest1');
        } else {
            self::assertFileNotExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest1');
        }
 
        self::assertFileExists('vfs://Foo/cache/data/UnitTestCache/BackendFileTest2');
    }
 
    public function ‪flushUnfreezesTheCache(): void
    {
        $mockCache = $this->createMock(AbstractFrontend::class);
        $mockCache->expects(self::atLeastOnce())->method('getIdentifier')->willReturn('UnitTestCache');
 
        $backend = $this->getMockBuilder(FileBackend::class)
            ->setMethods(['dummy'])
            ->disableOriginalConstructor()
            ->getMock();
        $backend->setCacheDirectory('vfs://Foo/');
        $backend->setCache($mockCache);
 
        $backend->freeze();
 
        self::assertTrue($backend->isFrozen());
        $backend->flush();
        self::assertFalse($backend->isFrozen());
    }
}