View source
<?php
namespace Drupal\KernelTests\Core\Entity;
use Drupal\Core\Entity\EntityStorageException;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Site\Settings;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\Tests\system\Functional\Entity\Traits\EntityDefinitionTestTrait;
class FieldableEntityDefinitionUpdateTest extends EntityKernelTestBase {
use EntityDefinitionTestTrait;
protected $entityDefinitionUpdateManager;
protected $lastInstalledSchemaRepository;
protected $installedStorageSchema;
protected $entityTypeManager;
protected $entityFieldManager;
protected $database;
protected $entityTypeId = 'entity_test_update';
protected $testEntities = [];
protected static $modules = [
'content_translation',
'entity_test_update',
'language',
];
protected function setUp() : void {
parent::setUp();
$this->entityDefinitionUpdateManager = $this->container
->get('entity.definition_update_manager');
$this->lastInstalledSchemaRepository = $this->container
->get('entity.last_installed_schema.repository');
$this->installedStorageSchema = $this->container
->get('keyvalue')
->get('entity.storage_schema.sql');
$this->entityTypeManager = $this->container
->get('entity_type.manager');
$this->entityFieldManager = $this->container
->get('entity_field.manager');
$this->database = $this->container
->get('database');
$this
->addBundleField('string', FALSE, TRUE);
$fields['changed'] = BaseFieldDefinition::create('changed')
->setLabel(t('Changed'))
->setDescription(t('The time that the custom block was last edited.'))
->setTranslatable(TRUE)
->setRevisionable(TRUE);
$this->state
->set('entity_test_update.additional_base_field_definitions', $fields);
$this
->installEntitySchema($this->entityTypeId);
$this
->installEntitySchema('configurable_language');
ConfigurableLanguage::createFromLangcode('ro')
->save();
$settings = Settings::getAll();
$settings['entity_update_batch_size'] = 1;
new Settings($settings);
}
public function testFieldableEntityTypeUpdates($initial_rev, $initial_mul, $new_rev, $new_mul, $data_migration_supported) {
if ($initial_rev || $initial_mul) {
$entity_type = $this
->getUpdatedEntityTypeDefinition($initial_rev, $initial_mul);
$field_storage_definitions = $this
->getUpdatedFieldStorageDefinitions($initial_rev, $initial_mul);
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($entity_type, $field_storage_definitions);
$this
->assertEntityTypeSchema($initial_rev, $initial_mul);
}
$this
->insertData($initial_rev, $initial_mul);
$updated_entity_type = $this
->getUpdatedEntityTypeDefinition($new_rev, $new_mul);
$updated_field_storage_definitions = $this
->getUpdatedFieldStorageDefinitions($new_rev, $new_mul);
if (!$data_migration_supported) {
$this
->expectException(EntityStorageException::class);
$this
->expectExceptionMessage('Converting an entity type from revisionable to non-revisionable or from translatable to non-translatable is not supported.');
}
if ($data_migration_supported) {
$this
->assertEntityData($initial_rev, $initial_mul);
}
$this->state
->set('entity_test_update.install_new_base_field_during_update', TRUE);
$sandbox = [];
do {
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions, $sandbox);
} while ($sandbox['#finished'] != 1);
$this
->assertEntityTypeSchema($new_rev, $new_mul, TRUE);
$this
->assertEntityData($initial_rev, $initial_mul);
$change_list = $this->entityDefinitionUpdateManager
->getChangeList();
$this
->assertArrayNotHasKey('entity_test_update', $change_list, "There are no remaining updates for the 'entity_test_update' entity type.");
$this
->insertData($new_rev, $new_mul);
$this
->assertBackupTables();
}
public function providerTestFieldableEntityTypeUpdates() {
return [
'no change' => [
'initial_rev' => FALSE,
'initial_mul' => FALSE,
'new_rev' => FALSE,
'new_mul' => FALSE,
'data_migration_supported' => TRUE,
],
'non_rev non_mul to rev non_mul' => [
'initial_rev' => FALSE,
'initial_mul' => FALSE,
'new_rev' => TRUE,
'new_mul' => FALSE,
'data_migration_supported' => TRUE,
],
'non_rev non_mul to rev mul' => [
'initial_rev' => FALSE,
'initial_mul' => FALSE,
'new_rev' => TRUE,
'new_mul' => TRUE,
'data_migration_supported' => TRUE,
],
'non_rev non_mul to non_rev mul' => [
'initial_rev' => FALSE,
'initial_mul' => FALSE,
'new_rev' => FALSE,
'new_mul' => TRUE,
'data_migration_supported' => TRUE,
],
'rev non_mul to non_rev non_mul' => [
'initial_rev' => TRUE,
'initial_mul' => FALSE,
'new_rev' => FALSE,
'new_mul' => FALSE,
'data_migration_supported' => FALSE,
],
'rev non_mul to non_rev mul' => [
'initial_rev' => TRUE,
'initial_mul' => FALSE,
'new_rev' => FALSE,
'new_mul' => TRUE,
'data_migration_supported' => FALSE,
],
'rev non_mul to rev mul' => [
'initial_rev' => TRUE,
'initial_mul' => FALSE,
'new_rev' => TRUE,
'new_mul' => TRUE,
'data_migration_supported' => TRUE,
],
'non_rev mul to non_rev non_mul' => [
'initial_rev' => FALSE,
'initial_mul' => TRUE,
'new_rev' => FALSE,
'new_mul' => FALSE,
'data_migration_supported' => FALSE,
],
'non_rev mul to rev non_mul' => [
'initial_rev' => FALSE,
'initial_mul' => TRUE,
'new_rev' => TRUE,
'new_mul' => FALSE,
'data_migration_supported' => FALSE,
],
'non_rev mul to rev mul' => [
'initial_rev' => FALSE,
'initial_mul' => TRUE,
'new_rev' => TRUE,
'new_mul' => TRUE,
'data_migration_supported' => TRUE,
],
'rev mul to non_rev non_mul' => [
'initial_rev' => TRUE,
'initial_mul' => TRUE,
'new_rev' => FALSE,
'new_mul' => FALSE,
'data_migration_supported' => FALSE,
],
'rev mul to rev non_mul' => [
'initial_rev' => TRUE,
'initial_mul' => TRUE,
'new_rev' => TRUE,
'new_mul' => FALSE,
'data_migration_supported' => FALSE,
],
'rev mul to non_rev mul' => [
'initial_rev' => TRUE,
'initial_mul' => TRUE,
'new_rev' => FALSE,
'new_mul' => TRUE,
'data_migration_supported' => FALSE,
],
];
}
protected function insertData($revisionable, $translatable) {
$storage = $this->entityTypeManager
->getStorage($this->entityTypeId);
$next_id = $storage
->getQuery()
->accessCheck(FALSE)
->count()
->execute() + 1;
for ($i = $next_id; $i <= $next_id + 2; $i++) {
$entity = $storage
->create([
'id' => $i,
'type' => 'test_bundle',
'name' => 'test entity - ' . $i . ' - en',
'new_bundle_field' => 'bundle field - ' . $i . ' - en',
'test_multiple_properties' => [
'value1' => 'shared table - ' . $i . ' - value 1 - en',
'value2' => 'shared table - ' . $i . ' - value 2 - en',
],
'test_multiple_properties_multiple_values' => [
[
'value1' => 'dedicated table - ' . $i . ' - delta 0 - value 1 - en',
'value2' => 'dedicated table - ' . $i . ' - delta 0 - value 2 - en',
],
[
'value1' => 'dedicated table - ' . $i . ' - delta 1 - value 1 - en',
'value2' => 'dedicated table - ' . $i . ' - delta 1 - value 2 - en',
],
],
]);
$entity
->save();
if ($translatable) {
$translation = $entity
->addTranslation('ro', [
'name' => 'test entity - ' . $i . ' - ro',
'new_bundle_field' => 'bundle field - ' . $i . ' - ro',
'test_multiple_properties' => [
'value1' => 'shared table - ' . $i . ' - value 1 - ro',
'value2' => 'shared table - ' . $i . ' - value 2 - ro',
],
'test_multiple_properties_multiple_values' => [
[
'value1' => 'dedicated table - ' . $i . ' - delta 0 - value 1 - ro',
'value2' => 'dedicated table - ' . $i . ' - delta 0 - value 2 - ro',
],
[
'value1' => 'dedicated table - ' . $i . ' - delta 1 - value 1 - ro',
'value2' => 'dedicated table - ' . $i . ' - delta 1 - value 2 - ro',
],
],
]);
$translation
->save();
}
$this->testEntities[$entity
->id()] = $entity;
if ($revisionable) {
$revision_2 = $storage
->createRevision($entity, FALSE);
$revision_2->name = 'test entity - ' . $i . ' - en - rev2';
$revision_2->new_bundle_field = 'bundle field - ' . $i . ' - en - rev2';
$revision_2->test_multiple_properties->value1 = 'shared table - ' . $i . ' - value 1 - en - rev2';
$revision_2->test_multiple_properties->value2 = 'shared table - ' . $i . ' - value 2 - en - rev2';
$revision_2->test_multiple_properties_multiple_values[0]->value1 = 'dedicated table - ' . $i . ' - delta 0 - value 1 - en - rev2';
$revision_2->test_multiple_properties_multiple_values[0]->value2 = 'dedicated table - ' . $i . ' - delta 0 - value 2 - en - rev2';
$revision_2->test_multiple_properties_multiple_values[1]->value1 = 'dedicated table - ' . $i . ' - delta 1 - value 1 - en - rev2';
$revision_2->test_multiple_properties_multiple_values[1]->value2 = 'dedicated table - ' . $i . ' - delta 1 - value 2 - en - rev2';
$revision_2
->save();
if ($translatable) {
$revision_2_translation = $storage
->createRevision($entity
->getTranslation('ro'), FALSE);
$revision_2_translation->name = 'test entity - ' . $i . ' - ro - rev2';
$revision_2->new_bundle_field = 'bundle field - ' . $i . ' - ro - rev2';
$revision_2->test_multiple_properties->value1 = 'shared table - ' . $i . ' - value 1 - ro - rev2';
$revision_2->test_multiple_properties->value2 = 'shared table - ' . $i . ' - value 2 - ro - rev2';
$revision_2_translation->test_multiple_properties_multiple_values[0]->value1 = 'dedicated table - ' . $i . ' - delta 0 - value 1 - ro - rev2';
$revision_2_translation->test_multiple_properties_multiple_values[0]->value2 = 'dedicated table - ' . $i . ' - delta 0 - value 2 - ro - rev2';
$revision_2_translation->test_multiple_properties_multiple_values[1]->value1 = 'dedicated table - ' . $i . ' - delta 1 - value 1 - ro - rev2';
$revision_2_translation->test_multiple_properties_multiple_values[1]->value2 = 'dedicated table - ' . $i . ' - delta 1 - value 2 - ro - rev2';
$revision_2_translation
->save();
}
}
}
}
protected function assertEntityData(bool $revisionable, bool $translatable) : void {
$entities = $this->entityTypeManager
->getStorage($this->entityTypeId)
->loadMultiple();
$this
->assertCount(3, $entities);
foreach ($entities as $entity_id => $entity) {
$this
->assertEquals("test entity - {$entity->id()} - en", $entity
->label());
$this
->assertEquals("bundle field - {$entity->id()} - en", $entity->new_bundle_field->value);
$this
->assertEquals("shared table - {$entity->id()} - value 1 - en", $entity->test_multiple_properties->value1);
$this
->assertEquals("shared table - {$entity->id()} - value 2 - en", $entity->test_multiple_properties->value2);
$this
->assertEquals("dedicated table - {$entity->id()} - delta 0 - value 1 - en", $entity->test_multiple_properties_multiple_values[0]->value1);
$this
->assertEquals("dedicated table - {$entity->id()} - delta 0 - value 2 - en", $entity->test_multiple_properties_multiple_values[0]->value2);
$this
->assertEquals("dedicated table - {$entity->id()} - delta 1 - value 1 - en", $entity->test_multiple_properties_multiple_values[1]->value1);
$this
->assertEquals("dedicated table - {$entity->id()} - delta 1 - value 2 - en", $entity->test_multiple_properties_multiple_values[1]->value2);
if ($translatable) {
$translation = $entity
->getTranslation('ro');
$this
->assertEquals("test entity - {$translation->id()} - ro", $translation
->label());
$this
->assertEquals("bundle field - {$entity->id()} - ro", $translation->new_bundle_field->value);
$this
->assertEquals("shared table - {$translation->id()} - value 1 - ro", $translation->test_multiple_properties->value1);
$this
->assertEquals("shared table - {$translation->id()} - value 2 - ro", $translation->test_multiple_properties->value2);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 0 - value 1 - ro", $translation->test_multiple_properties_multiple_values[0]->value1);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 0 - value 2 - ro", $translation->test_multiple_properties_multiple_values[0]->value2);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 1 - value 1 - ro", $translation->test_multiple_properties_multiple_values[1]->value1);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 1 - value 2 - ro", $translation->test_multiple_properties_multiple_values[1]->value2);
}
}
if ($revisionable) {
$revisions_result = $this->entityTypeManager
->getStorage($this->entityTypeId)
->getQuery()
->accessCheck(FALSE)
->allRevisions()
->execute();
$revisions = $this->entityTypeManager
->getStorage($this->entityTypeId)
->loadMultipleRevisions(array_keys($revisions_result));
$this
->assertCount(6, $revisions);
foreach ($revisions as $revision) {
$revision_label = $revision
->isDefaultRevision() ? NULL : ' - rev2';
$this
->assertEquals("test entity - {$revision->id()} - en{$revision_label}", $revision
->label());
$this
->assertEquals("bundle field - {$revision->id()} - en{$revision_label}", $revision->new_bundle_field->value);
$this
->assertEquals("shared table - {$revision->id()} - value 1 - en{$revision_label}", $revision->test_multiple_properties->value1);
$this
->assertEquals("shared table - {$revision->id()} - value 2 - en{$revision_label}", $revision->test_multiple_properties->value2);
$this
->assertEquals("dedicated table - {$revision->id()} - delta 0 - value 1 - en{$revision_label}", $revision->test_multiple_properties_multiple_values[0]->value1);
$this
->assertEquals("dedicated table - {$revision->id()} - delta 0 - value 2 - en{$revision_label}", $revision->test_multiple_properties_multiple_values[0]->value2);
$this
->assertEquals("dedicated table - {$revision->id()} - delta 1 - value 1 - en{$revision_label}", $revision->test_multiple_properties_multiple_values[1]->value1);
$this
->assertEquals("dedicated table - {$revision->id()} - delta 1 - value 2 - en{$revision_label}", $revision->test_multiple_properties_multiple_values[1]->value2);
if ($translatable) {
$translation = $revision
->getTranslation('ro');
$this
->assertEquals("test entity - {$translation->id()} - ro{$revision_label}", $translation
->label());
$this
->assertEquals("bundle field - {$entity->id()} - ro{$revision_label}", $translation->new_bundle_field->value);
$this
->assertEquals("shared table - {$revision->id()} - value 1 - ro{$revision_label}", $translation->test_multiple_properties->value1);
$this
->assertEquals("shared table - {$revision->id()} - value 2 - ro{$revision_label}", $translation->test_multiple_properties->value2);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 0 - value 1 - ro{$revision_label}", $translation->test_multiple_properties_multiple_values[0]->value1);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 0 - value 2 - ro{$revision_label}", $translation->test_multiple_properties_multiple_values[0]->value2);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 1 - value 1 - ro{$revision_label}", $translation->test_multiple_properties_multiple_values[1]->value1);
$this
->assertEquals("dedicated table - {$translation->id()} - delta 1 - value 2 - ro{$revision_label}", $translation->test_multiple_properties_multiple_values[1]->value2);
}
}
}
}
protected function assertEntityTypeSchema(bool $revisionable, bool $translatable, bool $new_base_field = FALSE) : void {
$field_storage_definition = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition('new_base_field', $this->entityTypeId);
if ($new_base_field) {
$this
->assertNotNull($field_storage_definition);
}
else {
$this
->assertNull($field_storage_definition);
}
if ($revisionable && $translatable) {
$this
->assertRevisionableAndTranslatable();
}
elseif ($revisionable) {
$this
->assertRevisionable();
}
elseif ($translatable) {
$this
->assertTranslatable();
}
else {
$this
->assertNonRevisionableAndNonTranslatable();
}
$this
->assertBundleFieldSchema($revisionable);
}
protected function assertRevisionable() : void {
$entity_type = $this->entityDefinitionUpdateManager
->getEntityType($this->entityTypeId);
$this
->assertTrue($entity_type
->isRevisionable());
$revision_key = $entity_type
->getKey('revision');
$revision_default_key = $entity_type
->getRevisionMetadataKey('revision_default');
$revision_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($revision_key, $entity_type
->id());
$revision_default_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($revision_default_key, $entity_type
->id());
$this
->assertNotNull($revision_field);
$this
->assertNotNull($revision_default_field);
$database_schema = $this->database
->schema();
$base_table = $entity_type
->getBaseTable();
$revision_table = $entity_type
->getRevisionTable();
$this
->assertTrue($database_schema
->tableExists($revision_table));
$this
->assertTrue($database_schema
->fieldExists($base_table, $revision_key));
$this
->assertTrue($database_schema
->fieldExists($revision_table, $revision_key));
$this
->assertFalse($database_schema
->fieldExists($base_table, $revision_default_key));
$this
->assertTrue($database_schema
->fieldExists($revision_table, $revision_default_key));
foreach ([
'revision_log_message',
'revision_user',
'revision_created',
] as $key) {
if ($revision_metadata_key = $entity_type
->getRevisionMetadataKey($key)) {
$revision_metadata_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($revision_metadata_key, $entity_type
->id());
$this
->assertNotNull($revision_metadata_field);
$this
->assertFalse($database_schema
->fieldExists($base_table, $revision_metadata_key));
$this
->assertTrue($database_schema
->fieldExists($revision_table, $revision_metadata_key));
}
}
}
protected function assertTranslatable() : void {
$entity_type = $this->entityDefinitionUpdateManager
->getEntityType($this->entityTypeId);
$this
->assertTrue($entity_type
->isTranslatable());
$langcode_key = $entity_type
->getKey('langcode');
$default_langcode_key = $entity_type
->getKey('default_langcode');
$langcode_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($langcode_key, $entity_type
->id());
$default_langcode_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($default_langcode_key, $entity_type
->id());
$this
->assertNotNull($langcode_field);
$this
->assertNotNull($default_langcode_field);
$database_schema = $this->database
->schema();
$base_table = $entity_type
->getBaseTable();
$data_table = $entity_type
->getDataTable();
$this
->assertTrue($database_schema
->tableExists($data_table));
$this
->assertTrue($database_schema
->fieldExists($base_table, $langcode_key));
$this
->assertTrue($database_schema
->fieldExists($data_table, $langcode_key));
$this
->assertFalse($database_schema
->fieldExists($base_table, $default_langcode_key));
$this
->assertTrue($database_schema
->fieldExists($data_table, $default_langcode_key));
}
protected function assertRevisionableAndTranslatable() : void {
$this
->assertRevisionable();
$this
->assertTranslatable();
$entity_type = $this->entityDefinitionUpdateManager
->getEntityType($this->entityTypeId);
$langcode_key = $entity_type
->getKey('langcode');
$revision_translation_affected_key = $entity_type
->getKey('revision_translation_affected');
$revision_translation_affected_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($revision_translation_affected_key, $entity_type
->id());
$this
->assertNotNull($revision_translation_affected_field);
$database_schema = $this->database
->schema();
$base_table = $entity_type
->getBaseTable();
$data_table = $entity_type
->getDataTable();
$revision_table = $entity_type
->getRevisionTable();
$revision_data_table = $entity_type
->getRevisionDataTable();
$this
->assertTrue($database_schema
->tableExists($revision_data_table));
$this
->assertTrue($database_schema
->fieldExists($base_table, $langcode_key));
$this
->assertTrue($database_schema
->fieldExists($data_table, $langcode_key));
$this
->assertTrue($database_schema
->fieldExists($revision_table, $langcode_key));
$this
->assertTrue($database_schema
->fieldExists($revision_data_table, $langcode_key));
$this
->assertFalse($database_schema
->fieldExists($base_table, $revision_translation_affected_key));
$this
->assertFalse($database_schema
->fieldExists($revision_table, $revision_translation_affected_key));
$this
->assertTrue($database_schema
->fieldExists($data_table, $revision_translation_affected_key));
$this
->assertTrue($database_schema
->fieldExists($revision_data_table, $revision_translation_affected_key));
foreach ([
'revision_log_message',
'revision_user',
'revision_created',
] as $key) {
if ($revision_metadata_key = $entity_type
->getRevisionMetadataKey($key)) {
$revision_metadata_field = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition($revision_metadata_key, $entity_type
->id());
$this
->assertNotNull($revision_metadata_field);
$this
->assertFalse($database_schema
->fieldExists($base_table, $revision_metadata_key));
$this
->assertTrue($database_schema
->fieldExists($revision_table, $revision_metadata_key));
$this
->assertFalse($database_schema
->fieldExists($data_table, $revision_metadata_key));
$this
->assertFalse($database_schema
->fieldExists($revision_data_table, $revision_metadata_key));
}
}
}
protected function assertNonRevisionableAndNonTranslatable() : void {
$entity_type = $this->entityDefinitionUpdateManager
->getEntityType($this->entityTypeId);
$this
->assertFalse($entity_type
->isRevisionable());
$this
->assertFalse($entity_type
->isTranslatable());
$database_schema = $this->database
->schema();
$this
->assertTrue($database_schema
->tableExists($entity_type
->getBaseTable()));
$this
->assertFalse($database_schema
->tableExists($entity_type
->getDataTable()));
$this
->assertFalse($database_schema
->tableExists($entity_type
->getRevisionTable()));
$this
->assertFalse($database_schema
->tableExists($entity_type
->getRevisionDataTable()));
}
protected function assertBundleFieldSchema(bool $revisionable) : void {
$entity_type_id = 'entity_test_update';
$field_storage_definition = $this->entityFieldManager
->getFieldStorageDefinitions($entity_type_id)['new_bundle_field'];
$database_schema = $this->database
->schema();
$table_mapping = $this->entityTypeManager
->getStorage($entity_type_id)
->getTableMapping();
$this
->assertTrue($database_schema
->tableExists($table_mapping
->getDedicatedDataTableName($field_storage_definition)));
if ($revisionable) {
$this
->assertTrue($database_schema
->tableExists($table_mapping
->getDedicatedRevisionTableName($field_storage_definition)));
}
}
protected function assertBackupTables() : void {
$backups = \Drupal::keyValue('entity.update_backup')
->getAll();
$backup = reset($backups);
$schema = $this->database
->schema();
foreach ($backup['table_mapping']
->getTableNames() as $table_name) {
$this
->assertTrue($schema
->tableExists($table_name));
}
}
public function testFieldableEntityTypeUpdatesErrorHandling() {
$schema = $this->database
->schema();
$entity_type = $this
->getUpdatedEntityTypeDefinition(FALSE, TRUE);
$field_storage_definitions = $this
->getUpdatedFieldStorageDefinitions(FALSE, TRUE);
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($entity_type, $field_storage_definitions);
$this
->assertEntityTypeSchema(FALSE, TRUE);
$this
->insertData(FALSE, TRUE);
$tables = $schema
->findTables('old_%');
$this
->assertCount(4, $tables);
foreach ($tables as $table) {
$schema
->dropTable($table);
}
$original_entity_type = $this->lastInstalledSchemaRepository
->getLastInstalledDefinition('entity_test_update');
$original_storage_definitions = $this->lastInstalledSchemaRepository
->getLastInstalledFieldStorageDefinitions('entity_test_update');
$original_entity_schema_data = $this->installedStorageSchema
->get('entity_test_update.entity_schema_data', []);
$original_field_schema_data = [];
foreach ($original_storage_definitions as $storage_definition) {
$original_field_schema_data[$storage_definition
->getName()] = $this->installedStorageSchema
->get('entity_test_update.field_schema_data.' . $storage_definition
->getName(), []);
}
$this
->assertFalse($entity_type
->isRevisionable());
\Drupal::state()
->set('entity_test_update.throw_exception', TRUE);
$this
->expectException(EntityStorageException::class);
$this
->expectExceptionMessage('The entity update process failed while processing the entity type entity_test_update, ID: 1.');
try {
$updated_entity_type = $this
->getUpdatedEntityTypeDefinition(TRUE, TRUE);
$updated_field_storage_definitions = $this
->getUpdatedFieldStorageDefinitions(TRUE, TRUE);
$sandbox = [];
do {
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions, $sandbox);
} while ($sandbox['#finished'] != 1);
} catch (EntityStorageException $e) {
throw $e;
} finally {
$this
->assertSame('Peekaboo!', $e
->getPrevious()
->getMessage());
$new_entity_type = $this->lastInstalledSchemaRepository
->getLastInstalledDefinition('entity_test_update');
$this
->assertFalse($new_entity_type
->isRevisionable(), 'The entity type is kept unchanged.');
$new_storage_definitions = $this->lastInstalledSchemaRepository
->getLastInstalledFieldStorageDefinitions('entity_test_update');
$langcode_key = $original_entity_type
->getKey('langcode');
$this
->assertEquals($original_storage_definitions[$langcode_key]
->isRevisionable(), $new_storage_definitions[$langcode_key]
->isRevisionable(), "The 'langcode' field is kept unchanged.");
$storage = $this->entityTypeManager
->getStorage('entity_test_update');
$table_mapping = $storage
->getTableMapping();
$new_entity_schema_data = $this->installedStorageSchema
->get('entity_test_update.entity_schema_data', []);
$this
->assertEquals($original_entity_schema_data, $new_entity_schema_data);
foreach ($new_storage_definitions as $storage_definition) {
$new_field_schema_data[$storage_definition
->getName()] = $this->installedStorageSchema
->get('entity_test_update.field_schema_data.' . $storage_definition
->getName(), []);
}
$this
->assertEquals($original_field_schema_data, $new_field_schema_data);
$tables = $schema
->findTables('tmp_%');
$this
->assertCount(0, $tables);
$current_table_names = $storage
->getCustomTableMapping($original_entity_type, $original_storage_definitions)
->getTableNames();
foreach ($current_table_names as $table_name) {
$this
->assertTrue($schema
->tableExists($table_name));
}
$tables = $schema
->findTables('old_%');
$this
->assertCount(0, $tables);
$this
->assertTrue($schema
->tableExists('entity_test_update'));
$this
->assertTrue($schema
->tableExists('entity_test_update_data'));
$this
->assertFalse($schema
->tableExists('entity_test_update_revision'));
$this
->assertFalse($schema
->tableExists('entity_test_update_revision_data'));
$base_table_count = $this->database
->select('entity_test_update')
->countQuery()
->execute()
->fetchField();
$this
->assertEquals(3, $base_table_count);
$data_table_count = $this->database
->select('entity_test_update_data')
->countQuery()
->execute()
->fetchField();
$this
->assertEquals(6, $data_table_count);
$base_table_row = $this->database
->select('entity_test_update')
->fields('entity_test_update')
->condition('id', 1, '=')
->condition('langcode', 'en', '=')
->execute()
->fetchAllAssoc('id');
$this
->assertEquals($this->testEntities[1]
->uuid(), $base_table_row[1]->uuid);
$data_table_row = $this->database
->select('entity_test_update_data')
->fields('entity_test_update_data')
->condition('id', 1, '=')
->condition('langcode', 'en', '=')
->execute()
->fetchAllAssoc('id');
$this
->assertEquals('test entity - 1 - en', $data_table_row[1]->name);
$this
->assertEquals('shared table - 1 - value 1 - en', $data_table_row[1]->test_multiple_properties__value1);
$this
->assertEquals('shared table - 1 - value 2 - en', $data_table_row[1]->test_multiple_properties__value2);
$data_table_row = $this->database
->select('entity_test_update_data')
->fields('entity_test_update_data')
->condition('id', 1, '=')
->condition('langcode', 'ro', '=')
->execute()
->fetchAllAssoc('id');
$this
->assertEquals('test entity - 1 - ro', $data_table_row[1]->name);
$this
->assertEquals('shared table - 1 - value 1 - ro', $data_table_row[1]->test_multiple_properties__value1);
$this
->assertEquals('shared table - 1 - value 2 - ro', $data_table_row[1]->test_multiple_properties__value2);
$dedicated_table_name = $table_mapping
->getFieldTableName('test_multiple_properties_multiple_values');
$dedicated_table_row = $this->database
->select($dedicated_table_name)
->fields($dedicated_table_name)
->condition('entity_id', 1, '=')
->condition('langcode', 'en', '=')
->execute()
->fetchAllAssoc('delta');
$this
->assertEquals('dedicated table - 1 - delta 0 - value 1 - en', $dedicated_table_row[0]->test_multiple_properties_multiple_values_value1);
$this
->assertEquals('dedicated table - 1 - delta 0 - value 2 - en', $dedicated_table_row[0]->test_multiple_properties_multiple_values_value2);
$this
->assertEquals('dedicated table - 1 - delta 1 - value 1 - en', $dedicated_table_row[1]->test_multiple_properties_multiple_values_value1);
$this
->assertEquals('dedicated table - 1 - delta 1 - value 2 - en', $dedicated_table_row[1]->test_multiple_properties_multiple_values_value2);
$dedicated_table_row = $this->database
->select($dedicated_table_name)
->fields($dedicated_table_name)
->condition('entity_id', 1, '=')
->condition('langcode', 'ro', '=')
->execute()
->fetchAllAssoc('delta');
$this
->assertEquals('dedicated table - 1 - delta 0 - value 1 - ro', $dedicated_table_row[0]->test_multiple_properties_multiple_values_value1);
$this
->assertEquals('dedicated table - 1 - delta 0 - value 2 - ro', $dedicated_table_row[0]->test_multiple_properties_multiple_values_value2);
$this
->assertEquals('dedicated table - 1 - delta 1 - value 1 - ro', $dedicated_table_row[1]->test_multiple_properties_multiple_values_value1);
$this
->assertEquals('dedicated table - 1 - delta 1 - value 2 - ro', $dedicated_table_row[1]->test_multiple_properties_multiple_values_value2);
}
}
public function testFieldableEntityTypeUpdatesRemoveBackupTables() {
$schema = $this->database
->schema();
$entity_type = $this
->getUpdatedEntityTypeDefinition(TRUE, FALSE);
$field_storage_definitions = $this
->getUpdatedFieldStorageDefinitions(TRUE, FALSE);
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($entity_type, $field_storage_definitions);
$tables = $schema
->findTables('old_%');
$this
->assertCount(4, $tables);
foreach ($tables as $table) {
$schema
->dropTable($table);
}
$settings = Settings::getAll();
$settings['entity_update_backup'] = FALSE;
new Settings($settings);
$entity_type = $this
->getUpdatedEntityTypeDefinition(TRUE, TRUE);
$field_storage_definitions = $this
->getUpdatedFieldStorageDefinitions(TRUE, TRUE);
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($entity_type, $field_storage_definitions);
$tables = $schema
->findTables('old_%');
$this
->assertCount(0, $tables);
}
}