View source
<?php
namespace Drupal\KernelTests\Core\Config;
use Drupal\entity_test\Entity\EntityTest;
use Drupal\KernelTests\Core\Entity\EntityKernelTestBase;
class ConfigDependencyTest extends EntityKernelTestBase {
public static $modules = [
'config_test',
'entity_test',
'user',
];
public function testNonEntity() {
$this
->installConfig([
'system',
]);
$config_manager = \Drupal::service('config.manager');
$dependents = $config_manager
->findConfigEntityDependents('module', [
'system',
]);
$this
->assertTrue(isset($dependents['system.site']), 'Simple configuration system.site has a UUID key even though it is not a configuration entity and therefore is found when looking for dependencies of the System module.');
$config_manager
->findConfigEntityDependentsAsEntities('module', [
'system',
]);
}
public function testDependencyManagement() {
$config_manager = \Drupal::service('config.manager');
$storage = $this->container
->get('entity_type.manager')
->getStorage('config_test');
$entity1 = $storage
->create([
'id' => 'entity1',
'dependencies' => [
'enforced' => [
'module' => [
'node',
],
],
],
]);
$entity1
->save();
$dependents = $config_manager
->findConfigEntityDependents('module', [
'node',
]);
$this
->assertTrue(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 has a dependency on the Node module.');
$dependents = $config_manager
->findConfigEntityDependents('module', [
'config_test',
]);
$this
->assertTrue(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 has a dependency on the config_test module.');
$dependents = $config_manager
->findConfigEntityDependents('module', [
'views',
]);
$this
->assertFalse(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 does not have a dependency on the Views module.');
$raw_config = $this
->config('config_test.dynamic.entity1');
$root_module_dependencies = $raw_config
->get('dependencies.module');
$this
->assertTrue(empty($root_module_dependencies), 'Node module is not written to the root dependencies array as it is enforced.');
$entity2 = $storage
->create([
'id' => 'entity2',
'dependencies' => [
'enforced' => [
'config' => [
$entity1
->getConfigDependencyName(),
],
],
],
]);
$entity2
->save();
$entity3 = $storage
->create([
'id' => 'entity3',
'dependencies' => [
'enforced' => [
'config' => [
$entity2
->getConfigDependencyName(),
],
],
],
]);
$entity3
->save();
$entity4 = $storage
->create([
'id' => 'entity4',
'dependencies' => [
'enforced' => [
'config' => [
$entity3
->getConfigDependencyName(),
],
],
],
]);
$entity4
->save();
$dependents = $config_manager
->findConfigEntityDependents('config', [
$entity1
->getConfigDependencyName(),
]);
$this
->assertFalse(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 does not have a dependency on itself.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity2']), 'config_test.dynamic.entity2 has a dependency on config_test.dynamic.entity1.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity3']), 'config_test.dynamic.entity3 has a dependency on config_test.dynamic.entity1.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity4']), 'config_test.dynamic.entity4 has a dependency on config_test.dynamic.entity1.');
$dependents = $config_manager
->findConfigEntityDependentsAsEntities('config', [
$entity2
->getConfigDependencyName(),
]);
$dependent_ids = $this
->getDependentIds($dependents);
$this
->assertNotContains('config_test:entity1', $dependent_ids, 'config_test.dynamic.entity1 does not have a dependency on config_test.dynamic.entity1.');
$this
->assertNotContains('config_test:entity2', $dependent_ids, 'config_test.dynamic.entity2 does not have a dependency on itself.');
$this
->assertContains('config_test:entity3', $dependent_ids, 'config_test.dynamic.entity3 has a dependency on config_test.dynamic.entity2.');
$this
->assertContains('config_test:entity4', $dependent_ids, 'config_test.dynamic.entity4 has a dependency on config_test.dynamic.entity2.');
$dependents = $config_manager
->findConfigEntityDependents('module', [
'node',
]);
$this
->assertTrue(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 has a dependency on the Node module.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity2']), 'config_test.dynamic.entity2 has a dependency on the Node module.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity3']), 'config_test.dynamic.entity3 has a dependency on the Node module.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity4']), 'config_test.dynamic.entity4 has a dependency on the Node module.');
$entity1
->setEnforcedDependencies([])
->save();
$entity3
->setEnforcedDependencies([
'module' => [
'node',
],
'config' => [
$entity2
->getConfigDependencyName(),
],
])
->save();
$dependents = $config_manager
->findConfigEntityDependents('module', [
'node',
]);
$this
->assertFalse(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 does not have a dependency on the Node module.');
$this
->assertFalse(isset($dependents['config_test.dynamic.entity2']), 'config_test.dynamic.entity2 does not have a dependency on the Node module.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity3']), 'config_test.dynamic.entity3 has a dependency on the Node module.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity4']), 'config_test.dynamic.entity4 has a dependency on the Node module.');
$entity_test = EntityTest::create([
'name' => $this
->randomString(),
'type' => 'entity_test',
]);
$entity_test
->save();
$entity2
->setEnforcedDependencies([
'config' => [
$entity1
->getConfigDependencyName(),
],
'content' => [
$entity_test
->getConfigDependencyName(),
],
])
->save();
$dependents = $config_manager
->findConfigEntityDependents('content', [
$entity_test
->getConfigDependencyName(),
]);
$this
->assertFalse(isset($dependents['config_test.dynamic.entity1']), 'config_test.dynamic.entity1 does not have a dependency on the content entity.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity2']), 'config_test.dynamic.entity2 has a dependency on the content entity.');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity3']), 'config_test.dynamic.entity3 has a dependency on the content entity (via entity2).');
$this
->assertTrue(isset($dependents['config_test.dynamic.entity4']), 'config_test.dynamic.entity4 has a dependency on the content entity (via entity3).');
$alt_storage = $this->container
->get('entity_type.manager')
->getStorage('config_query_test');
$alt_storage
->create([
'id' => 'entity1',
'dependencies' => [
'enforced' => [
'config' => [
$entity1
->getConfigDependencyName(),
],
],
],
])
->save();
$alt_storage
->create([
'id' => 'entity2',
'dependencies' => [
'enforced' => [
'module' => [
'views',
],
],
],
])
->save();
$dependents = $config_manager
->findConfigEntityDependentsAsEntities('config', [
$entity1
->getConfigDependencyName(),
]);
$dependent_ids = $this
->getDependentIds($dependents);
$this
->assertNotContains('config_test:entity1', $dependent_ids, 'config_test.dynamic.entity1 does not have a dependency on itself.');
$this
->assertContains('config_test:entity2', $dependent_ids, 'config_test.dynamic.entity2 has a dependency on config_test.dynamic.entity1.');
$this
->assertContains('config_test:entity3', $dependent_ids, 'config_test.dynamic.entity3 has a dependency on config_test.dynamic.entity1.');
$this
->assertContains('config_test:entity4', $dependent_ids, 'config_test.dynamic.entity4 has a dependency on config_test.dynamic.entity1.');
$this
->assertContains('config_query_test:entity1', $dependent_ids, 'config_query_test.dynamic.entity1 has a dependency on config_test.dynamic.entity1.');
$this
->assertNotContains('config_query_test:entity2', $dependent_ids, 'config_query_test.dynamic.entity2 does not have a dependency on config_test.dynamic.entity1.');
$dependents = $config_manager
->findConfigEntityDependentsAsEntities('module', [
'node',
'views',
]);
$dependent_ids = $this
->getDependentIds($dependents);
$this
->assertNotContains('config_test:entity1', $dependent_ids, 'config_test.dynamic.entity1 does not have a dependency on Views or Node.');
$this
->assertNotContains('config_test:entity2', $dependent_ids, 'config_test.dynamic.entity2 does not have a dependency on Views or Node.');
$this
->assertContains('config_test:entity3', $dependent_ids, 'config_test.dynamic.entity3 has a dependency on Views or Node.');
$this
->assertContains('config_test:entity4', $dependent_ids, 'config_test.dynamic.entity4 has a dependency on Views or Node.');
$this
->assertNotContains('config_query_test:entity1', $dependent_ids, 'config_test.query.entity1 does not have a dependency on Views or Node.');
$this
->assertContains('config_query_test:entity2', $dependent_ids, 'config_test.query.entity2 has a dependency on Views or Node.');
$dependents = $config_manager
->findConfigEntityDependentsAsEntities('module', [
'config_test',
]);
$dependent_ids = $this
->getDependentIds($dependents);
$this
->assertContains('config_test:entity1', $dependent_ids, 'config_test.dynamic.entity1 has a dependency on config_test module.');
$this
->assertContains('config_test:entity2', $dependent_ids, 'config_test.dynamic.entity2 has a dependency on config_test module.');
$this
->assertContains('config_test:entity3', $dependent_ids, 'config_test.dynamic.entity3 has a dependency on config_test module.');
$this
->assertContains('config_test:entity4', $dependent_ids, 'config_test.dynamic.entity4 has a dependency on config_test module.');
$this
->assertContains('config_query_test:entity1', $dependent_ids, 'config_test.query.entity1 has a dependency on config_test module.');
$this
->assertContains('config_query_test:entity2', $dependent_ids, 'config_test.query.entity2 has a dependency on config_test module.');
$missing_dependencies = $config_manager
->findMissingContentDependencies();
$this
->assertEqual([], $missing_dependencies);
$expected = [
$entity_test
->uuid() => [
'entity_type' => 'entity_test',
'bundle' => $entity_test
->bundle(),
'uuid' => $entity_test
->uuid(),
],
];
$entity_test
->delete();
$missing_dependencies = $config_manager
->findMissingContentDependencies();
$this
->assertEqual($expected, $missing_dependencies);
$entity1
->setEnforcedDependencies([
'content' => [
$entity_test
->getConfigDependencyName(),
'entity_test:bundle:uuid',
],
])
->save();
$expected['uuid'] = [
'entity_type' => 'entity_test',
'bundle' => 'bundle',
'uuid' => 'uuid',
];
$missing_dependencies = $config_manager
->findMissingContentDependencies();
$this
->assertEqual($expected, $missing_dependencies);
}
public function testConfigEntityUninstall() {
$config_manager = \Drupal::service('config.manager');
$storage = $this->container
->get('entity_type.manager')
->getStorage('config_test');
$entity1 = $storage
->create([
'id' => 'entity1',
'dependencies' => [
'enforced' => [
'module' => [
'node',
'config_test',
],
],
],
]);
$entity1
->save();
$entity2 = $storage
->create([
'id' => 'entity2',
'dependencies' => [
'enforced' => [
'config' => [
$entity1
->getConfigDependencyName(),
],
],
],
]);
$entity2
->save();
$config_manager
->uninstall('module', 'node');
$this
->assertNull($storage
->load('entity1'), 'Entity 1 deleted');
$this
->assertNull($storage
->load('entity2'), 'Entity 2 deleted');
}
public function providerConfigEntityUninstallComplex() {
return [
[
[
'a',
'b',
'c',
'd',
'e',
],
],
[
[
'e',
'd',
'c',
'b',
'a',
],
],
[
[
'e',
'c',
'd',
'a',
'b',
],
],
];
}
public function testConfigEntityUninstallComplex(array $entity_id_suffixes) {
$config_manager = \Drupal::service('config.manager');
$storage = $this->container
->get('entity_type.manager')
->getStorage('config_test');
$entity_1 = $storage
->create([
'id' => 'entity_' . $entity_id_suffixes[0],
'dependencies' => [
'enforced' => [
'module' => [
'node',
'config_test',
],
],
],
]);
$entity_1
->save();
$entity_2 = $storage
->create([
'id' => 'entity_' . $entity_id_suffixes[1],
'dependencies' => [
'enforced' => [
'config' => [
$entity_1
->getConfigDependencyName(),
],
],
],
]);
$entity_2
->save();
$entity_3 = $storage
->create([
'id' => 'entity_' . $entity_id_suffixes[2],
'dependencies' => [
'enforced' => [
'config' => [
$entity_2
->getConfigDependencyName(),
],
],
],
]);
$entity_3
->save();
$entity_4 = $storage
->create([
'id' => 'entity_' . $entity_id_suffixes[3],
'dependencies' => [
'enforced' => [
'config' => [
$entity_1
->getConfigDependencyName(),
],
'module' => [
'node',
'config_test',
],
],
],
]);
$entity_4
->save();
$entity_5 = $storage
->create([
'id' => 'entity_' . $entity_id_suffixes[4],
'dependencies' => [
'enforced' => [
'config' => [
$entity_1
->getConfigDependencyName(),
$entity_3
->getConfigDependencyName(),
],
],
],
]);
$entity_5
->save();
\Drupal::state()
->set('config_test.fix_dependencies', [
$entity_1
->getConfigDependencyName(),
]);
\Drupal::state()
->set('config_test.on_dependency_removal_called', []);
$config_entities = $config_manager
->getConfigEntitiesToChangeOnDependencyRemoval('module', [
'node',
]);
$called = \Drupal::state()
->get('config_test.on_dependency_removal_called', []);
$this
->assertArrayNotHasKey($entity_3
->id(), $called, 'ConfigEntityInterface::onDependencyRemoval() is not called for entity 3.');
$this
->assertSame([
$entity_1
->id(),
$entity_4
->id(),
$entity_2
->id(),
$entity_5
->id(),
], array_keys($called), 'The most dependent entites have ConfigEntityInterface::onDependencyRemoval() called first.');
$this
->assertSame([
'config' => [],
'content' => [],
'module' => [
'node',
],
'theme' => [],
], $called[$entity_1
->id()]);
$this
->assertSame([
'config' => [
$entity_1
->getConfigDependencyName(),
],
'content' => [],
'module' => [],
'theme' => [],
], $called[$entity_2
->id()]);
$this
->assertSame([
'config' => [
$entity_1
->getConfigDependencyName(),
],
'content' => [],
'module' => [
'node',
],
'theme' => [],
], $called[$entity_4
->id()]);
$this
->assertSame([
'config' => [
$entity_1
->getConfigDependencyName(),
],
'content' => [],
'module' => [],
'theme' => [],
], $called[$entity_5
->id()]);
$this
->assertEqual($entity_1
->uuid(), $config_entities['delete'][1]
->uuid(), 'Entity 1 will be deleted.');
$this
->assertEqual($entity_2
->uuid(), $config_entities['update'][0]
->uuid(), 'Entity 2 will be updated.');
$this
->assertEqual($entity_3
->uuid(), reset($config_entities['unchanged'])
->uuid(), 'Entity 3 is not changed.');
$this
->assertEqual($entity_4
->uuid(), $config_entities['delete'][0]
->uuid(), 'Entity 4 will be deleted.');
$this
->assertEqual($entity_5
->uuid(), $config_entities['update'][1]
->uuid(), 'Entity 5 is updated.');
$config_manager
->uninstall('module', 'node');
$this
->assertNull($storage
->load($entity_1
->id()), 'Entity 1 deleted');
$entity_2 = $storage
->load($entity_2
->id());
$this
->assertNotEmpty($entity_2, 'Entity 2 not deleted');
$this
->assertEqual($entity_2
->calculateDependencies()
->getDependencies()['config'], [], 'Entity 2 dependencies updated to remove dependency on entity 1.');
$entity_3 = $storage
->load($entity_3
->id());
$this
->assertNotEmpty($entity_3, 'Entity 3 not deleted');
$this
->assertEqual($entity_3
->calculateDependencies()
->getDependencies()['config'], [
$entity_2
->getConfigDependencyName(),
], 'Entity 3 still depends on entity 2.');
$this
->assertNull($storage
->load($entity_4
->id()), 'Entity 4 deleted');
}
public function testConfigEntityUninstallThirdParty() {
$config_manager = \Drupal::service('config.manager');
$storage = $this->container
->get('entity_type.manager')
->getStorage('config_test');
$entity_1 = $storage
->create([
'id' => 'entity_1',
'dependencies' => [
'enforced' => [
'module' => [
'config_test',
],
],
],
'third_party_settings' => [
'node' => [
'foo' => 'bar',
],
],
]);
$entity_1
->save();
$entity_2 = $storage
->create([
'id' => 'entity_2',
'dependencies' => [
'enforced' => [
'config' => [
$entity_1
->getConfigDependencyName(),
],
],
],
'third_party_settings' => [
'node' => [
'foo' => 'bar',
],
],
]);
$entity_2
->save();
$entity_3 = $storage
->create([
'id' => 'entity_3',
'dependencies' => [
'enforced' => [
'config' => [
$entity_2
->getConfigDependencyName(),
],
],
],
]);
$entity_3
->save();
$entity_4 = $storage
->create([
'id' => 'entity_4',
'dependencies' => [
'enforced' => [
'config' => [
$entity_1
->getConfigDependencyName(),
],
'module' => [
'node',
'config_test',
],
],
],
]);
$entity_4
->save();
\Drupal::state()
->set('config_test.fix_dependencies', []);
\Drupal::state()
->set('config_test.on_dependency_removal_called', []);
$config_entities = $config_manager
->getConfigEntitiesToChangeOnDependencyRemoval('module', [
'node',
]);
$config_entity_ids = [
'update' => [],
'delete' => [],
'unchanged' => [],
];
foreach ($config_entities as $type => $config_entities_by_type) {
foreach ($config_entities_by_type as $config_entity) {
$config_entity_ids[$type][] = $config_entity
->id();
}
}
$expected = [
'update' => [
$entity_1
->id(),
$entity_2
->id(),
],
'delete' => [
$entity_4
->id(),
],
'unchanged' => [
$entity_3
->id(),
],
];
$this
->assertSame($expected, $config_entity_ids);
$called = \Drupal::state()
->get('config_test.on_dependency_removal_called', []);
$this
->assertArrayNotHasKey($entity_3
->id(), $called, 'ConfigEntityInterface::onDependencyRemoval() is not called for entity 3.');
$this
->assertSame([
$entity_1
->id(),
$entity_4
->id(),
$entity_2
->id(),
], array_keys($called), 'The most dependent entities have ConfigEntityInterface::onDependencyRemoval() called first.');
$this
->assertSame([
'config' => [],
'content' => [],
'module' => [
'node',
],
'theme' => [],
], $called[$entity_1
->id()]);
$this
->assertSame([
'config' => [],
'content' => [],
'module' => [
'node',
],
'theme' => [],
], $called[$entity_2
->id()]);
$this
->assertSame([
'config' => [],
'content' => [],
'module' => [
'node',
],
'theme' => [],
], $called[$entity_4
->id()]);
$config_manager
->uninstall('module', 'node');
$entity_1 = $storage
->load($entity_1
->id());
$this
->assertNotEmpty($entity_1, 'Entity 1 not deleted');
$this
->assertSame($entity_1
->getThirdPartySettings('node'), [], 'Entity 1 third party settings updated.');
$entity_2 = $storage
->load($entity_2
->id());
$this
->assertNotEmpty($entity_2, 'Entity 2 not deleted');
$this
->assertSame($entity_2
->getThirdPartySettings('node'), [], 'Entity 2 third party settings updated.');
$this
->assertSame($entity_2
->calculateDependencies()
->getDependencies()['config'], [
$entity_1
->getConfigDependencyName(),
], 'Entity 2 still depends on entity 1.');
$entity_3 = $storage
->load($entity_3
->id());
$this
->assertNotEmpty($entity_3, 'Entity 3 not deleted');
$this
->assertSame($entity_3
->calculateDependencies()
->getDependencies()['config'], [
$entity_2
->getConfigDependencyName(),
], 'Entity 3 still depends on entity 2.');
$this
->assertNull($storage
->load($entity_4
->id()), 'Entity 4 deleted');
}
public function testConfigEntityDelete() {
$config_manager = \Drupal::service('config.manager');
$storage = $this->container
->get('entity_type.manager')
->getStorage('config_test');
$entity1 = $storage
->create([
'id' => 'entity1',
]);
$entity1
->save();
$entity2 = $storage
->create([
'id' => 'entity2',
'dependencies' => [
'enforced' => [
'config' => [
$entity1
->getConfigDependencyName(),
],
],
],
]);
$entity2
->save();
$config_entities = $config_manager
->getConfigEntitiesToChangeOnDependencyRemoval('config', [
$entity1
->getConfigDependencyName(),
]);
$this
->assertEqual($entity2
->uuid(), reset($config_entities['delete'])
->uuid(), 'Entity 2 will be deleted.');
$this
->assertTrue(empty($config_entities['update']), 'No dependent configuration entities will be updated.');
$this
->assertTrue(empty($config_entities['unchanged']), 'No dependent configuration entities will be unchanged.');
$entity1
->delete();
$this
->assertNull($storage
->load('entity1'), 'Entity 1 deleted');
$this
->assertNull($storage
->load('entity2'), 'Entity 2 deleted');
\Drupal::state()
->set('config_test.fix_dependencies', [
$entity1
->getConfigDependencyName(),
]);
$entity1 = $storage
->create([
'id' => 'entity1',
]);
$entity1
->save();
$entity2 = $storage
->create([
'id' => 'entity2',
'dependencies' => [
'enforced' => [
'config' => [
$entity1
->getConfigDependencyName(),
],
],
],
]);
$entity2
->save();
$entity3 = $storage
->create([
'id' => 'entity3',
'dependencies' => [
'enforced' => [
'config' => [
$entity2
->getConfigDependencyName(),
],
],
],
]);
$entity3
->save();
$config_entities = $config_manager
->getConfigEntitiesToChangeOnDependencyRemoval('config', [
$entity1
->getConfigDependencyName(),
]);
$this
->assertTrue(empty($config_entities['delete']), 'No dependent configuration entities will be deleted.');
$this
->assertEqual($entity2
->uuid(), reset($config_entities['update'])
->uuid(), 'Entity 2 will be updated.');
$this
->assertEqual($entity3
->uuid(), reset($config_entities['unchanged'])
->uuid(), 'Entity 3 is not changed.');
$entity1
->delete();
$this
->assertNull($storage
->load('entity1'), 'Entity 1 deleted');
$entity2 = $storage
->load('entity2');
$this
->assertNotEmpty($entity2, 'Entity 2 not deleted');
$this
->assertEqual($entity2
->calculateDependencies()
->getDependencies()['config'], [], 'Entity 2 dependencies updated to remove dependency on Entity1.');
$entity3 = $storage
->load('entity3');
$this
->assertNotEmpty($entity3, 'Entity 3 not deleted');
$this
->assertEqual($entity3
->calculateDependencies()
->getDependencies()['config'], [
$entity2
->getConfigDependencyName(),
], 'Entity 3 still depends on Entity 2.');
}
public function testContentEntityDelete() {
$this
->installEntitySchema('entity_test');
$config_manager = \Drupal::service('config.manager');
$content_entity = EntityTest::create();
$content_entity
->save();
$storage = $this->container
->get('entity_type.manager')
->getStorage('config_test');
$entity1 = $storage
->create([
'id' => 'entity1',
'dependencies' => [
'enforced' => [
'content' => [
$content_entity
->getConfigDependencyName(),
],
],
],
]);
$entity1
->save();
$entity2 = $storage
->create([
'id' => 'entity2',
'dependencies' => [
'enforced' => [
'config' => [
$entity1
->getConfigDependencyName(),
],
],
],
]);
$entity2
->save();
$entity3 = $storage
->create([
'id' => 'entity3',
]);
$entity3
->save();
$config_entities = $config_manager
->getConfigEntitiesToChangeOnDependencyRemoval('content', [
$content_entity
->getConfigDependencyName(),
]);
$this
->assertEqual($entity1
->uuid(), $config_entities['delete'][1]
->uuid(), 'Entity 1 will be deleted.');
$this
->assertEqual($entity2
->uuid(), $config_entities['delete'][0]
->uuid(), 'Entity 2 will be deleted.');
$this
->assertTrue(empty($config_entities['update']), 'No dependencies of the content entity will be updated.');
$this
->assertTrue(empty($config_entities['unchanged']), 'No dependencies of the content entity will be unchanged.');
}
protected function getDependentIds(array $dependents) {
$dependent_ids = [];
foreach ($dependents as $dependent) {
$dependent_ids[] = $dependent
->getEntityTypeId() . ':' . $dependent
->id();
}
return $dependent_ids;
}
}