trait EntityDefinitionTestTrait

trait EntityDefinitionTestTrait {
    
    /**
     * Applies all the detected valid changes.
     *
     * Use this with care, as it will apply updates for any module, which will
     * lead to unpredictable results.
     *
     * @param string $entity_type_id
     *   (optional) Applies changes only for the specified entity type ID.
     *   Defaults to NULL.
     */
    protected function applyEntityUpdates($entity_type_id = NULL) {
        $complete_change_list = \Drupal::entityDefinitionUpdateManager()->getChangeList();
        if ($complete_change_list) {
            // In case there are changes, explicitly invalidate caches.
            \Drupal::entityTypeManager()->clearCachedDefinitions();
            \Drupal::service('entity_field.manager')->clearCachedFieldDefinitions();
        }
        if ($entity_type_id) {
            $complete_change_list = array_intersect_key($complete_change_list, [
                $entity_type_id => TRUE,
            ]);
        }
        foreach ($complete_change_list as $entity_type_id => $change_list) {
            // Process entity type definition changes before storage definitions ones
            // this is necessary when you change an entity type from non-revisionable
            // to revisionable and at the same time add revisionable fields to the
            // entity type.
            if (!empty($change_list['entity_type'])) {
                $this->doEntityUpdate($change_list['entity_type'], $entity_type_id);
            }
            // Process field storage definition changes.
            if (!empty($change_list['field_storage_definitions'])) {
                $storage_definitions = \Drupal::service('entity_field.manager')->getFieldStorageDefinitions($entity_type_id);
                $original_storage_definitions = \Drupal::service('entity.last_installed_schema.repository')->getLastInstalledFieldStorageDefinitions($entity_type_id);
                foreach ($change_list['field_storage_definitions'] as $field_name => $change) {
                    $storage_definition = isset($storage_definitions[$field_name]) ? $storage_definitions[$field_name] : NULL;
                    $original_storage_definition = isset($original_storage_definitions[$field_name]) ? $original_storage_definitions[$field_name] : NULL;
                    $this->doFieldUpdate($change, $storage_definition, $original_storage_definition);
                }
            }
        }
    }
    
