class EntityDefinitionUpdateTest in Drupal 10

Tests EntityDefinitionUpdateManager functionality.

@coversDefaultClass \Drupal\Core\Entity\EntityDefinitionUpdateManager

@group Entity

Hierarchy

• class \Drupal\KernelTests\KernelTestBase extends \PHPUnit\Framework\TestCase implements ServiceProviderInterface uses \Drupal\Tests\PhpUnitCompatibilityTrait, \Symfony\Bridge\PhpUnit\ExpectDeprecationTrait, AssertContentTrait, ConfigTestTrait, ExtensionListTestTrait, RandomGeneratorTrait, TestRequirementsTrait, PhpUnitWarnings
  • class \Drupal\KernelTests\Core\Entity\EntityKernelTestBase uses UserCreationTrait
    • class \Drupal\KernelTests\Core\Entity\EntityDefinitionUpdateTest uses EntityDefinitionTestTrait

File

core/tests/Drupal/KernelTests/Core/Entity/EntityDefinitionUpdateTest.php, line 29

Namespace

Drupal\KernelTests\Core\Entity

class EntityDefinitionUpdateTest extends EntityKernelTestBase {
  use EntityDefinitionTestTrait;

  /**
   * The entity definition update manager.
   *
   * @var \Drupal\Core\Entity\EntityDefinitionUpdateManagerInterface
   */
  protected $entityDefinitionUpdateManager;

  /**
   * The entity field manager.
   *
   * @var \Drupal\Core\Entity\EntityFieldManagerInterface
   */
  protected $entityFieldManager;

  /**
   * The database connection.
   *
   * @var \Drupal\Core\Database\Connection
   */
  protected $database;

  /**
   * Modules to enable.
   *
   * @var array
   */
  protected static $modules = [
    'entity_test_update',
    'language',
  ];

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    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');

