View source
<?php
namespace Drupal\KernelTests\Core\Entity;
use Drupal\Component\Plugin\Exception\PluginNotFoundException;
use Drupal\Core\Database\Database;
use Drupal\Core\Database\DatabaseExceptionWrapper;
use Drupal\Core\Database\IntegrityConstraintViolationException;
use Drupal\Core\Entity\ContentEntityType;
use Drupal\Core\Entity\EntityStorageException;
use Drupal\Core\Entity\EntityTypeEvents;
use Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Field\FieldException;
use Drupal\Core\Field\FieldStorageDefinitionEvents;
use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\StringTranslation\TranslatableMarkup;
use Drupal\entity_test\FieldStorageDefinition;
use Drupal\entity_test_update\Entity\EntityTestUpdate;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\Tests\system\Functional\Entity\Traits\EntityDefinitionTestTrait;
class EntityDefinitionUpdateTest extends EntityKernelTestBase {
use EntityDefinitionTestTrait;
protected $entityDefinitionUpdateManager;
protected $entityFieldManager;
protected $database;
public static $modules = [
'entity_test_update',
'language',
];
protected function setUp() {
parent::setUp();
$this->entityDefinitionUpdateManager = $this->container
->get('entity.definition_update_manager');
$this->entityFieldManager = $this->container
->get('entity_field.manager');
$this->database = $this->container
->get('database');
foreach (array_diff_key($this->entityTypeManager
->getDefinitions(), array_flip([
'user',
'entity_test',
])) as $entity_type_id => $entity_type) {
$this
->installEntitySchema($entity_type_id);
}
}
public function testNewEntityType() {
$entity_type_id = 'entity_test_new';
$schema = $this->database
->schema();
$entity_types = $this->entityTypeManager
->getDefinitions();
$this
->assertFalse(isset($entity_types[$entity_type_id]), 'The "entity_test_new" entity type does not exist.');
$this
->assertFalse($schema
->tableExists($entity_type_id), 'Schema for the "entity_test_new" entity type does not exist.');
$this
->enableNewEntityType();
$entity_types = $this->entityTypeManager
->getDefinitions();
$this
->assertTrue(isset($entity_types[$entity_type_id]), 'The "entity_test_new" entity type exists.');
$this
->assertTrue($schema
->tableExists($entity_type_id), 'Schema for the "entity_test_new" entity type has been created.');
}
public function testNoUpdates() {
$this
->assertFalse($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that no updates are needed.');
$this
->assertIdentical($this->entityDefinitionUpdateManager
->getChangeSummary(), [], 'EntityDefinitionUpdateManager reports an empty change summary.');
$this
->assertIdentical($this->entityDefinitionUpdateManager
->getChangeList(), [], 'EntityDefinitionUpdateManager reports an empty change list.');
}
public function testEntityTypeUpdateWithoutData() {
$this
->assertFalse($this->database
->schema()
->tableExists('entity_test_update_revision'), 'Revision table not created for entity_test_update.');
$this
->updateEntityTypeToRevisionable();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$expected = [
'entity_test_update' => [
t('The %entity_type entity type needs to be updated.', [
'%entity_type' => $this->entityTypeManager
->getDefinition('entity_test_update')
->getLabel(),
]),
t('The %field_name field needs to be installed.', [
'%field_name' => 'Revision ID',
]),
t('The %field_name field needs to be installed.', [
'%field_name' => 'Default revision',
]),
],
];
$this
->assertEqual($this->entityDefinitionUpdateManager
->getChangeSummary(), $expected, 'EntityDefinitionUpdateManager reports the expected change summary.');
$this
->updateEntityTypeToRevisionable(TRUE);
$this
->assertTrue($this->database
->schema()
->tableExists('entity_test_update_revision'), 'Revision table created for entity_test_update.');
}
public function testEntityTypeUpdateWithEntityStorageChange() {
$entity_type = $this
->getUpdatedEntityTypeDefinition(TRUE, FALSE);
try {
$this->entityDefinitionUpdateManager
->updateEntityType($entity_type);
$this
->fail('EntityStorageException thrown when trying to apply an update that requires shared table schema changes.');
} catch (EntityStorageException $e) {
}
}
public function testInstallAdditionalBaseFieldDuringFieldableEntityTypeInstallation() {
$entity_type = clone $this->entityTypeManager
->getDefinition('entity_test_update');
$field_storage_definitions = \Drupal::service('entity_field.manager')
->getFieldStorageDefinitions('entity_test_update');
$this->state
->set('entity_test_update.install_new_base_field_during_create', TRUE);
$this->entityDefinitionUpdateManager
->installFieldableEntityType($entity_type, $field_storage_definitions);
$field_storage_definition = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition('new_base_field', 'entity_test_update');
$this
->assertNotNull($field_storage_definition);
}
public function testInstallFieldableEntityTypeWithoutInCodeDefinition() {
$entity_type = clone $this->entityTypeManager
->getDefinition('entity_test_update');
$field_storage_definitions = \Drupal::service('entity_field.manager')
->getFieldStorageDefinitions('entity_test_update');
$this
->deleteEntityType();
$this->entityDefinitionUpdateManager
->installFieldableEntityType($entity_type, $field_storage_definitions);
$this
->assertTrue($this->database
->schema()
->tableExists('entity_test_update'), 'The base table of the entity type has been created.');
}
public function testUpdateEntityTypeWithoutInCodeDefinition() {
$entity_type = clone $this->entityTypeManager
->getDefinition('entity_test_update');
$this
->deleteEntityType();
$this
->addEntityIndex();
$this->entityDefinitionUpdateManager
->updateEntityType($entity_type);
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index created.');
}
public function testUpdateFieldableEntityTypeWithoutInCodeDefinition() {
$entity_type = clone $this->entityTypeManager
->getDefinition('entity_test_update');
$field_storage_definitions = \Drupal::service('entity_field.manager')
->getFieldStorageDefinitions('entity_test_update');
$this
->deleteEntityType();
$entity_type
->set('base_table', 'entity_test_update_new');
$this->entityDefinitionUpdateManager
->updateFieldableEntityType($entity_type, $field_storage_definitions);
$this
->assertTrue($this->database
->schema()
->tableExists('entity_test_update_new'), 'The base table has been renamed.');
$this
->assertFalse($this->database
->schema()
->tableExists('entity_test_update'), 'The old base table does not exist anymore.');
}
public function testUninstallEntityTypeWithoutInCodeDefinition() {
$entity_type = clone $this->entityTypeManager
->getDefinition('entity_test_update');
$this
->deleteEntityType();
$this->entityDefinitionUpdateManager
->uninstallEntityType($entity_type);
$this
->assertFalse($this->database
->schema()
->tableExists('entity_test_update'), 'Base table for entity_test_update does not exist anymore.');
}
public function testBaseFieldCreateUpdateDeleteWithoutData() {
$this
->addBaseField();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new base field field needs to be installed.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertTrue($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field'), 'Column created in shared table for new_base_field.');
$this
->addBaseFieldIndex();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new base field field needs to be updated.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update_field__new_base_field'), 'Index created.');
$this
->removeBaseFieldIndex();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new base field field needs to be updated.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertFalse($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update_field__new_base_field'), 'Index deleted.');
$this
->modifyBaseField();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new base field field needs to be updated.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertFalse($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field'), 'Original column deleted in shared table for new_base_field.');
$this
->assertTrue($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field__value'), 'Value column created in shared table for new_base_field.');
$this
->assertTrue($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field__format'), 'Format column created in shared table for new_base_field.');
$this
->removeBaseField();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new base field field needs to be uninstalled.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertFalse($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field_value'), 'Value column deleted from shared table for new_base_field.');
$this
->assertFalse($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field_format'), 'Format column deleted from shared table for new_base_field.');
}
public function testBaseFieldWithoutLabelCreateUpdateDelete() {
$this
->addBaseField('string', 'entity_test_update', FALSE, FALSE);
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The new_base_field field needs to be installed.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->addBaseFieldIndex();
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The new_base_field field needs to be updated.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->removeBaseField();
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The new_base_field field needs to be uninstalled.', strip_tags($changes['entity_test_update'][0]));
}
public function testBundleFieldCreateUpdateDeleteWithoutData() {
$this
->addBundleField();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new bundle field field needs to be installed.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertTrue($this->database
->schema()
->tableExists('entity_test_update__new_bundle_field'), 'Dedicated table created for new_bundle_field.');
$this
->modifyBundleField();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new bundle field field needs to be updated.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertTrue($this->database
->schema()
->fieldExists('entity_test_update__new_bundle_field', 'new_bundle_field_format'), 'Format column created in dedicated table for new_base_field.');
$this
->removeBundleField();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$changes = $this->entityDefinitionUpdateManager
->getChangeSummary();
$this
->assertCount(1, $changes['entity_test_update']);
$this
->assertEquals('The A new bundle field field needs to be uninstalled.', strip_tags($changes['entity_test_update'][0]));
$this
->applyEntityUpdates();
$this
->assertFalse($this->database
->schema()
->tableExists('entity_test_update__new_bundle_field'), 'Dedicated table deleted for new_bundle_field.');
}
public function testBaseFieldCreateDeleteWithExistingEntities() {
$name = $this
->randomString();
$storage = $this->entityTypeManager
->getStorage('entity_test_update');
$entity = $storage
->create([
'name' => $name,
]);
$entity
->save();
$this
->addBaseField();
$this
->applyEntityUpdates();
$schema_handler = $this->database
->schema();
$this
->assertTrue($schema_handler
->fieldExists('entity_test_update', 'new_base_field'), 'Column created in shared table for new_base_field.');
$entity = $this->entityTypeManager
->getStorage('entity_test_update')
->load($entity
->id());
$this
->assertIdentical($entity->name->value, $name, 'Entity data preserved during field creation.');
$this
->removeBaseField();
$this
->applyEntityUpdates();
$this
->assertFalse($schema_handler
->fieldExists('entity_test_update', 'new_base_field'), 'Column deleted from shared table for new_base_field.');
$entity = $this->entityTypeManager
->getStorage('entity_test_update')
->load($entity
->id());
$this
->assertIdentical($entity->name->value, $name, 'Entity data preserved during field deletion.');
$this
->addBaseField('shape_required');
$this
->applyEntityUpdates();
$assert = $schema_handler
->fieldExists('entity_test_update', 'new_base_field__shape') && $schema_handler
->fieldExists('entity_test_update', 'new_base_field__color');
$this
->assertTrue($assert, 'Columns created in shared table for new_base_field.');
$entity
->delete();
$this
->removeBaseField();
$this
->applyEntityUpdates();
$assert = !$schema_handler
->fieldExists('entity_test_update', 'new_base_field__shape') && !$schema_handler
->fieldExists('entity_test_update', 'new_base_field__color');
$this
->assert($assert, 'Columns removed from the shared table for new_base_field.');
$this
->addBaseField('shape_required');
$this
->applyEntityUpdates();
$assert = $schema_handler
->fieldExists('entity_test_update', 'new_base_field__shape') && $schema_handler
->fieldExists('entity_test_update', 'new_base_field__color');
$this
->assertTrue($assert, 'Columns created again in shared table for new_base_field.');
$entity = $storage
->create([
'name' => $name,
]);
$entity
->save();
}
public function testBundleFieldCreateDeleteWithExistingEntities() {
$name = $this
->randomString();
$storage = $this->entityTypeManager
->getStorage('entity_test_update');
$entity = $storage
->create([
'name' => $name,
]);
$entity
->save();
$this
->addBundleField();
$this
->applyEntityUpdates();
$schema_handler = $this->database
->schema();
$this
->assertTrue($schema_handler
->tableExists('entity_test_update__new_bundle_field'), 'Dedicated table created for new_bundle_field.');
$entity = $this->entityTypeManager
->getStorage('entity_test_update')
->load($entity
->id());
$this
->assertIdentical($entity->name->value, $name, 'Entity data preserved during field creation.');
$this
->removeBundleField();
$this
->applyEntityUpdates();
$this
->assertFalse($schema_handler
->tableExists('entity_test_update__new_bundle_field'), 'Dedicated table deleted for new_bundle_field.');
$entity = $this->entityTypeManager
->getStorage('entity_test_update')
->load($entity
->id());
$this
->assertIdentical($entity->name->value, $name, 'Entity data preserved during field deletion.');
$this
->addBundleField('shape_required');
$this
->applyEntityUpdates();
$message = 'The new_bundle_field_shape column is not nullable.';
$values = [
'bundle' => $entity
->bundle(),
'deleted' => 0,
'entity_id' => $entity
->id(),
'revision_id' => $entity
->id(),
'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
'delta' => 0,
'new_bundle_field_color' => $this
->randomString(),
];
try {
$this->database
->insert('entity_test_update__new_bundle_field')
->fields($values)
->execute();
$this
->fail($message);
} catch (\RuntimeException $e) {
if ($e instanceof DatabaseExceptionWrapper || $e instanceof IntegrityConstraintViolationException) {
$values['new_bundle_field_shape'] = $this
->randomString();
$this->database
->insert('entity_test_update__new_bundle_field')
->fields($values)
->execute();
}
else {
throw $e;
}
}
}
public function testBaseFieldDeleteWithExistingData($entity_type_id, $create_entity_revision, $base_field_revisionable, $create_entity_translation) {
ConfigurableLanguage::createFromLangcode('ro')
->save();
$storage = $this->entityTypeManager
->getStorage($entity_type_id);
$schema_handler = $this->database
->schema();
$entity = $storage
->create();
$entity
->save();
$this
->addBaseField('string', $entity_type_id, $base_field_revisionable, TRUE, $create_entity_translation);
$this
->applyEntityUpdates();
$table_mapping = $storage
->getTableMapping();
$storage_definition = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledFieldStorageDefinitions($entity_type_id)['new_base_field'];
$entity = $storage
->create([
'new_base_field' => 'foo',
]);
$entity
->save();
if ($create_entity_translation) {
$translation = $entity
->addTranslation('ro', [
'new_base_field' => 'foo-ro',
]);
$translation
->save();
}
if ($create_entity_revision) {
$entity
->setNewRevision(TRUE);
$entity
->isDefaultRevision(FALSE);
$entity->new_base_field = 'bar';
$entity
->save();
if ($create_entity_translation) {
$translation = $entity
->getTranslation('ro');
$translation->new_base_field = 'bar-ro';
$translation
->save();
}
}
$this
->removeBaseField($entity_type_id);
$this
->applyEntityUpdates();
$this
->assertFalse($schema_handler
->fieldExists($entity_type_id, 'new_base_field'), 'Column deleted from shared table for new_base_field.');
$dedicated_deleted_table_name = $table_mapping
->getDedicatedDataTableName($storage_definition, TRUE);
$this
->assertTrue($schema_handler
->tableExists($dedicated_deleted_table_name), 'A dedicated table was created for the deleted new_base_field.');
$expected[] = [
'bundle' => $entity
->bundle(),
'deleted' => '1',
'entity_id' => '2',
'revision_id' => '2',
'langcode' => 'en',
'delta' => '0',
'new_base_field_value' => 'foo',
];
if ($create_entity_translation) {
$expected[] = [
'bundle' => $entity
->bundle(),
'deleted' => '1',
'entity_id' => '2',
'revision_id' => '2',
'langcode' => 'ro',
'delta' => '0',
'new_base_field_value' => 'foo-ro',
];
}
$result = $this->database
->select($dedicated_deleted_table_name, 't')
->fields('t')
->orderBy('revision_id', 'ASC')
->orderBy('langcode', 'ASC')
->execute()
->fetchAll(\PDO::FETCH_ASSOC);
$this
->assertCount(count($expected), $result);
$this
->assertEquals($expected, $result);
if ($create_entity_revision) {
$dedicated_deleted_revision_table_name = $table_mapping
->getDedicatedRevisionTableName($storage_definition, TRUE);
$this
->assertTrue($schema_handler
->tableExists($dedicated_deleted_revision_table_name), 'A dedicated revision table was created for the deleted new_base_field.');
if ($base_field_revisionable) {
$expected[] = [
'bundle' => $entity
->bundle(),
'deleted' => '1',
'entity_id' => '2',
'revision_id' => '3',
'langcode' => 'en',
'delta' => '0',
'new_base_field_value' => 'bar',
];
if ($create_entity_translation) {
$expected[] = [
'bundle' => $entity
->bundle(),
'deleted' => '1',
'entity_id' => '2',
'revision_id' => '3',
'langcode' => 'ro',
'delta' => '0',
'new_base_field_value' => 'bar-ro',
];
}
}
$result = $this->database
->select($dedicated_deleted_revision_table_name, 't')
->fields('t')
->orderBy('revision_id', 'ASC')
->orderBy('langcode', 'ASC')
->execute()
->fetchAll(\PDO::FETCH_ASSOC);
$this
->assertCount(count($expected), $result);
$this
->assertEquals($expected, $result);
}
$deleted_storage_definitions = \Drupal::service('entity_field.deleted_fields_repository')
->getFieldStorageDefinitions();
$this
->assertArrayHasKey($storage_definition
->getUniqueStorageIdentifier(), $deleted_storage_definitions, 'The base field is marked for purging.');
field_purge_batch(10);
$deleted_storage_definitions = \Drupal::service('entity_field.deleted_fields_repository')
->getFieldStorageDefinitions();
$this
->assertEmpty($deleted_storage_definitions, 'The base field has been deleted.');
$this
->assertFalse($schema_handler
->tableExists($dedicated_deleted_table_name), 'A dedicated field table was deleted after new_base_field was purged.');
if (isset($dedicated_deleted_revision_table_name)) {
$this
->assertFalse($schema_handler
->tableExists($dedicated_deleted_revision_table_name), 'A dedicated field revision table was deleted after new_base_field was purged.');
}
}
public function baseFieldDeleteWithExistingDataTestCases() {
return [
'Non-revisionable, non-translatable entity type' => [
'entity_test_update',
FALSE,
FALSE,
FALSE,
],
'Non-revisionable, non-translatable custom data table' => [
'entity_test_mul',
FALSE,
FALSE,
FALSE,
],
'Non-revisionable, non-translatable entity type, revisionable base field' => [
'entity_test_update',
FALSE,
TRUE,
FALSE,
],
'Non-revisionable, non-translatable custom data table, revisionable base field' => [
'entity_test_mul',
FALSE,
TRUE,
FALSE,
],
'Revisionable, translatable entity type, non revisionable and non-translatable base field' => [
'entity_test_mulrev',
TRUE,
FALSE,
FALSE,
],
'Revisionable, translatable entity type, revisionable and non-translatable base field' => [
'entity_test_mulrev',
TRUE,
TRUE,
FALSE,
],
'Revisionable and non-translatable entity type, revisionable and non-translatable base field' => [
'entity_test_rev',
TRUE,
TRUE,
FALSE,
],
'Revisionable and non-translatable entity type, non-revisionable and non-translatable base field' => [
'entity_test_rev',
TRUE,
FALSE,
FALSE,
],
'Revisionable and translatable entity type, non-revisionable and translatable base field' => [
'entity_test_mulrev',
TRUE,
FALSE,
TRUE,
],
'Revisionable and translatable entity type, revisionable and translatable base field' => [
'entity_test_mulrev',
TRUE,
TRUE,
TRUE,
],
];
}
public function testBundleFieldDeleteWithExistingData() {
$storage = $this->entityTypeManager
->getStorage('entity_test_update');
$schema_handler = $this->database
->schema();
$this
->addBundleField();
$this
->applyEntityUpdates();
$table_mapping = $storage
->getTableMapping();
$storage_definition = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledFieldStorageDefinitions('entity_test_update')['new_bundle_field'];
$dedicated_table_name = $table_mapping
->getDedicatedDataTableName($storage_definition);
$this
->assertTrue($schema_handler
->tableExists($dedicated_table_name), 'The bundle field uses a dedicated table.');
entity_test_create_bundle('custom');
$entity = $storage
->create([
'type' => 'test_bundle',
'new_bundle_field' => 'foo',
]);
$entity
->save();
$this
->removeBundleField();
$this
->applyEntityUpdates();
$this
->assertFalse($schema_handler
->tableExists($dedicated_table_name), 'The dedicated table of the bundle field no longer exists.');
$dedicated_deleted_table_name = $table_mapping
->getDedicatedDataTableName($storage_definition, TRUE);
$this
->assertTrue($schema_handler
->tableExists($dedicated_deleted_table_name), 'The dedicated table of the bundle fields has been renamed to use the "deleted" name.');
$result = $this->database
->select($dedicated_deleted_table_name, 't')
->fields('t')
->execute()
->fetchAll();
$this
->assertCount(1, $result);
$expected = [
'bundle' => $entity
->bundle(),
'deleted' => '1',
'entity_id' => $entity
->id(),
'revision_id' => $entity
->id(),
'langcode' => $entity
->language()
->getId(),
'delta' => '0',
'new_bundle_field_value' => $entity->new_bundle_field->value,
];
$this
->assertEquals($expected, (array) $result[0]);
$deleted_field_definitions = \Drupal::service('entity_field.deleted_fields_repository')
->getFieldDefinitions();
$this
->assertArrayHasKey($storage_definition
->getUniqueIdentifier(), $deleted_field_definitions, 'The bundle field is marked for purging.');
$deleted_storage_definitions = \Drupal::service('entity_field.deleted_fields_repository')
->getFieldStorageDefinitions();
$this
->assertArrayHasKey($storage_definition
->getUniqueStorageIdentifier(), $deleted_storage_definitions, 'The bundle field storage is marked for purging.');
field_purge_batch(10);
$deleted_field_definitions = \Drupal::service('entity_field.deleted_fields_repository')
->getFieldDefinitions();
$this
->assertEmpty($deleted_field_definitions, 'The bundle field has been deleted.');
$deleted_storage_definitions = \Drupal::service('entity_field.deleted_fields_repository')
->getFieldStorageDefinitions();
$this
->assertEmpty($deleted_storage_definitions, 'The bundle field storage has been deleted.');
$this
->assertFalse($schema_handler
->tableExists($dedicated_deleted_table_name), 'The dedicated table of the bundle field has been removed.');
}
public function testBaseFieldUpdateWithExistingData() {
$this
->addBaseField();
$this
->applyEntityUpdates();
$this->entityTypeManager
->getStorage('entity_test_update')
->create([
'new_base_field' => 'foo',
])
->save();
$this
->modifyBaseField();
try {
$this
->applyEntityUpdates();
$this
->fail('FieldStorageDefinitionUpdateForbiddenException thrown when trying to update a field schema that has data.');
} catch (FieldStorageDefinitionUpdateForbiddenException $e) {
}
}
public function testBundleFieldUpdateWithExistingData() {
$this
->addBundleField();
$this
->applyEntityUpdates();
entity_test_create_bundle('custom');
$this->entityTypeManager
->getStorage('entity_test_update')
->create([
'type' => 'test_bundle',
'new_bundle_field' => 'foo',
])
->save();
$this
->modifyBundleField();
try {
$this
->applyEntityUpdates();
$this
->fail('FieldStorageDefinitionUpdateForbiddenException thrown when trying to update a field schema that has data.');
} catch (FieldStorageDefinitionUpdateForbiddenException $e) {
}
}
public function testBundleFieldUpdateWithEntityTypeSchemaUpdate() {
$this
->addBundleField();
$this
->applyEntityUpdates();
$this
->updateEntityTypeToRevisionable();
$entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
$entity_definition_update_manager
->updateFieldStorageDefinition($entity_definition_update_manager
->getFieldStorageDefinition('new_bundle_field', 'entity_test_update'));
}
public function testEntityIndexCreateDeleteWithoutData() {
$this
->addEntityIndex();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$expected = [
'entity_test_update' => [
t('The %entity_type entity type needs to be updated.', [
'%entity_type' => $this->entityTypeManager
->getDefinition('entity_test_update')
->getLabel(),
]),
],
];
$this
->assertEqual($this->entityDefinitionUpdateManager
->getChangeSummary(), $expected, 'EntityDefinitionUpdateManager reports the expected change summary.');
$entity_type = \Drupal::entityTypeManager()
->getDefinition('entity_test_update');
$original = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledDefinition('entity_test_update');
\Drupal::service('entity_type.listener')
->onEntityTypeUpdate($entity_type, $original);
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index created.');
$this
->removeEntityIndex();
$this
->assertTrue($this->entityDefinitionUpdateManager
->needsUpdates(), 'EntityDefinitionUpdateManager reports that updates are needed.');
$expected = [
'entity_test_update' => [
t('The %entity_type entity type needs to be updated.', [
'%entity_type' => $this->entityTypeManager
->getDefinition('entity_test_update')
->getLabel(),
]),
],
];
$this
->assertEqual($this->entityDefinitionUpdateManager
->getChangeSummary(), $expected, 'EntityDefinitionUpdateManager reports the expected change summary.');
$entity_type = \Drupal::entityTypeManager()
->getDefinition('entity_test_update');
$original = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledDefinition('entity_test_update');
\Drupal::service('entity_type.listener')
->onEntityTypeUpdate($entity_type, $original);
$this
->assertFalse($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index deleted.');
$this
->addEntityIndex();
$entity_type = \Drupal::entityTypeManager()
->getDefinition('entity_test_update');
$original = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledDefinition('entity_test_update');
\Drupal::service('entity_type.listener')
->onEntityTypeUpdate($entity_type, $original);
$storage_definition = $this->entityDefinitionUpdateManager
->getFieldStorageDefinition('name', 'entity_test_update');
$this->entityDefinitionUpdateManager
->updateFieldStorageDefinition($storage_definition);
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index created.');
$this->entityDefinitionUpdateManager
->uninstallFieldStorageDefinition($storage_definition);
$this
->assertFalse($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index deleted.');
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('name', 'entity_test_update', 'entity_test', $storage_definition);
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index created again.');
}
public function testEntityIndexCreateWithData() {
$name = $this
->randomString();
$entity = $this->entityTypeManager
->getStorage('entity_test_update')
->create([
'name' => $name,
]);
$entity
->save();
$this
->addEntityIndex();
$entity_type = \Drupal::entityTypeManager()
->getDefinition('entity_test_update');
$original = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledDefinition('entity_test_update');
\Drupal::service('entity_type.listener')
->onEntityTypeUpdate($entity_type, $original);
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index added.');
}
public function testDefinitionEvents() {
$event_subscriber = $this->container
->get('entity_test.definition.subscriber');
$event_subscriber
->enableEventTracking();
$event_subscriber
->enableLiveDefinitionUpdates();
$storage_definition = FieldStorageDefinition::create('string')
->setName('field_storage_test')
->setLabel(new TranslatableMarkup('Field storage test'))
->setTargetEntityTypeId('entity_test_rev');
$this
->assertFalse($event_subscriber
->hasEventFired(FieldStorageDefinitionEvents::CREATE), 'Entity type create was not dispatched yet.');
\Drupal::service('field_storage_definition.listener')
->onFieldStorageDefinitionCreate($storage_definition);
$this
->assertTrue($event_subscriber
->hasEventFired(FieldStorageDefinitionEvents::CREATE), 'Entity type create event successfully dispatched.');
$this
->assertTrue($event_subscriber
->hasDefinitionBeenUpdated(FieldStorageDefinitionEvents::CREATE), 'Last installed field storage definition was created before the event was fired.');
$field_storage_definitions = $this->entityFieldManager
->getFieldStorageDefinitions('entity_test_rev');
$this
->assertArrayHasKey('field_storage_test', $field_storage_definitions);
$updated_storage_definition = clone $storage_definition;
$updated_storage_definition
->setLabel(new TranslatableMarkup('Updated field storage test'));
$this
->assertFalse($event_subscriber
->hasEventFired(FieldStorageDefinitionEvents::UPDATE), 'Entity type update was not dispatched yet.');
\Drupal::service('field_storage_definition.listener')
->onFieldStorageDefinitionUpdate($updated_storage_definition, $storage_definition);
$this
->assertTrue($event_subscriber
->hasEventFired(FieldStorageDefinitionEvents::UPDATE), 'Entity type update event successfully dispatched.');
$this
->assertTrue($event_subscriber
->hasDefinitionBeenUpdated(FieldStorageDefinitionEvents::UPDATE), 'Last installed field storage definition was updated before the event was fired.');
$field_storage_definitions = $this->entityFieldManager
->getFieldStorageDefinitions('entity_test_rev');
$this
->assertEquals(new TranslatableMarkup('Updated field storage test'), $field_storage_definitions['field_storage_test']
->getLabel());
$this
->assertFalse($event_subscriber
->hasEventFired(FieldStorageDefinitionEvents::DELETE), 'Entity type delete was not dispatched yet.');
\Drupal::service('field_storage_definition.listener')
->onFieldStorageDefinitionDelete($storage_definition);
$this
->assertTrue($event_subscriber
->hasEventFired(FieldStorageDefinitionEvents::DELETE), 'Entity type delete event successfully dispatched.');
$this
->assertTrue($event_subscriber
->hasDefinitionBeenUpdated(FieldStorageDefinitionEvents::DELETE), 'Last installed field storage definition was deleted before the event was fired.');
$field_storage_definitions = $this->entityFieldManager
->getFieldStorageDefinitions('entity_test_rev');
$this
->assertArrayNotHasKey('field_storage_test', $field_storage_definitions);
$entity_type = $this->entityTypeManager
->getDefinition('entity_test_rev');
$this
->assertFalse($event_subscriber
->hasEventFired(EntityTypeEvents::CREATE), 'Entity type create was not dispatched yet.');
\Drupal::service('entity_type.listener')
->onEntityTypeCreate($entity_type);
$this
->assertTrue($event_subscriber
->hasEventFired(EntityTypeEvents::CREATE), 'Entity type create event successfully dispatched.');
$this
->assertTrue($event_subscriber
->hasDefinitionBeenUpdated(EntityTypeEvents::CREATE), 'Last installed entity type definition was created before the event was fired.');
$updated_entity_type = clone $entity_type;
$updated_entity_type
->set('label', new TranslatableMarkup('Updated entity test rev'));
$this
->assertFalse($event_subscriber
->hasEventFired(EntityTypeEvents::UPDATE), 'Entity type update was not dispatched yet.');
\Drupal::service('entity_type.listener')
->onEntityTypeUpdate($updated_entity_type, $entity_type);
$this
->assertTrue($event_subscriber
->hasEventFired(EntityTypeEvents::UPDATE), 'Entity type update event successfully dispatched.');
$this
->assertTrue($event_subscriber
->hasDefinitionBeenUpdated(EntityTypeEvents::UPDATE), 'Last installed entity type definition was updated before the event was fired.');
$entity_type = $this->entityTypeManager
->getDefinition('entity_test_rev');
$this
->assertEquals(new TranslatableMarkup('Updated entity test rev'), $entity_type
->getLabel());
$this
->assertFalse($event_subscriber
->hasEventFired(EntityTypeEvents::DELETE), 'Entity type delete was not dispatched yet.');
\Drupal::service('entity_type.listener')
->onEntityTypeDelete($entity_type);
$this
->assertTrue($event_subscriber
->hasEventFired(EntityTypeEvents::DELETE), 'Entity type delete event successfully dispatched.');
$this
->assertTrue($event_subscriber
->hasDefinitionBeenUpdated(EntityTypeEvents::DELETE), 'Last installed entity type definition was deleted before the event was fired.');
$this
->assertNull($this->entityTypeManager
->getDefinition('entity_test_rev', FALSE));
}
public function testSingleActionCalls() {
$db_schema = $this->database
->schema();
$message = 'A non-existing entity type cannot be installed';
try {
$this->entityDefinitionUpdateManager
->installEntityType(new ContentEntityType([
'id' => 'foo',
]));
$this
->fail($message);
} catch (PluginNotFoundException $e) {
}
$message = 'A field cannot be installed on a non-existing entity type';
try {
$storage_definition = BaseFieldDefinition::create('string')
->setLabel(t('A new revisionable base field'))
->setRevisionable(TRUE);
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('bar', 'foo', 'entity_test', $storage_definition);
$this
->fail($message);
} catch (PluginNotFoundException $e) {
}
$entity_type = $this->entityDefinitionUpdateManager
->getEntityType('entity_test_update');
$this->entityDefinitionUpdateManager
->installEntityType($entity_type);
$this
->assertTrue($db_schema
->tableExists('entity_test_update'), 'Installing an existing entity type is a no-op');
$this
->addRevisionableBaseField();
$storage_definition = BaseFieldDefinition::create('string')
->setLabel(t('A new revisionable base field'))
->setRevisionable(TRUE);
$this
->assertFalse($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' does not exist before applying the update.");
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $storage_definition);
$this
->assertTrue($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' has been created on the 'entity_test_update' table.");
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $storage_definition);
$this
->assertTrue($db_schema
->fieldExists('entity_test_update', 'new_base_field'), 'Installing an existing field is a no-op');
$this
->modifyBaseField();
$storage_definition = BaseFieldDefinition::create('text')
->setName('new_base_field')
->setTargetEntityTypeId('entity_test_update')
->setLabel(t('A new revisionable base field'))
->setRevisionable(TRUE);
$this->entityDefinitionUpdateManager
->updateFieldStorageDefinition($storage_definition);
$this
->assertFalse($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "Previous schema for 'new_base_field' no longer exists.");
$this
->assertTrue($db_schema
->fieldExists('entity_test_update', 'new_base_field__value') && $db_schema
->fieldExists('entity_test_update', 'new_base_field__format'), "New schema for 'new_base_field' has been created.");
$this->entityDefinitionUpdateManager
->uninstallFieldStorageDefinition($storage_definition);
$this
->assertFalse($db_schema
->fieldExists('entity_test_update', 'new_base_field__value') || $db_schema
->fieldExists('entity_test_update', 'new_base_field__format'), "The schema for 'new_base_field' has been dropped.");
$this
->updateEntityTypeToRevisionable();
$this
->assertFalse($db_schema
->tableExists('entity_test_update_revision'), "The 'entity_test_update_revision' does not exist before applying the update.");
$this
->updateEntityTypeToRevisionable(TRUE);
$this
->assertTrue($db_schema
->tableExists('entity_test_update_revision'), "The 'entity_test_update_revision' table has been created.");
}
public function testCreateFieldAndIndexOnSharedTable() {
$this
->addBaseField();
$this
->addBaseFieldIndex();
$this
->applyEntityUpdates();
$this
->assertTrue($this->database
->schema()
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' has been created on the 'entity_test_update' table.");
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update_field__new_base_field'), "New index 'entity_test_update_field__new_base_field' has been created on the 'entity_test_update' table.");
if (Database::getConnection()
->driver() == 'mysql') {
$result = Database::getConnection()
->query('SHOW INDEX FROM {entity_test_update} WHERE key_name = \'entity_test_update_field__new_base_field\' and column_name = \'new_base_field\'')
->fetchObject();
$this
->assertEqual(191, $result->Sub_part, 'The index length has been restricted to 191 characters for UTF8MB4 compatibility.');
}
}
public function testCreateIndexUsingEntityStorageSchemaWithData() {
$name = $this
->randomString();
$storage = $this->entityTypeManager
->getStorage('entity_test_update');
$entity = $storage
->create([
'name' => $name,
]);
$entity
->save();
$indexes = [
'entity_test_update__type_index' => [
'type',
],
];
$this->state
->set('entity_test_update.additional_entity_indexes', $indexes);
$entity_type = \Drupal::entityTypeManager()
->getDefinition('entity_test_update');
$original = \Drupal::service('entity.last_installed_schema.repository')
->getLastInstalledDefinition('entity_test_update');
\Drupal::service('entity_type.listener')
->onEntityTypeUpdate($entity_type, $original);
$this
->assertTrue($this->database
->schema()
->indexExists('entity_test_update', 'entity_test_update__type_index'), "New index 'entity_test_update__type_index' has been created on the 'entity_test_update' table.");
if (Database::getConnection()
->driver() == 'mysql') {
$result = Database::getConnection()
->query('SHOW INDEX FROM {entity_test_update} WHERE key_name = \'entity_test_update__type_index\' and column_name = \'type\'')
->fetchObject();
$this
->assertEqual(191, $result->Sub_part, 'The index length has been restricted to 191 characters for UTF8MB4 compatibility.');
}
}
public function testBaseFieldEntityKeyUpdateWithExistingData() {
$this
->addBaseField();
$this
->applyEntityUpdates();
$this->entityTypeManager
->getStorage('entity_test_update')
->create([
'new_base_field' => $this
->randomString(),
])
->save();
$entity = $this->entityTypeManager
->getStorage('entity_test_update')
->create();
$entity
->save();
$this
->makeBaseFieldEntityKey();
$this->entityDefinitionUpdateManager
->updateEntityType($this->state
->get('entity_test_update.entity_type'));
$message = 'An error occurs when trying to enabling NOT NULL constraints with NULL data.';
try {
$this
->applyEntityUpdates();
$this
->fail($message);
} catch (EntityStorageException $e) {
}
$entity
->set('new_base_field', $this
->randomString());
$entity
->save();
$this
->applyEntityUpdates();
$entity
->set('new_base_field', NULL);
$message = 'The NOT NULL constraint was correctly applied.';
try {
$entity
->save();
$this
->fail($message);
} catch (EntityStorageException $e) {
}
}
public function testLongNameFieldIndexes() {
$this
->addLongNameBaseField();
$entity_type_id = 'entity_test_update';
$entity_type = $this->entityTypeManager
->getDefinition($entity_type_id);
$definitions = EntityTestUpdate::baseFieldDefinitions($entity_type);
$name = 'new_long_named_entity_reference_base_field';
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition($name, $entity_type_id, 'entity_test', $definitions[$name]);
$this
->assertFalse($this->entityDefinitionUpdateManager
->needsUpdates(), 'Entity and field schema data are correctly detected.');
}
public function testInitialValue() {
$storage = \Drupal::entityTypeManager()
->getStorage('entity_test_update');
$db_schema = $this->database
->schema();
$storage
->create()
->save();
$storage
->create()
->save();
$this
->addBaseField();
$storage_definition = BaseFieldDefinition::create('string')
->setLabel(t('A new base field'))
->setInitialValue('test value');
$this
->assertFalse($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' does not exist before applying the update.");
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $storage_definition);
$this
->assertTrue($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' has been created on the 'entity_test_update' table.");
$storage = \Drupal::entityTypeManager()
->getStorage('entity_test_update');
$entities = $storage
->loadMultiple();
$this
->assertEquals('test value', $entities[1]
->get('new_base_field')->value);
$this
->assertEquals('test value', $entities[2]
->get('new_base_field')->value);
}
public function testInitialValueFromField($default_initial_value, $expected_value) {
$storage = \Drupal::entityTypeManager()
->getStorage('entity_test_update');
$db_schema = $this->database
->schema();
$storage
->create([
'name' => 'First entity',
'test_single_property' => 'test existing value',
])
->save();
$storage
->create([
'name' => 'Second entity',
])
->save();
$definitions['new_base_field'] = BaseFieldDefinition::create('string')
->setName('new_base_field')
->setLabel('A new base field')
->setInitialValueFromField('name');
$definitions['another_base_field'] = BaseFieldDefinition::create('string')
->setName('another_base_field')
->setLabel('Another base field')
->setInitialValueFromField('test_single_property', $default_initial_value);
$this->state
->set('entity_test_update.additional_base_field_definitions', $definitions);
$this
->assertFalse($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' does not exist before applying the update.");
$this
->assertFalse($db_schema
->fieldExists('entity_test_update', 'another_base_field'), "New field 'another_base_field' does not exist before applying the update.");
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $definitions['new_base_field']);
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('another_base_field', 'entity_test_update', 'entity_test', $definitions['another_base_field']);
$this
->assertTrue($db_schema
->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' has been created on the 'entity_test_update' table.");
$this
->assertTrue($db_schema
->fieldExists('entity_test_update', 'another_base_field'), "New field 'another_base_field' has been created on the 'entity_test_update' table.");
$storage = \Drupal::entityTypeManager()
->getStorage('entity_test_update');
$entities = $storage
->loadMultiple();
$this
->assertEquals('First entity', $entities[1]
->get('new_base_field')->value);
$this
->assertEquals('Second entity', $entities[2]
->get('new_base_field')->value);
$this
->assertEquals('test existing value', $entities[1]
->get('another_base_field')->value);
$this
->assertEquals($expected_value, $entities[2]
->get('another_base_field')->value);
}
public function initialValueFromFieldTestCases() {
return [
'literal value' => [
'test initial value',
'test initial value',
],
'indexed array' => [
[
'value' => 'test initial value',
],
'test initial value',
],
'empty array' => [
[],
NULL,
],
'null' => [
NULL,
NULL,
],
];
}
public function testInitialValueFromFieldErrorHandling() {
try {
$this
->addBaseField();
$storage_definition = BaseFieldDefinition::create('string')
->setLabel(t('A new base field'))
->setInitialValueFromField('field_that_does_not_exist');
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $storage_definition);
$this
->fail('Using a non-existent field as initial value does not work.');
} catch (FieldException $e) {
$this
->assertEquals('Illegal initial value definition on new_base_field: The field field_that_does_not_exist does not exist.', $e
->getMessage());
}
try {
$this
->addBaseField();
$storage_definition = BaseFieldDefinition::create('integer')
->setLabel(t('A new base field'))
->setInitialValueFromField('name');
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $storage_definition);
$this
->fail('Using a field of a different type as initial value does not work.');
} catch (FieldException $e) {
$this
->assertEquals('Illegal initial value definition on new_base_field: The field types do not match.', $e
->getMessage());
}
try {
$initial_field = BaseFieldDefinition::create('string')
->setName('initial_field')
->setLabel(t('An initial field'))
->setCardinality(2);
$this->state
->set('entity_test_update.additional_base_field_definitions', [
'initial_field' => $initial_field,
]);
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('initial_field', 'entity_test_update', 'entity_test', $initial_field);
$new_base_field = BaseFieldDefinition::create('string')
->setName('new_base_field')
->setLabel(t('A new base field'))
->setInitialValueFromField('initial_field');
$this->state
->set('entity_test_update.additional_base_field_definitions', [
'initial_field' => $initial_field,
'new_base_field' => $new_base_field,
]);
$this->entityDefinitionUpdateManager
->installFieldStorageDefinition('new_base_field', 'entity_test_update', 'entity_test', $new_base_field);
$this
->fail('Using a field that is not stored in the shared tables as initial value does not work.');
} catch (FieldException $e) {
$this
->assertEquals('Illegal initial value definition on new_base_field: Both fields have to be stored in the shared entity tables.', $e
->getMessage());
}
}
public function testGetEntityTypes() {
$entity_type_definitions = $this->entityDefinitionUpdateManager
->getEntityTypes();
$this
->assertGreaterThanOrEqual(1, count($entity_type_definitions));
foreach ($entity_type_definitions as $entity_type_id => $entity_type) {
$this
->assertEquals($this->entityDefinitionUpdateManager
->getEntityType($entity_type_id), $entity_type);
}
}
}