    /**
     * Performs an entity type definition update.
     *
     * @param string $op
     *   The operation to perform, either static::DEFINITION_CREATED or
     *   static::DEFINITION_UPDATED.
     * @param string $entity_type_id
     *   The entity type ID.
     */
    protected function doEntityUpdate($op, $entity_type_id) {
        $entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);
        $field_storage_definitions = \Drupal::service('entity_field.manager')->getFieldStorageDefinitions($entity_type_id);
        switch ($op) {
            case EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED:
                \Drupal::service('entity_type.listener')->onEntityTypeCreate($entity_type);
                break;
            case EntityDefinitionUpdateManagerInterface::DEFINITION_UPDATED:
                $original = \Drupal::service('entity.last_installed_schema.repository')->getLastInstalledDefinition($entity_type_id);
                $original_field_storage_definitions = \Drupal::service('entity.last_installed_schema.repository')->getLastInstalledFieldStorageDefinitions($entity_type_id);
                \Drupal::service('entity_type.listener')->onFieldableEntityTypeUpdate($entity_type, $original, $field_storage_definitions, $original_field_storage_definitions);
                break;
        }
    }
    
    /**
     * Performs a field storage definition update.
     *
     * @param string $op
     *   The operation to perform, possible values are static::DEFINITION_CREATED,
     *   static::DEFINITION_UPDATED or static::DEFINITION_DELETED.
     * @param array|null $storage_definition
     *   The new field storage definition.
     * @param array|null $original_storage_definition
     *   The original field storage definition.
     */
    protected function doFieldUpdate($op, $storage_definition = NULL, $original_storage_definition = NULL) {
        switch ($op) {
            case EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED:
                \Drupal::service('field_storage_definition.listener')->onFieldStorageDefinitionCreate($storage_definition);
                break;
            case EntityDefinitionUpdateManagerInterface::DEFINITION_UPDATED:
                \Drupal::service('field_storage_definition.listener')->onFieldStorageDefinitionUpdate($storage_definition, $original_storage_definition);
                break;
            case EntityDefinitionUpdateManagerInterface::DEFINITION_DELETED:
                \Drupal::service('field_storage_definition.listener')->onFieldStorageDefinitionDelete($original_storage_definition);
                break;
        }
    }
    
    /**
     * Enables a new entity type definition.
     */
    protected function enableNewEntityType() {
        $this->state
            ->set('entity_test_new', TRUE);
        $this->applyEntityUpdates('entity_test_new');
    }
    
    /**
     * Resets the entity type definition.
     */
    protected function resetEntityType() {
        $updated_entity_type = $this->getUpdatedEntityTypeDefinition(FALSE, FALSE);
        $updated_field_storage_definitions = $this->getUpdatedFieldStorageDefinitions(FALSE, FALSE);
        $this->entityDefinitionUpdateManager
            ->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions);
    }
    
    /**
     * Updates the 'entity_test_update' entity type to revisionable.
     *
     * @param bool $perform_update
     *   (optional) Whether the change should be performed by the entity
     *   definition update manager.
     */
    protected function updateEntityTypeToRevisionable($perform_update = FALSE) {
        $translatable = $this->entityDefinitionUpdateManager
            ->getEntityType('entity_test_update')
            ->isTranslatable();
        $updated_entity_type = $this->getUpdatedEntityTypeDefinition(TRUE, $translatable);
        $updated_field_storage_definitions = $this->getUpdatedFieldStorageDefinitions(TRUE, $translatable);
        if ($perform_update) {
            $this->entityDefinitionUpdateManager
                ->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions);
        }
    }
    
    /**
     * Updates the 'entity_test_update' entity type not revisionable.
     *
     * @param bool $perform_update
     *   (optional) Whether the change should be performed by the entity
     *   definition update manager.
     */
    protected function updateEntityTypeToNotRevisionable($perform_update = FALSE) {
        $translatable = $this->entityDefinitionUpdateManager
            ->getEntityType('entity_test_update')
            ->isTranslatable();
        $updated_entity_type = $this->getUpdatedEntityTypeDefinition(FALSE, $translatable);
        $updated_field_storage_definitions = $this->getUpdatedFieldStorageDefinitions(FALSE, $translatable);
        if ($perform_update) {
            $this->entityDefinitionUpdateManager
                ->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions);
        }
    }
    
    /**
     * Updates the 'entity_test_update' entity type to translatable.
     *
     * @param bool $perform_update
     *   (optional) Whether the change should be performed by the entity
     *   definition update manager.
     */
    protected function updateEntityTypeToTranslatable($perform_update = FALSE) {
        $revisionable = $this->entityDefinitionUpdateManager
            ->getEntityType('entity_test_update')
            ->isRevisionable();
        $updated_entity_type = $this->getUpdatedEntityTypeDefinition($revisionable, TRUE);
        $updated_field_storage_definitions = $this->getUpdatedFieldStorageDefinitions($revisionable, TRUE);
        if ($perform_update) {
            $this->entityDefinitionUpdateManager
                ->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions);
        }
    }
    
    /**
     * Updates the 'entity_test_update' entity type to not translatable.
     *
     * @param bool $perform_update
     *   (optional) Whether the change should be performed by the entity
     *   definition update manager.
     */
    protected function updateEntityTypeToNotTranslatable($perform_update = FALSE) {
        $revisionable = $this->entityDefinitionUpdateManager
            ->getEntityType('entity_test_update')
            ->isRevisionable();
        $updated_entity_type = $this->getUpdatedEntityTypeDefinition($revisionable, FALSE);
        $updated_field_storage_definitions = $this->getUpdatedFieldStorageDefinitions($revisionable, FALSE);
        if ($perform_update) {
            $this->entityDefinitionUpdateManager
                ->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions);
        }
    }
    
    /**
     * Updates the 'entity_test_update' entity type to revisionable and
     * translatable.
     *
     * @param bool $perform_update
     *   (optional) Whether the change should be performed by the entity
     *   definition update manager.
     */
    protected function updateEntityTypeToRevisionableAndTranslatable($perform_update = FALSE) {
        $updated_entity_type = $this->getUpdatedEntityTypeDefinition(TRUE, TRUE);
        $updated_field_storage_definitions = $this->getUpdatedFieldStorageDefinitions(TRUE, TRUE);
        if ($perform_update) {
            $this->entityDefinitionUpdateManager
                ->updateFieldableEntityType($updated_entity_type, $updated_field_storage_definitions);
        }
    }
    
    /**
     * Adds a new base field to the 'entity_test_update' entity type.
     *
     * @param string $type
     *   (optional) The field type for the new field. Defaults to 'string'.
     * @param string $entity_type_id
     *   (optional) The entity type ID the base field should be attached to.
     *   Defaults to 'entity_test_update'.
     * @param bool $is_revisionable
     *   (optional) If the base field should be revisionable or not. Defaults to
     *   FALSE.
     * @param bool $set_label
     *   (optional) If the base field should have a label or not. Defaults to
     *   TRUE.
     * @param bool $is_translatable
     *   (optional) If the base field should be translatable or not. Defaults to
     *   FALSE.
     */
    protected function addBaseField($type = 'string', $entity_type_id = 'entity_test_update', $is_revisionable = FALSE, $set_label = TRUE, $is_translatable = FALSE) {
        $definitions['new_base_field'] = BaseFieldDefinition::create($type)->setName('new_base_field')
            ->setRevisionable($is_revisionable)
            ->setTranslatable($is_translatable);
        if ($set_label) {
            $definitions['new_base_field']->setLabel(t('A new base field'));
        }
        $this->state
            ->set($entity_type_id . '.additional_base_field_definitions', $definitions);
    }
    
    /**
     * Adds a long-named base field to the 'entity_test_update' entity type.
     */
    protected function addLongNameBaseField() {
        $key = 'entity_test_update.additional_base_field_definitions';
        $definitions = $this->state
            ->get($key, []);
        $definitions['new_long_named_entity_reference_base_field'] = BaseFieldDefinition::create('entity_reference')->setName('new_long_named_entity_reference_base_field')
            ->setLabel(t('A new long-named base field'))
            ->setSetting('target_type', 'user')
            ->setSetting('handler', 'default');
        $this->state
            ->set($key, $definitions);
    }
    
    /**
     * Adds a new revisionable base field to the 'entity_test_update' entity type.
     *
     * @param string $type
     *   (optional) The field type for the new field. Defaults to 'string'.
     */
    protected function addRevisionableBaseField($type = 'string') {
        $definitions['new_base_field'] = BaseFieldDefinition::create($type)->setName('new_base_field')
            ->setLabel(t('A new revisionable base field'))
            ->setRevisionable(TRUE);
        $this->state
            ->set('entity_test_update.additional_base_field_definitions', $definitions);
    }
    
    /**
     * Modifies the new base field from 'string' to 'text'.
     */
    protected function modifyBaseField() {
        $this->addBaseField('text');
    }
    
    /**
     * Promotes a field to an entity key.
     */
    protected function makeBaseFieldEntityKey() {
        $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_update');
        $entity_keys = $entity_type->getKeys();
        $entity_keys['new_base_field'] = 'new_base_field';
        $entity_type->set('entity_keys', $entity_keys);
        $this->state
            ->set('entity_test_update.entity_type', $entity_type);
    }
    
    /**
     * Removes the new base field from the 'entity_test_update' entity type.
     *
     * @param string $entity_type_id
     *   (optional) The entity type ID the base field should be attached to.
     */
    protected function removeBaseField($entity_type_id = 'entity_test_update') {
        $this->state
            ->delete($entity_type_id . '.additional_base_field_definitions');
    }
    
    /**
     * Adds a single-field index to the base field.
     */
    protected function addBaseFieldIndex() {
        $this->state
            ->set('entity_test_update.additional_field_index.entity_test_update.new_base_field', TRUE);
    }
    
    /**
     * Removes the index added in addBaseFieldIndex().
     */
    protected function removeBaseFieldIndex() {
        $this->state
            ->delete('entity_test_update.additional_field_index.entity_test_update.new_base_field');
    }
    
    /**
     * Adds a new bundle field to the 'entity_test_update' entity type.
     *
     * @param string $type
     *   (optional) The field type for the new field. Defaults to 'string'.
     * @param bool $revisionable
     *   (optional) Whether the field should be revisionable. Defaults to FALSE.
     * @param bool $translatable
     *   (optional) Whether the field should be translatable. Defaults to FALSE.
     */
    protected function addBundleField($type = 'string', $revisionable = FALSE, $translatable = FALSE) {
        $definitions['new_bundle_field'] = FieldStorageDefinition::create($type)->setName('new_bundle_field')
            ->setLabel(t('A new bundle field'))
            ->setTargetEntityTypeId('entity_test_update')
            ->setRevisionable($revisionable)
            ->setTranslatable($translatable);
        $this->state
            ->set('entity_test_update.additional_field_storage_definitions', $definitions);
        $this->state
            ->set('entity_test_update.additional_bundle_field_definitions.test_bundle', $definitions);
    }
    
    /**
     * Modifies the new bundle field from 'string' to 'text'.
     */
    protected function modifyBundleField() {
        $this->addBundleField('text');
    }
    
    /**
     * Removes the new bundle field from the 'entity_test_update' entity type.
     */
    protected function removeBundleField() {
        $this->state
            ->delete('entity_test_update.additional_field_storage_definitions');
        $this->state
            ->delete('entity_test_update.additional_bundle_field_definitions.test_bundle');
    }
    
    /**
     * Adds an index to the 'entity_test_update' entity type's base table.
     *
     * @see \Drupal\entity_test\EntityTestStorageSchema::getEntitySchema()
     */
    protected function addEntityIndex() {
        $indexes = [
            'entity_test_update__new_index' => [
                'name',
                'test_single_property',
            ],
        ];
        $this->state
            ->set('entity_test_update.additional_entity_indexes', $indexes);
    }
    
    /**
     * Removes the index added in addEntityIndex().
     */
    protected function removeEntityIndex() {
        $this->state
            ->delete('entity_test_update.additional_entity_indexes');
    }
    
    /**
     * Renames the base table to 'entity_test_update_new'.
     */
    protected function renameBaseTable() {
        $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_update');
        $entity_type->set('base_table', 'entity_test_update_new');
        $this->state
            ->set('entity_test_update.entity_type', $entity_type);
    }
    
    /**
     * Renames the data table to 'entity_test_update_data_new'.
     */
    protected function renameDataTable() {
        $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_update');
        $entity_type->set('data_table', 'entity_test_update_data_new');
        $this->state
            ->set('entity_test_update.entity_type', $entity_type);
    }
    
    /**
     * Renames the revision table to 'entity_test_update_revision_new'.
     */
    protected function renameRevisionBaseTable() {
        $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_update');
        $entity_type->set('revision_table', 'entity_test_update_revision_new');
        $this->state
            ->set('entity_test_update.entity_type', $entity_type);
    }
    
    /**
     * Renames the revision data table to 'entity_test_update_revision_data_new'.
     */
    protected function renameRevisionDataTable() {
        $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_update');
        $entity_type->set('revision_data_table', 'entity_test_update_revision_data_new');
        $this->state
            ->set('entity_test_update.entity_type', $entity_type);
    }
    
    /**
     * Removes the entity type.
     */
    protected function deleteEntityType() {
        $this->state
            ->set('entity_test_update.entity_type', 'null');
    }
    
    /**
     * Returns an entity type definition, possibly updated to be rev or mul.
     *
     * @param bool $revisionable
     *   (optional) Whether the entity type should be revisionable or not.
     *   Defaults to FALSE.
     * @param bool $translatable
     *   (optional) Whether the entity type should be translatable or not.
     *   Defaults to FALSE.
     *
     * @return \Drupal\Core\Entity\EntityTypeInterface
     *   An entity type definition.
     */
    protected function getUpdatedEntityTypeDefinition($revisionable = FALSE, $translatable = FALSE) {
        $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_update');
        if ($revisionable) {
            $keys = $entity_type->getKeys();
            $keys['revision'] = 'revision_id';
            $entity_type->set('entity_keys', $keys);
            $entity_type->set('revision_table', 'entity_test_update_revision');
        }
        else {
            $keys = $entity_type->getKeys();
            $keys['revision'] = '';
            $entity_type->set('entity_keys', $keys);
            $entity_type->set('revision_table', NULL);
        }
        if ($translatable) {
            $entity_type->set('translatable', TRUE);
            $entity_type->set('data_table', 'entity_test_update_data');
        }
        else {
            $entity_type->set('translatable', FALSE);
            $entity_type->set('data_table', NULL);
        }
        if ($revisionable && $translatable) {
            $entity_type->set('revision_data_table', 'entity_test_update_revision_data');
        }
        else {
            $entity_type->set('revision_data_table', NULL);
        }
        $this->state
            ->set('entity_test_update.entity_type', $entity_type);
        $this->container
            ->get('entity_type.manager')
            ->clearCachedDefinitions();
        $this->container
            ->get('entity_type.bundle.info')
            ->clearCachedBundles();
        $this->container
            ->get('entity_field.manager')
            ->clearCachedFieldDefinitions();
        return $entity_type;
    }
    
    /**
     * Returns the required rev / mul field definitions for an entity type.
     *
     * @param bool $revisionable
     *   (optional) Whether the entity type should be revisionable or not.
     *   Defaults to FALSE.
     * @param bool $translatable
     *   (optional) Whether the entity type should be translatable or not.
     *   Defaults to FALSE.
     *
     * @return \Drupal\Core\Field\FieldStorageDefinitionInterface[]
     *   An array of field storage definition objects.
     */
    protected function getUpdatedFieldStorageDefinitions($revisionable = FALSE, $translatable = FALSE) {
        
        /** @var \Drupal\Core\Field\BaseFieldDefinition[] $field_storage_definitions */
        $field_storage_definitions = \Drupal::service('entity_field.manager')->getFieldStorageDefinitions('entity_test_update');
        if ($revisionable) {
            // The 'langcode' is already available for the 'entity_test_update' entity
            // type because it has the 'langcode' entity key defined.
            $field_storage_definitions['langcode']->setRevisionable(TRUE);
            $field_storage_definitions['revision_id'] = BaseFieldDefinition::create('integer')->setName('revision_id')
                ->setTargetEntityTypeId('entity_test_update')
                ->setTargetBundle(NULL)
                ->setLabel(new TranslatableMarkup('Revision ID'))
                ->setReadOnly(TRUE)
                ->setSetting('unsigned', TRUE);
            $field_storage_definitions['revision_default'] = BaseFieldDefinition::create('boolean')->setName('revision_default')
                ->setTargetEntityTypeId('entity_test_update')
                ->setTargetBundle(NULL)
                ->setLabel(new TranslatableMarkup('Default revision'))
                ->setDescription(new TranslatableMarkup('A flag indicating whether this was a default revision when it was saved.'))
                ->setStorageRequired(TRUE)
                ->setInternal(TRUE)
                ->setTranslatable(FALSE)
                ->setRevisionable(TRUE);
        }
        if ($translatable) {
            // The 'langcode' is already available for the 'entity_test_update' entity
            // type because it has the 'langcode' entity key defined.
            $field_storage_definitions['langcode']->setTranslatable(TRUE);
            $field_storage_definitions['default_langcode'] = BaseFieldDefinition::create('boolean')->setName('default_langcode')
                ->setTargetEntityTypeId('entity_test_update')
                ->setTargetBundle(NULL)
                ->setLabel(new TranslatableMarkup('Default translation'))
                ->setDescription(new TranslatableMarkup('A flag indicating whether this is the default translation.'))
                ->setTranslatable(TRUE)
                ->setRevisionable(TRUE)
                ->setDefaultValue(TRUE);
        }
        if ($revisionable && $translatable) {
            $field_storage_definitions['revision_translation_affected'] = BaseFieldDefinition::create('boolean')->setName('revision_translation_affected')
                ->setTargetEntityTypeId('entity_test_update')
                ->setTargetBundle(NULL)
                ->setLabel(new TranslatableMarkup('Revision translation affected'))
                ->setDescription(new TranslatableMarkup('Indicates if the last edit of a translation belongs to current revision.'))
                ->setReadOnly(TRUE)
                ->setRevisionable(TRUE)
                ->setTranslatable(TRUE);
        }
        return $field_storage_definitions;
    }

}