core/modules/migrate_drupal/tests/src/Kernel/Plugin/migrate/source/ContentEntityTest.php
View source
<?php
namespace Drupal\Tests\migrate_drupal\Kernel\Plugin\migrate\source;
use Drupal\Component\Plugin\Exception\InvalidPluginDefinitionException;
use Drupal\Component\Plugin\PluginBase;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\Core\Language\LanguageInterface;
use Drupal\file\Entity\File;
use Drupal\KernelTests\KernelTestBase;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\media\Entity\Media;
use Drupal\migrate\Plugin\MigrateSourceInterface;
use Drupal\migrate\Plugin\MigrationInterface;
use Drupal\migrate_drupal\Plugin\migrate\source\ContentEntity;
use Drupal\node\Entity\Node;
use Drupal\node\Entity\NodeType;
use Drupal\taxonomy\Entity\Term;
use Drupal\taxonomy\Entity\Vocabulary;
use Drupal\Tests\field\Traits\EntityReferenceTestTrait;
use Drupal\Tests\media\Traits\MediaTypeCreationTrait;
use Drupal\user\Entity\User;
class ContentEntityTest extends KernelTestBase {
use EntityReferenceTestTrait;
use MediaTypeCreationTrait;
public static $modules = [
'user',
'migrate',
'migrate_drupal',
'system',
'node',
'taxonomy',
'field',
'file',
'image',
'media',
'media_test_source',
'text',
'filter',
'language',
'content_translation',
];
protected $bundle = 'article';
protected $fieldName = 'field_entity_reference';
protected $vocabulary = 'fruit';
protected $user;
protected $migrationPluginManager;
protected function setUp() {
parent::setUp();
$this
->installEntitySchema('node');
$this
->installEntitySchema('file');
$this
->installEntitySchema('media');
$this
->installEntitySchema('taxonomy_term');
$this
->installEntitySchema('taxonomy_vocabulary');
$this
->installEntitySchema('user');
$this
->installSchema('system', [
'sequences',
]);
$this
->installSchema('user', 'users_data');
$this
->installSchema('file', 'file_usage');
$this
->installSchema('node', [
'node_access',
]);
$this
->installConfig($this->modules);
ConfigurableLanguage::createFromLangcode('fr')
->save();
$node_type = NodeType::create([
'type' => $this->bundle,
'name' => 'Article',
]);
$node_type
->save();
$vocabulary = Vocabulary::create([
'name' => $this->vocabulary,
'description' => $this->vocabulary,
'vid' => $this->vocabulary,
'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
]);
$vocabulary
->save();
$this
->createEntityReferenceField('node', $this->bundle, $this->fieldName, 'Term reference', 'taxonomy_term', 'default', [
'target_bundles' => [
$this->vocabulary,
],
], FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
$this
->createEntityReferenceField('user', 'user', $this->fieldName, 'Term reference', 'taxonomy_term', 'default', [
'target_bundles' => [
$this->vocabulary,
],
], FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
$this->user = User::create([
'name' => 'user123',
'uid' => 1,
'mail' => 'example@example.com',
]);
$this->user
->save();
$term = Term::create([
'vid' => $this->vocabulary,
'name' => 'Apples',
'uid' => $this->user
->id(),
]);
$term
->save();
$this->user
->set($this->fieldName, $term
->id());
$this->user
->save();
$node = Node::create([
'type' => $this->bundle,
'title' => 'Apples',
$this->fieldName => $term
->id(),
'uid' => $this->user
->id(),
]);
$node
->save();
$node
->addTranslation('fr', [
'title' => 'Pommes',
$this->fieldName => $term
->id(),
])
->save();
$this->migrationPluginManager = $this->container
->get('plugin.manager.migration');
}
public function testConstructorEntityTypeMissing() {
$migration = $this
->prophesize(MigrationInterface::class)
->reveal();
$configuration = [];
$plugin_definition = [
'entity_type' => '',
];
$this
->expectException(InvalidPluginDefinitionException::class);
$this
->expectExceptionMessage('Missing required "entity_type" definition.');
ContentEntity::create($this->container, $configuration, 'content_entity', $plugin_definition, $migration);
}
public function testConstructorNonContentEntity() {
$migration = $this
->prophesize(MigrationInterface::class)
->reveal();
$configuration = [];
$plugin_definition = [
'entity_type' => 'node_type',
];
$this
->expectException(InvalidPluginDefinitionException::class);
$this
->expectExceptionMessage('The entity type (node_type) is not supported. The "content_entity" source plugin only supports content entities.');
ContentEntity::create($this->container, $configuration, 'content_entity:node_type', $plugin_definition, $migration);
}
public function testConstructorNotBundable() {
$migration = $this
->prophesize(MigrationInterface::class)
->reveal();
$configuration = [
'bundle' => 'foo',
];
$plugin_definition = [
'entity_type' => 'user',
];
$this
->expectException(\InvalidArgumentException::class);
$this
->expectExceptionMessage('A bundle was provided but the entity type (user) is not bundleable');
ContentEntity::create($this->container, $configuration, 'content_entity:user', $plugin_definition, $migration);
}
public function testConstructorInvalidBundle() {
$migration = $this
->prophesize(MigrationInterface::class)
->reveal();
$configuration = [
'bundle' => 'foo',
];
$plugin_definition = [
'entity_type' => 'node',
];
$this
->expectException(\InvalidArgumentException::class);
$this
->expectExceptionMessage('The provided bundle (foo) is not valid for the (node) entity type.');
ContentEntity::create($this->container, $configuration, 'content_entity:node', $plugin_definition, $migration);
}
protected function assertIds(MigrateSourceInterface $source, array $configuration) {
$ids = $source
->getIds();
list(, $entity_type_id) = explode(PluginBase::DERIVATIVE_SEPARATOR, $source
->getPluginId());
$entity_type = \Drupal::entityTypeManager()
->getDefinition($entity_type_id);
$this
->assertArrayHasKey($entity_type
->getKey('id'), $ids);
$ids_count_expected = 1;
if ($entity_type
->isTranslatable()) {
$ids_count_expected++;
$this
->assertArrayHasKey($entity_type
->getKey('langcode'), $ids);
}
if ($entity_type
->isRevisionable() && $configuration['add_revision_id']) {
$ids_count_expected++;
$this
->assertArrayHasKey($entity_type
->getKey('revision'), $ids);
}
$this
->assertCount($ids_count_expected, $ids);
}
public function testUserSource(array $configuration) {
$migration = $this->migrationPluginManager
->createStubMigration($this
->migrationDefinition('content_entity:user', $configuration));
$user_source = $migration
->getSourcePlugin();
$this
->assertSame('users', $user_source
->__toString());
if (!$configuration['include_translations']) {
$this
->assertEquals(1, $user_source
->count());
}
$this
->assertIds($user_source, $configuration);
$fields = $user_source
->fields();
$this
->assertArrayHasKey('name', $fields);
$this
->assertArrayHasKey('pass', $fields);
$this
->assertArrayHasKey('mail', $fields);
$this
->assertArrayHasKey('uid', $fields);
$this
->assertArrayHasKey('roles', $fields);
$user_source
->rewind();
$values = $user_source
->current()
->getSource();
$this
->assertEquals('example@example.com', $values['mail'][0]['value']);
$this
->assertEquals('user123', $values['name'][0]['value']);
$this
->assertEquals(1, $values['uid']);
$this
->assertEquals(1, $values['field_entity_reference'][0]['target_id']);
}
public function testFileSource(array $configuration) {
$file = File::create([
'filename' => 'foo.txt',
'uid' => $this->user
->id(),
'uri' => 'public://foo.txt',
]);
$file
->save();
$migration = $this->migrationPluginManager
->createStubMigration($this
->migrationDefinition('content_entity:file', $configuration));
$file_source = $migration
->getSourcePlugin();
$this
->assertSame('files', $file_source
->__toString());
if (!$configuration['include_translations']) {
$this
->assertEquals(1, $file_source
->count());
}
$this
->assertIds($file_source, $configuration);
$fields = $file_source
->fields();
$this
->assertArrayHasKey('fid', $fields);
$this
->assertArrayHasKey('filemime', $fields);
$this
->assertArrayHasKey('filename', $fields);
$this
->assertArrayHasKey('uid', $fields);
$this
->assertArrayHasKey('uri', $fields);
$file_source
->rewind();
$values = $file_source
->current()
->getSource();
$this
->assertEquals('text/plain', $values['filemime'][0]['value']);
$this
->assertEquals('public://foo.txt', $values['uri'][0]['value']);
$this
->assertEquals('foo.txt', $values['filename'][0]['value']);
$this
->assertEquals(1, $values['fid']);
}
public function testNodeSource(array $configuration) {
$configuration += [
'bundle' => $this->bundle,
];
$migration = $this->migrationPluginManager
->createStubMigration($this
->migrationDefinition('content_entity:node', $configuration));
$node_source = $migration
->getSourcePlugin();
$this
->assertSame('content items', $node_source
->__toString());
$this
->assertIds($node_source, $configuration);
$fields = $node_source
->fields();
$this
->assertArrayHasKey('nid', $fields);
$this
->assertArrayHasKey('vid', $fields);
$this
->assertArrayHasKey('title', $fields);
$this
->assertArrayHasKey('uid', $fields);
$this
->assertArrayHasKey('sticky', $fields);
$node_source
->rewind();
$values = $node_source
->current()
->getSource();
$this
->assertEquals($this->bundle, $values['type'][0]['target_id']);
$this
->assertEquals(1, $values['nid']);
if ($configuration['add_revision_id']) {
$this
->assertEquals(1, $values['vid']);
}
else {
$this
->assertEquals([
[
'value' => '1',
],
], $values['vid']);
}
$this
->assertEquals('en', $values['langcode']);
$this
->assertEquals(1, $values['status'][0]['value']);
$this
->assertEquals('Apples', $values['title'][0]['value']);
$this
->assertEquals(1, $values['default_langcode'][0]['value']);
$this
->assertEquals(1, $values['field_entity_reference'][0]['target_id']);
if ($configuration['include_translations']) {
$node_source
->next();
$values = $node_source
->current()
->getSource();
$this
->assertEquals($this->bundle, $values['type'][0]['target_id']);
$this
->assertEquals(1, $values['nid']);
if ($configuration['add_revision_id']) {
$this
->assertEquals(1, $values['vid']);
}
else {
$this
->assertEquals([
0 => [
'value' => 1,
],
], $values['vid']);
}
$this
->assertEquals('fr', $values['langcode']);
$this
->assertEquals(1, $values['status'][0]['value']);
$this
->assertEquals('Pommes', $values['title'][0]['value']);
$this
->assertEquals(0, $values['default_langcode'][0]['value']);
$this
->assertEquals(1, $values['field_entity_reference'][0]['target_id']);
}
}
public function testMediaSource(array $configuration) {
$values = [
'id' => 'image',
'label' => 'Image',
'source' => 'test',
'new_revision' => FALSE,
];
$media_type = $this
->createMediaType('test', $values);
$media = Media::create([
'name' => 'Foo media',
'uid' => $this->user
->id(),
'bundle' => $media_type
->id(),
]);
$media
->save();
$configuration += [
'bundle' => 'image',
];
$migration = $this->migrationPluginManager
->createStubMigration($this
->migrationDefinition('content_entity:media', $configuration));
$media_source = $migration
->getSourcePlugin();
$this
->assertSame('media items', $media_source
->__toString());
if (!$configuration['include_translations']) {
$this
->assertEquals(1, $media_source
->count());
}
$this
->assertIds($media_source, $configuration);
$fields = $media_source
->fields();
$this
->assertArrayHasKey('bundle', $fields);
$this
->assertArrayHasKey('mid', $fields);
$this
->assertArrayHasKey('vid', $fields);
$this
->assertArrayHasKey('name', $fields);
$this
->assertArrayHasKey('status', $fields);
$media_source
->rewind();
$values = $media_source
->current()
->getSource();
$this
->assertEquals(1, $values['mid']);
if ($configuration['add_revision_id']) {
$this
->assertEquals(1, $values['vid']);
}
else {
$this
->assertEquals([
[
'value' => 1,
],
], $values['vid']);
}
$this
->assertEquals('Foo media', $values['name'][0]['value']);
$this
->assertNull($values['thumbnail'][0]['title']);
$this
->assertEquals(1, $values['uid'][0]['target_id']);
$this
->assertEquals('image', $values['bundle'][0]['target_id']);
}
public function testTermSource(array $configuration) {
$term2 = Term::create([
'vid' => $this->vocabulary,
'name' => 'Granny Smith',
'uid' => $this->user
->id(),
'parent' => 1,
]);
$term2
->save();
$configuration += [
'bundle' => $this->vocabulary,
];
$migration = $this->migrationPluginManager
->createStubMigration($this
->migrationDefinition('content_entity:taxonomy_term', $configuration));
$term_source = $migration
->getSourcePlugin();
$this
->assertSame('taxonomy terms', $term_source
->__toString());
if (!$configuration['include_translations']) {
$this
->assertEquals(2, $term_source
->count());
}
$this
->assertIds($term_source, $configuration);
$fields = $term_source
->fields();
$this
->assertArrayHasKey('vid', $fields);
$this
->assertArrayHasKey('revision_id', $fields);
$this
->assertArrayHasKey('tid', $fields);
$this
->assertArrayHasKey('name', $fields);
$term_source
->rewind();
$values = $term_source
->current()
->getSource();
$this
->assertEquals($this->vocabulary, $values['vid'][0]['target_id']);
$this
->assertEquals(1, $values['tid']);
$this
->assertEquals('Apples', $values['name'][0]['value']);
$term_source
->next();
$values = $term_source
->current()
->getSource();
$this
->assertEquals($this->vocabulary, $values['vid'][0]['target_id']);
$this
->assertEquals(2, $values['tid']);
$this
->assertEquals('Granny Smith', $values['name'][0]['value']);
}
public function migrationConfigurationProvider() {
$data = [];
foreach ([
FALSE,
TRUE,
] as $include_translations) {
foreach ([
FALSE,
TRUE,
] as $add_revision_id) {
$configuration = [
'include_translations' => $include_translations,
'add_revision_id' => $add_revision_id,
];
$data[http_build_query($configuration)] = [
$configuration,
];
}
}
return $data;
}
protected function migrationDefinition($plugin_id, array $configuration = []) {
return [
'source' => [
'plugin' => $plugin_id,
] + $configuration,
'process' => [],
'destination' => [
'plugin' => 'null',
],
];
}
}