core/tests/Drupal/Tests/Core/Entity/KeyValueStore/KeyValueEntityStorageTest.php
View source
<?php
declare (strict_types=1);
namespace Drupal\Tests\Core\Entity\KeyValueStore;
use Drupal\Component\Datetime\Time;
use Drupal\Core\Cache\MemoryCache\MemoryCache;
use Drupal\Core\Config\Entity\ConfigEntityInterface;
use Drupal\Core\DependencyInjection\ContainerBuilder;
use Drupal\Core\Entity\EntityBase;
use Drupal\Core\Entity\EntityFieldManagerInterface;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityMalformedException;
use Drupal\Core\Entity\EntityStorageException;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Language\Language;
use Drupal\Tests\UnitTestCase;
use Drupal\Core\Entity\KeyValueStore\KeyValueEntityStorage;
class KeyValueEntityStorageTest extends UnitTestCase {
protected $entityType;
protected $keyValueStore;
protected $moduleHandler;
protected $uuidService;
protected $languageManager;
protected $entityStorage;
protected $entityTypeManager;
protected $entityFieldManager;
protected $cacheTagsInvalidator;
protected function setUp() : void {
parent::setUp();
$this->entityType = $this
->createMock('Drupal\\Core\\Entity\\EntityTypeInterface');
}
protected function setUpKeyValueEntityStorage($uuid_key = 'uuid') {
$this->entityType
->expects($this
->atLeastOnce())
->method('getKey')
->willReturnMap([
[
'id',
'id',
],
[
'uuid',
$uuid_key,
],
[
'langcode',
'langcode',
],
]);
$this->entityType
->expects($this
->atLeastOnce())
->method('id')
->willReturn('test_entity_type');
$this->entityType
->expects($this
->any())
->method('getListCacheTags')
->willReturn([
'test_entity_type_list',
]);
$this->entityTypeManager = $this
->createMock(EntityTypeManagerInterface::class);
$this->entityTypeManager
->expects($this
->any())
->method('getDefinition')
->with('test_entity_type')
->willReturn($this->entityType);
$this->entityFieldManager = $this
->createMock(EntityFieldManagerInterface::class);
$this->cacheTagsInvalidator = $this
->createMock('Drupal\\Core\\Cache\\CacheTagsInvalidatorInterface');
$this->keyValueStore = $this
->createMock('Drupal\\Core\\KeyValueStore\\KeyValueStoreInterface');
$this->moduleHandler = $this
->createMock('Drupal\\Core\\Extension\\ModuleHandlerInterface');
$this->uuidService = $this
->createMock('Drupal\\Component\\Uuid\\UuidInterface');
$this->languageManager = $this
->createMock('Drupal\\Core\\Language\\LanguageManagerInterface');
$language = new Language([
'langcode' => 'en',
]);
$this->languageManager
->expects($this
->any())
->method('getDefaultLanguage')
->willReturn($language);
$this->languageManager
->expects($this
->any())
->method('getCurrentLanguage')
->willReturn($language);
$this->entityStorage = new KeyValueEntityStorage($this->entityType, $this->keyValueStore, $this->uuidService, $this->languageManager, new MemoryCache(new Time()));
$this->entityStorage
->setModuleHandler($this->moduleHandler);
$container = new ContainerBuilder();
$container
->set('entity_field.manager', $this->entityFieldManager);
$container
->set('entity_type.manager', $this->entityTypeManager);
$container
->set('language_manager', $this->languageManager);
$container
->set('cache_tags.invalidator', $this->cacheTagsInvalidator);
\Drupal::setContainer($container);
}
public function testCreateWithPredefinedUuid() {
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($this
->getMockEntity()));
$this
->setUpKeyValueEntityStorage();
$hooks = [
'test_entity_type_create',
'entity_create',
];
$this->moduleHandler
->expects($this
->exactly(count($hooks)))
->method('invokeAll')
->with($this
->callback(function (string $hook) use (&$hooks) : bool {
return array_shift($hooks) === $hook;
}));
$this->uuidService
->expects($this
->never())
->method('generate');
$entity = $this->entityStorage
->create([
'id' => 'foo',
'uuid' => 'baz',
]);
$this
->assertInstanceOf('Drupal\\Core\\Entity\\EntityInterface', $entity);
$this
->assertSame('foo', $entity
->id());
$this
->assertSame('baz', $entity
->uuid());
}
public function testCreateWithoutUuidKey() {
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($this
->getMockEntity()));
$this
->setUpKeyValueEntityStorage(NULL);
$hooks = [
'test_entity_type_create',
'entity_create',
];
$this->moduleHandler
->expects($this
->exactly(count($hooks)))
->method('invokeAll')
->with($this
->callback(function (string $hook) use (&$hooks) : bool {
return array_shift($hooks) === $hook;
}));
$this->uuidService
->expects($this
->never())
->method('generate');
$entity = $this->entityStorage
->create([
'id' => 'foo',
'uuid' => 'baz',
]);
$this
->assertInstanceOf('Drupal\\Core\\Entity\\EntityInterface', $entity);
$this
->assertSame('foo', $entity
->id());
$this
->assertSame('baz', $entity
->uuid());
}
public function testCreate() {
$entity = $this
->getMockEntity(EntityBaseTest::class, [], [
'toArray',
]);
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($entity));
$this
->setUpKeyValueEntityStorage();
$hooks = [
'test_entity_type_create',
'entity_create',
];
$this->moduleHandler
->expects($this
->exactly(count($hooks)))
->method('invokeAll')
->with($this
->callback(function (string $hook) use (&$hooks) : bool {
return array_shift($hooks) === $hook;
}));
$this->uuidService
->expects($this
->once())
->method('generate')
->willReturn('bar');
$entity = $this->entityStorage
->create([
'id' => 'foo',
]);
$this
->assertInstanceOf('Drupal\\Core\\Entity\\EntityInterface', $entity);
$this
->assertSame('foo', $entity
->id());
$this
->assertSame('bar', $entity
->uuid());
return $entity;
}
public function testSaveInsert(EntityInterface $entity) {
$this
->setUpKeyValueEntityStorage();
$expected = [
'id' => 'foo',
];
$this->keyValueStore
->expects($this
->exactly(2))
->method('has')
->with('foo')
->willReturn(FALSE);
$this->keyValueStore
->expects($this
->never())
->method('getMultiple');
$this->keyValueStore
->expects($this
->never())
->method('delete');
$entity
->expects($this
->atLeastOnce())
->method('toArray')
->willReturn($expected);
$hooks = [
'test_entity_type_presave',
'entity_presave',
'test_entity_type_insert',
'entity_insert',
];
$this->moduleHandler
->expects($this
->exactly(count($hooks)))
->method('invokeAll')
->with($this
->callback(function (string $hook) use (&$hooks) : bool {
return array_shift($hooks) === $hook;
}));
$this->keyValueStore
->expects($this
->once())
->method('set')
->with('foo', $expected);
$return = $this->entityStorage
->save($entity);
$this
->assertSame(SAVED_NEW, $return);
return $entity;
}
public function testSaveUpdate(EntityInterface $entity) {
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($entity));
$this
->setUpKeyValueEntityStorage();
$expected = [
'id' => 'foo',
];
$this->keyValueStore
->expects($this
->exactly(2))
->method('has')
->with('foo')
->willReturn(TRUE);
$this->keyValueStore
->expects($this
->once())
->method('getMultiple')
->with([
'foo',
])
->willReturn([
[
'id' => 'foo',
],
]);
$this->keyValueStore
->expects($this
->never())
->method('delete');
$hooks = [
'test_entity_type_presave',
'entity_presave',
'test_entity_type_update',
'entity_update',
];
$this->moduleHandler
->expects($this
->exactly(count($hooks)))
->method('invokeAll')
->with($this
->callback(function (string $hook) use (&$hooks) : bool {
return array_shift($hooks) === $hook;
}));
$this->keyValueStore
->expects($this
->once())
->method('set')
->with('foo', $expected);
$return = $this->entityStorage
->save($entity);
$this
->assertSame(SAVED_UPDATED, $return);
return $entity;
}
public function testSaveConfigEntity() {
$this
->setUpKeyValueEntityStorage();
$entity = $this
->getMockEntity('Drupal\\Core\\Config\\Entity\\ConfigEntityBase', [
[
'id' => 'foo',
],
], [
'toArray',
'preSave',
]);
$entity
->enforceIsNew();
$this
->assertSame('foo', $entity
->getOriginalId());
$expected = [
'id' => 'foo',
];
$entity
->expects($this
->atLeastOnce())
->method('toArray')
->willReturn($expected);
$this->keyValueStore
->expects($this
->exactly(2))
->method('has')
->with('foo')
->willReturn(FALSE);
$this->keyValueStore
->expects($this
->once())
->method('set')
->with('foo', $expected);
$this->keyValueStore
->expects($this
->never())
->method('delete');
$return = $this->entityStorage
->save($entity);
$this
->assertSame(SAVED_NEW, $return);
return $entity;
}
public function testSaveRenameConfigEntity(ConfigEntityInterface $entity) {
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($entity));
$this
->setUpKeyValueEntityStorage();
$expected = [
'id' => 'foo',
];
$entity
->expects($this
->once())
->method('toArray')
->willReturn($expected);
$this->keyValueStore
->expects($this
->exactly(2))
->method('has')
->with('foo')
->willReturn(TRUE);
$this->keyValueStore
->expects($this
->once())
->method('getMultiple')
->with([
'foo',
])
->willReturn([
[
'id' => 'foo',
],
]);
$this->keyValueStore
->expects($this
->once())
->method('delete')
->with('foo');
$this->keyValueStore
->expects($this
->once())
->method('set')
->with('bar', $expected);
$this
->assertSame('foo', $entity
->getOriginalId());
$entity
->set('id', 'bar');
$this
->assertSame('foo', $entity
->getOriginalId());
$return = $this->entityStorage
->save($entity);
$this
->assertSame(SAVED_UPDATED, $return);
$this
->assertSame('bar', $entity
->getOriginalId());
}
public function testSaveContentEntity() {
$this->entityType
->expects($this
->any())
->method('getKeys')
->willReturn([
'id' => 'id',
]);
$this
->setUpKeyValueEntityStorage();
$expected = [
'id' => 'foo',
];
$this->keyValueStore
->expects($this
->exactly(2))
->method('has')
->with('foo')
->willReturn(FALSE);
$this->keyValueStore
->expects($this
->once())
->method('set')
->with('foo', $expected);
$this->keyValueStore
->expects($this
->never())
->method('delete');
$entity = $this
->getMockEntity('Drupal\\Core\\Entity\\ContentEntityBase', [], [
'toArray',
'id',
]);
$entity
->expects($this
->atLeastOnce())
->method('id')
->willReturn('foo');
$entity
->expects($this
->once())
->method('toArray')
->willReturn($expected);
$this->entityStorage
->save($entity);
}
public function testSaveInvalid() {
$this
->setUpKeyValueEntityStorage();
$entity = $this
->getMockEntity('Drupal\\Core\\Config\\Entity\\ConfigEntityBase');
$this->keyValueStore
->expects($this
->never())
->method('has');
$this->keyValueStore
->expects($this
->never())
->method('set');
$this->keyValueStore
->expects($this
->never())
->method('delete');
$this
->expectException(EntityMalformedException::class);
$this
->expectExceptionMessage('The entity does not have an ID.');
$this->entityStorage
->save($entity);
}
public function testSaveDuplicate() {
$this
->setUpKeyValueEntityStorage();
$entity = $this
->getMockEntity(EntityBaseTest::class, [
[
'id' => 'foo',
],
]);
$entity
->enforceIsNew();
$this->keyValueStore
->expects($this
->once())
->method('has')
->willReturn(TRUE);
$this->keyValueStore
->expects($this
->never())
->method('set');
$this->keyValueStore
->expects($this
->never())
->method('delete');
$this
->expectException(EntityStorageException::class);
$this
->expectExceptionMessage("'test_entity_type' entity with ID 'foo' already exists");
$this->entityStorage
->save($entity);
}
public function testLoad() {
$entity = $this
->getMockEntity();
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($entity));
$this
->setUpKeyValueEntityStorage();
$this->keyValueStore
->expects($this
->once())
->method('getMultiple')
->with([
'foo',
])
->willReturn([
[
'id' => 'foo',
],
]);
$entity = $this->entityStorage
->load('foo');
$this
->assertInstanceOf('Drupal\\Core\\Entity\\EntityInterface', $entity);
$this
->assertSame('foo', $entity
->id());
}
public function testLoadMissingEntity() {
$this
->setUpKeyValueEntityStorage();
$this->keyValueStore
->expects($this
->once())
->method('getMultiple')
->with([
'foo',
])
->willReturn([]);
$entity = $this->entityStorage
->load('foo');
$this
->assertNull($entity);
}
public function testLoadMultipleAll() {
$expected['foo'] = $this
->getMockEntity(EntityBaseTest::class, [
[
'id' => 'foo',
],
]);
$expected['bar'] = $this
->getMockEntity(EntityBaseTest::class, [
[
'id' => 'bar',
],
]);
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class(reset($expected)));
$this
->setUpKeyValueEntityStorage();
$this->keyValueStore
->expects($this
->once())
->method('getAll')
->willReturn([
[
'id' => 'foo',
],
[
'id' => 'bar',
],
]);
$entities = $this->entityStorage
->loadMultiple();
foreach ($entities as $id => $entity) {
$this
->assertInstanceOf('Drupal\\Core\\Entity\\EntityInterface', $entity);
$this
->assertSame($id, $entity
->id());
$this
->assertSame($id, $expected[$id]
->id());
}
}
public function testLoadMultipleIds() {
$entity = $this
->getMockEntity(EntityBaseTest::class, [
[
'id' => 'foo',
],
]);
$this->entityType
->expects($this
->once())
->method('getClass')
->willReturn(get_class($entity));
$this
->setUpKeyValueEntityStorage();
$expected[] = $entity;
$this->keyValueStore
->expects($this
->once())
->method('getMultiple')
->with([
'foo',
])
->willReturn([
[
'id' => 'foo',
],
]);
$entities = $this->entityStorage
->loadMultiple([
'foo',
]);
foreach ($entities as $id => $entity) {
$this
->assertInstanceOf('Drupal\\Core\\Entity\\EntityInterface', $entity);
$this
->assertSame($id, $entity
->id());
}
}
public function testLoadRevision() {
$this
->expectDeprecation('Drupal\\Core\\Entity\\KeyValueStore\\KeyValueEntityStorage::loadRevision() is deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use \\Drupal\\Core\\Entity\\RevisionableStorageInterface::loadRevision instead. See https://www.drupal.org/node/3294237');
$this
->setUpKeyValueEntityStorage();
$this
->assertNull($this->entityStorage
->loadRevision(1));
}
public function testDeleteRevision() {
$this
->expectDeprecation('Drupal\\Core\\Entity\\KeyValueStore\\KeyValueEntityStorage::deleteRevision() is deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use \\Drupal\\Core\\Entity\\RevisionableStorageInterface::deleteRevision instead. See https://www.drupal.org/node/3294237');
$this
->setUpKeyValueEntityStorage();
$this
->assertNull($this->entityStorage
->deleteRevision(1));
}
public function testDelete() {
$entities['foo'] = $this
->getMockEntity(EntityBaseTest::class, [
[
'id' => 'foo',
],
]);
$entities['bar'] = $this
->getMockEntity(EntityBaseTest::class, [
[
'id' => 'bar',
],
]);
$this
->setUpKeyValueEntityStorage();
$hooks = [
'test_entity_type_predelete',
'entity_predelete',
'test_entity_type_predelete',
'entity_predelete',
'test_entity_type_delete',
'entity_delete',
'test_entity_type_delete',
'entity_delete',
];
$this->moduleHandler
->expects($this
->exactly(count($hooks)))
->method('invokeAll')
->with($this
->callback(function (string $hook) use (&$hooks) : bool {
return array_shift($hooks) === $hook;
}));
$this->keyValueStore
->expects($this
->once())
->method('deleteMultiple')
->with([
'foo',
'bar',
]);
$this->entityStorage
->delete($entities);
}
public function testDeleteNothing() {
$this
->setUpKeyValueEntityStorage();
$this->moduleHandler
->expects($this
->never())
->method($this
->anything());
$this->keyValueStore
->expects($this
->never())
->method('delete');
$this->keyValueStore
->expects($this
->never())
->method('deleteMultiple');
$this->entityStorage
->delete([]);
}
public function getMockEntity($class = EntityBaseTest::class, array $arguments = [], $methods = []) {
if (!isset($arguments[0])) {
$arguments[0] = [];
}
if (!isset($arguments[1])) {
$arguments[1] = 'test_entity_type';
}
return $this
->getMockForAbstractClass($class, $arguments, '', TRUE, TRUE, TRUE, $methods);
}
}
class EntityBaseTest extends EntityBase {
public $id;
public $langcode;
public $uuid;
public $label;
public $original;
}
namespace Drupal\Core\Entity\KeyValueStore;
if (!defined('SAVED_NEW')) {
define('SAVED_NEW', 1);
}
if (!defined('SAVED_UPDATED')) {
define('SAVED_UPDATED', 2);
}