ChainedFastBackendFactoryTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\Core\Cache;

use Drupal\Component\DependencyInjection\ContainerInterface;
use Drupal\Core\Cache\CacheBackendInterface;
use Drupal\Core\Cache\CacheFactoryInterface;
use Drupal\Core\Cache\ChainedFastBackend;
use Drupal\Core\Cache\ChainedFastBackendFactory;
use Drupal\Tests\UnitTestCase;

/**
 * @coversDefaultClass \Drupal\Core\Cache\ChainedFastBackendFactory
 * @group Cache
 */
class ChainedFastBackendFactoryTest extends UnitTestCase {
    
    /**
     * Test if the same name is provided for consistent and fast services.
     */
    public function testIdenticalService() : void {
        $container = $this->createMock(ContainerInterface::class);
        $testCacheFactory = $this->createMock(CacheFactoryInterface::class);
        $testCacheBackend = $this->createMock(CacheBackendInterface::class);
        $container->expects($this->once())
            ->method('get')
            ->with('cache.backend.test')
            ->willReturn($testCacheFactory);
        $testCacheFactory->expects($this->once())
            ->method('get')
            ->with('test_bin')
            ->willReturn($testCacheBackend);
        $cacheFactory = new ChainedFastBackendFactory(NULL, 'cache.backend.test', 'cache.backend.test');
        $cacheFactory->setContainer($container);
        $cacheBackend = $cacheFactory->get('test_bin');
        // The test backend should be returned directly.
        $this->assertSame($testCacheBackend, $cacheBackend);
    }
    
    /**
     * Test if different names are provided for consistent and fast services.
     */
    public function testDifferentServices() : void {
        $container = $this->createMock(ContainerInterface::class);
        $testConsistentCacheFactory = $this->createMock(CacheFactoryInterface::class);
        $testFastCacheFactory = $this->createMock(CacheFactoryInterface::class);
        $testConsistentCacheBackend = $this->createMock(CacheBackendInterface::class);
        $testFastCacheBackend = $this->createMock(CacheBackendInterface::class);
        $container->expects($this->exactly(2))
            ->method('get')
            ->willReturnCallback(function ($service) use ($testFastCacheFactory, $testConsistentCacheFactory) {
            return match ($service) {    'cache.backend.test_consistent' => $testConsistentCacheFactory,
                'cache.backend.test_fast' => $testFastCacheFactory,
            
            };
        });
        // The same bin should be retrieved from both backends.
        $testConsistentCacheFactory->expects($this->once())
            ->method('get')
            ->with('test_bin')
            ->willReturn($testConsistentCacheBackend);
        $testFastCacheFactory->expects($this->once())
            ->method('get')
            ->with('test_bin')
            ->willReturn($testFastCacheBackend);
        $cacheFactory = new ChainedFastBackendFactory(NULL, 'cache.backend.test_consistent', 'cache.backend.test_fast');
        $cacheFactory->setContainer($container);
        // A wrapping ChainedFastBackend should be returned.
        $cacheBackend = $cacheFactory->get('test_bin');
        $this->assertInstanceOf(ChainedFastBackend::class, $cacheBackend);
    }

}