function EntityDefinitionUpdateProviderTest::testBaseFieldDeleteWithExistingData

Tests deleting a base field when it has existing data.

@dataProvider baseFieldDeleteWithExistingDataTestCases

File

core/tests/Drupal/KernelTests/Core/Entity/EntityDefinitionUpdateProviderTest.php, line 70

Class

EntityDefinitionUpdateProviderTest

Tests EntityDefinitionUpdateManager functionality.

Namespace

Code

public function testBaseFieldDeleteWithExistingData($entity_type_id, $create_entity_revision, $base_field_revisionable, $create_entity_translation) : void {
    // 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.');
    }
}