    // Install every entity type's schema that wasn't installed in the parent
    // method.
    foreach (array_diff_key($this->entityTypeManager
      ->getDefinitions(), array_flip([
      'user',
      'entity_test',
    ])) as $entity_type_id => $entity_type) {
      $this
        ->installEntitySchema($entity_type_id);
    }
  }

  /**
   * Tests that new entity type definitions are correctly handled.
   */
  public function testNewEntityType() {
    $entity_type_id = 'entity_test_new';
    $schema = $this->database
      ->schema();

    // Check that the "entity_test_new" is not defined.
    $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.');

    // Check that the "entity_test_new" is now defined and the related schema
    // has been created.
    $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.');
  }

  /**
   * Tests when no definition update is needed.
   */
  public function testNoUpdates() {

    // Ensure that the definition update manager reports no updates.
    $this
      ->assertFalse($this->entityDefinitionUpdateManager
      ->needsUpdates(), 'EntityDefinitionUpdateManager reports that no updates are needed.');
    $this
      ->assertSame([], $this->entityDefinitionUpdateManager
      ->getChangeSummary(), 'EntityDefinitionUpdateManager reports an empty change summary.');
    $this
      ->assertSame([], $this->entityDefinitionUpdateManager
      ->getChangeList(), 'EntityDefinitionUpdateManager reports an empty change list.');
  }

  /**
   * Tests updating entity schema when there are no existing entities.
   */
  public function testEntityTypeUpdateWithoutData() {

    // The 'entity_test_update' entity type starts out non-revisionable, so
    // ensure the revision table hasn't been created during setUp().
    $this
      ->assertFalse($this->database
      ->schema()
      ->tableExists('entity_test_update_revision'), 'Revision table not created for entity_test_update.');

    // Update it to be revisionable and ensure the definition update manager
    // reports that an update is needed.
    $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(),
        ]),
        // The revision key is now defined, so the revision field needs to be
        // created.
        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
      ->assertEquals($expected, $this->entityDefinitionUpdateManager
      ->getChangeSummary(), 'EntityDefinitionUpdateManager reports the expected change summary.');

    // Run the update and ensure the revision table is created.
    $this
      ->updateEntityTypeToRevisionable(TRUE);
    $this
      ->assertTrue($this->database
      ->schema()
      ->tableExists('entity_test_update_revision'), 'Revision table created for entity_test_update.');
  }

  /**
   * Tests updating entity schema when there are entity storage changes.
   */
  public function testEntityTypeUpdateWithEntityStorageChange() {

    // Update the entity type to be revisionable and try to apply the update.
    // It's expected to throw an exception.
    $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) {

      // Expected exception; just continue testing.
    }
  }

  /**
   * Tests installing an additional base field while installing an entity type.
   *
   * @covers ::installFieldableEntityType
   */
  public function testInstallAdditionalBaseFieldDuringFieldableEntityTypeInstallation() {
    $entity_type = clone $this->entityTypeManager
      ->getDefinition('entity_test_update');
    $field_storage_definitions = \Drupal::service('entity_field.manager')
      ->getFieldStorageDefinitions('entity_test_update');

    // Enable the creation of a new base field during the installation of a
    // fieldable entity type.
    $this->state
      ->set('entity_test_update.install_new_base_field_during_create', TRUE);

    // Install the entity type and check that the additional base field was also
    // installed.
    $this->entityDefinitionUpdateManager
      ->installFieldableEntityType($entity_type, $field_storage_definitions);

    // Check whether the 'new_base_field' field has been installed correctly.
    $field_storage_definition = $this->entityDefinitionUpdateManager
      ->getFieldStorageDefinition('new_base_field', 'entity_test_update');
    $this
      ->assertNotNull($field_storage_definition);
  }

  /**
   * Tests creating a fieldable entity type that doesn't exist in code anymore.
   *
   * @covers ::installFieldableEntityType
   */
  public function testInstallFieldableEntityTypeWithoutInCodeDefinition() {
    $entity_type = clone $this->entityTypeManager
      ->getDefinition('entity_test_update');
    $field_storage_definitions = \Drupal::service('entity_field.manager')
      ->getFieldStorageDefinitions('entity_test_update');

    // Remove the entity type definition. This is the same thing as removing the
    // code that defines it.
    $this
      ->deleteEntityType();

    // Install the entity type and check that its tables have been created.
    $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.');
  }

  /**
   * Tests updating an entity type that doesn't exist in code anymore.
   *
   * @covers ::updateEntityType
   */
  public function testUpdateEntityTypeWithoutInCodeDefinition() {
    $entity_type = clone $this->entityTypeManager
      ->getDefinition('entity_test_update');

    // Remove the entity type definition. This is the same thing as removing the
    // code that defines it.
    $this
      ->deleteEntityType();

    // Add an entity index, update the entity type and check that the index has
    // been created.
    $this
      ->addEntityIndex();
    $this->entityDefinitionUpdateManager
      ->updateEntityType($entity_type);
    $this
      ->assertTrue($this->database
      ->schema()
      ->indexExists('entity_test_update', 'entity_test_update__new_index'), 'Index created.');
  }

  /**
   * Tests updating a fieldable entity type that doesn't exist in code anymore.
   *
   * @covers ::updateFieldableEntityType
   */
  public function testUpdateFieldableEntityTypeWithoutInCodeDefinition() {
    $entity_type = clone $this->entityTypeManager
      ->getDefinition('entity_test_update');
    $field_storage_definitions = \Drupal::service('entity_field.manager')
      ->getFieldStorageDefinitions('entity_test_update');

    // Remove the entity type definition. This is the same thing as removing the
    // code that defines it.
    $this
      ->deleteEntityType();

    // Rename the base table, update the fieldable entity type and check that
    // the table has been renamed.
    $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.');
  }

  /**
   * Tests uninstalling an entity type that doesn't exist in code anymore.
   *
   * @covers ::uninstallEntityType
   */
  public function testUninstallEntityTypeWithoutInCodeDefinition() {
    $entity_type = clone $this->entityTypeManager
      ->getDefinition('entity_test_update');

    // Remove the entity type definition. This is the same thing as removing the
    // code that defines it.
    $this
      ->deleteEntityType();

    // Now uninstall it and check that the tables have been removed.
    $this->entityDefinitionUpdateManager
      ->uninstallEntityType($entity_type);
    $this
      ->assertFalse($this->database
      ->schema()
      ->tableExists('entity_test_update'), 'Base table for entity_test_update does not exist anymore.');
  }

  /**
   * Tests creating, updating, and deleting a base field if no entities exist.
   */
  public function testBaseFieldCreateUpdateDeleteWithoutData() {

    // Add a base field, ensure the update manager reports it, and the update
    // creates its schema.
    $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.');

    // Add an index on the base field, ensure the update manager reports it,
    // and the update creates it.
    $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.');

    // Remove the above index, ensure the update manager reports it, and the
    // update deletes it.
    $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.');

    // Update the type of the base field from 'string' to 'text', ensure the
    // update manager reports it, and the update adjusts the schema
    // accordingly.
    $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.');

    // Remove the base field, ensure the update manager reports it, and the
    // update deletes the schema.
    $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.');
  }

  /**
   * Tests creating, updating, and deleting a base field with no label set.
   *
   * See testBaseFieldCreateUpdateDeleteWithoutData() for more details
   */
  public function testBaseFieldWithoutLabelCreateUpdateDelete() {

    // Add a base field, ensure the update manager reports it with the
    // field id.
    $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();

    // Add an index on the base field, ensure the update manager reports it with
    // the field id.
    $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();

    // Remove the base field, ensure the update manager reports it with the
    // field id.
    $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]));
  }

  /**
   * Tests creating, updating, and deleting a bundle field if no entities exist.
   */
  public function testBundleFieldCreateUpdateDeleteWithoutData() {

    // Add a bundle field, ensure the update manager reports it, and the update
    // creates its schema.
    $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.');

    // Update the type of the base field from 'string' to 'text', ensure the
    // update manager reports it, and the update adjusts the schema
    // accordingly.
    $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.');

    // Remove the bundle field, ensure the update manager reports it, and the
    // update deletes the schema.
    $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.');
  }

  /**
   * Tests creating and deleting a base field if entities exist.
   *
   * This tests deletion when there are existing entities, but non-existent data
   * for the field being deleted.
   *
   * @see testBaseFieldDeleteWithExistingData()
   */
  public function testBaseFieldCreateDeleteWithExistingEntities() {

    // Save an entity.
    $name = $this
      ->randomString();
    $storage = $this->entityTypeManager
      ->getStorage('entity_test_update');
    $entity = $storage
      ->create([
      'name' => $name,
    ]);
    $entity
      ->save();

    // Add a base field and run the update. Ensure the base field's column is
    // created and the prior saved entity data is still there.
    $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
      ->assertSame($name, $entity->name->value, 'Entity data preserved during field creation.');

    // Remove the base field and run the update. Ensure the base field's column
    // is deleted and the prior saved entity data is still there.
    $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
      ->assertSame($name, $entity->name->value, 'Entity data preserved during field deletion.');

    // Add a base field with a required property and run the update. Ensure
    // 'not null' is not applied and thus no exception is thrown.
    $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.');

    // Recreate the field after emptying the base table and check that its
    // columns are not 'not null'.
    // @todo Revisit this test when allowing for required storage field
    //   definitions. See https://www.drupal.org/node/2390495.
    $entity
      ->delete();
    $this
      ->removeBaseField();
    $this
      ->applyEntityUpdates();
    $this
      ->assertFalse($schema_handler
      ->fieldExists('entity_test_update', 'new_base_field__shape'), 'Shape column should be removed from the shared table for new_base_field.');
    $this
      ->assertFalse($schema_handler
      ->fieldExists('entity_test_update', 'new_base_field__color'), 'Color column should be 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();
  }

  /**
   * Tests creating and deleting a bundle field if entities exist.
   *
   * This tests deletion when there are existing entities, but non-existent data
   * for the field being deleted.
   *
   * @see testBundleFieldDeleteWithExistingData()
   */
  public function testBundleFieldCreateDeleteWithExistingEntities() {

    // Save an entity.
    $name = $this
      ->randomString();
    $storage = $this->entityTypeManager
      ->getStorage('entity_test_update');
    $entity = $storage
      ->create([
      'name' => $name,
    ]);
    $entity
      ->save();

    // Add a bundle field and run the update. Ensure the bundle field's table
    // is created and the prior saved entity data is still there.
    $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
      ->assertSame($name, $entity->name->value, 'Entity data preserved during field creation.');

    // Remove the base field and run the update. Ensure the bundle field's
    // table is deleted and the prior saved entity data is still there.
    $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
      ->assertSame($name, $entity->name->value, 'Entity data preserved during field deletion.');

    // Test that required columns are created as 'not null'.
    $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 {

      // Try to insert a record without providing a value for the 'not null'
      // column. This should fail.
      $this->database
        ->insert('entity_test_update__new_bundle_field')
        ->fields($values)
        ->execute();
      $this
        ->fail($message);
    } catch (IntegrityConstraintViolationException $e) {

      // Now provide a value for the 'not null' column. This is expected to
      // succeed.
      $values['new_bundle_field_shape'] = $this
        ->randomString();
      $this->database
        ->insert('entity_test_update__new_bundle_field')
        ->fields($values)
        ->execute();
    }
  }

  /**
   * Tests deleting a base field when it has existing data.
   *
   * @dataProvider baseFieldDeleteWithExistingDataTestCases
   */
  public function testBaseFieldDeleteWithExistingData($entity_type_id, $create_entity_revision, $base_field_revisionable, $create_entity_translation) {

    // Enable an additional language.
    ConfigurableLanguage::createFromLangcode('ro')
      ->save();

    /** @var \Drupal\Core\Entity\Sql\SqlEntityStorageInterface $storage */
    $storage = $this->entityTypeManager
      ->getStorage($entity_type_id);
    $schema_handler = $this->database
      ->schema();

    // Create an entity without the base field, to ensure NULL values are not
    // added to the dedicated table storage to be purged.

    /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
    $entity = $storage
      ->create();
    $entity
      ->save();

    // Add the base field and run the update.
    $this
      ->addBaseField('string', $entity_type_id, $base_field_revisionable, TRUE, $create_entity_translation);
    $this
      ->applyEntityUpdates();

    /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
    $table_mapping = $storage
      ->getTableMapping();
    $storage_definition = \Drupal::service('entity.last_installed_schema.repository')
      ->getLastInstalledFieldStorageDefinitions($entity_type_id)['new_base_field'];

    // Save an entity with the base field populated.
    $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();
      }
    }

    // Remove the base field and apply updates.
    $this
      ->removeBaseField($entity_type_id);
    $this
      ->applyEntityUpdates();

    // Check that the base field's column is deleted.
    $this
      ->assertFalse($schema_handler
      ->fieldExists($entity_type_id, 'new_base_field'), 'Column deleted from shared table for new_base_field.');

    // Check that a dedicated 'deleted' table was created for the deleted 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',
      ];
    }

    // Check that the deleted field's data is preserved in the dedicated
    // 'deleted' table.
    $result = $this->database
      ->select($dedicated_deleted_table_name, 't')
      ->fields('t')
      ->orderBy('revision_id', 'ASC')
      ->orderBy('langcode', 'ASC')
      ->execute()
      ->fetchAll(\PDO::FETCH_ASSOC);
    $this
      ->assertSameSize($expected, $result);

    // Use assertEquals and not assertSame here to prevent that a different
    // sequence of the columns in the table will affect the check.
    $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
        ->assertSameSize($expected, $result);

      // Use assertEquals and not assertSame here to prevent that a different
      // sequence of the columns in the table will affect the check.
      $this
        ->assertEquals($expected, $result);
    }

    // Check that the field storage definition is marked for purging.
    $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.');

    // Purge field data, and check that the storage definition has been
    // completely removed once the data is purged.
    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.');
    }
  }

  /**
   * Test cases for ::testBaseFieldDeleteWithExistingData.
   */
  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,
      ],
    ];
  }

  /**
   * Tests deleting a bundle field when it has existing data.
   */
  public function testBundleFieldDeleteWithExistingData() {

    /** @var \Drupal\Core\Entity\Sql\SqlEntityStorageInterface $storage */
    $storage = $this->entityTypeManager
      ->getStorage('entity_test_update');
    $schema_handler = $this->database
      ->schema();

    // Add the bundle field and run the update.
    $this
      ->addBundleField();
    $this
      ->applyEntityUpdates();

    /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
    $table_mapping = $storage
      ->getTableMapping();
    $storage_definition = \Drupal::service('entity.last_installed_schema.repository')
      ->getLastInstalledFieldStorageDefinitions('entity_test_update')['new_bundle_field'];

    // Check that the bundle field has a dedicated table.
    $dedicated_table_name = $table_mapping
      ->getDedicatedDataTableName($storage_definition);
    $this
      ->assertTrue($schema_handler
      ->tableExists($dedicated_table_name), 'The bundle field uses a dedicated table.');

    // Save an entity with the bundle field populated.
    entity_test_create_bundle('custom');
    $entity = $storage
      ->create([
      'type' => 'test_bundle',
      'new_bundle_field' => 'foo',
    ]);
    $entity
      ->save();

    // Remove the bundle field and apply updates.
    $this
      ->removeBundleField();
    $this
      ->applyEntityUpdates();

    // Check that the table of the bundle field has been renamed to use a
    // 'deleted' table name.
    $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.');

    // Check that the deleted field's data is preserved in the dedicated
    // 'deleted' table.
    $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,
    ];

    // Use assertEquals and not assertSame here to prevent that a different
    // sequence of the columns in the table will affect the check.
    $this
      ->assertEquals($expected, (array) $result[0]);

    // Check that the field definition is marked for purging.
    $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.');

    // Check that the field storage definition 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.');

    // Purge field data, and check that the storage definition has been
    // completely removed once the data is purged.
    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.');
  }

  /**
   * Tests updating a base field when it has existing data.
   */
  public function testBaseFieldUpdateWithExistingData() {

    // Add the base field and run the update.
    $this
      ->addBaseField();
    $this
      ->applyEntityUpdates();

    // Save an entity with the base field populated.
    $this->entityTypeManager
      ->getStorage('entity_test_update')
      ->create([
      'new_base_field' => 'foo',
    ])
      ->save();

    // Change the field's field type and apply updates. It's expected to
    // throw an exception.
    $this
      ->modifyBaseField();
    try {
      $this
        ->applyEntityUpdates();
      $this
        ->fail('FieldStorageDefinitionUpdateForbiddenException thrown when trying to update a field schema that has data.');
    } catch (FieldStorageDefinitionUpdateForbiddenException $e) {

      // Expected exception; just continue testing.
    }
  }

  /**
   * Tests updating a bundle field when it has existing data.
   */
  public function testBundleFieldUpdateWithExistingData() {

    // Add the bundle field and run the update.
    $this
      ->addBundleField();
    $this
      ->applyEntityUpdates();

    // Save an entity with the bundle field populated.
    entity_test_create_bundle('custom');
    $this->entityTypeManager
      ->getStorage('entity_test_update')
      ->create([
      'type' => 'test_bundle',
      'new_bundle_field' => 'foo',
    ])
      ->save();

    // Change the field's field type and apply updates. It's expected to
    // throw an exception.
    $this
      ->modifyBundleField();
    try {
      $this
        ->applyEntityUpdates();
      $this
        ->fail('FieldStorageDefinitionUpdateForbiddenException thrown when trying to update a field schema that has data.');
    } catch (FieldStorageDefinitionUpdateForbiddenException $e) {

      // Expected exception; just continue testing.
    }
  }

  /**
   * Tests updating a bundle field when the entity type schema has changed.
   */
  public function testBundleFieldUpdateWithEntityTypeSchemaUpdate() {

    // Add the bundle field and run the update.
    $this
      ->addBundleField();
    $this
      ->applyEntityUpdates();

    // Update the entity type schema to revisionable but don't run the updates
    // yet.
    $this
      ->updateEntityTypeToRevisionable();

    // Perform a no-op update on the bundle field, which should work because
    // both the storage and the storage schema are using the last installed
    // entity type definition.
    $entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
    $entity_definition_update_manager
      ->updateFieldStorageDefinition($entity_definition_update_manager
      ->getFieldStorageDefinition('new_bundle_field', 'entity_test_update'));
  }

  /**
   * Tests creating and deleting a multi-field index when there are no existing entities.
   */
  public function testEntityIndexCreateDeleteWithoutData() {

    // Add an entity index and ensure the update manager reports that as an
    // update to the entity type.
    $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
      ->assertEquals($expected, $this->entityDefinitionUpdateManager
      ->getChangeSummary(), 'EntityDefinitionUpdateManager reports the expected change summary.');

    // Run the update and ensure the new index is created.
    $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.');

    // Remove the index and ensure the update manager reports that as an
    // update to the entity type.
    $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
      ->assertEquals($expected, $this->entityDefinitionUpdateManager
      ->getChangeSummary(), 'EntityDefinitionUpdateManager reports the expected change summary.');

    // Run the update and ensure the index is deleted.
    $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.');

    // Test that composite indexes are handled correctly when dropping and
    // re-creating one of their columns.
    $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.');
  }

  /**
   * Tests creating a multi-field index when there are existing entities.
   */
  public function testEntityIndexCreateWithData() {

    // Save an entity.
    $name = $this
      ->randomString();
    $entity = $this->entityTypeManager
      ->getStorage('entity_test_update')
      ->create([
      'name' => $name,
    ]);
    $entity
      ->save();

    // Add an entity index, run the update. Ensure that the index is created
    // despite having data.
    $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.');
  }

  /**
   * Tests entity type and field storage definition events.
   */
  public function testDefinitionEvents() {

    /** @var \Drupal\entity_test\EntityTestDefinitionSubscriber $event_subscriber */
    $event_subscriber = $this->container
      ->get('entity_test.definition.subscriber');
    $event_subscriber
      ->enableEventTracking();
    $event_subscriber
      ->enableLiveDefinitionUpdates();

    // Test field storage definition events.
    $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.');

    // Check that the newly added field can be retrieved from the live field
    // storage definitions.
    $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.');

    // Check that the updated field can be retrieved from the live field storage
    // definitions.
    $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.');

    // Check that the deleted field can no longer be retrieved from the live
    // field storage definitions.
    $field_storage_definitions = $this->entityFieldManager
      ->getFieldStorageDefinitions('entity_test_rev');
    $this
      ->assertArrayNotHasKey('field_storage_test', $field_storage_definitions);

    // Test entity type events.
    $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.');

    // Check that the updated definition can be retrieved from the live entity
    // type definitions.
    $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.');

    // Check that the deleted entity type can no longer be retrieved from the
    // live entity type definitions.
    $this
      ->assertNull($this->entityTypeManager
      ->getDefinition('entity_test_rev', FALSE));
  }

  /**
   * Tests applying single updates.
   */
  public function testSingleActionCalls() {
    $db_schema = $this->database
      ->schema();

    // Ensure that a non-existing entity type cannot be installed.
    $message = 'A non-existing entity type cannot be installed';
    try {
      $this->entityDefinitionUpdateManager
        ->installEntityType(new ContentEntityType([
        'id' => 'foo',
      ]));
      $this
        ->fail($message);
    } catch (PluginNotFoundException $e) {

      // Expected exception; just continue testing.
    }

    // Ensure that a field cannot be installed on non-existing entity type.
    $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) {

      // Expected exception; just continue testing.
    }

    // Ensure that installing an existing entity type is a no-op.
    $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');

    // Create a new base field.
    $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.");

    // Ensure that installing an existing field is a no-op.
    $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');

    // Update an existing field schema.
    $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.");

    // Drop an existing field schema.
    $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.");

    // Make the entity type revisionable.
    $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.");
  }

  /**
   * Ensures that a new field and index on a shared table are created.
   *
   * @see Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema::createSharedTableSchema
   */
  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.");

    // Check index size in for MySQL.
    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
        ->assertEquals(191, $result->Sub_part, 'The index length has been restricted to 191 characters for UTF8MB4 compatibility.');
    }
  }

  /**
   * Ensures that a new entity level index is created when data exists.
   *
   * @see Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema::onEntityTypeUpdate
   */
  public function testCreateIndexUsingEntityStorageSchemaWithData() {

    // Save an entity.
    $name = $this
      ->randomString();
    $storage = $this->entityTypeManager
      ->getStorage('entity_test_update');
    $entity = $storage
      ->create([
      'name' => $name,
    ]);
    $entity
      ->save();

    // Create an index.
    $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.");

    // Check index size in for MySQL.
    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
        ->assertEquals(191, $result->Sub_part, 'The index length has been restricted to 191 characters for UTF8MB4 compatibility.');
    }
  }

  /**
   * Tests updating a base field when it has existing data.
   */
  public function testBaseFieldEntityKeyUpdateWithExistingData() {

    // Add the base field and run the update.
    $this
      ->addBaseField();
    $this
      ->applyEntityUpdates();

    // Save an entity with the base field populated.
    $this->entityTypeManager
      ->getStorage('entity_test_update')
      ->create([
      'new_base_field' => $this
        ->randomString(),
    ])
      ->save();

    // Save an entity with the base field not populated.

    /** @var \Drupal\entity_test\Entity\EntityTestUpdate $entity */
    $entity = $this->entityTypeManager
      ->getStorage('entity_test_update')
      ->create();
    $entity
      ->save();

    // Promote the base field to an entity key. This will trigger the addition
    // of a NOT NULL constraint.
    $this
      ->makeBaseFieldEntityKey();

    // Field storage CRUD operations use the last installed entity type
    // definition so we need to update it before doing any other field storage
    // updates.
    $this->entityDefinitionUpdateManager
      ->updateEntityType($this->state
      ->get('entity_test_update.entity_type'));

    // Try to apply the update and verify they fail since we have a NULL value.
    $message = 'An error occurs when trying to enabling NOT NULL constraints with NULL data.';
    try {
      $this
        ->applyEntityUpdates();
      $this
        ->fail($message);
    } catch (EntityStorageException $e) {

      // Expected exception; just continue testing.
    }

    // Check that the update is correctly applied when no NULL data is left.
    $entity
      ->set('new_base_field', $this
      ->randomString());
    $entity
      ->save();
    $this
      ->applyEntityUpdates();

    // Check that the update actually applied a NOT NULL constraint.
    $entity
      ->set('new_base_field', NULL);
    $message = 'The NOT NULL constraint was correctly applied.';
    try {
      $entity
        ->save();
      $this
        ->fail($message);
    } catch (EntityStorageException $e) {

      // Expected exception; just continue testing.
    }
  }

  /**
   * Check that field schema is correctly handled with long-named fields.
   */
  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.');
  }

  /**
   * Tests adding a base field with initial values.
   */
  public function testInitialValue() {
    $storage = \Drupal::entityTypeManager()
      ->getStorage('entity_test_update');
    $db_schema = $this->database
      ->schema();

    // Create two entities before adding the base field.

    /** @var \Drupal\entity_test\Entity\EntityTestUpdate $entity */
    $storage
      ->create()
      ->save();
    $storage
      ->create()
      ->save();

    // Add a base field with an initial value.
    $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.");

    // Check that the initial values have been applied.
    $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);
  }

  /**
   * Tests adding a base field with initial values inherited from another field.
   *
   * @dataProvider initialValueFromFieldTestCases
   */
  public function testInitialValueFromField($default_initial_value, $expected_value) {
    $storage = \Drupal::entityTypeManager()
      ->getStorage('entity_test_update');
    $db_schema = $this->database
      ->schema();

    // Create two entities before adding the base field.

    /** @var \Drupal\entity_test_update\Entity\EntityTestUpdate $entity */
    $storage
      ->create([
      'name' => 'First entity',
      'test_single_property' => 'test existing value',
    ])
      ->save();

    // The second entity does not have any value for the 'test_single_property'
    // field, allowing us to test the 'default_value' parameter of
    // \Drupal\Core\Field\BaseFieldDefinition::setInitialValueFromField().
    $storage
      ->create([
      'name' => 'Second entity',
    ])
      ->save();

    // Add a base field with an initial value inherited from another field.
    $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.");

    // Check that the initial values have been applied.
    $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);
  }

  /**
   * Test cases for ::testInitialValueFromField.
   */
  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,
      ],
    ];
  }

  /**
   * Tests the error handling when using initial values from another field.
   */
  public function testInitialValueFromFieldErrorHandling() {

    // Check that setting invalid values for 'initial value from field' doesn't
    // work.
    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 {

      // Add a base field that will not be stored in the shared tables.
      $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);

      // Now add the base field which will try to use the previously added field
      // as the source of its initial values.
      $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());
    }
  }

  /**
   * @covers ::getEntityTypes
   */
  public function testGetEntityTypes() {
    $entity_type_definitions = $this->entityDefinitionUpdateManager
      ->getEntityTypes();

    // Ensure that we have at least one entity type to check below.
    $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);
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AssertContentTrait::$content	protected	property	The current raw content.
AssertContentTrait::$drupalSettings	protected	property	The drupalSettings value from the current raw $content.
AssertContentTrait::$elements	protected	property	The XML structure parsed from the current raw $content.	1
AssertContentTrait::$plainTextContent	protected	property	The plain-text content of raw $content (text nodes).
AssertContentTrait::assertEscaped	protected	function	Passes if the raw text IS found escaped on the loaded page, fail otherwise.
AssertContentTrait::assertField	protected	function	Asserts that a field exists with the given name or ID.
AssertContentTrait::assertFieldById	protected	function	Asserts that a field exists with the given ID and value.
AssertContentTrait::assertFieldByName	protected	function	Asserts that a field exists with the given name and value.
AssertContentTrait::assertFieldByXPath	protected	function	Asserts that a field exists in the current page by the given XPath.
AssertContentTrait::assertFieldChecked	protected	function	Asserts that a checkbox field in the current page is checked.
AssertContentTrait::assertFieldsByValue	protected	function	Asserts that a field exists in the current page with a given Xpath result.
AssertContentTrait::assertLink	protected	function	Passes if a link with the specified label is found.
AssertContentTrait::assertLinkByHref	protected	function	Passes if a link containing a given href (part) is found.
AssertContentTrait::assertNoDuplicateIds	protected	function	Asserts that each HTML ID is used for just a single element.
AssertContentTrait::assertNoEscaped	protected	function	Passes if the raw text IS NOT found escaped on the loaded page, fail otherwise.
AssertContentTrait::assertNoField	protected	function	Asserts that a field does not exist with the given name or ID.
AssertContentTrait::assertNoFieldById	protected	function	Asserts that a field does not exist with the given ID and value.
AssertContentTrait::assertNoFieldByName	protected	function	Asserts that a field does not exist with the given name and value.
AssertContentTrait::assertNoFieldByXPath	protected	function	Asserts that a field does not exist or its value does not match, by XPath.
AssertContentTrait::assertNoFieldChecked	protected	function	Asserts that a checkbox field in the current page is not checked.
AssertContentTrait::assertNoLink	protected	function	Passes if a link with the specified label is not found.
AssertContentTrait::assertNoLinkByHref	protected	function	Passes if a link containing a given href (part) is not found.
AssertContentTrait::assertNoLinkByHrefInMainRegion	protected	function	Passes if a link containing a given href is not found in the main region.
AssertContentTrait::assertNoOption	protected	function	Asserts that a select option in the current page does not exist.
AssertContentTrait::assertNoOptionSelected	protected	function	Asserts that a select option in the current page is not checked.
AssertContentTrait::assertNoPattern	protected	function	Triggers a pass if the perl regex pattern is not found in raw content.
AssertContentTrait::assertNoRaw	protected	function	Passes if the raw text is NOT found on the loaded page, fail otherwise.
AssertContentTrait::assertNoText	protected	function	Passes if the page (with HTML stripped) does not contains the text.
AssertContentTrait::assertNoTitle	protected	function	Pass if the page title is not the given string.
AssertContentTrait::assertNoUniqueText	protected	function	Passes if the text is found MORE THAN ONCE on the text version of the page.
AssertContentTrait::assertOption	protected	function	Asserts that a select option in the current page exists.
AssertContentTrait::assertOptionByText	protected	function	Asserts that a select option with the visible text exists.
AssertContentTrait::assertOptionSelected	protected	function	Asserts that a select option in the current page is checked.
AssertContentTrait::assertOptionSelectedWithDrupalSelector	protected	function	Asserts that a select option in the current page is checked.
AssertContentTrait::assertOptionWithDrupalSelector	protected	function	Asserts that a select option in the current page exists.
AssertContentTrait::assertPattern	protected	function	Triggers a pass if the Perl regex pattern is found in the raw content.
AssertContentTrait::assertRaw	protected	function	Passes if the raw text IS found on the loaded page, fail otherwise.
AssertContentTrait::assertText	protected	function	Passes if the page (with HTML stripped) contains the text.
AssertContentTrait::assertTextHelper	protected	function	Helper for assertText and assertNoText.
AssertContentTrait::assertTextPattern	protected	function	Asserts that a Perl regex pattern is found in the plain-text content.
AssertContentTrait::assertThemeOutput	protected	function	Asserts themed output.
AssertContentTrait::assertTitle	protected	function	Pass if the page title is the given string.
AssertContentTrait::assertUniqueText	protected	function	Passes if the text is found ONLY ONCE on the text version of the page.
AssertContentTrait::assertUniqueTextHelper	protected	function	Helper for assertUniqueText and assertNoUniqueText.
AssertContentTrait::buildXPathQuery	protected	function	Builds an XPath query.
AssertContentTrait::constructFieldXpath	protected	function	Helper: Constructs an XPath for the given set of attributes and value.
AssertContentTrait::cssSelect	protected	function	Searches elements using a CSS selector in the raw content.
AssertContentTrait::getAllOptions	protected	function	Get all option elements, including nested options, in a select.
AssertContentTrait::getDrupalSettings	protected	function	Gets the value of drupalSettings for the currently-loaded page.
AssertContentTrait::getRawContent	protected	function	Gets the current raw content.
AssertContentTrait::getSelectedItem	protected	function	Get the selected value from a select field.
AssertContentTrait::getTextContent	protected	function	Retrieves the plain-text content from the current raw content.
AssertContentTrait::parse	protected	function	Parse content returned from curlExec using DOM and SimpleXML.
AssertContentTrait::removeWhiteSpace	protected	function	Removes all white-space between HTML tags from the raw content.
AssertContentTrait::setDrupalSettings	protected	function	Sets the value of drupalSettings for the currently-loaded page.
AssertContentTrait::setRawContent	protected	function	Sets the raw content (e.g. HTML).
AssertContentTrait::xpath	protected	function	Performs an xpath search on the contents of the internal browser.
ConfigTestTrait::configImporter	protected	function	Returns a ConfigImporter object to import test configuration.
ConfigTestTrait::copyConfig	protected	function	Copies configuration objects from source storage to target storage.
EntityDefinitionTestTrait::addBaseField	protected	function	Adds a new base field to the 'entity_test_update' entity type.
EntityDefinitionTestTrait::addBaseFieldIndex	protected	function	Adds a single-field index to the base field.
EntityDefinitionTestTrait::addBundleField	protected	function	Adds a new bundle field to the 'entity_test_update' entity type.
EntityDefinitionTestTrait::addEntityIndex	protected	function	Adds an index to the 'entity_test_update' entity type's base table.
EntityDefinitionTestTrait::addLongNameBaseField	protected	function	Adds a long-named base field to the 'entity_test_update' entity type.
EntityDefinitionTestTrait::addRevisionableBaseField	protected	function	Adds a new revisionable base field to the 'entity_test_update' entity type.
EntityDefinitionTestTrait::applyEntityUpdates	protected	function	Applies all the detected valid changes.
EntityDefinitionTestTrait::deleteEntityType	protected	function	Removes the entity type.
EntityDefinitionTestTrait::doEntityUpdate	protected	function	Performs an entity type definition update.
EntityDefinitionTestTrait::doFieldUpdate	protected	function	Performs a field storage definition update.
EntityDefinitionTestTrait::enableNewEntityType	protected	function	Enables a new entity type definition.
EntityDefinitionTestTrait::getUpdatedEntityTypeDefinition	protected	function	Returns an entity type definition, possibly updated to be rev or mul.
EntityDefinitionTestTrait::getUpdatedFieldStorageDefinitions	protected	function	Returns the required rev / mul field definitions for an entity type.
EntityDefinitionTestTrait::makeBaseFieldEntityKey	protected	function	Promotes a field to an entity key.
EntityDefinitionTestTrait::modifyBaseField	protected	function	Modifies the new base field from 'string' to 'text'.
EntityDefinitionTestTrait::modifyBundleField	protected	function	Modifies the new bundle field from 'string' to 'text'.
EntityDefinitionTestTrait::removeBaseField	protected	function	Removes the new base field from the 'entity_test_update' entity type.
EntityDefinitionTestTrait::removeBaseFieldIndex	protected	function	Removes the index added in addBaseFieldIndex().
EntityDefinitionTestTrait::removeBundleField	protected	function	Removes the new bundle field from the 'entity_test_update' entity type.
EntityDefinitionTestTrait::removeEntityIndex	protected	function	Removes the index added in addEntityIndex().
EntityDefinitionTestTrait::renameBaseTable	protected	function	Renames the base table to 'entity_test_update_new'.
EntityDefinitionTestTrait::renameDataTable	protected	function	Renames the data table to 'entity_test_update_data_new'.
EntityDefinitionTestTrait::renameRevisionBaseTable	protected	function	Renames the revision table to 'entity_test_update_revision_new'.
EntityDefinitionTestTrait::renameRevisionDataTable	protected	function	Renames the revision data table to 'entity_test_update_revision_data_new'.
EntityDefinitionTestTrait::resetEntityType	protected	function	Resets the entity type definition.
EntityDefinitionTestTrait::updateEntityTypeToNotRevisionable	protected	function	Updates the 'entity_test_update' entity type not revisionable.
EntityDefinitionTestTrait::updateEntityTypeToNotTranslatable	protected	function	Updates the 'entity_test_update' entity type to not translatable.
EntityDefinitionTestTrait::updateEntityTypeToRevisionable	protected	function	Updates the 'entity_test_update' entity type to revisionable.
EntityDefinitionTestTrait::updateEntityTypeToRevisionableAndTranslatable	protected	function	Updates the 'entity_test_update' entity type to revisionable and translatable.
EntityDefinitionTestTrait::updateEntityTypeToTranslatable	protected	function	Updates the 'entity_test_update' entity type to translatable.
EntityDefinitionUpdateTest::$database	protected	property	The database connection.
EntityDefinitionUpdateTest::$entityDefinitionUpdateManager	protected	property	The entity definition update manager.
EntityDefinitionUpdateTest::$entityFieldManager	protected	property	The entity field manager.
EntityDefinitionUpdateTest::$modules	protected static	property	Modules to enable. Overrides EntityKernelTestBase::$modules
EntityDefinitionUpdateTest::baseFieldDeleteWithExistingDataTestCases	public	function	Test cases for ::testBaseFieldDeleteWithExistingData.
EntityDefinitionUpdateTest::initialValueFromFieldTestCases	public	function	Test cases for ::testInitialValueFromField.
EntityDefinitionUpdateTest::setUp	protected	function	Overrides EntityKernelTestBase::setUp
EntityDefinitionUpdateTest::testBaseFieldCreateDeleteWithExistingEntities	public	function	Tests creating and deleting a base field if entities exist.
EntityDefinitionUpdateTest::testBaseFieldCreateUpdateDeleteWithoutData	public	function	Tests creating, updating, and deleting a base field if no entities exist.
EntityDefinitionUpdateTest::testBaseFieldDeleteWithExistingData	public	function	Tests deleting a base field when it has existing data.
EntityDefinitionUpdateTest::testBaseFieldEntityKeyUpdateWithExistingData	public	function	Tests updating a base field when it has existing data.
EntityDefinitionUpdateTest::testBaseFieldUpdateWithExistingData	public	function	Tests updating a base field when it has existing data.
EntityDefinitionUpdateTest::testBaseFieldWithoutLabelCreateUpdateDelete	public	function	Tests creating, updating, and deleting a base field with no label set.
EntityDefinitionUpdateTest::testBundleFieldCreateDeleteWithExistingEntities	public	function	Tests creating and deleting a bundle field if entities exist.
EntityDefinitionUpdateTest::testBundleFieldCreateUpdateDeleteWithoutData	public	function	Tests creating, updating, and deleting a bundle field if no entities exist.
EntityDefinitionUpdateTest::testBundleFieldDeleteWithExistingData	public	function	Tests deleting a bundle field when it has existing data.
EntityDefinitionUpdateTest::testBundleFieldUpdateWithEntityTypeSchemaUpdate	public	function	Tests updating a bundle field when the entity type schema has changed.
EntityDefinitionUpdateTest::testBundleFieldUpdateWithExistingData	public	function	Tests updating a bundle field when it has existing data.
EntityDefinitionUpdateTest::testCreateFieldAndIndexOnSharedTable	public	function	Ensures that a new field and index on a shared table are created.
EntityDefinitionUpdateTest::testCreateIndexUsingEntityStorageSchemaWithData	public	function	Ensures that a new entity level index is created when data exists.
EntityDefinitionUpdateTest::testDefinitionEvents	public	function	Tests entity type and field storage definition events.
EntityDefinitionUpdateTest::testEntityIndexCreateDeleteWithoutData	public	function	Tests creating and deleting a multi-field index when there are no existing entities.
EntityDefinitionUpdateTest::testEntityIndexCreateWithData	public	function	Tests creating a multi-field index when there are existing entities.
EntityDefinitionUpdateTest::testEntityTypeUpdateWithEntityStorageChange	public	function	Tests updating entity schema when there are entity storage changes.
EntityDefinitionUpdateTest::testEntityTypeUpdateWithoutData	public	function	Tests updating entity schema when there are no existing entities.
EntityDefinitionUpdateTest::testGetEntityTypes	public	function	@covers ::getEntityTypes
EntityDefinitionUpdateTest::testInitialValue	public	function	Tests adding a base field with initial values.
EntityDefinitionUpdateTest::testInitialValueFromField	public	function	Tests adding a base field with initial values inherited from another field.
EntityDefinitionUpdateTest::testInitialValueFromFieldErrorHandling	public	function	Tests the error handling when using initial values from another field.
EntityDefinitionUpdateTest::testInstallAdditionalBaseFieldDuringFieldableEntityTypeInstallation	public	function	Tests installing an additional base field while installing an entity type.
EntityDefinitionUpdateTest::testInstallFieldableEntityTypeWithoutInCodeDefinition	public	function	Tests creating a fieldable entity type that doesn't exist in code anymore.
EntityDefinitionUpdateTest::testLongNameFieldIndexes	public	function	Check that field schema is correctly handled with long-named fields.
EntityDefinitionUpdateTest::testNewEntityType	public	function	Tests that new entity type definitions are correctly handled.
EntityDefinitionUpdateTest::testNoUpdates	public	function	Tests when no definition update is needed.
EntityDefinitionUpdateTest::testSingleActionCalls	public	function	Tests applying single updates.
EntityDefinitionUpdateTest::testUninstallEntityTypeWithoutInCodeDefinition	public	function	Tests uninstalling an entity type that doesn't exist in code anymore.
EntityDefinitionUpdateTest::testUpdateEntityTypeWithoutInCodeDefinition	public	function	Tests updating an entity type that doesn't exist in code anymore.
EntityDefinitionUpdateTest::testUpdateFieldableEntityTypeWithoutInCodeDefinition	public	function	Tests updating a fieldable entity type that doesn't exist in code anymore.
EntityKernelTestBase::$entityTypeManager	protected	property	The entity type manager service.	1
EntityKernelTestBase::$generatedIds	protected	property	A list of generated identifiers.
EntityKernelTestBase::$state	protected	property	The state service.
EntityKernelTestBase::createUser	protected	function	Creates a user.
EntityKernelTestBase::generateRandomEntityId	protected	function	Generates a random ID avoiding collisions.
EntityKernelTestBase::getHooksInfo	protected	function	Returns the entity_test hook invocation info.
EntityKernelTestBase::installModule	protected	function	Installs a module and refreshes services.
EntityKernelTestBase::refreshServices	protected	function	Refresh services.
EntityKernelTestBase::reloadEntity	protected	function	Reloads the given entity from the storage and returns it.
EntityKernelTestBase::uninstallModule	protected	function	Uninstalls a module and refreshes services.
ExtensionListTestTrait::getModulePath	protected	function	Gets the path for the specified module.
ExtensionListTestTrait::getThemePath	protected	function	Gets the path for the specified theme.
KernelTestBase::$backupGlobals	protected	property	Back up and restore any global variables that may be changed by tests.
KernelTestBase::$backupStaticAttributes	protected	property	Back up and restore static class properties that may be changed by tests.
KernelTestBase::$backupStaticAttributesBlacklist	protected	property	Contains a few static class properties for performance.
KernelTestBase::$classLoader	protected	property
KernelTestBase::$configImporter	protected	property	@todo Move into Config test base class.	3
KernelTestBase::$configSchemaCheckerExclusions	protected static	property	An array of config object names that are excluded from schema checking.
KernelTestBase::$container	protected	property
KernelTestBase::$databasePrefix	protected	property
KernelTestBase::$preserveGlobalState	protected	property	Do not forward any global state from the parent process to the processes that run the actual tests.
KernelTestBase::$root	protected	property	The app root.
KernelTestBase::$runTestInSeparateProcess	protected	property	Kernel tests are run in separate processes because they allow autoloading of code from extensions. Running the test in a separate process isolates this behavior from other tests. Subclasses should not override this property.
KernelTestBase::$siteDirectory	protected	property
KernelTestBase::$strictConfigSchema	protected	property	Set to TRUE to strict check all configuration saved.	4
KernelTestBase::$vfsRoot	protected	property	The virtual filesystem root directory.
KernelTestBase::assertPostConditions	protected	function		1
KernelTestBase::bootEnvironment	protected	function	Bootstraps a basic test environment.
KernelTestBase::bootKernel	private	function	Bootstraps a kernel for a test.
KernelTestBase::config	protected	function	Configuration accessor for tests. Returns non-overridden configuration.
KernelTestBase::disableModules	protected	function	Disables modules for this test.
KernelTestBase::enableModules	protected	function	Enables modules for this test.
KernelTestBase::getConfigSchemaExclusions	protected	function	Gets the config schema exclusions for this test.
KernelTestBase::getDatabaseConnectionInfo	protected	function	Returns the Database connection info to be used for this test.	2
KernelTestBase::getDatabasePrefix	public	function
KernelTestBase::getExtensionsForModules	private	function	Returns Extension objects for $modules to enable.
KernelTestBase::getModulesToEnable	private static	function	Returns the modules to enable for this test.
KernelTestBase::initFileCache	protected	function	Initializes the FileCache component.
KernelTestBase::installConfig	protected	function	Installs default configuration for a given list of modules.
KernelTestBase::installEntitySchema	protected	function	Installs the storage schema for a specific entity type.
KernelTestBase::installSchema	protected	function	Installs database tables from a module schema definition.
KernelTestBase::prepareTemplate	protected	function
KernelTestBase::register	public	function	Registers test-specific services. Overrides ServiceProviderInterface::register	14
KernelTestBase::render	protected	function	Renders a render array.
KernelTestBase::setInstallProfile	protected	function	Sets the install profile and rebuilds the container to update it.
KernelTestBase::setSetting	protected	function	Sets an in-memory Settings variable.
KernelTestBase::setUpBeforeClass	public static	function
KernelTestBase::setUpFilesystem	protected	function	Sets up the filesystem, so things like the file directory.	1
KernelTestBase::stop	protected	function	Stops test execution.
KernelTestBase::tearDown	protected	function		3
KernelTestBase::tearDownCloseDatabaseConnection	public	function	@after
KernelTestBase::vfsDump	protected	function	Dumps the current state of the virtual filesystem to STDOUT.
KernelTestBase::__sleep	public	function	Prevents serializing any properties.
PhpUnitWarnings::$deprecationWarnings	private static	property	Deprecation warnings from PHPUnit to raise with @trigger_error().
PhpUnitWarnings::addWarning	public	function	Converts PHPUnit deprecation warnings to E_USER_DEPRECATED.
RandomGeneratorTrait::$randomGenerator	protected	property	The random generator.
RandomGeneratorTrait::getRandomGenerator	protected	function	Gets the random generator for the utility methods.
RandomGeneratorTrait::randomMachineName	protected	function	Generates a unique random string containing letters and numbers.
RandomGeneratorTrait::randomObject	public	function	Generates a random PHP object.
RandomGeneratorTrait::randomString	public	function	Generates a pseudo-random string of ASCII characters of codes 32 to 126.
RandomGeneratorTrait::randomStringValidate	public	function	Callback for random string validation.
StorageCopyTrait::replaceStorageContents	protected static	function	Copy the configuration from one storage to another and remove stale items.
TestRequirementsTrait::checkModuleRequirements	private	function	Checks missing module requirements.
TestRequirementsTrait::checkRequirements	protected	function	Check module requirements for the Drupal use case.
TestRequirementsTrait::getDrupalRoot	protected static	function	Returns the Drupal root directory.
UserCreationTrait::checkPermissions	protected	function	Checks whether a given list of permission names is valid. Aliased as: drupalCheckPermissions
UserCreationTrait::createAdminRole	protected	function	Creates an administrative role. Aliased as: drupalCreateAdminRole
UserCreationTrait::createRole	protected	function	Creates a role with specified permissions. Aliased as: drupalCreateRole
UserCreationTrait::createUser	protected	function	Create a user with a given set of permissions. Aliased as: drupalCreateUser
UserCreationTrait::grantPermissions	protected	function	Grant permissions to a user role. Aliased as: drupalGrantPermissions
UserCreationTrait::setCurrentUser	protected	function	Switch the current logged in user. Aliased as: drupalSetCurrentUser
UserCreationTrait::setUpCurrentUser	protected	function	Creates a random user account and sets it as current user. Aliased as: drupalSetUpCurrentUser