9.5/_pdo_backend_test_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Core\Tests\Unit\Cache\Backend;


/*

 * 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\Cache\Backend\PdoBackend;

use ‪TYPO3\CMS\Core\Cache\Exception;

use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;

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

use TYPO3\TestingFramework\Core\Unit\UnitTestCase;


class ‪PdoBackendTest extends UnitTestCase

{

    protected ‪$resetSingletonInstances = true;


    public function ‪setThrowsExceptionIfNoFrontEndHasBeenSet()

    {

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

        $this->expectExceptionCode(1259515600);


        $backend = new ‪PdoBackend('Testing');

        $data = 'Some data';

        $identifier = 'MyIdentifier';

        $backend->set($identifier, $data);

    }


    public function ‪itIsPossibleToSetAndCheckExistenceInCache()

    {

        $backend = $this->‪setUpBackend();

        $data = 'Some data';

        $identifier = 'MyIdentifier';

        $backend->set($identifier, $data);

        $this->assertTrue($backend->has($identifier));

    }


    public function ‪itIsPossibleToSetAndGetEntry()

    {

        $backend = $this->‪setUpBackend();

        $data = 'Some data';

        $identifier = 'MyIdentifier';

        $backend->set($identifier, $data);

        $fetchedData = $backend->get($identifier);

        $this->assertEquals($data, $fetchedData);

    }


    public function ‪itIsPossibleToRemoveEntryFromCache()

    {

        $backend = $this->‪setUpBackend();

        $data = 'Some data';

        $identifier = 'MyIdentifier';

        $backend->set($identifier, $data);

        $backend->remove($identifier);

        $this->assertFalse($backend->has($identifier));

    }


    public function ‪itIsPossibleToOverwriteAnEntryInTheCache()

    {

        $backend = $this->‪setUpBackend();

        $data = 'Some data';

        $identifier = 'MyIdentifier';

        $backend->set($identifier, $data);

        $otherData = 'some other data';

        $backend->set($identifier, $otherData);

        $fetchedData = $backend->get($identifier);

        $this->assertEquals($otherData, $fetchedData);

    }


    public function ‪findIdentifiersByTagFindsSetEntries()

    {

        $backend = $this->‪setUpBackend();

        $data = 'Some data';

        $entryIdentifier = 'MyIdentifier';

        $backend->set($entryIdentifier, $data, ['UnitTestTag%tag1', 'UnitTestTag%tag2']);

        $retrieved = $backend->findIdentifiersByTag('UnitTestTag%tag1');

        $this->assertEquals($entryIdentifier, $retrieved[0]);

        $retrieved = $backend->findIdentifiersByTag('UnitTestTag%tag2');

        $this->assertEquals($entryIdentifier, $retrieved[0]);

    }


    public function ‪setRemovesTagsFromPreviousSet()

    {

        $backend = $this->‪setUpBackend();

        $data = 'Some data';

        $entryIdentifier = 'MyIdentifier';

        $backend->set($entryIdentifier, $data, ['UnitTestTag%tag1', 'UnitTestTag%tag2']);

        $backend->set($entryIdentifier, $data, ['UnitTestTag%tag3']);

        $retrieved = $backend->findIdentifiersByTag('UnitTestTag%tag2');

        $this->assertEquals([], $retrieved);

    }


    public function ‪setOverwritesExistingEntryThatExceededItsLifetimeWithNewData()

    {

        $backend = $this->‪setUpBackend();

        $data1 = 'data1';

        $entryIdentifier = $this->getUniqueId('test');

        $backend->set($entryIdentifier, $data1, [], 1);

        $data2 = 'data2';

        ‪$GLOBALS['EXEC_TIME'] += 2;

        $backend->set($entryIdentifier, $data2, [], 10);

        $this->assertEquals($data2, $backend->get($entryIdentifier));

    }


    public function ‪hasReturnsFalseIfTheEntryDoesntExist()

    {

        $backend = $this->‪setUpBackend();

        $identifier = 'NonExistingIdentifier';

        $this->assertFalse($backend->has($identifier));

    }


    public function ‪removeReturnsFalseIfTheEntryDoesntExist()

    {

        $backend = $this->‪setUpBackend();

        $identifier = 'NonExistingIdentifier';

        $this->assertFalse($backend->remove($identifier));

    }


    public function ‪flushByTagRemovesCacheEntriesWithSpecifiedTag()

    {

        $backend = $this->‪setUpBackend();

        $data = 'some data' . microtime();

        $backend->set('PdoBackendTest1', $data, ['UnitTestTag%test', 'UnitTestTag%boring']);

        $backend->set('PdoBackendTest2', $data, ['UnitTestTag%test', 'UnitTestTag%special']);

        $backend->set('PdoBackendTest3', $data, ['UnitTestTag%test']);

        $backend->flushByTag('UnitTestTag%special');

        $this->assertTrue($backend->has('PdoBackendTest1'), 'PdoBackendTest1');

        $this->assertFalse($backend->has('PdoBackendTest2'), 'PdoBackendTest2');

        $this->assertTrue($backend->has('PdoBackendTest3'), 'PdoBackendTest3');

    }


    public function ‪flushByTagsRemovesCacheEntriesWithSpecifiedTags()

    {

        $backend = $this->‪setUpBackend();

        $data = 'some data' . microtime();

        $backend->set('PdoBackendTest1', $data, ['UnitTestTag%test', 'UnitTestTags%boring']);

        $backend->set('PdoBackendTest2', $data, ['UnitTestTag%test', 'UnitTestTag%special']);

        $backend->set('PdoBackendTest3', $data, ['UnitTestTag%test']);

        $backend->flushByTags(['UnitTestTag%special', 'UnitTestTags%boring']);

        $this->assertFalse($backend->has('PdoBackendTest1'), 'PdoBackendTest1');

        $this->assertFalse($backend->has('PdoBackendTest2'), 'PdoBackendTest2');

        $this->assertTrue($backend->has('PdoBackendTest3'), 'PdoBackendTest3');

    }


    public function ‪flushRemovesAllCacheEntries()

    {

        $backend = $this->‪setUpBackend();

        $data = 'some data' . microtime();

        $backend->set('PdoBackendTest1', $data);

        $backend->set('PdoBackendTest2', $data);

        $backend->set('PdoBackendTest3', $data);

        $backend->flush();

        $this->assertFalse($backend->has('PdoBackendTest1'), 'PdoBackendTest1');

        $this->assertFalse($backend->has('PdoBackendTest2'), 'PdoBackendTest2');

        $this->assertFalse($backend->has('PdoBackendTest3'), 'PdoBackendTest3');

    }


    public function ‪flushRemovesOnlyOwnEntries()

    {

        $thisCache = $this->createMock(FrontendInterface::class);

        $thisCache->expects($this->any())->method('getIdentifier')->will($this->returnValue('thisCache'));

        $thisBackend = $this->‪setUpBackend();

        $thisBackend->setCache($thisCache);

        $thatCache = $this->createMock(FrontendInterface::class);

        $thatCache->expects($this->any())->method('getIdentifier')->will($this->returnValue('thatCache'));

        $thatBackend = $this->‪setUpBackend();

        $thatBackend->setCache($thatCache);

        $thisBackend->set('thisEntry', 'Hello');

        $thatBackend->set('thatEntry', 'World!');

        $thatBackend->flush();

        $this->assertEquals('Hello', $thisBackend->get('thisEntry'));

        $this->assertFalse($thatBackend->has('thatEntry'));

    }


    public function ‪collectGarbageReallyRemovesAnExpiredCacheEntry()

    {

        $backend = $this->‪setUpBackend();

        $data = 'some data' . microtime();

        $entryIdentifier = 'BackendPDORemovalTest';

        $backend->set($entryIdentifier, $data, [], 1);

        $this->assertTrue($backend->has($entryIdentifier));

        ‪$GLOBALS['EXEC_TIME'] += 2;

        $backend->collectGarbage();

        $this->assertFalse($backend->has($entryIdentifier));

    }


    public function ‪collectGarbageReallyRemovesAllExpiredCacheEntries()

    {

        $backend = $this->‪setUpBackend();

        $data = 'some data' . microtime();

        $entryIdentifier = 'BackendPDORemovalTest';

        $backend->set($entryIdentifier . 'A', $data, [], null);

        $backend->set($entryIdentifier . 'B', $data, [], 10);

        $backend->set($entryIdentifier . 'C', $data, [], 1);

        $backend->set($entryIdentifier . 'D', $data, [], 1);

        $this->assertTrue($backend->has($entryIdentifier . 'A'));

        $this->assertTrue($backend->has($entryIdentifier . 'B'));

        $this->assertTrue($backend->has($entryIdentifier . 'C'));

        $this->assertTrue($backend->has($entryIdentifier . 'D'));

        ‪$GLOBALS['EXEC_TIME'] += 2;

        $backend->collectGarbage();

        $this->assertTrue($backend->has($entryIdentifier . 'A'));

        $this->assertTrue($backend->has($entryIdentifier . 'B'));

        $this->assertFalse($backend->has($entryIdentifier . 'C'));

        $this->assertFalse($backend->has($entryIdentifier . 'D'));

    }


    protected function ‪setUpBackend()

    {

        $mockCache = $this->createMock(FrontendInterface::class);

        $mockCache->expects($this->any())->method('getIdentifier')->will($this->returnValue('TestCache'));

        $backend = GeneralUtility::makeInstance(PdoBackend::class, 'Testing');

        $backend->setCache($mockCache);

        $backend->setDataSourceName('sqlite::memory:');

        $backend->initializeObject();

        return $backend;

    }

}