updated core and modules

core/modules/migrate/tests/modules/migrate_entity_test/migrate_entity_test.info.yml

@@ -0,0 +1,12 @@
+name: 'Migrate entity test'
+type: module
+description: 'Support module for entity destination test.'
+package: Testing
+# version: VERSION
+# core: 8.x
+
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
+core: '8.x'
+project: 'drupal'
+datestamp: 1502903957

core/modules/migrate/tests/modules/migrate_entity_test/src/Entity/StringIdEntityTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\migrate_entity_test\Entity;
+
+use Drupal\Core\Entity\ContentEntityBase;
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\Core\Field\BaseFieldDefinition;
+
+/**
+ * Defines a content entity type that has a string ID.
+ *
+ * @ContentEntityType(
+ *   id = "migrate_string_id_entity_test",
+ *   label = @Translation("String id entity test"),
+ *   base_table = "migrate_entity_test_string_id",
+ *   entity_keys = {
+ *     "id" = "id",
+ *   }
+ * )
+ */
+class StringIdEntityTest extends ContentEntityBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
+    return [
+      'id' => BaseFieldDefinition::create('integer')
+        ->setSetting('size', 'big')
+        ->setLabel('ID'),
+      'version' => BaseFieldDefinition::create('string')
+        ->setLabel('Version'),
+    ];
+  }
+
+}

core/modules/migrate/tests/modules/migrate_events_test/migrate_events_test.info.yml

@@ -4,8 +4,8 @@ package: Testing
 # version: VERSION
 # core: 8.x
 
-# Information added by Drupal.org packaging script on 2016-08-03
-version: '8.1.8'
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
 core: '8.x'
 project: 'drupal'
-datestamp: 1470233791
+datestamp: 1502903957

core/modules/migrate/tests/modules/migrate_events_test/src/Plugin/migrate/destination/DummyDestination.php

@@ -32,7 +32,7 @@ class DummyDestination extends DestinationBase {
   /**
    * {@inheritdoc}
    */
-  public function import(Row $row, array $old_destination_id_values = array()) {
+  public function import(Row $row, array $old_destination_id_values = []) {
     return ['value' => $row->getDestinationProperty('value')];
   }
 

core/modules/migrate/tests/modules/migrate_external_translated_test/migrate_external_translated_test.info.yml

@@ -7,8 +7,8 @@ dependencies:
   - node
   - migrate
 
-# Information added by Drupal.org packaging script on 2016-08-03
-version: '8.1.8'
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
 core: '8.x'
 project: 'drupal'
-datestamp: 1470233791
+datestamp: 1502903957

core/modules/migrate/tests/modules/migrate_external_translated_test/migrations/migrate.migration.external_translated_test_node_translation.yml

@@ -7,7 +7,7 @@ source:
     type: external_test
 process:
   nid:
-    plugin: migration
+    plugin: migration_lookup
     source: name
     migration: external_translated_test_node
   type: constants/type

core/modules/migrate/tests/modules/migrate_high_water_test/config/install/node.type.sql_import_node.yml

@@ -0,0 +1,9 @@
+langcode: en
+status: true
+name: High Water import node
+type: high_water_import_node
+description: ''
+help: ''
+new_revision: false
+preview_mode: 1
+display_submitted: true

core/modules/migrate/tests/modules/migrate_high_water_test/migrate_high_water_test.info.yml

@@ -0,0 +1,13 @@
+type: module
+name: Migration High Water Test
+description: 'Provides test fixtures for testing high water marks.'
+package: Testing
+# core: 8.x
+dependencies:
+  - migrate
+
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
+core: '8.x'
+project: 'drupal'
+datestamp: 1502903957

core/modules/migrate/tests/modules/migrate_high_water_test/migration_templates/migrate.migration.high_water_test.yml

@@ -0,0 +1,16 @@
+id: high_water_test
+label: High water test.
+source:
+  plugin: high_water_test
+  high_water_property:
+    name: changed
+destination:
+  plugin: entity:node
+migration_tags:
+  test: test
+process:
+  changed: changed
+  title: title
+  type:
+    plugin: default_value
+    default_value: high_water_import_node

core/modules/migrate/tests/modules/migrate_high_water_test/src/Plugin/migrate/source/HighWaterTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Drupal\migrate_high_water_test\Plugin\migrate\source;
+
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+
+/**
+ * Source plugin for migration high water tests.
+ *
+ * @MigrateSource(
+ *   id = "high_water_test"
+ * )
+ */
+class HighWaterTest extends SqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $field_names = array_keys($this->fields());
+    $query = $this
+      ->select('high_water_node', 'm')
+      ->fields('m', $field_names);
+    foreach ($field_names as $field_name) {
+      $query->groupBy($field_name);
+    }
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'id' => $this->t('Id'),
+      'title' => $this->t('Title'),
+      'changed' => $this->t('Changed'),
+    ];
+
+    return $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    return [
+      'id' => [
+        'type' => 'integer',
+      ],
+    ];
+  }
+
+}

core/modules/migrate/tests/modules/migrate_prepare_row_test/migrate_prepare_row_test.info.yml

@@ -5,8 +5,8 @@ package: Testing
 # version: VERSION
 # core: 8.x
 
-# Information added by Drupal.org packaging script on 2016-08-03
-version: '8.1.8'
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
 core: '8.x'
 project: 'drupal'
-datestamp: 1470233791
+datestamp: 1502903957

core/modules/migrate/tests/modules/migrate_prepare_row_test/migrate_prepare_row_test.module

@@ -18,9 +18,11 @@ function migrate_prepare_row_test_migrate_prepare_row(Row $row, MigrateSourceInt
   // Test both options for save_to_map.
   $data = $row->getSourceProperty('data');
   if ($data == 'skip_and_record') {
+    // Record mapping but don't record a message.
     throw new MigrateSkipRowException('', TRUE);
   }
   elseif ($data == 'skip_and_dont_record') {
-    throw new MigrateSkipRowException('', FALSE);
+    // Don't record mapping but record a message.
+    throw new MigrateSkipRowException('skip_and_dont_record message', FALSE);
   }
 }

core/modules/migrate/tests/modules/migrate_prepare_row_test/src/Plugin/migrate/process/TestSkipRowProcess.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\migrate_prepare_row_test\Plugin\migrate\process;
+
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\MigrateSkipRowException;
+use Drupal\migrate\ProcessPluginBase;
+use Drupal\migrate\Row;
+
+/**
+ * Provides a testing process plugin that skips rows.
+ *
+ * @MigrateProcessPlugin(
+ *   id = "test_skip_row_process"
+ * )
+ */
+class TestSkipRowProcess extends ProcessPluginBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function transform($value, MigrateExecutableInterface $migrate_executable, Row $row, $destination_property) {
+    // Test both options for save_to_map.
+    $data = $row->getSourceProperty('data');
+    if ($data == 'skip_and_record (use plugin)') {
+      throw new MigrateSkipRowException('', TRUE);
+    }
+    elseif ($data == 'skip_and_dont_record (use plugin)') {
+      throw new MigrateSkipRowException('', FALSE);
+    }
+    return $value;
+  }
+
+}

core/modules/migrate/tests/modules/migrate_query_batch_test/migrate_query_batch_test.info.yml

@@ -0,0 +1,13 @@
+type: module
+name: Migrate query batch Source test
+description: 'Provides a database table and records for SQL import with batch testing.'
+package: Testing
+# core: 8.x
+dependencies:
+  - migrate
+
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
+core: '8.x'
+project: 'drupal'
+datestamp: 1502903957

core/modules/migrate/tests/modules/migrate_query_batch_test/src/Plugin/migrate/source/QueryBatchTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\migrate_query_batch_test\Plugin\migrate\source;
+
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+
+/**
+ * Source plugin for migration high water tests.
+ *
+ * @MigrateSource(
+ *   id = "query_batch_test"
+ * )
+ */
+class QueryBatchTest extends SqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    return ($this->select('query_batch_test', 'q')->fields('q'));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'id' => $this->t('Id'),
+      'data' => $this->t('data'),
+    ];
+    return $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    return [
+      'id' => [
+        'type' => 'integer',
+      ],
+    ];
+  }
+
+}

core/modules/migrate/tests/src/Functional/process/DownloadFunctionalTest.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Drupal\Tests\migrate\Functional\process;
+
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\MigrateMessage;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Tests the 'download' process plugin.
+ *
+ * @group migrate
+ */
+class DownloadFunctionalTest extends BrowserTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate', 'file'];
+
+  /**
+   * Tests that an exception is thrown bu migration continues with the next row.
+   */
+  public function testExceptionThrow() {
+    $invalid_url = "{$this->baseUrl}/not-existent-404";
+    $valid_url = "{$this->baseUrl}/core/misc/favicon.ico";
+
+    $definition = [
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => [
+          ['url' => $invalid_url, 'uri' => 'public://first.txt'],
+          ['url' => $valid_url, 'uri' => 'public://second.ico'],
+        ],
+        'ids' => [
+          'url' => ['type' => 'string'],
+        ],
+      ],
+      'process' => [
+        'uri' => [
+          'plugin' => 'download',
+          'source' => ['url', 'uri'],
+        ]
+      ],
+      'destination' => [
+        'plugin' => 'entity:file',
+      ],
+    ];
+
+    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($definition);
+
+    $executable = new MigrateExecutable($migration, new MigrateMessage());
+    $result = $executable->import();
+
+    // Check that the migration has completed.
+    $this->assertEquals($result, MigrationInterface::RESULT_COMPLETED);
+
+    /** @var \Drupal\migrate\Plugin\MigrateIdMapInterface $id_map_plugin */
+    $id_map_plugin = $migration->getIdMap();
+
+    // Check that the first row was marked as failed in the id map table.
+    $map_row = $id_map_plugin->getRowBySource(['url' => $invalid_url]);
+    $this->assertEquals(MigrateIdMapInterface::STATUS_FAILED, $map_row['source_row_status']);
+    $this->assertNull($map_row['destid1']);
+
+    // Check that a message with the thrown exception has been logged.
+    $messages = $id_map_plugin->getMessageIterator(['url' => $invalid_url])->fetchAll();
+    $this->assertCount(1, $messages);
+    $message = reset($messages);
+    $this->assertEquals("Cannot read from non-readable stream ($invalid_url)", $message->message);
+    $this->assertEquals(MigrationInterface::MESSAGE_ERROR, $message->level);
+
+    // Check that the second row was migrated successfully.
+    $map_row = $id_map_plugin->getRowBySource(['url' => $valid_url]);
+    $this->assertEquals(MigrateIdMapInterface::STATUS_IMPORTED, $map_row['source_row_status']);
+    $this->assertEquals(1, $map_row['destid1']);
+  }
+
+}

core/modules/migrate/tests/src/Kernel/HighWaterNotJoinableTest.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+/**
+ * Tests the high water handling.
+ *
+ * @covers \Drupal\migrate_high_water_test\Plugin\migrate\source\HighWaterTest
+ * @group migrate
+ */
+class HighWaterNotJoinableTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate', 'migrate_drupal', 'migrate_high_water_test'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // Test high water when the map is not joinable.
+    // The source data.
+    $tests[0]['source_data']['high_water_node'] = [
+      [
+        'id' => 1,
+        'title' => 'Item 1',
+        'changed' => 1,
+      ],
+      [
+        'id' => 2,
+        'title' => 'Item 2',
+        'changed' => 2,
+      ],
+      [
+        'id' => 3,
+        'title' => 'Item 3',
+        'changed' => 3,
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'id' => 2,
+        'title' => 'Item 2',
+        'changed' => 2,
+      ],
+      [
+        'id' => 3,
+        'title' => 'Item 3',
+        'changed' => 3,
+      ],
+    ];
+
+    // The expected count is the count returned by the query before the query
+    // is modified by SqlBase::initializeIterator().
+    $tests[0]['expected_count'] = 3;
+    $tests[0]['configuration'] = [
+      'high_water_property' => [
+        'name' => 'changed',
+      ],
+    ];
+    $tests[0]['high_water'] = $tests[0]['source_data']['high_water_node'][0]['changed'];
+
+    // Test high water initialized to NULL.
+    $tests[1]['source_data'] = $tests[0]['source_data'];
+    $tests[1]['expected_data'] = [
+      [
+        'id' => 1,
+        'title' => 'Item 1',
+        'changed' => 1,
+      ],
+      [
+        'id' => 2,
+        'title' => 'Item 2',
+        'changed' => 2,
+      ],
+      [
+        'id' => 3,
+        'title' => 'Item 3',
+        'changed' => 3,
+      ],
+    ];
+    $tests[1]['expected_count'] = $tests[0]['expected_count'];
+    $tests[1]['configuration'] = $tests[0]['configuration'];
+    $tests[1]['high_water'] = NULL;
+
+    // Test high water initialized to an empty string.
+    $tests[2]['source_data'] = $tests[0]['source_data'];
+    $tests[2]['expected_data'] = [
+      [
+        'id' => 1,
+        'title' => 'Item 1',
+        'changed' => 1,
+      ],
+      [
+        'id' => 2,
+        'title' => 'Item 2',
+        'changed' => 2,
+      ],
+      [
+        'id' => 3,
+        'title' => 'Item 3',
+        'changed' => 3,
+      ],
+    ];
+    $tests[2]['expected_count'] = $tests[0]['expected_count'];
+    $tests[2]['configuration'] = $tests[0]['configuration'];
+    $tests[2]['high_water'] = '';
+
+    return $tests;
+  }
+
+}

core/modules/migrate/tests/src/Kernel/HighWaterTest.php

@@ -0,0 +1,235 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+/**
+ * Tests migration high water property.
+ *
+ * @group migrate
+ */
+class HighWaterTest extends MigrateTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'system',
+    'user',
+    'node',
+    'migrate',
+    'migrate_high_water_test',
+    'field',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    // Create source test table.
+    $this->sourceDatabase->schema()->createTable('high_water_node', [
+      'fields' => [
+        'id' => [
+          'description' => 'Serial',
+          'type' => 'serial',
+          'unsigned' => TRUE,
+          'not null' => TRUE,
+        ],
+        'changed' => [
+          'description' => 'Highwater',
+          'type' => 'int',
+          'unsigned' => TRUE,
+        ],
+        'title' => [
+          'description' => 'Title',
+          'type' => 'varchar',
+          'length' => 128,
+          'not null' => TRUE,
+          'default' => '',
+        ],
+      ],
+      'primary key' => [
+        'id',
+      ],
+      'description' => 'Contains nodes to import',
+    ]);
+
+    // Add 3 items to source table.
+    $this->sourceDatabase->insert('high_water_node')
+      ->fields([
+        'title',
+        'changed',
+      ])
+      ->values([
+        'title' => 'Item 1',
+        'changed' => 1,
+      ])
+      ->values([
+        'title' => 'Item 2',
+        'changed' => 2,
+      ])
+      ->values([
+        'title' => 'Item 3',
+        'changed' => 3,
+      ])
+      ->execute();
+
+    $this->installEntitySchema('node');
+    $this->installEntitySchema('user');
+    $this->installSchema('node', 'node_access');
+
+    $this->executeMigration('high_water_test');
+  }
+
+  /**
+   * Tests high water property of SqlBase.
+   */
+  public function testHighWater() {
+    // Assert all of the nodes have been imported.
+    $this->assertNodeExists('Item 1');
+    $this->assertNodeExists('Item 2');
+    $this->assertNodeExists('Item 3');
+
+    // Update Item 1 setting its high_water_property to value that is below
+    // current high water mark.
+    $this->sourceDatabase->update('high_water_node')
+      ->fields([
+        'title' => 'Item 1 updated',
+        'changed' => 2,
+      ])
+      ->condition('title', 'Item 1')
+      ->execute();
+
+    // Update Item 2 setting its high_water_property to value equal to
+    // current high water mark.
+    $this->sourceDatabase->update('high_water_node')
+      ->fields([
+        'title' => 'Item 2 updated',
+        'changed' => 3,
+      ])
+      ->condition('title', 'Item 2')
+      ->execute();
+
+    // Update Item 3 setting its high_water_property to value that is above
+    // current high water mark.
+    $this->sourceDatabase->update('high_water_node')
+      ->fields([
+        'title' => 'Item 3 updated',
+        'changed' => 4,
+      ])
+      ->condition('title', 'Item 3')
+      ->execute();
+
+    // Execute migration again.
+    $this->executeMigration('high_water_test');
+
+    // Item with lower highwater should not be updated.
+    $this->assertNodeExists('Item 1');
+    $this->assertNodeDoesNotExist('Item 1 updated');
+
+    // Item with equal highwater should not be updated.
+    $this->assertNodeExists('Item 2');
+    $this->assertNodeDoesNotExist('Item 2 updated');
+
+    // Item with greater highwater should be updated.
+    $this->assertNodeExists('Item 3 updated');
+    $this->assertNodeDoesNotExist('Item 3');
+  }
+
+  /**
+   * Tests high water property of SqlBase when rows marked for update.
+   */
+  public function testHighWaterUpdate() {
+    // Assert all of the nodes have been imported.
+    $this->assertNodeExists('Item 1');
+    $this->assertNodeExists('Item 2');
+    $this->assertNodeExists('Item 3');
+
+    // Update Item 1 setting its high_water_property to value that is below
+    // current high water mark.
+    $this->sourceDatabase->update('high_water_node')
+      ->fields([
+        'title' => 'Item 1 updated',
+        'changed' => 2,
+      ])
+      ->condition('title', 'Item 1')
+      ->execute();
+
+    // Update Item 2 setting its high_water_property to value equal to
+    // current high water mark.
+    $this->sourceDatabase->update('high_water_node')
+      ->fields([
+        'title' => 'Item 2 updated',
+        'changed' => 3,
+      ])
+      ->condition('title', 'Item 2')
+      ->execute();
+
+    // Update Item 3 setting its high_water_property to value that is above
+    // current high water mark.
+    $this->sourceDatabase->update('high_water_node')
+      ->fields([
+        'title' => 'Item 3 updated',
+        'changed' => 4,
+      ])
+      ->condition('title', 'Item 3')
+      ->execute();
+
+    // Set all rows as needing an update.
+    $id_map = $this->getMigration('high_water_test')->getIdMap();
+    $id_map->prepareUpdate();
+
+    $this->executeMigration('high_water_test');
+
+    // Item with lower highwater should be updated.
+    $this->assertNodeExists('Item 1 updated');
+    $this->assertNodeDoesNotExist('Item 1');
+
+    // Item with equal highwater should be updated.
+    $this->assertNodeExists('Item 2 updated');
+    $this->assertNodeDoesNotExist('Item 2');
+
+    // Item with greater highwater should be updated.
+    $this->assertNodeExists('Item 3 updated');
+    $this->assertNodeDoesNotExist('Item 3');
+  }
+
+  /**
+   * Assert that node with given title exists.
+   *
+   * @param string $title
+   *   Title of the node.
+   */
+  protected function assertNodeExists($title) {
+    self::assertTrue($this->nodeExists($title));
+  }
+
+  /**
+   * Assert that node with given title does not exist.
+   *
+   * @param string $title
+   *   Title of the node.
+   */
+  protected function assertNodeDoesNotExist($title) {
+    self::assertFalse($this->nodeExists($title));
+  }
+
+  /**
+   * Checks if node with given title exists.
+   *
+   * @param string $title
+   *   Title of the node.
+   *
+   * @return bool
+   */
+  protected function nodeExists($title) {
+    $query = \Drupal::entityQuery('node');
+    $result = $query
+      ->condition('title', $title)
+      ->range(0, 1)
+      ->execute();
+
+    return !empty($result);
+  }
+
+}

core/modules/migrate/tests/src/Kernel/MigrateConfigRollbackTest.php

@@ -0,0 +1,170 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+use Drupal\migrate\MigrateExecutable;
+
+/**
+ * Tests rolling back of configuration objects.
+ *
+ * @group migrate
+ */
+class MigrateConfigRollbackTest extends MigrateTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['system', 'language', 'config_translation'];
+
+  /**
+   * Tests rolling back configuration.
+   */
+  public function testConfigRollback() {
+    // Use system.site configuration to demonstrate importing and rolling back
+    // configuration.
+    $variable = [
+      [
+        'id' => 'site_name',
+        'site_name' => 'Some site',
+        'site_slogan' => 'Awesome slogan',
+      ],
+    ];
+    $ids = [
+      'id' =>
+        [
+          'type' => 'string'
+        ],
+    ];
+    $definition = [
+      'id' => 'config',
+      'migration_tags' => ['Import and rollback test'],
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => $variable,
+        'ids' => $ids,
+      ],
+      'process' => [
+        'name' => 'site_name',
+        'slogan' => 'site_slogan',
+      ],
+      'destination' => [
+        'plugin' => 'config',
+        'config_name' => 'system.site',
+      ],
+    ];
+
+    /** @var \Drupal\migrate\Plugin\Migration $config_migration */
+    $config_migration = \Drupal::service('plugin.manager.migration')
+      ->createStubMigration($definition);
+    $config_id_map = $config_migration->getIdMap();
+
+    // Rollback is not enabled for configuration translations.
+    $this->assertFalse($config_migration->getDestinationPlugin()->supportsRollback());
+
+    // Import and validate config entities were created.
+    $config_executable = new MigrateExecutable($config_migration, $this);
+    $config_executable->import();
+    $config = $this->config('system.site');
+    $this->assertSame('Some site', $config->get('name'));
+    $this->assertSame('Awesome slogan', $config->get('slogan'));
+    $map_row = $config_id_map->getRowBySource(['id' => $variable[0]['id']]);
+    $this->assertNotNull($map_row['destid1']);
+
+    // Rollback and verify the configuration changes are still there.
+    $config_executable->rollback();
+    $config = $this->config('system.site');
+    $this->assertSame('Some site', $config->get('name'));
+    $this->assertSame('Awesome slogan', $config->get('slogan'));
+    // Confirm the map row is deleted.
+    $map_row = $config_id_map->getRowBySource(['id' => $variable[0]['id']]);
+    $this->assertNull($map_row['destid1']);
+
+    // We use system configuration to demonstrate importing and rolling back
+    // configuration translations.
+    $i18n_variable = [
+      [
+        'id' => 'site_name',
+        'language' => 'fr',
+        'site_name' => 'fr - Some site',
+        'site_slogan' => 'fr - Awesome slogan',
+      ],
+      [
+        'id' => 'site_name',
+        'language' => 'is',
+        'site_name' => 'is - Some site',
+        'site_slogan' => 'is - Awesome slogan',
+      ],
+    ];
+    $ids = [
+      'id' =>
+        [
+          'type' => 'string'
+        ],
+      'language' =>
+        [
+          'type' => 'string'
+        ]
+    ];
+    $definition = [
+      'id' => 'i18n_config',
+      'migration_tags' => ['Import and rollback test'],
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => $i18n_variable,
+        'ids' => $ids,
+      ],
+      'process' => [
+        'langcode' => 'language',
+        'name' => 'site_name',
+        'slogan' => 'site_slogan',
+      ],
+      'destination' => [
+        'plugin' => 'config',
+        'config_name' => 'system.site',
+        'translations' => 'true',
+      ],
+    ];
+
+    $config_migration = \Drupal::service('plugin.manager.migration')
+      ->createStubMigration($definition);
+    $config_id_map = $config_migration->getIdMap();
+
+    // Rollback is enabled for configuration translations.
+    $this->assertTrue($config_migration->getDestinationPlugin()->supportsRollback());
+
+    // Import and validate config entities were created.
+    $config_executable = new MigrateExecutable($config_migration, $this);
+    $config_executable->import();
+
+    $language_manager = \Drupal::service('language_manager');
+    foreach ($i18n_variable as $row) {
+      $langcode = $row['language'];
+      /** @var \Drupal\language\Config\LanguageConfigOverride $config_translation */
+      $config_translation = $language_manager->getLanguageConfigOverride($langcode, 'system.site');
+      $this->assertSame($row['site_name'], $config_translation->get('name'));
+      $this->assertSame($row['site_slogan'], $config_translation->get('slogan'));
+      $map_row = $config_id_map->getRowBySource(['id' => $row['id'], 'language' => $row['language']]);
+      $this->assertNotNull($map_row['destid1']);
+    }
+
+    // Rollback and verify the translation have been removed.
+    $config_executable->rollback();
+    foreach ($i18n_variable as $row) {
+      $langcode = $row['language'];
+      $config_translation = $language_manager->getLanguageConfigOverride($langcode, 'system.site');
+      $this->assertNull($config_translation->get('name'));
+      $this->assertNull($config_translation->get('slogan'));
+      // Confirm the map row is deleted.
+      $map_row = $config_id_map->getRowBySource(['id' => $row['id'], 'language' => $langcode]);
+      $this->assertFalse($map_row);
+    }
+
+    // Test that the configuration is still present.
+    $config = $this->config('system.site');
+    $this->assertSame('Some site', $config->get('name'));
+    $this->assertSame('Awesome slogan', $config->get('slogan'));
+  }
+
+}

core/modules/migrate/tests/src/Kernel/MigrateEntityContentBaseTest.php

@@ -4,6 +4,8 @@ namespace Drupal\Tests\migrate\Kernel;
 
 use Drupal\KernelTests\KernelTestBase;
 use Drupal\language\Entity\ConfigurableLanguage;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\MigrateMessage;
 use Drupal\migrate\Plugin\migrate\destination\EntityContentBase;
 use Drupal\migrate\Plugin\MigrateIdMapInterface;
 use Drupal\migrate\Plugin\MigrationInterface;
@@ -123,7 +125,7 @@ class MigrateEntityContentBaseTest extends KernelTestBase {
 
     // Import some rows.
     foreach ($destination_rows as $idx => $destination_row) {
-      $row = new Row([], []);
+      $row = new Row();
       foreach ($destination_row as $key => $value) {
         $row->setDestinationProperty($key, $value);
       }
@@ -156,4 +158,50 @@ class MigrateEntityContentBaseTest extends KernelTestBase {
     $this->assertTranslations(4, 'fr');
   }
 
+  /**
+   * Tests creation of ID columns table with definitions taken from entity type.
+   */
+  public function testEntityWithStringId() {
+    $this->enableModules(['migrate_entity_test']);
+    $this->installEntitySchema('migrate_string_id_entity_test');
+
+    $definition = [
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => [
+          ['id' => 123, 'version' => 'foo'],
+          // This integer needs an 'int' schema with 'big' size. If 'destid1'
+          // is not correctly taking the definition from the destination entity
+          // type, the import will fail with a SQL exception.
+          ['id' => 123456789012, 'version' => 'bar'],
+        ],
+        'ids' => [
+          'id' => ['type' => 'integer', 'size' => 'big'],
+          'version' => ['type' => 'string'],
+        ],
+      ],
+      'process' => [
+        'id' => 'id',
+        'version' => 'version',
+      ],
+      'destination' => [
+        'plugin' => 'entity:migrate_string_id_entity_test',
+      ],
+    ];
+
+    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($definition);
+    $executable = new MigrateExecutable($migration, new MigrateMessage());
+    $result = $executable->import();
+    $this->assertEquals(MigrationInterface::RESULT_COMPLETED, $result);
+
+    /** @var \Drupal\migrate\Plugin\MigrateIdMapInterface $id_map_plugin */
+    $id_map_plugin = $migration->getIdMap();
+
+    // Check that the destination has been stored.
+    $map_row = $id_map_plugin->getRowBySource(['id' => 123, 'version' => 'foo']);
+    $this->assertEquals(123, $map_row['destid1']);
+    $map_row = $id_map_plugin->getRowBySource(['id' => 123456789012, 'version' => 'bar']);
+    $this->assertEquals(123456789012, $map_row['destid1']);
+  }
+
 }

core/modules/migrate/tests/src/Kernel/MigrateEventsTest.php

@@ -40,17 +40,17 @@ class MigrateEventsTest extends KernelTestBase {
     parent::setUp();
     $this->state = \Drupal::state();
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::MAP_SAVE,
-      array($this, 'mapSaveEventRecorder'));
+      [$this, 'mapSaveEventRecorder']);
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::MAP_DELETE,
-      array($this, 'mapDeleteEventRecorder'));
+      [$this, 'mapDeleteEventRecorder']);
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::PRE_IMPORT,
-      array($this, 'preImportEventRecorder'));
+      [$this, 'preImportEventRecorder']);
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::POST_IMPORT,
-      array($this, 'postImportEventRecorder'));
+      [$this, 'postImportEventRecorder']);
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::PRE_ROW_SAVE,
-      array($this, 'preRowSaveEventRecorder'));
+      [$this, 'preRowSaveEventRecorder']);
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::POST_ROW_SAVE,
-      array($this, 'postRowSaveEventRecorder'));
+      [$this, 'postRowSaveEventRecorder']);
   }
 
   /**
@@ -129,11 +129,11 @@ class MigrateEventsTest extends KernelTestBase {
    *   The event name.
    */
   public function mapSaveEventRecorder(MigrateMapSaveEvent $event, $name) {
-    $this->state->set('migrate_events_test.map_save_event', array(
+    $this->state->set('migrate_events_test.map_save_event', [
       'event_name' => $name,
       'map' => $event->getMap(),
       'fields' => $event->getFields(),
-    ));
+    ]);
   }
 
   /**
@@ -145,11 +145,11 @@ class MigrateEventsTest extends KernelTestBase {
    *   The event name.
    */
   public function mapDeleteEventRecorder(MigrateMapDeleteEvent $event, $name) {
-    $this->state->set('migrate_events_test.map_delete_event', array(
+    $this->state->set('migrate_events_test.map_delete_event', [
       'event_name' => $name,
       'map' => $event->getMap(),
       'source_id' => $event->getSourceId(),
-    ));
+    ]);
   }
 
   /**
@@ -161,10 +161,10 @@ class MigrateEventsTest extends KernelTestBase {
    *   The event name.
    */
   public function preImportEventRecorder(MigrateImportEvent $event, $name) {
-    $this->state->set('migrate_events_test.pre_import_event', array(
+    $this->state->set('migrate_events_test.pre_import_event', [
       'event_name' => $name,
       'migration' => $event->getMigration(),
-    ));
+    ]);
   }
 
   /**
@@ -176,10 +176,10 @@ class MigrateEventsTest extends KernelTestBase {
    *   The event name.
    */
   public function postImportEventRecorder(MigrateImportEvent $event, $name) {
-    $this->state->set('migrate_events_test.post_import_event', array(
+    $this->state->set('migrate_events_test.post_import_event', [
       'event_name' => $name,
       'migration' => $event->getMigration(),
-    ));
+    ]);
   }
 
   /**
@@ -191,11 +191,11 @@ class MigrateEventsTest extends KernelTestBase {
    *   The event name.
    */
   public function preRowSaveEventRecorder(MigratePreRowSaveEvent $event, $name) {
-    $this->state->set('migrate_events_test.pre_row_save_event', array(
+    $this->state->set('migrate_events_test.pre_row_save_event', [
       'event_name' => $name,
       'migration' => $event->getMigration(),
       'row' => $event->getRow(),
-    ));
+    ]);
   }
 
   /**
@@ -207,12 +207,12 @@ class MigrateEventsTest extends KernelTestBase {
    *   The event name.
    */
   public function postRowSaveEventRecorder(MigratePostRowSaveEvent $event, $name) {
-    $this->state->set('migrate_events_test.post_row_save_event', array(
+    $this->state->set('migrate_events_test.post_row_save_event', [
       'event_name' => $name,
       'migration' => $event->getMigration(),
       'row' => $event->getRow(),
       'destination_id_values' => $event->getDestinationIdValues(),
-    ));
+    ]);
   }
 
 }

core/modules/migrate/tests/src/Kernel/MigrateExternalTranslatedTest.php

@@ -18,11 +18,8 @@ class MigrateExternalTranslatedTest extends MigrateTestBase {
 
   /**
    * {@inheritdoc}
-   *
-   * @todo: Remove migrate_drupal when https://www.drupal.org/node/2560795 is
-   * fixed.
    */
-  public static $modules = ['system', 'user', 'language', 'node', 'field', 'migrate_drupal', 'migrate_external_translated_test'];
+  public static $modules = ['system', 'user', 'language', 'node', 'field', 'migrate_external_translated_test'];
 
   /**
    * {@inheritdoc}
@@ -30,7 +27,7 @@ class MigrateExternalTranslatedTest extends MigrateTestBase {
   public function setUp() {
     parent::setUp();
     $this->installSchema('system', ['sequences']);
-    $this->installSchema('node', array('node_access'));
+    $this->installSchema('node', ['node_access']);
     $this->installEntitySchema('user');
     $this->installEntitySchema('node');
 

core/modules/migrate/tests/src/Kernel/MigrateInterruptionTest.php

@@ -29,7 +29,7 @@ class MigrateInterruptionTest extends KernelTestBase {
   protected function setUp() {
     parent::setUp();
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::POST_ROW_SAVE,
-      array($this, 'postRowSaveEventRecorder'));
+      [$this, 'postRowSaveEventRecorder']);
   }
 
   /**

core/modules/migrate/tests/src/Kernel/MigrateMessageTest.php

@@ -89,7 +89,7 @@ class MigrateMessageTest extends KernelTestBase implements MigrateMessageInterfa
   public function testMessagesTeed() {
     // Ask to receive any messages sent to the idmap.
     \Drupal::service('event_dispatcher')->addListener(MigrateEvents::IDMAP_MESSAGE,
-      array($this, 'mapMessageRecorder'));
+      [$this, 'mapMessageRecorder']);
     $executable = new MigrateExecutable($this->migration, $this);
     $executable->import();
     $this->assertIdentical(count($this->messages), 1);

core/modules/migrate/tests/src/Kernel/MigrateRollbackEntityConfigTest.php

@@ -0,0 +1,168 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+use Drupal\migrate\MigrateExecutable;
+use Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Tests rolling back of imports.
+ *
+ * @group migrate
+ */
+class MigrateRollbackEntityConfigTest extends MigrateTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['field', 'taxonomy', 'text', 'language', 'config_translation'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installEntitySchema('taxonomy_vocabulary');
+    $this->installEntitySchema('taxonomy_term');
+    $this->installConfig(['taxonomy']);
+  }
+
+  /**
+   * Tests rolling back configuration entity translations.
+   */
+  public function testConfigEntityRollback() {
+    // We use vocabularies to demonstrate importing and rolling back
+    // configuration entities with translations. First, import vocabularies.
+    $vocabulary_data_rows = [
+      ['id' => '1', 'name' => 'categories', 'weight' => '2'],
+      ['id' => '2', 'name' => 'tags', 'weight' => '1'],
+    ];
+    $ids = ['id' => ['type' => 'integer']];
+    $definition = [
+      'id' => 'vocabularies',
+      'migration_tags' => ['Import and rollback test'],
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => $vocabulary_data_rows,
+        'ids' => $ids,
+      ],
+      'process' => [
+        'vid' => 'id',
+        'name' => 'name',
+        'weight' => 'weight',
+      ],
+      'destination' => ['plugin' => 'entity:taxonomy_vocabulary'],
+    ];
+
+    /** @var \Drupal\migrate\Plugin\Migration $vocabulary_migration */
+    $vocabulary_migration = \Drupal::service('plugin.manager.migration')
+      ->createStubMigration($definition);
+    $vocabulary_id_map = $vocabulary_migration->getIdMap();
+
+    $this->assertTrue($vocabulary_migration->getDestinationPlugin()
+      ->supportsRollback());
+
+    // Import and validate vocabulary config entities were created.
+    $vocabulary_executable = new MigrateExecutable($vocabulary_migration, $this);
+    $vocabulary_executable->import();
+    foreach ($vocabulary_data_rows as $row) {
+      /** @var \Drupal\taxonomy\Entity\Vocabulary $vocabulary */
+      $vocabulary = Vocabulary::load($row['id']);
+      $this->assertTrue($vocabulary);
+      $map_row = $vocabulary_id_map->getRowBySource(['id' => $row['id']]);
+      $this->assertNotNull($map_row['destid1']);
+    }
+
+    // Second, import translations of the vocabulary name property.
+    $vocabulary_i18n_data_rows = [
+      [
+        'id' => '1',
+        'name' => '1',
+        'language' => 'fr',
+        'property' => 'name',
+        'translation' => 'fr - categories'
+      ],
+      [
+        'id' => '2',
+        'name' => '2',
+        'language' => 'fr',
+        'property' => 'name',
+        'translation' => 'fr - tags'
+      ],
+    ];
+    $ids = [
+      'id' => ['type' => 'integer'],
+      'language' => ['type' => 'string'],
+    ];
+    $definition = [
+      'id' => 'i18n_vocabularies',
+      'migration_tags' => ['Import and rollback test'],
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => $vocabulary_i18n_data_rows,
+        'ids' => $ids,
+        'constants' => [
+          'name' => 'name',
+        ]
+      ],
+      'process' => [
+        'vid' => 'id',
+        'langcode' => 'language',
+        'property' => 'constants/name',
+        'translation' => 'translation',
+      ],
+      'destination' => [
+        'plugin' => 'entity:taxonomy_vocabulary',
+        'translations' => 'true',
+      ],
+    ];
+
+    $vocabulary_i18n__migration = \Drupal::service('plugin.manager.migration')
+      ->createStubMigration($definition);
+    $vocabulary_i18n_id_map = $vocabulary_i18n__migration->getIdMap();
+
+    $this->assertTrue($vocabulary_i18n__migration->getDestinationPlugin()
+      ->supportsRollback());
+
+    // Import and validate vocabulary config entities were created.
+    $vocabulary_i18n_executable = new MigrateExecutable($vocabulary_i18n__migration, $this);
+    $vocabulary_i18n_executable->import();
+
+    $language_manager = \Drupal::service('language_manager');
+    foreach ($vocabulary_i18n_data_rows as $row) {
+      $langcode = $row['language'];
+      $id = 'taxonomy.vocabulary.' . $row['id'];
+      /** @var \Drupal\language\Config\LanguageConfigOverride $config_translation */
+      $config_translation = $language_manager->getLanguageConfigOverride($langcode, $id);
+      $this->assertSame($row['translation'], $config_translation->get('name'));
+      $map_row = $vocabulary_i18n_id_map->getRowBySource(['id' => $row['id'], 'language' => $row['language']]);
+      $this->assertNotNull($map_row['destid1']);
+    }
+
+    // Perform the rollback and confirm the translation was deleted and the map
+    // table row removed.
+    $vocabulary_i18n_executable->rollback();
+    foreach ($vocabulary_i18n_data_rows as $row) {
+      $langcode = $row['language'];
+      $id = 'taxonomy.vocabulary.' . $row['id'];
+      /** @var \Drupal\language\Config\LanguageConfigOverride $config_translation */
+      $config_translation = $language_manager->getLanguageConfigOverride($langcode, $id);
+      $this->assertNull($config_translation->get('name'));
+      $map_row = $vocabulary_i18n_id_map->getRowBySource(['id' => $row['id'], 'language' => $row['language']]);
+      $this->assertFalse($map_row);
+    }
+
+    // Confirm the original vocabulary still exists.
+    foreach ($vocabulary_data_rows as $row) {
+      /** @var \Drupal\taxonomy\Entity\Vocabulary $vocabulary */
+      $vocabulary = Vocabulary::load($row['id']);
+      $this->assertTrue($vocabulary);
+      $map_row = $vocabulary_id_map->getRowBySource(['id' => $row['id']]);
+      $this->assertNotNull($map_row['destid1']);
+    }
+
+  }
+
+}

core/modules/migrate/tests/src/Kernel/MigrateRollbackTest.php

@@ -128,6 +128,9 @@ class MigrateRollbackTest extends MigrateTestBase {
       $this->assertNotNull($map_row['destid1']);
     }
 
+    // Add a failed row to test if this can be rolled back without errors.
+    $this->mockFailure($term_migration, ['id' => '4', 'vocab' => '2', 'name' => 'FAIL']);
+
     // Rollback and verify the entities are gone.
     $term_executable->rollback();
     foreach ($term_data_rows as $row) {

core/modules/migrate/tests/src/Kernel/MigrateSkipRowTest.php

@@ -54,14 +54,49 @@ class MigrateSkipRowTest extends KernelTestBase {
     $result = $executable->import();
     $this->assertEqual($result, MigrationInterface::RESULT_COMPLETED);
 
+    /** @var \Drupal\migrate\Plugin\MigrateIdMapInterface $id_map_plugin */
     $id_map_plugin = $migration->getIdMap();
     // The first row is recorded in the map as ignored.
     $map_row = $id_map_plugin->getRowBySource(['id' => 1]);
     $this->assertEqual(MigrateIdMapInterface::STATUS_IGNORED, $map_row['source_row_status']);
+    // Check that no message has been logged for the first exception.
+    $messages = $id_map_plugin->getMessageIterator(['id' => 1])->fetchAll();
+    $this->assertEmpty($messages);
+
     // The second row is not recorded in the map.
     $map_row = $id_map_plugin->getRowBySource(['id' => 2]);
     $this->assertFalse($map_row);
+    // Check that the correct message has been logged for the second exception.
+    $messages = $id_map_plugin->getMessageIterator(['id' => 2])->fetchAll();
+    $this->assertCount(1, $messages);
+    $message = reset($messages);
+    $this->assertEquals('skip_and_dont_record message', $message->message);
+    $this->assertEquals(MigrationInterface::MESSAGE_INFORMATIONAL, $message->level);
 
+    // Insert a custom processor in the process flow.
+    $definition['process']['value'] = [
+      'source' => 'data',
+      'plugin' => 'test_skip_row_process',
+    ];
+    // Change data to avoid triggering again hook_migrate_prepare_row().
+    $definition['source']['data_rows'] = [
+      ['id' => '1', 'data' => 'skip_and_record (use plugin)'],
+      ['id' => '2', 'data' => 'skip_and_dont_record (use plugin)'],
+    ];
+    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($definition);
+
+    $executable = new MigrateExecutable($migration, new MigrateMessage());
+    $result = $executable->import();
+    $this->assertEquals($result, MigrationInterface::RESULT_COMPLETED);
+
+    $id_map_plugin = $migration->getIdMap();
+
+    // The first row is recorded in the map as ignored.
+    $map_row = $id_map_plugin->getRowBySource(['id' => 1]);
+    $this->assertEquals(MigrateIdMapInterface::STATUS_IGNORED, $map_row['source_row_status']);
+    // The second row is not recorded in the map.
+    $map_row = $id_map_plugin->getRowBySource(['id' => 2]);
+    $this->assertFalse($map_row);
   }
 
 }

core/modules/migrate/tests/src/Kernel/MigrateSourceTestBase.php

@@ -0,0 +1,195 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Base class for tests of Migrate source plugins.
+ */
+abstract class MigrateSourceTestBase extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate'];
+
+  /**
+   * The mocked migration.
+   *
+   * @var MigrationInterface|\Prophecy\Prophecy\ObjectProphecy
+   */
+  protected $migration;
+
+  /**
+   * The source plugin under test.
+   *
+   * @var \Drupal\migrate\Plugin\MigrateSourceInterface
+   */
+  protected $plugin;
+
+  /**
+   * The data provider.
+   *
+   * @see \Drupal\Tests\migrate\Kernel\MigrateSourceTestBase::testSource
+   *
+   * @return array
+   *   Array of data sets to test, each of which is a numerically indexed array
+   *   with the following elements:
+   *   - An array of source data, which can be optionally processed and set up
+   *     by subclasses.
+   *   - An array of expected result rows.
+   *   - (optional) The number of result rows the plugin under test is expected
+   *     to return. If this is not a numeric value, the plugin will not be
+   *     counted.
+   *   - (optional) Array of configuration options for the plugin under test.
+   */
+  abstract public function providerSource();
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Create a mock migration. This will be injected into the source plugin
+    // under test.
+    $this->migration = $this->prophesize(MigrationInterface::class);
+
+    $this->migration->id()->willReturn(
+      $this->randomMachineName(16)
+    );
+    // Prophesize a useless ID map plugin and an empty set of destination IDs.
+    // Calling code can override these prophecies later and set up different
+    // behaviors.
+    $this->migration->getIdMap()->willReturn(
+      $this->prophesize(MigrateIdMapInterface::class)->reveal()
+    );
+    $this->migration->getDestinationIds()->willReturn([]);
+  }
+
+  /**
+   * Determines the plugin to be tested by reading the class @covers annotation.
+   *
+   * @return string
+   */
+  protected function getPluginClass() {
+    $annotations = $this->getAnnotations();
+
+    if (isset($annotations['class']['covers'])) {
+      return $annotations['class']['covers'][0];
+    }
+    else {
+      $this->fail('No plugin class was specified');
+    }
+  }
+
+  /**
+   * Instantiates the source plugin under test.
+   *
+   * @param array $configuration
+   *   The source plugin configuration.
+   *
+   * @return \Drupal\migrate\Plugin\MigrateSourceInterface|object
+   *   The fully configured source plugin.
+   */
+  protected function getPlugin(array $configuration) {
+    // Only create the plugin once per test.
+    if ($this->plugin) {
+      return $this->plugin;
+    }
+
+    $class = ltrim($this->getPluginClass(), '\\');
+
+    /** @var \Drupal\migrate\Plugin\MigratePluginManager $plugin_manager */
+    $plugin_manager = $this->container->get('plugin.manager.migrate.source');
+
+    foreach ($plugin_manager->getDefinitions() as $id => $definition) {
+      if (ltrim($definition['class'], '\\') == $class) {
+        $this->plugin = $plugin_manager
+          ->createInstance($id, $configuration, $this->migration->reveal());
+
+        $this->migration
+          ->getSourcePlugin()
+          ->willReturn($this->plugin);
+
+        return $this->plugin;
+      }
+    }
+    $this->fail('No plugin found for class ' . $class);
+  }
+
+  /**
+   * Tests the source plugin against a particular data set.
+   *
+   * @param array $source_data
+   *   The source data that the source plugin will read.
+   * @param array $expected_data
+   *   The result rows the source plugin is expected to return.
+   * @param mixed $expected_count
+   *   (optional) How many rows the source plugin is expected to return.
+   *   Defaults to count($expected_data). If set to a non-null, non-numeric
+   *   value (like FALSE or 'nope'), the source plugin will not be counted.
+   * @param array $configuration
+   *   (optional) Configuration for the source plugin.
+   * @param mixed $high_water
+   *   (optional) The value of the high water field.
+   *
+   * @dataProvider providerSource
+   */
+  public function testSource(array $source_data, array $expected_data, $expected_count = NULL, array $configuration = [], $high_water = NULL) {
+    $plugin = $this->getPlugin($configuration);
+
+    // All source plugins must define IDs.
+    $this->assertNotEmpty($plugin->getIds());
+
+    // If there is a high water mark, set it in the high water storage.
+    if (isset($high_water)) {
+      $this->container
+        ->get('keyvalue')
+        ->get('migrate:high_water')
+        ->set($this->migration->reveal()->id(), $high_water);
+    }
+
+    if (is_null($expected_count)) {
+      $expected_count = count($expected_data);
+    }
+    // If an expected count was given, assert it only if the plugin is
+    // countable.
+    if (is_numeric($expected_count)) {
+      $this->assertInstanceOf('\Countable', $plugin);
+      $this->assertCount($expected_count, $plugin);
+    }
+
+    $i = 0;
+    /** @var \Drupal\migrate\Row $row */
+    foreach ($plugin as $row) {
+      $this->assertInstanceOf(Row::class, $row);
+
+      $expected = $expected_data[$i++];
+      $actual = $row->getSource();
+
+      foreach ($expected as $key => $value) {
+        $this->assertArrayHasKey($key, $actual);
+
+        if (is_array($value)) {
+          ksort($value);
+          ksort($actual[$key]);
+          $this->assertEquals($value, $actual[$key]);
+        }
+        else {
+          $this->assertSame((string) $value, (string) $actual[$key]);
+        }
+      }
+    }
+    // False positives occur if the foreach is not entered. So, confirm the
+    // foreach loop was entered if the expected count is greater than 0.
+    if ($expected_count > 0) {
+      $this->assertGreaterThan(0, $i);
+    }
+  }
+
+}

core/modules/migrate/tests/src/Kernel/MigrateSqlSourceTestBase.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+use Drupal\Core\Database\Driver\sqlite\Connection;
+
+/**
+ * Base class for tests of Migrate source plugins that use a database.
+ */
+abstract class MigrateSqlSourceTestBase extends MigrateSourceTestBase {
+
+  /**
+   * Builds an in-memory SQLite database from a set of source data.
+   *
+   * @param array $source_data
+   *   The source data, keyed by table name. Each table is an array containing
+   *   the rows in that table.
+   *
+   * @return \Drupal\Core\Database\Driver\sqlite\Connection
+   *   The SQLite database connection.
+   */
+  protected function getDatabase(array $source_data) {
+    // Create an in-memory SQLite database. Plugins can interact with it like
+    // any other database, and it will cease to exist when the connection is
+    // closed.
+    $connection_options = ['database' => ':memory:'];
+    $pdo = Connection::open($connection_options);
+    $connection = new Connection($pdo, $connection_options);
+
+    // Create the tables and fill them with data.
+    foreach ($source_data as $table => $rows) {
+      // Use the biggest row to build the table schema.
+      $counts = array_map('count', $rows);
+      asort($counts);
+      end($counts);
+      $pilot = $rows[key($counts)];
+
+      $connection->schema()
+        ->createTable($table, [
+          // SQLite uses loose affinity typing, so it's OK for every field to
+          // be a text field.
+          'fields' => array_map(function() { return ['type' => 'text']; }, $pilot),
+        ]);
+
+      $fields = array_keys($pilot);
+      $insert = $connection->insert($table)->fields($fields);
+      array_walk($rows, [$insert, 'values']);
+      $insert->execute();
+    }
+
+    return $connection;
+  }
+
+  /**
+   * Tests the source plugin against a particular data set.
+   *
+   * @param array $source_data
+   *   The source data that the plugin will read. See getDatabase() for the
+   *   expected format.
+   * @param array $expected_data
+   *   The result rows the plugin is expected to return.
+   * @param int $expected_count
+   *   (optional) How many rows the source plugin is expected to return.
+   * @param array $configuration
+   *   (optional) Configuration for the source plugin.
+   * @param mixed $high_water
+   *   (optional) The value of the high water field.
+   *
+   * @dataProvider providerSource
+   *
+   * @requires extension pdo_sqlite
+   */
+  public function testSource(array $source_data, array $expected_data, $expected_count = NULL, array $configuration = [], $high_water = NULL) {
+    $plugin = $this->getPlugin($configuration);
+
+    // Since we don't yet inject the database connection, we need to use a
+    // reflection hack to set it in the plugin instance.
+    $reflector = new \ReflectionObject($plugin);
+    $property = $reflector->getProperty('database');
+    $property->setAccessible(TRUE);
+    $property->setValue($plugin, $this->getDatabase($source_data));
+
+    parent::testSource($source_data, $expected_data, $expected_count, $configuration, $high_water);
+  }
+
+}

core/modules/migrate/tests/src/Kernel/MigrateStatusTest.php

@@ -33,13 +33,13 @@ class MigrateStatusTest extends MigrateTestBase {
     $this->assertIdentical($status, MigrationInterface::STATUS_IDLE);
 
     // Test setting and retrieving all known status values.
-    $status_list = array(
+    $status_list = [
       MigrationInterface::STATUS_IDLE,
       MigrationInterface::STATUS_IMPORTING,
       MigrationInterface::STATUS_ROLLING_BACK,
       MigrationInterface::STATUS_STOPPING,
       MigrationInterface::STATUS_DISABLED,
-    );
+    ];
     foreach ($status_list as $status) {
       $migration->setStatus($status);
       $this->assertIdentical($migration->getStatus(), $status);

core/modules/migrate/tests/src/Kernel/MigrateTestBase.php

@@ -7,6 +7,8 @@ use Drupal\KernelTests\KernelTestBase;
 use Drupal\migrate\MigrateExecutable;
 use Drupal\migrate\MigrateMessageInterface;
 use Drupal\migrate\Plugin\MigrateIdMapInterface;
+use Drupal\migrate\Plugin\Migration;
+use Drupal\migrate\Plugin\MigrationInterface;
 use Drupal\migrate\Row;
 
 /**
@@ -45,7 +47,7 @@ abstract class MigrateTestBase extends KernelTestBase implements MigrateMessageI
    */
   protected $sourceDatabase;
 
-  public static $modules = array('migrate');
+  public static $modules = ['migrate'];
 
   /**
    * {@inheritdoc}
@@ -136,6 +138,16 @@ abstract class MigrateTestBase extends KernelTestBase implements MigrateMessageI
     }
   }
 
+  /**
+   * Modify a migration's configuration before executing it.
+   *
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration to execute.
+   */
+  protected function prepareMigration(MigrationInterface $migration) {
+    // Default implementation for test classes not requiring modification.
+  }
+
   /**
    * Executes a single migration.
    *
@@ -152,6 +164,8 @@ abstract class MigrateTestBase extends KernelTestBase implements MigrateMessageI
     if ($this instanceof MigrateDumpAlterInterface) {
       static::migrateDumpAlter($this);
     }
+
+    $this->prepareMigration($this->migration);
     (new MigrateExecutable($this->migration, $this))->import();
   }
 
@@ -187,7 +201,7 @@ abstract class MigrateTestBase extends KernelTestBase implements MigrateMessageI
    */
   public function startCollectingMessages() {
     $this->collectMessages = TRUE;
-    $this->migrateMessages = array();
+    $this->migrateMessages = [];
   }
 
   /**

core/modules/migrate/tests/src/Kernel/MigrationTest.php

@@ -34,8 +34,8 @@ class MigrationTest extends KernelTestBase {
     $this->assertEqual('entity:entity_view_mode', $migration->getDestinationPlugin()->getPluginId());
 
     // Test the source plugin is invalidated.
-    $migration->set('source', ['plugin' => 'd6_field']);
-    $this->assertEqual('d6_field', $migration->getSourcePlugin()->getPluginId());
+    $migration->set('source', ['plugin' => 'embedded_data', 'data_rows' => [], 'ids' => []]);
+    $this->assertEqual('embedded_data', $migration->getSourcePlugin()->getPluginId());
 
     // Test the destination plugin is invalidated.
     $migration->set('destination', ['plugin' => 'null']);

core/modules/migrate/tests/src/Kernel/Plugin/EntityExistsTest.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\Plugin;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\Row;
+use Drupal\user\Entity\User;
+
+/**
+ * Tests the EntityExists process plugin.
+ *
+ * @group migrate
+ */
+class EntityExistsTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate', 'system', 'user'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installSchema('system', ['sequences']);
+    $this->installEntitySchema('user');
+  }
+
+  /**
+   * Test the EntityExists plugin.
+   */
+  public function testEntityExists() {
+    $user = User::create([
+      'name' => $this->randomString(),
+    ]);
+    $user->save();
+    $uid = $user->id();
+
+    $plugin = \Drupal::service('plugin.manager.migrate.process')
+      ->createInstance('entity_exists', [
+        'entity_type' => 'user',
+      ]);
+    $executable = $this->prophesize(MigrateExecutableInterface::class)->reveal();
+    $row = new Row();
+
+    // Ensure that the entity ID is returned if it really exists.
+    $value = $plugin->transform($uid, $executable, $row, 'buffalo');
+    $this->assertSame($uid, $value);
+
+    // Ensure that the plugin returns FALSE if the entity doesn't exist.
+    $value = $plugin->transform(420, $executable, $row, 'buffalo');
+    $this->assertFalse($value);
+
+    // Make sure the plugin can gracefully handle an array as input.
+    $value = $plugin->transform([$uid, 420], $executable, $row, 'buffalo');
+    $this->assertSame($uid, $value);
+  }
+
+}

core/modules/migrate/tests/src/Kernel/Plugin/LogTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\Plugin;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Tests the Log process plugin.
+ *
+ * @group migrate
+ */
+class LogTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate'];
+
+  /**
+   * Test the Log plugin.
+   */
+  public function testLog() {
+    $plugin = \Drupal::service('plugin.manager.migrate.process')
+      ->createInstance('log');
+    $executable = $this->prophesize(MigrateExecutableInterface::class)->reveal();
+    $row = new Row();
+    $log_message = "Testing the log message";
+
+    // Ensure the log is getting saved.
+    $saved_message = $plugin->transform($log_message, $executable, $row, 'buffalo');
+    $this->assertSame($log_message, $saved_message);
+  }
+
+}

core/modules/migrate/tests/src/Kernel/Plugin/MigrationPluginConfigurationTest.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\Plugin;
+
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * Tests the migration plugin manager.
+ *
+ * @coversDefaultClass \Drupal\migrate\Plugin\MigratePluginManager
+ * @group migrate
+ */
+class MigrationPluginConfigurationTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'migrate',
+    'migrate_drupal',
+    // Test with a simple migration.
+    'ban',
+  ];
+
+  /**
+   * Test merging configuration into a plugin through the plugin manager.
+   *
+   * @dataProvider mergeProvider
+   */
+  public function testConfigurationMerge($configuration, $expected) {
+    /** @var \Drupal\migrate\Plugin\MigrationInterface $migration */
+    $migration = $this->container->get('plugin.manager.migration')->createInstance('d7_blocked_ips', $configuration);
+    $source_configuration = $migration->getSourceConfiguration();
+    $this->assertEquals($expected, $source_configuration);
+  }
+
+  /**
+   * Provide configuration data for testing.
+   */
+  public function mergeProvider() {
+    return [
+      // Tests adding new configuration to a migration.
+      [
+        // New configuration.
+        [
+          'source' => [
+            'constants' => [
+              'added_setting' => 'Ban them all!',
+            ],
+          ],
+        ],
+        // Expected final source configuration.
+        [
+          'plugin' => 'd7_blocked_ips',
+          'constants' => [
+            'added_setting' => 'Ban them all!',
+          ],
+        ],
+      ],
+      // Tests overriding pre-existing configuration in a migration.
+      [
+        // New configuration.
+        [
+          'source' => [
+            'plugin' => 'a_different_plugin',
+          ],
+        ],
+        // Expected final source configuration.
+        [
+          'plugin' => 'a_different_plugin',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/migrate/tests/src/Kernel/Plugin/MigrationPluginListTest.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\Plugin;
+
+use Drupal\Core\Database\Database;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\Exception\RequirementsException;
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+use Drupal\migrate\Plugin\RequirementsInterface;
+
+/**
+ * Tests the migration plugin manager.
+ *
+ * @coversDefaultClass \Drupal\migrate\Plugin\MigratePluginManager
+ * @group migrate
+ */
+class MigrationPluginListTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'migrate',
+    // Test with all modules containing Drupal migrations.
+    'action',
+    'aggregator',
+    'ban',
+    'block',
+    'block_content',
+    'book',
+    'comment',
+    'contact',
+    'dblog',
+    'field',
+    'file',
+    'filter',
+    'forum',
+    'image',
+    'language',
+    'locale',
+    'menu_link_content',
+    'menu_ui',
+    'node',
+    'path',
+    'search',
+    'shortcut',
+    'simpletest',
+    'statistics',
+    'syslog',
+    'system',
+    'taxonomy',
+    'text',
+    'tracker',
+    'update',
+    'user',
+  ];
+
+  /**
+   * @covers ::getDefinitions
+   */
+  public function testGetDefinitions() {
+    // Make sure retrieving all the core migration plugins does not throw any
+    // errors.
+    $migration_plugins = $this->container->get('plugin.manager.migration')->getDefinitions();
+    // All the plugins provided by core depend on migrate_drupal.
+    $this->assertEmpty($migration_plugins);
+
+    // Enable a module that provides migrations that do not depend on
+    // migrate_drupal.
+    $this->enableModules(['migrate_external_translated_test']);
+    $migration_plugins = $this->container->get('plugin.manager.migration')->getDefinitions();
+    // All the plugins provided by migrate_external_translated_test do not
+    // depend on migrate_drupal.
+    $this::assertArrayHasKey('external_translated_test_node', $migration_plugins);
+    $this::assertArrayHasKey('external_translated_test_node_translation', $migration_plugins);
+
+    // Disable the test module and the list should be empty again.
+    $this->disableModules(['migrate_external_translated_test']);
+    $migration_plugins = $this->container->get('plugin.manager.migration')->getDefinitions();
+    // All the plugins provided by core depend on migrate_drupal.
+    $this->assertEmpty($migration_plugins);
+
+    // Enable migrate_drupal to test that the plugins can now be discovered.
+    $this->enableModules(['migrate_drupal']);
+
+    // Make sure retrieving these migration plugins in the absence of a database
+    // connection does not throw any errors.
+    $migration_plugins = $this->container->get('plugin.manager.migration')->createInstances([]);
+    // Any database-based source plugins should fail a requirements test in the
+    // absence of a source database connection (e.g., a connection with the
+    // 'migrate' key).
+    $source_plugins = array_map(function ($migration_plugin) { return $migration_plugin->getSourcePlugin(); }, $migration_plugins);
+    foreach ($source_plugins as $id => $source_plugin) {
+      if ($source_plugin instanceof RequirementsInterface) {
+        try {
+          $source_plugin->checkRequirements();
+        }
+        catch (RequirementsException $e) {
+          unset($source_plugins[$id]);
+        }
+      }
+    }
+
+    // Without a connection defined, no database-based plugins should be
+    // returned.
+    foreach ($source_plugins as $id => $source_plugin) {
+      $this->assertNotInstanceOf(SqlBase::class, $source_plugin);
+    }
+
+    // Set up a migrate database connection so that plugin discovery works.
+    // Clone the current connection and replace the current prefix.
+    $connection_info = Database::getConnectionInfo('migrate');
+    if ($connection_info) {
+      Database::renameConnection('migrate', 'simpletest_original_migrate');
+    }
+    $connection_info = Database::getConnectionInfo('default');
+    foreach ($connection_info as $target => $value) {
+      $prefix = is_array($value['prefix']) ? $value['prefix']['default'] : $value['prefix'];
+      // Simpletest uses 7 character prefixes at most so this can't cause
+      // collisions.
+      $connection_info[$target]['prefix']['default'] = $prefix . '0';
+
+      // Add the original simpletest prefix so SQLite can attach its database.
+      // @see \Drupal\Core\Database\Driver\sqlite\Connection::init()
+      $connection_info[$target]['prefix'][$value['prefix']['default']] = $value['prefix']['default'];
+    }
+    Database::addConnectionInfo('migrate', 'default', $connection_info['default']);
+
+    $migration_plugins = $this->container->get('plugin.manager.migration')->getDefinitions();
+    // All the plugins provided by core depend on migrate_drupal.
+    $this->assertNotEmpty($migration_plugins);
+  }
+
+}

core/modules/migrate/tests/src/Kernel/Plugin/MigrationTest.php

@@ -33,10 +33,27 @@ class MigrationTest extends KernelTestBase {
    * @covers ::getMigrationDependencies
    */
   public function testGetMigrationDependencies() {
-    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration([
-        'migration_dependencies' => NULL
-    ]);
-    $this->assertNotEmpty($migration->getMigrationDependencies(), 'Migration dependencies is not empty');
+    $plugin_manager = \Drupal::service('plugin.manager.migration');
+    $plugin_definition = [
+      'process' => [
+        'f1' => 'bar',
+        'f2' => [
+          'plugin' => 'migration',
+          'migration' => 'm1'
+        ],
+        'f3' => [
+          'plugin' => 'iterator',
+          'process' => [
+            'target_id' => [
+              'plugin' => 'migration',
+              'migration' => 'm2',
+            ],
+          ],
+        ],
+      ],
+    ];
+    $migration = $plugin_manager->createStubMigration($plugin_definition);
+    $this->assertSame(['required' => [], 'optional' => ['m1', 'm2']], $migration->getMigrationDependencies());
   }
 
   /**

core/modules/migrate/tests/src/Kernel/QueryBatchTest.php

@@ -0,0 +1,261 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\Core\Database\Driver\sqlite\Connection;
+
+/**
+ * Tests query batching.
+ *
+ * @covers \Drupal\migrate_query_batch_test\Plugin\migrate\source\QueryBatchTest
+ * @group migrate
+ */
+class QueryBatchTest extends KernelTestBase {
+
+  /**
+   * The mocked migration.
+   *
+   * @var MigrationInterface|\Prophecy\Prophecy\ObjectProphecy
+   */
+  protected $migration;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'migrate',
+    'migrate_query_batch_test',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Create a mock migration. This will be injected into the source plugin
+    // under test.
+    $this->migration = $this->prophesize(MigrationInterface::class);
+
+    $this->migration->id()->willReturn(
+      $this->randomMachineName(16)
+    );
+    // Prophesize a useless ID map plugin and an empty set of destination IDs.
+    // Calling code can override these prophecies later and set up different
+    // behaviors.
+    $this->migration->getIdMap()->willReturn(
+      $this->prophesize(MigrateIdMapInterface::class)->reveal()
+    );
+    $this->migration->getDestinationIds()->willReturn([]);
+  }
+
+  /**
+   * Tests a negative batch size throws an exception.
+   */
+  public function testBatchSizeNegative() {
+    $this->setExpectedException(MigrateException::class, 'batch_size must be greater than or equal to zero');
+    $plugin = $this->getPlugin(['batch_size' => -1]);
+    $plugin->next();
+  }
+
+  /**
+   * Tests a non integer batch size throws an exception.
+   */
+  public function testBatchSizeNonInteger() {
+    $this->setExpectedException(MigrateException::class, 'batch_size must be greater than or equal to zero');
+    $plugin = $this->getPlugin(['batch_size' => '1']);
+    $plugin->next();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function queryDataProvider() {
+    // Define the parameters for building the data array. The first element is
+    // the number of source data rows, the second is the batch size to set on
+    // the plugin configuration.
+    $test_parameters = [
+      // Test when batch size is 0.
+      [200, 0],
+      // Test when rows mod batch size is 0.
+      [200, 20],
+      // Test when rows mod batch size is > 0.
+      [200, 30],
+      // Test when batch size = row count.
+      [200, 200],
+      // Test when batch size > row count.
+      [200, 300],
+    ];
+
+    // Build the data provider array. The provider array consists of the source
+    // data rows, the expected result data, the expected count, the plugin
+    // configuration, the expected batch size and the expected batch count.
+    $table = 'query_batch_test';
+    $tests = [];
+    $data_set = 0;
+    foreach ($test_parameters as $data) {
+      list($num_rows, $batch_size) = $data;
+      for ($i = 0; $i < $num_rows; $i++) {
+        $tests[$data_set]['source_data'][$table][] = [
+          'id' => $i,
+          'data' => $this->randomString(),
+        ];
+      }
+      $tests[$data_set]['expected_data'] = $tests[$data_set]['source_data'][$table];
+      $tests[$data_set][2] = $num_rows;
+      // Plugin configuration array.
+      $tests[$data_set][3] = ['batch_size' => $batch_size];
+      // Expected batch size.
+      $tests[$data_set][4] = $batch_size;
+      // Expected batch count is 0 unless a batch size is set.
+      $expected_batch_count = 0;
+      if ($batch_size > 0) {
+        $expected_batch_count = (int) ($num_rows / $batch_size);
+        if ($num_rows % $batch_size) {
+          // If there is a remainder an extra batch is needed to get the
+          // remaining rows.
+          $expected_batch_count++;
+        }
+      }
+      $tests[$data_set][5] = $expected_batch_count;
+      $data_set++;
+    }
+    return $tests;
+  }
+
+  /**
+   * Tests query batch size.
+   *
+   * @param array $source_data
+   *   The source data, keyed by table name. Each table is an array containing
+   *   the rows in that table.
+   * @param array $expected_data
+   *   The result rows the plugin is expected to return.
+   * @param int $num_rows
+   *   How many rows the source plugin is expected to return.
+   * @param array $configuration
+   *   Configuration for the source plugin specifying the batch size.
+   * @param int $expected_batch_size
+   *   The expected batch size, will be set to zero for invalid batch sizes.
+   * @param int $expected_batch_count
+   *   The total number of batches.
+   *
+   * @dataProvider queryDataProvider
+   */
+  public function testQueryBatch($source_data, $expected_data, $num_rows, $configuration, $expected_batch_size, $expected_batch_count) {
+    $plugin = $this->getPlugin($configuration);
+
+    // Since we don't yet inject the database connection, we need to use a
+    // reflection hack to set it in the plugin instance.
+    $reflector = new \ReflectionObject($plugin);
+    $property = $reflector->getProperty('database');
+    $property->setAccessible(TRUE);
+
+    $connection = $this->getDatabase($source_data);
+    $property->setValue($plugin, $connection);
+
+    // Test the results.
+    $i = 0;
+    /** @var \Drupal\migrate\Row $row */
+    foreach ($plugin as $row) {
+
+      $expected = $expected_data[$i++];
+      $actual = $row->getSource();
+
+      foreach ($expected as $key => $value) {
+        $this->assertArrayHasKey($key, $actual);
+        $this->assertSame((string) $value, (string) $actual[$key]);
+      }
+    }
+
+    // Test that all rows were retrieved.
+    self::assertSame($num_rows, $i);
+
+    // Test the batch size.
+    if (is_null($expected_batch_size)) {
+      $expected_batch_size = $configuration['batch_size'];
+    }
+    $property = $reflector->getProperty('batchSize');
+    $property->setAccessible(TRUE);
+    self::assertSame($expected_batch_size, $property->getValue($plugin));
+
+    // Test the batch count.
+    if (is_null($expected_batch_count)) {
+      $expected_batch_count = intdiv($num_rows, $expected_batch_size);
+      if ($num_rows % $configuration['batch_size']) {
+        $expected_batch_count++;
+      }
+    }
+    $property = $reflector->getProperty('batch');
+    $property->setAccessible(TRUE);
+    self::assertSame($expected_batch_count, $property->getValue($plugin));
+  }
+
+  /**
+   * Instantiates the source plugin under test.
+   *
+   * @param array $configuration
+   *   The source plugin configuration.
+   *
+   * @return \Drupal\migrate\Plugin\MigrateSourceInterface|object
+   *   The fully configured source plugin.
+   */
+  protected function getPlugin($configuration) {
+    /** @var \Drupal\migrate\Plugin\MigratePluginManager $plugin_manager */
+    $plugin_manager = $this->container->get('plugin.manager.migrate.source');
+    $plugin = $plugin_manager->createInstance('query_batch_test', $configuration, $this->migration->reveal());
+
+    $this->migration
+      ->getSourcePlugin()
+      ->willReturn($plugin);
+    return $plugin;
+  }
+
+  /**
+   * Builds an in-memory SQLite database from a set of source data.
+   *
+   * @param array $source_data
+   *   The source data, keyed by table name. Each table is an array containing
+   *   the rows in that table.
+   *
+   * @return \Drupal\Core\Database\Driver\sqlite\Connection
+   *   The SQLite database connection.
+   */
+  protected function getDatabase(array $source_data) {
+    // Create an in-memory SQLite database. Plugins can interact with it like
+    // any other database, and it will cease to exist when the connection is
+    // closed.
+    $connection_options = ['database' => ':memory:'];
+    $pdo = Connection::open($connection_options);
+    $connection = new Connection($pdo, $connection_options);
+
+    // Create the tables and fill them with data.
+    foreach ($source_data as $table => $rows) {
+      // Use the biggest row to build the table schema.
+      $counts = array_map('count', $rows);
+      asort($counts);
+      end($counts);
+      $pilot = $rows[key($counts)];
+
+      $connection->schema()
+        ->createTable($table, [
+          // SQLite uses loose affinity typing, so it's OK for every field to
+          // be a text field.
+          'fields' => array_map(function () {
+            return ['type' => 'text'];
+          }, $pilot),
+        ]);
+
+      $fields = array_keys($pilot);
+      $insert = $connection->insert($table)->fields($fields);
+      array_walk($rows, [$insert, 'values']);
+      $insert->execute();
+    }
+    return $connection;
+  }
+
+}

core/modules/migrate/tests/src/Kernel/SqlBaseTest.php

@@ -30,7 +30,7 @@ class SqlBaseTest extends MigrateTestBase {
 
     $target = 'test_db_target';
     $key = 'test_migrate_connection';
-    $config = array('target' => $target, 'key' => $key);
+    $config = ['target' => $target, 'key' => $key];
     $sql_base->setConfiguration($config);
     Database::addConnectionInfo($key, $target, Database::getConnectionInfo('default')['default']);
 
@@ -44,7 +44,7 @@ class SqlBaseTest extends MigrateTestBase {
     $target = 'test_db_target2';
     $key = 'test_migrate_connection2';
     $database = Database::getConnectionInfo('default')['default'];
-    $config = array('target' => $target, 'key' => $key, 'database' => $database);
+    $config = ['target' => $target, 'key' => $key, 'database' => $database];
     $sql_base->setConfiguration($config);
 
     // Call getDatabase() to get the connection defined.

core/modules/migrate/tests/src/Kernel/process/DownloadTest.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\process;
+
+use Drupal\Core\StreamWrapper\StreamWrapperInterface;
+use Drupal\KernelTests\Core\File\FileTestBase;
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Plugin\migrate\process\Download;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\Row;
+use GuzzleHttp\Client;
+use GuzzleHttp\Psr7\Response;
+
+/**
+ * Tests the download process plugin.
+ *
+ * @group migrate
+ */
+class DownloadTest extends FileTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['system'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->container->get('stream_wrapper_manager')->registerWrapper('temporary', 'Drupal\Core\StreamWrapper\TemporaryStream', StreamWrapperInterface::LOCAL_NORMAL);
+  }
+
+  /**
+   * Tests a download that overwrites an existing local file.
+   */
+  public function testOverwritingDownload() {
+    // Create a pre-existing file at the destination, to test overwrite behavior.
+    $destination_uri = $this->createUri('existing_file.txt');
+
+    // Test destructive download.
+    $actual_destination = $this->doTransform($destination_uri);
+    $this->assertSame($destination_uri, $actual_destination, 'Import returned a destination that was not renamed');
+    $this->assertFileNotExists('public://existing_file_0.txt', 'Import did not rename the file');
+  }
+
+  /**
+   * Tests a download that renames the downloaded file if there's a collision.
+   */
+  public function testNonDestructiveDownload() {
+    // Create a pre-existing file at the destination, to test overwrite behavior.
+    $destination_uri = $this->createUri('another_existing_file.txt');
+
+    // Test non-destructive download.
+    $actual_destination = $this->doTransform($destination_uri, ['rename' => TRUE]);
+    $this->assertSame('public://another_existing_file_0.txt', $actual_destination, 'Import returned a renamed destination');
+    $this->assertFileExists($actual_destination, 'Downloaded file was created');
+  }
+
+  /**
+   * Tests that an exception is thrown if the destination URI is not writable.
+   */
+  public function testWriteProtectedDestination() {
+    // Create a pre-existing file at the destination, to test overwrite behavior.
+    $destination_uri = $this->createUri('not-writable.txt');
+
+    // Make the destination non-writable.
+    $this->container
+      ->get('file_system')
+      ->chmod($destination_uri, 0444);
+
+    // Pass or fail, we'll need to make the file writable again so the test
+    // can clean up after itself.
+    $fix_permissions = function () use ($destination_uri) {
+      $this->container
+        ->get('file_system')
+        ->chmod($destination_uri, 0755);
+    };
+
+    try {
+      $this->doTransform($destination_uri);
+      $fix_permissions();
+      $this->fail('MigrateException was not thrown for non-writable destination URI.');
+    }
+    catch (MigrateException $e) {
+      $this->assertTrue(TRUE, 'MigrateException was thrown for non-writable destination URI.');
+      $fix_permissions();
+    }
+  }
+
+  /**
+   * Runs an input value through the download plugin.
+   *
+   * @param string $destination_uri
+   *   The destination URI to download to.
+   * @param array $configuration
+   *   (optional) Configuration for the download plugin.
+   *
+   * @return string
+   *   The local URI of the downloaded file.
+   */
+  protected function doTransform($destination_uri, $configuration = []) {
+    // The HTTP client will return a file with contents 'It worked!'
+    $body = fopen('data://text/plain;base64,SXQgd29ya2VkIQ==', 'r');
+
+    // Prepare a mock HTTP client.
+    $this->container->set('http_client', $this->getMock(Client::class));
+    $this->container->get('http_client')
+      ->method('get')
+      ->willReturn(new Response(200, [], $body));
+
+    // Instantiate the plugin statically so it can pull dependencies out of
+    // the container.
+    $plugin = Download::create($this->container, $configuration, 'download', []);
+
+    // Execute the transformation.
+    $executable = $this->getMock(MigrateExecutableInterface::class);
+    $row = new Row([], []);
+
+    // Return the downloaded file's local URI.
+    $value = [
+      'http://drupal.org/favicon.ico',
+      $destination_uri,
+    ];
+    return $plugin->transform($value, $executable, $row, 'foobaz');
+  }
+
+}

core/modules/migrate/tests/src/Kernel/process/ExtractTest.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\process;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\MigrateMessage;
+use Drupal\migrate\Plugin\MigrationInterface;
+
+/**
+ * Tests the extract process plugin.
+ *
+ * @group migrate
+ */
+class ExtractTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate'];
+
+  /**
+   * Returns test migration definition.
+   *
+   * @return array
+   */
+  public function getDefinition() {
+    return [
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => [],
+        'ids' => [
+          'id' => ['type' => 'string'],
+        ],
+      ],
+      'process' => [
+        'first' => [
+          'plugin' => 'extract',
+          'index' => [0],
+          'source' => 'simple_array',
+        ],
+        'second' => [
+          'plugin' => 'extract',
+          'index' => [1],
+          'source' => 'complex_array',
+        ],
+      ],
+      'destination' => [
+        'plugin' => 'config',
+        'config_name' => 'migrate_test.settings',
+      ],
+    ];
+  }
+
+  /**
+   * Tests multiple value handling.
+   *
+   * @dataProvider multipleValueProviderSource
+   *
+   * @param array $source_data
+   * @param array $expected_data
+   */
+  public function testMultipleValueExplode(array $source_data, array $expected_data) {
+    $definition = $this->getDefinition();
+    $definition['source']['data_rows'] = [$source_data];
+
+    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($definition);
+
+    $executable = new MigrateExecutable($migration, new MigrateMessage());
+    $result = $executable->import();
+
+    // Migration needs to succeed before further assertions are made.
+    $this->assertSame(MigrationInterface::RESULT_COMPLETED, $result);
+
+    // Compare with expected data.
+    $this->assertEquals($expected_data, \Drupal::config('migrate_test.settings')->get());
+  }
+
+  /**
+   * Provides multiple source data for "extract" process plugin test.
+   */
+  public function multipleValueProviderSource() {
+    $tests = [
+      [
+        'source_data' => [
+          'id' => '1',
+          'simple_array' => ['alpha', 'beta'],
+          'complex_array' => [['alpha', 'beta'], ['psi', 'omega']],
+        ],
+        'expected_data' => [
+          'first' => 'alpha',
+          'second' => ['psi', 'omega'],
+        ],
+      ],
+      [
+        'source_data' => [
+          'id' => '2',
+          'simple_array' => ['one'],
+          'complex_array' => [0, 1],
+        ],
+        'expected_data' => [
+          'first' => 'one',
+          'second' => 1,
+        ],
+      ],
+    ];
+
+    return $tests;
+  }
+
+}

core/modules/migrate/tests/src/Kernel/process/FileCopyTest.php

@@ -0,0 +1,232 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\process;
+
+use Drupal\Core\StreamWrapper\StreamWrapperInterface;
+use Drupal\KernelTests\Core\File\FileTestBase;
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Plugin\migrate\process\FileCopy;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\Plugin\MigrateProcessInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Tests the file_copy process plugin.
+ *
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\FileCopy
+ *
+ * @group migrate
+ */
+class FileCopyTest extends FileTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate', 'system'];
+
+  /**
+   * The file system service.
+   *
+   * @var \Drupal\Core\File\FileSystemInterface
+   */
+  protected $fileSystem;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->fileSystem = $this->container->get('file_system');
+    $this->container->get('stream_wrapper_manager')->registerWrapper('temporary', 'Drupal\Core\StreamWrapper\TemporaryStream', StreamWrapperInterface::LOCAL_NORMAL);
+  }
+
+  /**
+   * Test successful imports/copies.
+   */
+  public function testSuccessfulCopies() {
+    $file = $this->createUri(NULL, NULL, 'temporary');
+    $file_absolute = $this->fileSystem->realpath($file);
+    $data_sets = [
+      // Test a local to local copy.
+      [
+        $this->root . '/core/modules/simpletest/files/image-test.jpg',
+        'public://file1.jpg'
+      ],
+      // Test a temporary file using an absolute path.
+      [
+        $file_absolute,
+        'temporary://test.jpg'
+      ],
+      // Test a temporary file using a relative path.
+      [
+        $file_absolute,
+        'temporary://core/modules/simpletest/files/test.jpg'
+      ],
+    ];
+    foreach ($data_sets as $data) {
+      list($source_path, $destination_path) = $data;
+      $actual_destination = $this->doTransform($source_path, $destination_path);
+      $message = sprintf('File %s exists', $destination_path);
+      $this->assertFileExists($destination_path, $message);
+      // Make sure we didn't accidentally do a move.
+      $this->assertFileExists($source_path, $message);
+      $this->assertSame($actual_destination, $destination_path, 'The import returned the copied filename.');
+    }
+  }
+
+  /**
+   * Test successful file reuse.
+   */
+  public function testSuccessfulReuse() {
+    $source_path = $this->root . '/core/modules/simpletest/files/image-test.jpg';
+    $destination_path = 'public://file1.jpg';
+    $file_reuse = file_unmanaged_copy($source_path, $destination_path);
+    $timestamp = (new \SplFileInfo($file_reuse))->getMTime();
+    $this->assertInternalType('int', $timestamp);
+
+    // We need to make sure the modified timestamp on the file is sooner than
+    // the attempted migration.
+    sleep(1);
+    $configuration = ['reuse' => TRUE];
+    $this->doTransform($source_path, $destination_path, $configuration);
+    clearstatcache(TRUE, $destination_path);
+    $modified_timestamp = (new \SplFileInfo($destination_path))->getMTime();
+    $this->assertEquals($timestamp, $modified_timestamp);
+
+    $configuration = ['reuse' => FALSE];
+    $this->doTransform($source_path, $destination_path, $configuration);
+    clearstatcache(TRUE, $destination_path);
+    $modified_timestamp = (new \SplFileInfo($destination_path))->getMTime();
+    $this->assertGreaterThan($timestamp, $modified_timestamp);
+  }
+
+  /**
+   * Test successful moves.
+   */
+  public function testSuccessfulMoves() {
+    $file_1 = $this->createUri(NULL, NULL, 'temporary');
+    $file_1_absolute = $this->fileSystem->realpath($file_1);
+    $file_2 = $this->createUri(NULL, NULL, 'temporary');
+    $file_2_absolute = $this->fileSystem->realpath($file_2);
+    $local_file = $this->createUri(NULL, NULL, 'public');
+    $data_sets = [
+      // Test a local to local copy.
+      [
+        $local_file,
+        'public://file1.jpg'
+      ],
+      // Test a temporary file using an absolute path.
+      [
+        $file_1_absolute,
+        'temporary://test.jpg'
+      ],
+      // Test a temporary file using a relative path.
+      [
+        $file_2_absolute,
+        'temporary://core/modules/simpletest/files/test.jpg'
+      ],
+    ];
+    foreach ($data_sets as $data) {
+      list($source_path, $destination_path) = $data;
+      $actual_destination = $this->doTransform($source_path, $destination_path, ['move' => TRUE]);
+      $message = sprintf('File %s exists', $destination_path);
+      $this->assertFileExists($destination_path, $message);
+      $message = sprintf('File %s does not exist', $source_path);
+      $this->assertFileNotExists($source_path, $message);
+      $this->assertSame($actual_destination, $destination_path, 'The importer returned the moved filename.');
+    }
+  }
+
+  /**
+   * Test that non-existent files throw an exception.
+   */
+  public function testNonExistentSourceFile() {
+    $source = '/non/existent/file';
+    $this->setExpectedException(MigrateException::class, "File '/non/existent/file' does not exist");
+    $this->doTransform($source, 'public://wontmatter.jpg');
+  }
+
+  /**
+   * Tests that non-writable destination throw an exception.
+   *
+   * @covers ::transform
+   */
+  public function testNonWritableDestination() {
+    $source = $this->createUri('file.txt', NULL, 'temporary');
+
+    // Create the parent location.
+    $this->createDirectory('public://dir');
+
+    // Copy the file under public://dir/subdir1/.
+    $this->doTransform($source, 'public://dir/subdir1/file.txt');
+
+    // Check that 'subdir1' was created and the file was successfully migrated.
+    $this->assertFileExists('public://dir/subdir1/file.txt');
+
+    // Remove all permissions from public://dir to trigger a failure when
+    // trying to create a subdirectory 'subdir2' inside public://dir.
+    $this->fileSystem->chmod('public://dir', 0);
+
+    // Check that the proper exception is raised.
+    $this->setExpectedException(MigrateException::class, "Could not create or write to directory 'public://dir/subdir2'");
+    $this->doTransform($source, 'public://dir/subdir2/file.txt');
+  }
+
+  /**
+   * Test the 'rename' overwrite mode.
+   */
+  public function testRenameFile() {
+    $source = $this->createUri(NULL, NULL, 'temporary');
+    $destination = $this->createUri('foo.txt', NULL, 'public');
+    $expected_destination = 'public://foo_0.txt';
+    $actual_destination = $this->doTransform($source, $destination, ['rename' => TRUE]);
+    $this->assertFileExists($expected_destination, 'File was renamed on import');
+    $this->assertSame($actual_destination, $expected_destination, 'The importer returned the renamed filename.');
+  }
+
+  /**
+   * Tests that remote URIs are delegated to the download plugin.
+   */
+  public function testDownloadRemoteUri() {
+    $download_plugin = $this->getMock(MigrateProcessInterface::class);
+    $download_plugin->expects($this->once())->method('transform');
+
+    $plugin = new FileCopy(
+      [],
+      $this->randomMachineName(),
+      [],
+      $this->container->get('stream_wrapper_manager'),
+      $this->container->get('file_system'),
+      $download_plugin
+    );
+
+    $plugin->transform(
+      ['http://drupal.org/favicon.ico', '/destination/path'],
+      $this->getMock(MigrateExecutableInterface::class),
+      new Row([], []),
+      $this->randomMachineName()
+    );
+  }
+
+  /**
+   * Do an import using the destination.
+   *
+   * @param string $source_path
+   *   Source path to copy from.
+   * @param string $destination_path
+   *   The destination path to copy to.
+   * @param array $configuration
+   *   Process plugin configuration settings.
+   *
+   * @return string
+   *   The URI of the copied file.
+   */
+  protected function doTransform($source_path, $destination_path, $configuration = []) {
+    $plugin = FileCopy::create($this->container, $configuration, 'file_copy', []);
+    $executable = $this->prophesize(MigrateExecutableInterface::class)->reveal();
+    $row = new Row([], []);
+
+    return $plugin->transform([$source_path, $destination_path], $executable, $row, 'foobaz');
+  }
+
+}

core/modules/migrate/tests/src/Kernel/process/HandleMultiplesTest.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\process;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\MigrateMessage;
+use Drupal\migrate\Plugin\MigrationInterface;
+
+/**
+ * Tests process pipelines with scalar and multiple values handling.
+ *
+ * @group migrate
+ */
+class HandleMultiplesTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate'];
+
+  /**
+   * Provides the test migration definition.
+   *
+   * @return array
+   */
+  public function getDefinition() {
+    return [
+      'source' => [
+        'plugin' => 'embedded_data',
+        'data_rows' => [],
+        'ids' => [
+          'id' => ['type' => 'string'],
+        ],
+      ],
+      'process' => [
+        // Process pipeline for testing values from string to array to string.
+        'first' => [
+          // Expects a string and returns an array.
+          [
+            'plugin' => 'explode',
+            'source' => 'scalar',
+            'delimiter' => '/',
+          ],
+          // Expects an array and returns a string.
+          [
+            'plugin' => 'extract',
+            'index' => [1],
+          ],
+          // Expects a string and returns a string.
+          [
+            'plugin' => 'callback',
+            'callable' => 'strtoupper',
+          ],
+        ],
+        // Process pipeline for testing values from array to string to array.
+        'second' => [
+          // Expects an array and returns a string.
+          [
+            'plugin' => 'extract',
+            'source' => 'multiple',
+            'index' => [1],
+          ],
+          // Expects a string and returns a string.
+          [
+            'plugin' => 'callback',
+            'callable' => 'strtoupper',
+          ],
+          // Expects a string and returns an array.
+          [
+            'plugin' => 'explode',
+            'delimiter' => '/',
+          ],
+        ],
+      ],
+      'destination' => [
+        'plugin' => 'config',
+        'config_name' => 'migrate_test.settings',
+      ],
+    ];
+  }
+
+  /**
+   * Tests process pipelines with scalar and multiple values handling.
+   *
+   * @dataProvider scalarAndMultipleValuesProviderSource
+   *
+   * @param array $source_data
+   * @param array $expected_data
+   */
+  public function testScalarAndMultipleValues(array $source_data, array $expected_data) {
+    $definition = $this->getDefinition();
+    $definition['source']['data_rows'] = [$source_data];
+
+    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($definition);
+
+    $executable = new MigrateExecutable($migration, new MigrateMessage());
+    $result = $executable->import();
+
+    // Migration needs to succeed before further assertions are made.
+    $this->assertSame(MigrationInterface::RESULT_COMPLETED, $result);
+
+    // Compare with expected data.
+    $this->assertEquals($expected_data, \Drupal::config('migrate_test.settings')->get());
+  }
+
+  /**
+   * Provides the source data with scalar and multiple values.
+   *
+   * @return array
+   */
+  public function scalarAndMultipleValuesProviderSource() {
+    return [
+      [
+        'source_data' => [
+          'id' => '1',
+          // Source value for the first pipeline.
+          'scalar' => 'foo/bar',
+          // Source value for the second pipeline.
+          'multiple' => [
+            'foo',
+            'bar/baz',
+          ],
+        ],
+        'expected_data' => [
+          // Expected value from the first pipeline.
+          'first' => 'BAR',
+          // Expected value from the second pipeline.
+          'second' => [
+            'BAR',
+            'BAZ',
+          ],
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/migrate/tests/src/Kernel/process/RouteTest.php

@@ -0,0 +1,278 @@
+<?php
+
+namespace Drupal\Tests\migrate\Kernel\process;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\Plugin\migrate\process\Route;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Row;
+use Drupal\user\Entity\User;
+
+/**
+ * Tests the route process plugin.
+ *
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\Route
+ *
+ * @group migrate
+ */
+class RouteTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['user', 'system'];
+
+  /**
+   * Tests Route plugin based on providerTestRoute() values.
+   *
+   * @param mixed $value
+   *   Input value for the Route process plugin.
+   * @param array $expected
+   *   The expected results from the Route transform process.
+   *
+   * @dataProvider providerTestRoute
+   */
+  public function testRoute($value, $expected) {
+    $actual = $this->doTransform($value);
+    $this->assertSame($expected, $actual);
+  }
+
+  /**
+   * Data provider for testRoute().
+   *
+   * @return array
+   *   An array of arrays, where the first element is the input to the Route
+   *   process plugin, and the second is the expected results.
+   */
+  public function providerTestRoute() {
+    // Internal link tests.
+    // Valid link path and options.
+    $values[0] = [
+      'user/login',
+      [
+        'attributes' => [
+          'title' => 'Test menu link 1',
+        ],
+      ],
+    ];
+    $expected[0] = [
+      'route_name' => 'user.login',
+      'route_parameters' => [],
+      'options' => [
+        'query' => [],
+        'attributes' => [
+          'title' => 'Test menu link 1',
+        ],
+      ],
+      'url' => NULL,
+    ];
+
+    // Valid link path and empty options.
+    $values[1] = [
+      'user/login',
+      [],
+    ];
+    $expected[1] = [
+      'route_name' => 'user.login',
+      'route_parameters' => [],
+      'options' => [
+        'query' => [],
+      ],
+      'url' => NULL,
+    ];
+
+    // Valid link path and no options.
+    $values[2] = 'user/login';
+    $expected[2] = [
+      'route_name' => 'user.login',
+      'route_parameters' => [],
+      'options' => [
+        'query' => [],
+      ],
+      'url' => NULL,
+    ];
+
+    // Invalid link path.
+    $values[3] = 'users';
+    $expected[3] = [];
+
+    // Valid link path with parameter.
+    $values[4] = [
+      'system/timezone/nzdt',
+      [
+        'attributes' => [
+          'title' => 'Show NZDT',
+        ],
+      ],
+    ];
+    $expected[4] = [
+      'route_name' => 'system.timezone',
+      'route_parameters' => [
+        'abbreviation' => 'nzdt',
+        'offset' => -1,
+        'is_daylight_saving_time' => NULL,
+      ],
+      'options' => [
+        'query' => [],
+        'attributes' => [
+          'title' => 'Show NZDT',
+        ],
+      ],
+      'url' => NULL,
+    ];
+
+    // External link tests.
+    // Valid external link path and options.
+    $values[5] = [
+      'https://www.drupal.org',
+      [
+        'attributes' => [
+          'title' => 'Drupal',
+        ],
+      ],
+    ];
+    $expected[5] = [
+      'route_name' => NULL,
+      'route_parameters' => [],
+      'options' => [
+        'attributes' => [
+          'title' => 'Drupal',
+        ],
+      ],
+      'url' => 'https://www.drupal.org',
+    ];
+
+    // Valid external link path and options.
+    $values[6] = [
+      'https://www.drupal.org/user/1/edit?pass-reset-token=QgtDKcRV4e4fjg6v2HTa6CbWx-XzMZ5XBZTufinqsM73qIhscIuU_BjZ6J2tv4dQI6N50ZJOag',
+      [
+        'attributes' => [
+          'title' => 'Drupal password reset',
+        ],
+      ],
+    ];
+    $expected[6] = [
+      'route_name' => NULL,
+      'route_parameters' => [],
+      'options' => [
+        'attributes' => [
+          'title' => 'Drupal password reset',
+        ],
+      ],
+      'url' => 'https://www.drupal.org/user/1/edit?pass-reset-token=QgtDKcRV4e4fjg6v2HTa6CbWx-XzMZ5XBZTufinqsM73qIhscIuU_BjZ6J2tv4dQI6N50ZJOag',
+    ];
+
+    return [
+      // Test data for internal paths.
+      // Test with valid link path and options.
+      [$values[0], $expected[0]],
+      // Test with valid link path and empty options.
+      [$values[1], $expected[1]],
+      // Test with valid link path and no options.
+      [$values[2], $expected[2]],
+      // Test with Invalid link path.
+      [$values[3], $expected[3]],
+      // Test with Valid link path with query options and parameters.
+      [$values[4], $expected[4]],
+
+      // Test data for external paths.
+      // Test with external link path and options.
+      [$values[5], $expected[5]],
+      // Test with valid link path and query options.
+      [$values[6], $expected[6]],
+    ];
+  }
+
+  /**
+   * Tests Route plugin based on providerTestRoute() values.
+   *
+   * @param mixed $value
+   *   Input value for the Route process plugin.
+   * @param array $expected
+   *   The expected results from the Route transform process.
+   *
+   * @dataProvider providerTestRouteWithParamQuery
+   */
+  public function testRouteWithParamQuery($value, $expected) {
+    $this->installSchema('system', ['sequences']);
+    $this->installEntitySchema('user');
+    $this->installConfig(['user']);
+
+    // Create a user so that user/1/edit is a valid path.
+    $adminUser = User::create([
+      'name' => $this->randomMachineName(),
+    ]);
+    $adminUser->save();
+
+    $actual = $this->doTransform($value);
+    $this->assertSame($expected, $actual);
+  }
+
+  /**
+   * Data provider for testRouteWithParamQuery().
+   *
+   * @return array
+   *   An array of arrays, where the first element is the input to the Route
+   *   process plugin, and the second is the expected results.
+   */
+  public function providerTestRouteWithParamQuery() {
+    $values = [];
+    $expected = [];
+    // Valid link path with query options and parameters.
+    $values[0] = [
+      'user/1/edit',
+      [
+        'attributes' => [
+          'title' => 'Edit admin',
+        ],
+        'query' => [
+          'destination' => '/admin/people',
+        ],
+      ],
+    ];
+    $expected[0] = [
+      'route_name' => 'entity.user.edit_form',
+      'route_parameters' => [
+        'user' => '1',
+      ],
+      'options' => [
+        'attributes' => [
+          'title' => 'Edit admin',
+        ],
+        'query' => [
+          'destination' => '/admin/people',
+        ],
+      ],
+      'url' => NULL,
+    ];
+
+    return [
+      // Test with valid link path with parameters and options.
+      [$values[0], $expected[0]],
+    ];
+  }
+
+  /**
+   * Transforms link path data to a route.
+   *
+   * @param array|string $value
+   *   Source link path information.
+   *
+   * @return array
+   *   The route information based on the source link_path.
+   */
+  protected function doTransform($value) {
+    // Rebuild the routes.
+    $this->container->get('router.builder')->rebuild();
+    $pathValidator = $this->container->get('path.validator');
+    $row = new Row();
+    $migration = $this->prophesize(MigrationInterface::class)->reveal();
+    $executable = $this->prophesize(MigrateExecutableInterface::class)->reveal();
+
+    $plugin = new Route([], 'route', [], $migration, $pathValidator);
+    $actual = $plugin->transform($value, $executable, $row, 'destinationproperty');
+    return $actual;
+  }
+
+}

core/modules/migrate/tests/src/Unit/Event/EventBaseTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\Event;
+
+use Drupal\migrate\Event\EventBase;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Event\EventBase
+ * @group migrate
+ */
+class EventBaseTest extends \PHPUnit_Framework_TestCase {
+
+  /**
+   * Test getMigration method.
+   *
+   * @covers ::__construct
+   * @covers ::getMigration
+   */
+  public function testGetMigration() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface')->reveal();
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface')->reveal();
+    $row = $this->prophesize('\Drupal\migrate\Row')->reveal();
+    $event = new EventBase($migration, $message_service, $row, [1, 2, 3]);
+    $this->assertSame($migration, $event->getMigration());
+  }
+
+  /**
+   * Test logging a message.
+   *
+   * @covers ::__construct
+   * @covers ::logMessage
+   */
+  public function testLogMessage() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface')->reveal();
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface');
+    $event = new EventBase($migration, $message_service->reveal());
+    // Assert that the intended calls to the services happen.
+    $message_service->display('status message', 'status')->shouldBeCalledTimes(1);
+    $event->logMessage('status message');
+    $message_service->display('warning message', 'warning')->shouldBeCalledTimes(1);
+    $event->logMessage('warning message', 'warning');
+  }
+
+}

core/modules/migrate/tests/src/Unit/Event/MigrateImportEventTest.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\Event;
+
+use Drupal\migrate\Event\MigrateImportEvent;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Event\MigrateImportEvent
+ * @group migrate
+ */
+class MigrateImportEventTest extends \PHPUnit_Framework_TestCase {
+
+  /**
+   * Test getMigration method.
+   *
+   * @covers ::__construct
+   * @covers ::getMigration
+   */
+  public function testGetMigration() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface')->reveal();
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface')->reveal();
+    $event = new MigrateImportEvent($migration, $message_service);
+    $this->assertSame($migration, $event->getMigration());
+  }
+
+  /**
+   * Test logging a message.
+   *
+   * @covers ::__construct
+   * @covers ::logMessage
+   */
+  public function testLogMessage() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface');
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface');
+    $event = new MigrateImportEvent($migration->reveal(), $message_service->reveal());
+    // Assert that the intended calls to the services happen.
+    $message_service->display('status message', 'status')->shouldBeCalledTimes(1);
+    $event->logMessage('status message');
+    $message_service->display('warning message', 'warning')->shouldBeCalledTimes(1);
+    $event->logMessage('warning message', 'warning');
+  }
+
+}

core/modules/migrate/tests/src/Unit/Event/MigratePostRowSaveEventTest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\Event;
+
+use Drupal\migrate\Event\MigratePostRowSaveEvent;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Event\MigratePostRowSaveEvent
+ * @group migrate
+ */
+class MigratePostRowSaveEventTest extends EventBaseTest {
+
+  /**
+   * Test getDestinationIdValues method.
+   *
+   * @covers ::__construct
+   * @covers ::getDestinationIdValues
+   */
+  public function testGetDestinationIdValues() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface')->reveal();
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface')->reveal();
+    $row = $this->prophesize('\Drupal\migrate\Row')->reveal();
+    $event = new MigratePostRowSaveEvent($migration, $message_service, $row, [1, 2, 3]);
+    $this->assertSame([1, 2, 3], $event->getDestinationIdValues());
+  }
+
+  /**
+   * Test getRow method.
+   *
+   * @covers ::__construct
+   * @covers ::getRow
+   */
+  public function testGetRow() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface')->reveal();
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface');
+    $row = $this->prophesize('\Drupal\migrate\Row')->reveal();
+    $event = new MigratePostRowSaveEvent($migration, $message_service->reveal(), $row, [1, 2, 3]);
+    $this->assertSame($row, $event->getRow());
+  }
+
+}

core/modules/migrate/tests/src/Unit/Event/MigratePreRowSaveEventTest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\Event;
+
+use Drupal\migrate\Event\MigratePreRowSaveEvent;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Event\MigratePreRowSaveEvent
+ * @group migrate
+ */
+class MigratePreRowSaveEventTest extends EventBaseTest {
+
+  /**
+   * Test getRow method.
+   *
+   * @covers ::__construct
+   * @covers ::getRow
+   */
+  public function testGetRow() {
+    $migration = $this->prophesize('\Drupal\migrate\Plugin\MigrationInterface')->reveal();
+    $message_service = $this->prophesize('\Drupal\migrate\MigrateMessageInterface')->reveal();
+    $row = $this->prophesize('\Drupal\migrate\Row')->reveal();
+    $event = new MigratePreRowSaveEvent($migration, $message_service, $row);
+    $this->assertSame($row, $event->getRow());
+  }
+
+}

core/modules/migrate/tests/src/Unit/Exception/RequirementsExceptionTest.php

@@ -34,18 +34,18 @@ class RequirementsExceptionTest extends UnitTestCase {
    * Provides a list of requirements to test.
    */
   public function getRequirementsProvider() {
-    return array(
-      array(
+    return [
+      [
         'requirements: random_jackson_pivot.',
         'Single Requirement',
-        array('requirements' => $this->missingRequirements[0]),
-      ),
-      array(
+        ['requirements' => $this->missingRequirements[0]],
+      ],
+      [
         'requirements: random_jackson_pivot. requirements: 51_Eridani_b.',
         'Multiple Requirements',
-        array('requirements' => $this->missingRequirements),
-      ),
-    );
+        ['requirements' => $this->missingRequirements],
+      ],
+    ];
   }
 
 }

core/modules/migrate/tests/src/Unit/MigrateExecutableMemoryExceededTest.php

@@ -35,9 +35,9 @@ class MigrateExecutableMemoryExceededTest extends MigrateTestCase {
    *
    * @var array
    */
-  protected $migrationConfiguration = array(
+  protected $migrationConfiguration = [
     'id' => 'test',
-  );
+  ];
 
   /**
    * The php.ini memory_limit value.

core/modules/migrate/tests/src/Unit/MigrateExecutableTest.php

@@ -3,6 +3,7 @@
 namespace Drupal\Tests\migrate\Unit;
 
 use Drupal\Component\Utility\Html;
+use Drupal\migrate\Plugin\MigrateProcessInterface;
 use Drupal\migrate\Plugin\MigrationInterface;
 use Drupal\migrate\Plugin\MigrateIdMapInterface;
 use Drupal\migrate\MigrateException;
@@ -40,9 +41,9 @@ class MigrateExecutableTest extends MigrateTestCase {
    *
    * @var array
    */
-  protected $migrationConfiguration = array(
+  protected $migrationConfiguration = [
     'id' => 'test',
-  );
+  ];
 
   /**
    * {@inheritdoc}
@@ -91,12 +92,12 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $row->expects($this->once())
       ->method('getSourceIdValues')
-      ->will($this->returnValue(array('id' => 'test')));
+      ->will($this->returnValue(['id' => 'test']));
 
     $this->idMap->expects($this->once())
       ->method('lookupDestinationId')
-      ->with(array('id' => 'test'))
-      ->will($this->returnValue(array('test')));
+      ->with(['id' => 'test'])
+      ->will($this->returnValue(['test']));
 
     $source->expects($this->once())
       ->method('current')
@@ -106,17 +107,17 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $this->migration->expects($this->once())
       ->method('getProcessPlugins')
-      ->will($this->returnValue(array()));
+      ->will($this->returnValue([]));
 
     $destination = $this->getMock('Drupal\migrate\Plugin\MigrateDestinationInterface');
     $destination->expects($this->once())
       ->method('import')
-      ->with($row, array('test'))
-      ->will($this->returnValue(array('id' => 'test')));
+      ->with($row, ['test'])
+      ->will($this->returnValue(['id' => 'test']));
 
-    $this->migration->expects($this->once())
+    $this->migration
       ->method('getDestinationPlugin')
-      ->will($this->returnValue($destination));
+      ->willReturn($destination);
 
     $this->assertSame(MigrationInterface::RESULT_COMPLETED, $this->executable->import());
   }
@@ -133,12 +134,12 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $row->expects($this->once())
       ->method('getSourceIdValues')
-      ->will($this->returnValue(array('id' => 'test')));
+      ->will($this->returnValue(['id' => 'test']));
 
     $this->idMap->expects($this->once())
       ->method('lookupDestinationId')
-      ->with(array('id' => 'test'))
-      ->will($this->returnValue(array('test')));
+      ->with(['id' => 'test'])
+      ->will($this->returnValue(['test']));
 
     $source->expects($this->once())
       ->method('current')
@@ -148,17 +149,17 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $this->migration->expects($this->once())
       ->method('getProcessPlugins')
-      ->will($this->returnValue(array()));
+      ->will($this->returnValue([]));
 
     $destination = $this->getMock('Drupal\migrate\Plugin\MigrateDestinationInterface');
     $destination->expects($this->once())
       ->method('import')
-      ->with($row, array('test'))
+      ->with($row, ['test'])
       ->will($this->returnValue(TRUE));
 
-    $this->migration->expects($this->once())
+    $this->migration
       ->method('getDestinationPlugin')
-      ->will($this->returnValue($destination));
+      ->willReturn($destination);
 
     $this->idMap->expects($this->never())
       ->method('saveIdMapping');
@@ -178,7 +179,7 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $row->expects($this->once())
       ->method('getSourceIdValues')
-      ->will($this->returnValue(array('id' => 'test')));
+      ->will($this->returnValue(['id' => 'test']));
 
     $source->expects($this->once())
       ->method('current')
@@ -188,21 +189,21 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $this->migration->expects($this->once())
       ->method('getProcessPlugins')
-      ->will($this->returnValue(array()));
+      ->will($this->returnValue([]));
 
     $destination = $this->getMock('Drupal\migrate\Plugin\MigrateDestinationInterface');
     $destination->expects($this->once())
       ->method('import')
-      ->with($row, array('test'))
-      ->will($this->returnValue(array()));
+      ->with($row, ['test'])
+      ->will($this->returnValue([]));
 
-    $this->migration->expects($this->once())
+    $this->migration
       ->method('getDestinationPlugin')
-      ->will($this->returnValue($destination));
+      ->willReturn($destination);
 
     $this->idMap->expects($this->once())
       ->method('saveIdMapping')
-      ->with($row, array(), MigrateIdMapInterface::STATUS_FAILED, NULL);
+      ->with($row, [], MigrateIdMapInterface::STATUS_FAILED, NULL);
 
     $this->idMap->expects($this->once())
       ->method('messageCount')
@@ -213,8 +214,8 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $this->idMap->expects($this->once())
       ->method('lookupDestinationId')
-      ->with(array('id' => 'test'))
-      ->will($this->returnValue(array('test')));
+      ->with(['id' => 'test'])
+      ->will($this->returnValue(['test']));
 
     $this->message->expects($this->once())
       ->method('display')
@@ -238,7 +239,7 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $row->expects($this->once())
       ->method('getSourceIdValues')
-      ->will($this->returnValue(array('id' => 'test')));
+      ->will($this->returnValue(['id' => 'test']));
 
     $source->expects($this->once())
       ->method('current')
@@ -248,29 +249,29 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $this->migration->expects($this->once())
       ->method('getProcessPlugins')
-      ->will($this->returnValue(array()));
+      ->will($this->returnValue([]));
 
     $destination = $this->getMock('Drupal\migrate\Plugin\MigrateDestinationInterface');
     $destination->expects($this->once())
       ->method('import')
-      ->with($row, array('test'))
+      ->with($row, ['test'])
       ->will($this->throwException(new MigrateException($exception_message)));
 
-    $this->migration->expects($this->once())
+    $this->migration
       ->method('getDestinationPlugin')
-      ->will($this->returnValue($destination));
+      ->willReturn($destination);
 
     $this->idMap->expects($this->once())
       ->method('saveIdMapping')
-      ->with($row, array(), MigrateIdMapInterface::STATUS_FAILED, NULL);
+      ->with($row, [], MigrateIdMapInterface::STATUS_FAILED, NULL);
 
     $this->idMap->expects($this->once())
       ->method('saveMessage');
 
     $this->idMap->expects($this->once())
       ->method('lookupDestinationId')
-      ->with(array('id' => 'test'))
-      ->will($this->returnValue(array('test')));
+      ->with(['id' => 'test'])
+      ->will($this->returnValue(['test']));
 
     $this->assertSame(MigrationInterface::RESULT_COMPLETED, $this->executable->import());
   }
@@ -290,7 +291,7 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $row->expects($this->once())
       ->method('getSourceIdValues')
-      ->willReturn(array('id' => 'test'));
+      ->willReturn(['id' => 'test']);
 
     $source->expects($this->once())
       ->method('current')
@@ -306,13 +307,13 @@ class MigrateExecutableTest extends MigrateTestCase {
     $destination->expects($this->never())
       ->method('import');
 
-    $this->migration->expects($this->once())
+    $this->migration
       ->method('getDestinationPlugin')
       ->willReturn($destination);
 
     $this->idMap->expects($this->once())
       ->method('saveIdMapping')
-      ->with($row, array(), MigrateIdMapInterface::STATUS_FAILED, NULL);
+      ->with($row, [], MigrateIdMapInterface::STATUS_FAILED, NULL);
 
     $this->idMap->expects($this->once())
       ->method('saveMessage');
@@ -336,7 +337,7 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $row->expects($this->once())
       ->method('getSourceIdValues')
-      ->will($this->returnValue(array('id' => 'test')));
+      ->will($this->returnValue(['id' => 'test']));
 
     $source->expects($this->once())
       ->method('current')
@@ -346,29 +347,29 @@ class MigrateExecutableTest extends MigrateTestCase {
 
     $this->migration->expects($this->once())
       ->method('getProcessPlugins')
-      ->will($this->returnValue(array()));
+      ->will($this->returnValue([]));
 
     $destination = $this->getMock('Drupal\migrate\Plugin\MigrateDestinationInterface');
     $destination->expects($this->once())
       ->method('import')
-      ->with($row, array('test'))
+      ->with($row, ['test'])
       ->will($this->throwException(new \Exception($exception_message)));
 
-    $this->migration->expects($this->once())
+    $this->migration
       ->method('getDestinationPlugin')
-      ->will($this->returnValue($destination));
+      ->willReturn($destination);
 
     $this->idMap->expects($this->once())
       ->method('saveIdMapping')
-      ->with($row, array(), MigrateIdMapInterface::STATUS_FAILED, NULL);
+      ->with($row, [], MigrateIdMapInterface::STATUS_FAILED, NULL);
 
     $this->idMap->expects($this->once())
       ->method('saveMessage');
 
     $this->idMap->expects($this->once())
       ->method('lookupDestinationId')
-      ->with(array('id' => 'test'))
-      ->will($this->returnValue(array('test')));
+      ->with(['id' => 'test'])
+      ->will($this->returnValue(['test']));
 
     $this->message->expects($this->once())
       ->method('display')
@@ -381,15 +382,15 @@ class MigrateExecutableTest extends MigrateTestCase {
    * Tests the processRow method.
    */
   public function testProcessRow() {
-    $expected = array(
+    $expected = [
       'test' => 'test destination',
       'test1' => 'test1 destination'
-    );
+    ];
     foreach ($expected as $key => $value) {
       $plugins[$key][0] = $this->getMock('Drupal\migrate\Plugin\MigrateProcessInterface');
       $plugins[$key][0]->expects($this->once())
         ->method('getPluginDefinition')
-        ->will($this->returnValue(array()));
+        ->will($this->returnValue([]));
       $plugins[$key][0]->expects($this->once())
         ->method('transform')
         ->will($this->returnValue($value));
@@ -398,7 +399,7 @@ class MigrateExecutableTest extends MigrateTestCase {
       ->method('getProcessPlugins')
       ->with(NULL)
       ->will($this->returnValue($plugins));
-    $row = new Row(array(), array());
+    $row = new Row();
     $this->executable->processRow($row);
     foreach ($expected as $key => $value) {
       $this->assertSame($row->getDestinationProperty($key), $value);
@@ -413,10 +414,29 @@ class MigrateExecutableTest extends MigrateTestCase {
     $this->migration->expects($this->once())
       ->method('getProcessPlugins')
       ->with(NULL)
-      ->will($this->returnValue(array('test' => array())));
-    $row = new Row(array(), array());
+      ->will($this->returnValue(['test' => []]));
+    $row = new Row();
+    $this->executable->processRow($row);
+    $this->assertSame($row->getDestination(), []);
+  }
+
+  /**
+   * Tests the processRow pipeline exception.
+   */
+  public function testProcessRowPipelineException() {
+    $row = new Row();
+    $plugin = $this->prophesize(MigrateProcessInterface::class);
+    $plugin->getPluginDefinition()->willReturn(['handle_multiples' => FALSE]);
+    $plugin->transform(NULL, $this->executable, $row, 'destination_id')
+      ->willReturn('transform_return_string');
+    $plugin->multiple()->willReturn(TRUE);
+    $plugin->getPluginId()->willReturn('plugin_id');
+    $plugin = $plugin->reveal();
+    $plugins['destination_id'] = [$plugin, $plugin];
+    $this->migration->method('getProcessPlugins')->willReturn($plugins);
+
+    $this->setExpectedException(MigrateException::class, 'Pipeline failed at plugin_id plugin for destination destination_id: transform_return_string received instead of an array,');
     $this->executable->processRow($row);
-    $this->assertSame($row->getDestination(), array());
   }
 
   /**

core/modules/migrate/tests/src/Unit/MigrateSourceTest.php

@@ -10,6 +10,9 @@ namespace Drupal\Tests\migrate\Unit;
 use Drupal\Core\Cache\CacheBackendInterface;
 use Drupal\Core\DependencyInjection\ContainerBuilder;
 use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\KeyValueStore\KeyValueFactoryInterface;
+use Drupal\Core\KeyValueStore\KeyValueStoreInterface;
+use Drupal\migrate\MigrateException;
 use Drupal\migrate\MigrateExecutable;
 use Drupal\migrate\MigrateSkipRowException;
 use Drupal\migrate\Plugin\migrate\source\SourcePluginBase;
@@ -75,7 +78,21 @@ class MigrateSourceTest extends MigrateTestCase {
    * @return \Drupal\migrate\Plugin\MigrateSourceInterface
    *   A mocked source plugin.
    */
-  protected function getSource($configuration = [], $migrate_config = [], $status = MigrateIdMapInterface::STATUS_NEEDS_UPDATE) {
+  protected function getSource($configuration = [], $migrate_config = [], $status = MigrateIdMapInterface::STATUS_NEEDS_UPDATE, $high_water_value = NULL) {
+    $container = new ContainerBuilder();
+    \Drupal::setContainer($container);
+
+    $key_value = $this->getMock(KeyValueStoreInterface::class);
+
+    $key_value_factory = $this->getMock(KeyValueFactoryInterface::class);
+    $key_value_factory
+      ->method('get')
+      ->with('migrate:high_water')
+      ->willReturn($key_value);
+    $container->set('keyvalue', $key_value_factory);
+
+    $container->set('cache.migrate', $this->getMock(CacheBackendInterface::class));
+
     $this->migrationConfiguration = $this->defaultMigrationConfiguration + $migrate_config;
     $this->migration = parent::getMigration();
     $this->executable = $this->getMigrateExecutable($this->migration);
@@ -90,57 +107,54 @@ class MigrateSourceTest extends MigrateTestCase {
       ->willReturn($id_map_array);
 
     $constructor_args = [$configuration, 'd6_action', [], $this->migration];
-    $methods = ['getModuleHandler', 'fields', 'getIds', '__toString', 'getIterator', 'prepareRow', 'initializeIterator', 'calculateDependencies'];
-    $source_plugin = $this->getMock('\Drupal\migrate\Plugin\migrate\source\SourcePluginBase', $methods, $constructor_args);
+    $methods = ['getModuleHandler', 'fields', 'getIds', '__toString', 'prepareRow', 'initializeIterator'];
+    $source_plugin = $this->getMock(SourcePluginBase::class, $methods, $constructor_args);
 
     $source_plugin
-      ->expects($this->any())
       ->method('fields')
       ->willReturn([]);
     $source_plugin
-      ->expects($this->any())
       ->method('getIds')
       ->willReturn([]);
     $source_plugin
-      ->expects($this->any())
       ->method('__toString')
       ->willReturn('');
     $source_plugin
-      ->expects($this->any())
       ->method('prepareRow')
       ->willReturn(empty($migrate_config['prepare_row_false']));
+
+    $rows = [$this->row];
+    if (isset($configuration['high_water_property']) && isset($high_water_value)) {
+      $property = $configuration['high_water_property']['name'];
+      $rows = array_filter($rows, function (array $row) use ($property, $high_water_value) {
+        return $row[$property] >= $high_water_value;
+      });
+    }
+    $iterator = new \ArrayIterator($rows);
+
     $source_plugin
-      ->expects($this->any())
       ->method('initializeIterator')
-      ->willReturn([]);
-    $iterator = new \ArrayIterator([$this->row]);
-    $source_plugin
-      ->expects($this->any())
-      ->method('getIterator')
       ->willReturn($iterator);
 
-    $module_handler = $this->getMock('\Drupal\Core\Extension\ModuleHandlerInterface');
+    $module_handler = $this->getMock(ModuleHandlerInterface::class);
     $source_plugin
-      ->expects($this->any())
       ->method('getModuleHandler')
       ->willReturn($module_handler);
 
     $this->migration
-      ->expects($this->any())
       ->method('getSourcePlugin')
       ->willReturn($source_plugin);
 
-    return $this->migration->getSourcePlugin();
+    return $source_plugin;
   }
 
   /**
    * @covers ::__construct
-   * @expectedException \Drupal\migrate\MigrateException
    */
   public function testHighwaterTrackChangesIncompatible() {
-    $source_config = ['track_changes' => TRUE];
-    $migration_config = ['highWaterProperty' => ['name' => 'something']];
-    $this->getSource($source_config, $migration_config);
+    $source_config = ['track_changes' => TRUE, 'high_water_property' => ['name' => 'something']];
+    $this->setExpectedException(MigrateException::class);
+    $this->getSource($source_config);
   }
 
   /**
@@ -153,7 +167,7 @@ class MigrateSourceTest extends MigrateTestCase {
     $container = new ContainerBuilder();
     $cache = $this->getMock(CacheBackendInterface::class);
     $cache->expects($this->any())->method('set')
-        ->with($this->isType('string'), $this->isType('int'), $this->isType('int'));
+      ->with($this->isType('string'), $this->isType('int'), $this->isType('int'));
     $container->set('cache.migrate', $cache);
     \Drupal::setContainer($container);
 
@@ -168,9 +182,20 @@ class MigrateSourceTest extends MigrateTestCase {
     // Test the skip argument.
     $source = $this->getSource(['skip_count' => TRUE]);
     $this->assertEquals(-1, $source->count());
+
+    $this->migrationConfiguration['id'] = 'test_migration';
+    $migration = $this->getMigration();
+    $source = new StubSourceGeneratorPlugin([], '', [], $migration);
+
+    // Test the skipCount property's default value.
+    $this->assertEquals(-1, $source->count());
+
+    // Test the count value using a generator.
+    $source = new StubSourceGeneratorPlugin(['skip_count' => FALSE], '', [], $migration);
+    $this->assertEquals(3, $source->count());
   }
 
-   /**
+  /**
    * Test that the key can be set for the count cache.
    *
    * @covers ::count
@@ -180,7 +205,7 @@ class MigrateSourceTest extends MigrateTestCase {
     $container = new ContainerBuilder();
     $cache = $this->getMock(CacheBackendInterface::class);
     $cache->expects($this->any())->method('set')
-        ->with('test_key', $this->isType('int'), $this->isType('int'));
+      ->with('test_key', $this->isType('int'), $this->isType('int'));
     $container->set('cache.migrate', $cache);
     \Drupal::setContainer($container);
 
@@ -219,14 +244,12 @@ class MigrateSourceTest extends MigrateTestCase {
    * Test that an outdated highwater mark does not cause a row to be imported.
    */
   public function testOutdatedHighwater() {
-
-    $source = $this->getSource([], [], MigrateIdMapInterface::STATUS_IMPORTED);
-
-    // Set the originalHighwater to something higher than our timestamp.
-    $this->migration
-      ->expects($this->any())
-      ->method('getHighwater')
-      ->willReturn($this->row['timestamp'] + 1);
+    $configuration = [
+      'high_water_property' => [
+        'name' => 'timestamp',
+      ],
+    ];
+    $source = $this->getSource($configuration, [], MigrateIdMapInterface::STATUS_IMPORTED, $this->row['timestamp'] + 1);
 
     // The current highwater mark is now higher than the row timestamp so no row
     // is expected.
@@ -240,13 +263,17 @@ class MigrateSourceTest extends MigrateTestCase {
    * @throws \Exception
    */
   public function testNewHighwater() {
-
+    $configuration = [
+      'high_water_property' => [
+        'name' => 'timestamp',
+      ],
+    ];
     // Set a highwater property field for source. Now we should have a row
     // because the row timestamp is greater than the current highwater mark.
-    $source = $this->getSource([], ['highWaterProperty' => ['name' => 'timestamp']], MigrateIdMapInterface::STATUS_IMPORTED);
+    $source = $this->getSource($configuration, [], MigrateIdMapInterface::STATUS_IMPORTED, $this->row['timestamp'] - 1);
 
     $source->rewind();
-    $this->assertTrue(is_a($source->current(), 'Drupal\migrate\Row'), 'Incoming row timestamp is greater than current highwater mark so we have a row.');
+    $this->assertInstanceOf(Row::class, $source->current(), 'Incoming row timestamp is greater than current highwater mark so we have a row.');
   }
 
   /**
@@ -260,7 +287,7 @@ class MigrateSourceTest extends MigrateTestCase {
     // Get a new migration with an id.
     $migration = $this->getMigration();
     $source = new StubSourcePlugin([], '', [], $migration);
-    $row = new Row([], []);
+    $row = new Row();
 
     $module_handler = $this->prophesize(ModuleHandlerInterface::class);
     $module_handler->invokeAll('migrate_prepare_row', [$row, $source, $migration])
@@ -302,7 +329,7 @@ class MigrateSourceTest extends MigrateTestCase {
 
     $migration = $this->getMigration();
     $source = new StubSourcePlugin([], '', [], $migration);
-    $row = new Row([], []);
+    $row = new Row();
 
     $module_handler = $this->prophesize(ModuleHandlerInterface::class);
     // Return a failure from a prepare row hook.
@@ -331,7 +358,7 @@ class MigrateSourceTest extends MigrateTestCase {
 
     $migration = $this->getMigration();
     $source = new StubSourcePlugin([], '', [], $migration);
-    $row = new Row([], []);
+    $row = new Row();
 
     $module_handler = $this->prophesize(ModuleHandlerInterface::class);
     // Return a failure from a prepare row hook.
@@ -360,7 +387,7 @@ class MigrateSourceTest extends MigrateTestCase {
 
     $migration = $this->getMigration();
     $source = new StubSourcePlugin([], '', [], $migration);
-    $row = new Row([], []);
+    $row = new Row();
 
     $module_handler = $this->prophesize(ModuleHandlerInterface::class);
     // Return a failure from a prepare row hook.
@@ -387,6 +414,21 @@ class MigrateSourceTest extends MigrateTestCase {
     $this->assertFalse($source->prepareRow($row));
   }
 
+  /**
+   * Test that cacheCounts, skipCount, trackChanges preserve their default
+   * values.
+   */
+  public function testDefaultPropertiesValues() {
+    $this->migrationConfiguration['id'] = 'test_migration';
+    $migration = $this->getMigration();
+    $source = new StubSourceGeneratorPlugin([], '', [], $migration);
+
+    // Test the default value of the skipCount Value;
+    $this->assertTrue($source->getSkipCount());
+    $this->assertTrue($source->getCacheCounts());
+    $this->assertTrue($source->getTrackChanges());
+  }
+
   /**
    * Gets a mock executable for the test.
    *
@@ -450,3 +492,61 @@ class StubSourcePlugin extends SourcePluginBase {
   }
 
 }
+
+/**
+ * Stubbed source plugin with a generator as iterator. Also it overwrites the
+ * $skipCount, $cacheCounts and $trackChanges properties.
+ */
+class StubSourceGeneratorPlugin extends StubSourcePlugin {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $skipCount = TRUE;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $cacheCounts = TRUE;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $trackChanges = TRUE;
+
+  /**
+   * Return the skipCount value.
+   */
+  public function getSkipCount() {
+    return $this->skipCount;
+  }
+
+  /**
+   * Return the cacheCounts value.
+   */
+  public function getCacheCounts() {
+    return $this->cacheCounts;
+  }
+
+  /**
+   * Return the trackChanges value.
+   */
+  public function getTrackChanges() {
+    return $this->trackChanges;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function initializeIterator() {
+    $data = [
+      ['title' => 'foo'],
+      ['title' => 'bar'],
+      ['title' => 'iggy'],
+    ];
+    foreach ($data as $row) {
+      yield $row;
+    }
+  }
+
+}

core/modules/migrate/tests/src/Unit/MigrateSqlIdMapEnsureTablesTest.php

@@ -16,63 +16,70 @@ class MigrateSqlIdMapEnsureTablesTest extends MigrateTestCase {
    *
    * @var array
    */
-  protected $migrationConfiguration = array(
+  protected $migrationConfiguration = [
     'id' => 'sql_idmap_test',
-  );
+  ];
 
   /**
    * Tests the ensureTables method when the tables do not exist.
    */
   public function testEnsureTablesNotExist() {
-    $fields['source_ids_hash'] = Array(
+    $fields['source_ids_hash'] = [
       'type' => 'varchar',
       'length' => 64,
       'not null' => 1,
       'description' => 'Hash of source ids. Used as primary key'
-    );
-    $fields['sourceid1'] = array(
+    ];
+    $fields['sourceid1'] = [
       'type' => 'int',
       'not null' => TRUE,
-    );
-    $fields['destid1'] = array(
+    ];
+    $fields['sourceid2'] = [
+      'type' => 'int',
+      'not null' => TRUE,
+    ];
+    $fields['destid1'] = [
       'type' => 'varchar',
       'length' => 255,
       'not null' => FALSE,
-    );
-    $fields['source_row_status'] = array(
+    ];
+    $fields['source_row_status'] = [
       'type' => 'int',
       'size' => 'tiny',
       'unsigned' => TRUE,
       'not null' => TRUE,
       'default' => MigrateIdMapInterface::STATUS_IMPORTED,
       'description' => 'Indicates current status of the source row',
-    );
-    $fields['rollback_action'] = array(
+    ];
+    $fields['rollback_action'] = [
       'type' => 'int',
       'size' => 'tiny',
       'unsigned' => TRUE,
       'not null' => TRUE,
       'default' => MigrateIdMapInterface::ROLLBACK_DELETE,
       'description' => 'Flag indicating what to do for this item on rollback',
-    );
-    $fields['last_imported'] = array(
+    ];
+    $fields['last_imported'] = [
       'type' => 'int',
       'unsigned' => TRUE,
       'not null' => TRUE,
       'default' => 0,
       'description' => 'UNIX timestamp of the last time this row was imported',
-    );
-    $fields['hash'] = array(
+    ];
+    $fields['hash'] = [
       'type' => 'varchar',
       'length' => '64',
       'not null' => FALSE,
       'description' => 'Hash of source row data, for detecting changes',
-    );
-    $map_table_schema = array(
+    ];
+    $map_table_schema = [
       'description' => 'Mappings from source identifier value(s) to destination identifier value(s).',
       'fields' => $fields,
-      'primary key' => array('source_ids_hash'),
-    );
+      'primary key' => ['source_ids_hash'],
+      'indexes' => [
+        'source' => ['sourceid1', 'sourceid2'],
+      ],
+    ];
     $schema = $this->getMockBuilder('Drupal\Core\Database\Schema')
       ->disableOriginalConstructor()
       ->getMock();
@@ -84,34 +91,34 @@ class MigrateSqlIdMapEnsureTablesTest extends MigrateTestCase {
       ->method('createTable')
       ->with('migrate_map_sql_idmap_test', $map_table_schema);
     // Now do the message table.
-    $fields = array();
-    $fields['msgid'] = array(
+    $fields = [];
+    $fields['msgid'] = [
       'type' => 'serial',
       'unsigned' => TRUE,
       'not null' => TRUE,
-    );
-    $fields['source_ids_hash'] = Array(
+    ];
+    $fields['source_ids_hash'] = [
       'type' => 'varchar',
       'length' => 64,
       'not null' => 1,
       'description' => 'Hash of source ids. Used as primary key'
-    );
-    $fields['level'] = array(
+    ];
+    $fields['level'] = [
       'type' => 'int',
       'unsigned' => TRUE,
       'not null' => TRUE,
       'default' => 1,
-    );
-    $fields['message'] = array(
+    ];
+    $fields['message'] = [
       'type' => 'text',
       'size' => 'medium',
       'not null' => TRUE,
-    );
-    $table_schema = array(
+    ];
+    $table_schema = [
       'description' => 'Messages generated during a migration process',
       'fields' => $fields,
-      'primary key' => array('msgid'),
-    );
+      'primary key' => ['msgid'],
+    ];
 
     $schema->expects($this->at(2))
       ->method('tableExists')
@@ -140,14 +147,14 @@ class MigrateSqlIdMapEnsureTablesTest extends MigrateTestCase {
       ->method('fieldExists')
       ->with('migrate_map_sql_idmap_test', 'rollback_action')
       ->will($this->returnValue(FALSE));
-    $field_schema = array(
+    $field_schema = [
       'type' => 'int',
       'size' => 'tiny',
       'unsigned' => TRUE,
       'not null' => TRUE,
       'default' => 0,
       'description' => 'Flag indicating what to do for this item on rollback',
-    );
+    ];
     $schema->expects($this->at(2))
       ->method('addField')
       ->with('migrate_map_sql_idmap_test', 'rollback_action', $field_schema);
@@ -155,12 +162,12 @@ class MigrateSqlIdMapEnsureTablesTest extends MigrateTestCase {
       ->method('fieldExists')
       ->with('migrate_map_sql_idmap_test', 'hash')
       ->will($this->returnValue(FALSE));
-    $field_schema = array(
+    $field_schema = [
       'type' => 'varchar',
       'length' => '64',
       'not null' => FALSE,
       'description' => 'Hash of source row data, for detecting changes',
-    );
+    ];
     $schema->expects($this->at(4))
       ->method('addField')
       ->with('migrate_map_sql_idmap_test', 'hash', $field_schema);
@@ -168,12 +175,12 @@ class MigrateSqlIdMapEnsureTablesTest extends MigrateTestCase {
       ->method('fieldExists')
       ->with('migrate_map_sql_idmap_test', 'source_ids_hash')
       ->will($this->returnValue(FALSE));
-    $field_schema = array(
+    $field_schema = [
       'type' => 'varchar',
       'length' => '64',
       'not null' => TRUE,
       'description' => 'Hash of source ids. Used as primary key',
-    );
+    ];
     $schema->expects($this->at(6))
       ->method('addField')
       ->with('migrate_map_sql_idmap_test', 'source_ids_hash', $field_schema);
@@ -201,28 +208,31 @@ class MigrateSqlIdMapEnsureTablesTest extends MigrateTestCase {
     $plugin = $this->getMock('Drupal\migrate\Plugin\MigrateSourceInterface');
     $plugin->expects($this->any())
       ->method('getIds')
-      ->willReturn(array(
-      'source_id_property' => array(
+      ->willReturn([
+      'source_id_property' => [
         'type' => 'integer',
-      ),
-    ));
+      ],
+      'source_id_property_2' => [
+        'type' => 'integer',
+      ],
+    ]);
     $migration->expects($this->any())
       ->method('getSourcePlugin')
       ->willReturn($plugin);
     $plugin = $this->getMock('Drupal\migrate\Plugin\MigrateSourceInterface');
     $plugin->expects($this->any())
       ->method('getIds')
-      ->willReturn(array(
-      'destination_id_property' => array(
+      ->willReturn([
+      'destination_id_property' => [
         'type' => 'string',
-      ),
-    ));
+      ],
+    ]);
     $migration->expects($this->any())
       ->method('getDestinationPlugin')
       ->willReturn($plugin);
     /** @var \Symfony\Component\EventDispatcher\EventDispatcherInterface $event_dispatcher */
     $event_dispatcher = $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface');
-    $map = new TestSqlIdMap($database, array(), 'sql', array(), $migration, $event_dispatcher);
+    $map = new TestSqlIdMap($database, [], 'sql', [], $migration, $event_dispatcher);
     $map->getDatabase();
   }
 

core/modules/migrate/tests/src/Unit/MigrateSqlIdMapTest.php

@@ -130,11 +130,11 @@ class MigrateSqlIdMapTest extends MigrateTestCase {
    *   - hash
    */
   protected function idMapDefaults() {
-    $defaults = array(
+    $defaults = [
       'source_row_status' => MigrateIdMapInterface::STATUS_IMPORTED,
       'rollback_action' => MigrateIdMapInterface::ROLLBACK_DELETE,
       'hash' => '',
-    );
+    ];
     // By default, the PDO SQLite driver strongly prefers to return strings
     // from SELECT queries. Even for columns that don't store strings. Even
     // if the connection's STRINGIFY_FETCHES attribute is FALSE. This can cause
@@ -157,9 +157,9 @@ class MigrateSqlIdMapTest extends MigrateTestCase {
    * - updating work.
    */
   public function testSaveIdMapping() {
-    $source = array(
+    $source = [
       'source_id_property' => 'source_value',
-    );
+    ];
     $row = new Row($source, ['source_id_property' => []]);
     $id_map = $this->getIdMap();
     $id_map->saveIdMapping($row, ['destination_id_property' => 2]);
@@ -640,6 +640,35 @@ class MigrateSqlIdMapTest extends MigrateTestCase {
     $this->assertSame(0, count($source_id));
   }
 
+  /**
+   * Tests currentDestination() and currentSource().
+   */
+  public function testCurrentDestinationAndSource() {
+    // Simple map with one source and one destination ID.
+    $id_map = $this->setupRows(['nid'], ['nid'], [
+      [1, 101],
+      [2, 102],
+      [3, 103],
+      // Mock a failed row by setting the destination ID to NULL.
+      [4, NULL],
+    ]);
+
+    // The rows are ordered by destination ID so the failed row should be first.
+    $id_map->rewind();
+    $this->assertEquals([], $id_map->currentDestination());
+    $this->assertEquals(['nid' => 4], $id_map->currentSource());
+    $id_map->next();
+    $this->assertEquals(['nid' => 101], $id_map->currentDestination());
+    $this->assertEquals(['nid' => 1], $id_map->currentSource());
+    $id_map->next();
+    $this->assertEquals(['nid' => 102], $id_map->currentDestination());
+    $this->assertEquals(['nid' => 2], $id_map->currentSource());
+    $id_map->next();
+    $this->assertEquals(['nid' => 103], $id_map->currentDestination());
+    $this->assertEquals(['nid' => 3], $id_map->currentSource());
+    $id_map->next();
+  }
+
   /**
    * Tests the imported count method.
    *

core/modules/migrate/tests/src/Unit/MigrateSqlSourceTestCase.php

@@ -3,9 +3,16 @@
 namespace Drupal\Tests\migrate\Unit;
 
 use Drupal\Core\Database\Query\SelectInterface;
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\DependencyInjection\ContainerNotInitializedException;
+use Drupal\Core\KeyValueStore\KeyValueFactoryInterface;
+use Drupal\Core\KeyValueStore\KeyValueStoreInterface;
 
 /**
  * Base class for Migrate module source unit tests.
+ *
+ * @deprecated in Drupal 8.2.0, will be removed before Drupal 9.0.0. Use
+ * \Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase instead.
  */
 abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
 
@@ -26,7 +33,7 @@ abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
    *
    * @var array
    */
-  protected $databaseContents = array();
+  protected $databaseContents = [];
 
   /**
    * The plugin class under test.
@@ -44,16 +51,16 @@ abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
    * Once the migration is run, we save a mark of the migrated sources, so the
    * migration can run again and update only new sources or changed sources.
    *
-   * @var string
+   * @var mixed
    */
-  const ORIGINAL_HIGH_WATER = '';
+  const ORIGINAL_HIGH_WATER = NULL;
 
   /**
    * Expected results after the source parsing.
    *
    * @var array
    */
-  protected $expectedResults = array();
+  protected $expectedResults = [];
 
   /**
    * Expected count of source rows.
@@ -77,14 +84,38 @@ abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
     $state = $this->getMock('Drupal\Core\State\StateInterface');
     $entity_manager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
 
+    // Mock a key-value store to return high-water values.
+    $key_value = $this->getMock(KeyValueStoreInterface::class);
+
+    // SourcePluginBase does not yet support full dependency injection so we
+    // need to make sure that \Drupal::keyValue() works as expected by mocking
+    // the keyvalue service.
+    $key_value_factory = $this->getMock(KeyValueFactoryInterface::class);
+    $key_value_factory
+      ->method('get')
+      ->with('migrate:high_water')
+      ->willReturn($key_value);
+
+    try {
+      $container = \Drupal::getContainer();
+    }
+    catch (ContainerNotInitializedException $e) {
+      $container = new ContainerBuilder();
+    }
+    $container->set('keyvalue', $key_value_factory);
+    \Drupal::setContainer($container);
+
     $migration = $this->getMigration();
-    $migration->expects($this->any())
-      ->method('getHighWater')
-      ->will($this->returnValue(static::ORIGINAL_HIGH_WATER));
+
+    // Set the high water value.
+    \Drupal::keyValue('migrate:high_water')
+      ->expects($this->any())
+      ->method('get')
+      ->willReturn(static::ORIGINAL_HIGH_WATER);
 
     // Setup the plugin.
     $plugin_class = static::PLUGIN_CLASS;
-    $plugin = new $plugin_class($this->migrationConfiguration['source'], $this->migrationConfiguration['source']['plugin'], array(), $migration, $state, $entity_manager);
+    $plugin = new $plugin_class($this->migrationConfiguration['source'], $this->migrationConfiguration['source']['plugin'], [], $migration, $state, $entity_manager);
 
     // Do some reflection to set the database and moduleHandler.
     $plugin_reflection = new \ReflectionClass($plugin);
@@ -94,7 +125,7 @@ abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
     $module_handler_property->setAccessible(TRUE);
 
     // Set the database and the module handler onto our plugin.
-    $database_property->setValue($plugin, $this->getDatabase($this->databaseContents + array('test_map' => array())));
+    $database_property->setValue($plugin, $this->getDatabase($this->databaseContents + ['test_map' => []]));
     $module_handler_property->setValue($plugin, $module_handler);
 
     $plugin->setStringTranslation($this->getStringTranslationStub());
@@ -119,7 +150,7 @@ abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
   public function testSourceCount() {
     $count = $this->source->count();
     $this->assertTrue(is_numeric($count));
-    $this->assertEquals($count, $this->expectedCount);
+    $this->assertEquals($this->expectedCount, $count);
   }
 
   /**

core/modules/migrate/tests/src/Unit/MigrateTestCase.php

@@ -80,7 +80,7 @@ abstract class MigrateTestCase extends UnitTestCase {
 
     $migration->method('getHighWaterProperty')
       ->willReturnCallback(function () use ($configuration) {
-        return isset($configuration['highWaterProperty']) ? $configuration['highWaterProperty'] : '';
+        return isset($configuration['high_water_property']) ? $configuration['high_water_property'] : '';
       });
 
     $migration->method('set')

core/modules/migrate/tests/src/Unit/MigrationTest.php

@@ -27,9 +27,6 @@ class MigrationTest extends UnitTestCase {
    * Tests checking requirements for source plugins.
    *
    * @covers ::checkRequirements
-   *
-   * @expectedException \Drupal\migrate\Exception\RequirementsException
-   * @expectedExceptionMessage Missing source requirement
    */
   public function testRequirementsForSourcePlugin() {
     $migration = new TestMigration();
@@ -43,6 +40,7 @@ class MigrationTest extends UnitTestCase {
     $migration->setSourcePlugin($source_plugin);
     $migration->setDestinationPlugin($destination_plugin);
 
+    $this->setExpectedException(RequirementsException::class, 'Missing source requirement');
     $migration->checkRequirements();
   }
 
@@ -50,9 +48,6 @@ class MigrationTest extends UnitTestCase {
    * Tests checking requirements for destination plugins.
    *
    * @covers ::checkRequirements
-   *
-   * @expectedException \Drupal\migrate\Exception\RequirementsException
-   * @expectedExceptionMessage Missing destination requirement
    */
   public function testRequirementsForDestinationPlugin() {
     $migration = new TestMigration();
@@ -66,6 +61,7 @@ class MigrationTest extends UnitTestCase {
     $migration->setSourcePlugin($source_plugin);
     $migration->setDestinationPlugin($destination_plugin);
 
+    $this->setExpectedException(RequirementsException::class, 'Missing destination requirement');
     $migration->checkRequirements();
   }
 
@@ -73,9 +69,6 @@ class MigrationTest extends UnitTestCase {
    * Tests checking requirements for destination plugins.
    *
    * @covers ::checkRequirements
-   *
-   * @expectedException \Drupal\migrate\Exception\RequirementsException
-   * @expectedExceptionMessage Missing migrations test_a, test_c
    */
   public function testRequirementsForMigrations() {
     $migration = new TestMigration();
@@ -112,6 +105,7 @@ class MigrationTest extends UnitTestCase {
       ->with(['test_a', 'test_b', 'test_c', 'test_d'])
       ->willReturn(['test_b' => $migration_b, 'test_c' => $migration_c, 'test_d' => $migration_d]);
 
+    $this->setExpectedException(RequirementsException::class, 'Missing migrations test_a, test_c');
     $migration->checkRequirements();
   }
 

core/modules/migrate/tests/src/Unit/Plugin/migrate/destination/EntityContentBaseTest.php

@@ -11,7 +11,9 @@ use Drupal\Core\Entity\ContentEntityInterface;
 use Drupal\Core\Entity\ContentEntityType;
 use Drupal\Core\Entity\EntityManagerInterface;
 use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Field\BaseFieldDefinition;
 use Drupal\Core\Field\FieldTypePluginManagerInterface;
+use Drupal\migrate\MigrateException;
 use Drupal\migrate\Plugin\MigrationInterface;
 use Drupal\migrate\Plugin\migrate\destination\EntityContentBase;
 use Drupal\migrate\Plugin\MigrateIdMapInterface;
@@ -74,7 +76,7 @@ class EntityContentBaseTest extends UnitTestCase {
       ->willReturn(5);
     $destination->setEntity($entity->reveal());
     // Ensure the id is saved entity id is returned from import.
-    $this->assertEquals([5], $destination->import(new Row([], [])));
+    $this->assertEquals([5], $destination->import(new Row()));
     // Assert that import set the rollback action.
     $this->assertEquals(MigrateIdMapInterface::ROLLBACK_DELETE, $destination->rollbackAction());
   }
@@ -83,8 +85,6 @@ class EntityContentBaseTest extends UnitTestCase {
    * Test row skipping when we can't get an entity to save.
    *
    * @covers ::import
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage Unable to get entity
    */
   public function testImportEntityLoadFailure() {
     $bundles = [];
@@ -95,20 +95,20 @@ class EntityContentBaseTest extends UnitTestCase {
       $this->entityManager->reveal(),
       $this->prophesize(FieldTypePluginManagerInterface::class)->reveal());
     $destination->setEntity(FALSE);
-    $destination->import(new Row([], []));
+    $this->setExpectedException(MigrateException::class, 'Unable to get entity');
+    $destination->import(new Row());
   }
 
   /**
    * Test that translation destination fails for untranslatable entities.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage This entity type does not support translation
    */
   public function testUntranslatable() {
     // An entity type without a language.
     $entity_type = $this->prophesize(ContentEntityType::class);
     $entity_type->getKey('langcode')->willReturn('');
     $entity_type->getKey('id')->willReturn('id');
+    $this->entityManager->getBaseFieldDefinitions('foo')
+      ->willReturn(['id' => BaseFieldDefinitionTest::create('integer')]);
 
     $this->storage->getEntityType()->willReturn($entity_type->reveal());
 
@@ -122,6 +122,7 @@ class EntityContentBaseTest extends UnitTestCase {
       $this->entityManager->reveal(),
       $this->prophesize(FieldTypePluginManagerInterface::class)->reveal()
     );
+    $this->setExpectedException(MigrateException::class, 'This entity type does not support translation');
     $destination->getIds();
   }
 
@@ -144,4 +145,27 @@ class EntityTestDestination extends EntityContentBase {
     return $this->entity;
   }
 
+  public static function getEntityTypeId($plugin_id) {
+    return 'foo';
+  }
+
+}
+
+/**
+ * Stub class for BaseFieldDefinition.
+ */
+class BaseFieldDefinitionTest extends BaseFieldDefinition {
+
+  public static function create($type) {
+    return new static([]);
+  }
+
+  public function getSettings() {
+    return [];
+  }
+
+  public function getType() {
+    return 'integer';
+  }
+
 }

core/modules/migrate/tests/src/Unit/RowTest.php

@@ -17,19 +17,19 @@ class RowTest extends UnitTestCase {
    *
    * @var array
    */
-  protected $testSourceIds = array(
+  protected $testSourceIds = [
     'nid' => 'Node ID',
-  );
+  ];
 
   /**
    * The test values.
    *
    * @var array
    */
-  protected $testValues = array(
+  protected $testValues = [
     'nid' => 1,
     'title' => 'node 1',
-  );
+  ];
 
   /**
    * The test hash.
@@ -49,8 +49,8 @@ class RowTest extends UnitTestCase {
    * Tests object creation: empty.
    */
   public function testRowWithoutData() {
-    $row = new Row(array(), array());
-    $this->assertSame(array(), $row->getSource(), 'Empty row');
+    $row = new Row();
+    $this->assertSame([], $row->getSource(), 'Empty row');
   }
 
   /**
@@ -65,28 +65,25 @@ class RowTest extends UnitTestCase {
    * Tests object creation: multiple source IDs.
    */
   public function testRowWithMultipleSourceIds() {
-    $multi_source_ids = $this->testSourceIds + array('vid' => 'Node revision');
-    $multi_source_ids_values = $this->testValues + array('vid' => 1);
+    $multi_source_ids = $this->testSourceIds + ['vid' => 'Node revision'];
+    $multi_source_ids_values = $this->testValues + ['vid' => 1];
     $row = new Row($multi_source_ids_values, $multi_source_ids);
     $this->assertSame($multi_source_ids_values, $row->getSource(), 'Row with data, multifield id.');
   }
 
   /**
    * Tests object creation: invalid values.
-   *
-   * @expectedException \Exception
    */
   public function testRowWithInvalidData() {
-    $invalid_values = array(
+    $invalid_values = [
       'title' => 'node X',
-    );
+    ];
+    $this->setExpectedException(\Exception::class);
     $row = new Row($invalid_values, $this->testSourceIds);
   }
 
   /**
    * Tests source immutability after freeze.
-   *
-   * @expectedException \Exception
    */
   public function testSourceFreeze() {
     $row = new Row($this->testValues, $this->testSourceIds);
@@ -96,18 +93,17 @@ class RowTest extends UnitTestCase {
     $row->rehash();
     $this->assertSame($this->testHashMod, $row->getHash(), 'Hash changed correctly.');
     $row->freezeSource();
+    $this->setExpectedException(\Exception::class);
     $row->setSourceProperty('title', 'new title');
   }
 
   /**
    * Tests setting on a frozen row.
-   *
-   * @expectedException \Exception
-   * @expectedExceptionMessage The source is frozen and can't be changed any more
    */
   public function testSetFrozenRow() {
     $row = new Row($this->testValues, $this->testSourceIds);
     $row->freezeSource();
+    $this->setExpectedException(\Exception::class, "The source is frozen and can't be changed any more");
     $row->setSourceProperty('title', 'new title');
   }
 
@@ -123,11 +119,11 @@ class RowTest extends UnitTestCase {
     $this->assertSame($this->testHash, $row->getHash(), 'Correct hash even doing it twice.');
 
     // Set the map to needs update.
-    $test_id_map = array(
+    $test_id_map = [
       'original_hash' => '',
       'hash' => '',
       'source_row_status' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE,
-    );
+    ];
     $row->setIdMap($test_id_map);
     $this->assertTrue($row->needsUpdate());
 
@@ -143,30 +139,30 @@ class RowTest extends UnitTestCase {
     $this->assertSame(64, strlen($row->getHash()));
 
     // Set the map to successfully imported.
-    $test_id_map = array(
+    $test_id_map = [
       'original_hash' => '',
       'hash' => '',
       'source_row_status' => MigrateIdMapInterface::STATUS_IMPORTED,
-    );
+    ];
     $row->setIdMap($test_id_map);
     $this->assertFalse($row->needsUpdate());
 
     // Set the same hash value and ensure it was not changed.
     $random = $this->randomMachineName();
-    $test_id_map = array(
+    $test_id_map = [
       'original_hash' => $random,
       'hash' => $random,
       'source_row_status' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE,
-    );
+    ];
     $row->setIdMap($test_id_map);
     $this->assertFalse($row->changed());
 
     // Set different has values to ensure it is marked as changed.
-    $test_id_map = array(
+    $test_id_map = [
       'original_hash' => $this->randomMachineName(),
       'hash' => $this->randomMachineName(),
       'source_row_status' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE,
-    );
+    ];
     $row->setIdMap($test_id_map);
     $this->assertTrue($row->changed());
   }
@@ -179,11 +175,11 @@ class RowTest extends UnitTestCase {
    */
   public function testGetSetIdMap() {
     $row = new Row($this->testValues, $this->testSourceIds);
-    $test_id_map = array(
+    $test_id_map = [
       'original_hash' => '',
       'hash' => '',
       'source_row_status' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE,
-    );
+    ];
     $row->setIdMap($test_id_map);
     $this->assertEquals($test_id_map, $row->getIdMap());
   }
@@ -193,7 +189,40 @@ class RowTest extends UnitTestCase {
    */
   public function testSourceIdValues() {
     $row = new Row($this->testValues, $this->testSourceIds);
-    $this->assertSame(array('nid' => $this->testValues['nid']), $row->getSourceIdValues());
+    $this->assertSame(['nid' => $this->testValues['nid']], $row->getSourceIdValues());
+  }
+
+  /**
+   * Tests the multiple source IDs.
+   */
+  public function testMultipleSourceIdValues() {
+    // Set values in same order as ids.
+    $multi_source_ids = $this->testSourceIds + [
+        'vid' => 'Node revision',
+        'type' => 'Node type',
+        'langcode' => 'Node language',
+      ];
+    $multi_source_ids_values = $this->testValues + [
+        'vid' => 1,
+        'type' => 'page',
+        'langcode' => 'en',
+      ];
+    $row = new Row($multi_source_ids_values, $multi_source_ids);
+    $this->assertSame(array_keys($multi_source_ids), array_keys($row->getSourceIdValues()));
+
+    // Set values in different order.
+    $multi_source_ids = $this->testSourceIds + [
+        'vid' => 'Node revision',
+        'type' => 'Node type',
+        'langcode' => 'Node language',
+      ];
+    $multi_source_ids_values = $this->testValues + [
+        'langcode' => 'en',
+        'type' => 'page',
+        'vid' => 1,
+      ];
+    $row = new Row($multi_source_ids_values, $multi_source_ids);
+    $this->assertSame(array_keys($multi_source_ids), array_keys($row->getSourceIdValues()));
   }
 
   /**
@@ -219,7 +248,7 @@ class RowTest extends UnitTestCase {
     // Set a destination.
     $row->setDestinationProperty('nid', 2);
     $this->assertTrue($row->hasDestinationProperty('nid'));
-    $this->assertEquals(array('nid' => 2), $row->getDestination());
+    $this->assertEquals(['nid' => 2], $row->getDestination());
   }
 
   /**

core/modules/migrate/tests/src/Unit/SqlBaseTest.php

@@ -111,13 +111,14 @@ class SqlBaseTest extends UnitTestCase {
         ['driver' => 'mysql', 'username' => 'different_from_map', 'password' => 'different_from_map'],
         ['driver' => 'mysql', 'username' => 'different_from_source', 'password' => 'different_from_source'],
       ],
-      // Returns true because source and id map connection options are the same.
+      // Returns false because driver is pgsql and the databases are not the
+      // same.
       [
+        FALSE,
         TRUE,
         TRUE,
-        TRUE,
-        ['driver' => 'pgsql', 'username' => 'same_value', 'password' => 'same_value'],
-        ['driver' => 'pgsql', 'username' => 'same_value', 'password' => 'same_value'],
+        ['driver' => 'pgsql', 'database' => '1.pgsql', 'username' => 'same_value', 'password' => 'same_value'],
+        ['driver' => 'pgsql', 'database' => '2.pgsql', 'username' => 'same_value', 'password' => 'same_value'],
       ],
       // Returns false because driver is sqlite and the databases are not the
       // same.

core/modules/migrate/tests/src/Unit/TestSqlIdMap.php

@@ -55,21 +55,21 @@ class TestSqlIdMap extends Sql implements \Iterator {
    */
   protected function getFieldSchema(array $id_definition) {
     if (!isset($id_definition['type'])) {
-      return array();
+      return [];
     }
     switch ($id_definition['type']) {
       case 'integer':
-        return array(
+        return [
           'type' => 'int',
           'not null' => TRUE,
-        );
+        ];
 
       case 'string':
-        return array(
+        return [
           'type' => 'varchar',
           'length' => 255,
           'not null' => FALSE,
-        );
+        ];
 
       default:
         throw new MigrateException($id_definition['type'] . ' not supported');

core/modules/migrate/tests/src/Unit/destination/ConfigTest.php

@@ -16,9 +16,9 @@ class ConfigTest extends UnitTestCase {
    * Test the import method.
    */
   public function testImport() {
-    $source = array(
+    $source = [
       'test' => 'x',
-    );
+    ];
     $migration = $this->getMockBuilder('Drupal\migrate\Plugin\Migration')
       ->disableOriginalConstructor()
       ->getMock();
@@ -44,9 +44,6 @@ class ConfigTest extends UnitTestCase {
     $row = $this->getMockBuilder('Drupal\migrate\Row')
       ->disableOriginalConstructor()
       ->getMock();
-    $row->expects($this->once())
-      ->method('hasDestinationProperty')
-      ->will($this->returnValue(FALSE));
     $row->expects($this->any())
       ->method('getRawDestination')
       ->will($this->returnValue($source));
@@ -57,7 +54,7 @@ class ConfigTest extends UnitTestCase {
       ->method('getLanguageConfigOverride')
       ->with('fr', 'd8_config')
       ->will($this->returnValue($config));
-    $destination = new Config(array('config_name' => 'd8_config'), 'd8_config', array('pluginId' => 'd8_config'), $migration, $config_factory, $language_manager);
+    $destination = new Config(['config_name' => 'd8_config'], 'd8_config', ['pluginId' => 'd8_config'], $migration, $config_factory, $language_manager);
     $destination_id = $destination->import($row);
     $this->assertEquals($destination_id, ['d8_config']);
   }
@@ -66,9 +63,9 @@ class ConfigTest extends UnitTestCase {
    * Test the import method.
    */
   public function testLanguageImport() {
-    $source = array(
+    $source = [
       'langcode' => 'mi',
-    );
+    ];
     $migration = $this->getMockBuilder(MigrationInterface::class)
       ->disableOriginalConstructor()
       ->getMock();
@@ -94,9 +91,6 @@ class ConfigTest extends UnitTestCase {
     $row = $this->getMockBuilder('Drupal\migrate\Row')
       ->disableOriginalConstructor()
       ->getMock();
-    $row->expects($this->once())
-      ->method('hasDestinationProperty')
-      ->will($this->returnValue($source));
     $row->expects($this->any())
       ->method('getRawDestination')
       ->will($this->returnValue($source));
@@ -110,9 +104,9 @@ class ConfigTest extends UnitTestCase {
       ->method('getLanguageConfigOverride')
       ->with('mi', 'd8_config')
       ->will($this->returnValue($config));
-    $destination = new Config(array('config_name' => 'd8_config'), 'd8_config', array('pluginId' => 'd8_config'), $migration, $config_factory, $language_manager);
+    $destination = new Config(['config_name' => 'd8_config', 'translations' => 'true'], 'd8_config', ['pluginId' => 'd8_config'], $migration, $config_factory, $language_manager);
     $destination_id = $destination->import($row);
-    $this->assertEquals($destination_id, ['d8_config']);
+    $this->assertEquals($destination_id, ['d8_config', 'mi']);
   }
 
 }

core/modules/migrate/tests/src/Unit/destination/EntityRevisionTest.php

@@ -67,7 +67,7 @@ class EntityRevisionTest extends UnitTestCase {
     $this->storage->loadRevision(12)
       ->shouldBeCalled()
       ->willReturn($entity->reveal());
-    $row = new Row([], []);
+    $row = new Row();
     $this->assertEquals($entity->reveal(), $destination->getEntity($row, [12, 13]));
   }
 
@@ -212,7 +212,7 @@ class EntityRevision extends RealEntityRevision {
   /**
    * Allow public access for testing.
    */
-  public function save(ContentEntityInterface $entity, array $old_destination_id_values = array()) {
+  public function save(ContentEntityInterface $entity, array $old_destination_id_values = []) {
     return parent::save($entity, $old_destination_id_values);
   }
 

core/modules/migrate/tests/src/Unit/destination/PerComponentEntityDisplayTest.php

@@ -22,14 +22,14 @@ class PerComponentEntityDisplayTest extends MigrateTestCase {
    * Tests the entity display import method.
    */
   public function testImport() {
-    $values = array(
+    $values = [
       'entity_type' => 'entity_type_test',
       'bundle' => 'bundle_test',
       'view_mode' => 'view_mode_test',
       'field_name' => 'field_name_test',
-      'options' => array('test setting'),
-    );
-    $row = new Row(array(), array());
+      'options' => ['test setting'],
+    ];
+    $row = new Row();
     foreach ($values as $key => $value) {
       $row->setDestinationProperty($key, $value);
     }
@@ -38,14 +38,14 @@ class PerComponentEntityDisplayTest extends MigrateTestCase {
       ->getMock();
     $entity->expects($this->once())
       ->method('setComponent')
-      ->with('field_name_test', array('test setting'))
+      ->with('field_name_test', ['test setting'])
       ->will($this->returnSelf());
     $entity->expects($this->once())
       ->method('save')
       ->with();
     $plugin = new TestPerComponentEntityDisplay($entity);
-    $this->assertSame($plugin->import($row), array('entity_type_test', 'bundle_test', 'view_mode_test', 'field_name_test'));
-    $this->assertSame($plugin->getTestValues(), array('entity_type_test', 'bundle_test', 'view_mode_test'));
+    $this->assertSame($plugin->import($row), ['entity_type_test', 'bundle_test', 'view_mode_test', 'field_name_test']);
+    $this->assertSame($plugin->getTestValues(), ['entity_type_test', 'bundle_test', 'view_mode_test']);
   }
 
 }

core/modules/migrate/tests/src/Unit/destination/PerComponentEntityFormDisplayTest.php

@@ -22,14 +22,14 @@ class PerComponentEntityFormDisplayTest extends MigrateTestCase {
    * Tests the entity display import method.
    */
   public function testImport() {
-    $values = array(
+    $values = [
       'entity_type' => 'entity_type_test',
       'bundle' => 'bundle_test',
       'form_mode' => 'form_mode_test',
       'field_name' => 'field_name_test',
-      'options' => array('test setting'),
-    );
-    $row = new Row(array(), array());
+      'options' => ['test setting'],
+    ];
+    $row = new Row();
     foreach ($values as $key => $value) {
       $row->setDestinationProperty($key, $value);
     }
@@ -38,14 +38,14 @@ class PerComponentEntityFormDisplayTest extends MigrateTestCase {
       ->getMock();
     $entity->expects($this->once())
       ->method('setComponent')
-      ->with('field_name_test', array('test setting'))
+      ->with('field_name_test', ['test setting'])
       ->will($this->returnSelf());
     $entity->expects($this->once())
       ->method('save')
       ->with();
     $plugin = new TestPerComponentEntityFormDisplay($entity);
-    $this->assertSame($plugin->import($row), array('entity_type_test', 'bundle_test', 'form_mode_test', 'field_name_test'));
-    $this->assertSame($plugin->getTestValues(), array('entity_type_test', 'bundle_test', 'form_mode_test'));
+    $this->assertSame($plugin->import($row), ['entity_type_test', 'bundle_test', 'form_mode_test', 'field_name_test']);
+    $this->assertSame($plugin->getTestValues(), ['entity_type_test', 'bundle_test', 'form_mode_test']);
   }
 
 }

core/modules/migrate/tests/src/Unit/process/ArrayBuildTest.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Plugin\migrate\process\ArrayBuild;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\ArrayBuild
+ * @group migrate
+ */
+class ArrayBuildTest extends MigrateProcessTestCase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $configuration = [
+      'key' => 'foo',
+      'value' => 'bar',
+    ];
+    $this->plugin = new ArrayBuild($configuration, 'map', []);
+    parent::setUp();
+  }
+
+  /**
+   * Tests successful transformation.
+   */
+  public function testTransform() {
+    $source = [
+      ['foo' => 'Foo', 'bar' => 'Bar'],
+      ['foo' => 'foo bar', 'bar' => 'bar foo'],
+    ];
+    $expected = [
+      'Foo' => 'Bar',
+      'foo bar' => 'bar foo',
+    ];
+    $value = $this->plugin->transform($source, $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->assertSame($value, $expected);
+  }
+
+  /**
+   * Tests non-existent key for the key configuration.
+   */
+  public function testNonExistentKey() {
+    $source = [
+      ['bar' => 'foo'],
+    ];
+    $this->setExpectedException(MigrateException::class, "The key 'foo' does not exist");
+    $this->plugin->transform($source, $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+  /**
+   * Tests non-existent key for the value configuration.
+   */
+  public function testNonExistentValue() {
+    $source = [
+      ['foo' => 'bar'],
+    ];
+    $this->setExpectedException(MigrateException::class, "The key 'bar' does not exist");
+    $this->plugin->transform($source, $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+  /**
+   * Tests one-dimensional array input.
+   */
+  public function testOneDimensionalArrayInput() {
+    $source = ['foo' => 'bar'];
+    $this->setExpectedException(MigrateException::class, 'The input should be an array of arrays');
+    $this->plugin->transform($source, $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+  /**
+   * Tests string input.
+   */
+  public function testStringInput() {
+    $source = 'foo';
+    $this->setExpectedException(MigrateException::class, 'The input should be an array of arrays');
+    $this->plugin->transform($source, $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+}

core/modules/migrate/tests/src/Unit/process/CallbackTest.php

@@ -37,7 +37,7 @@ class CallbackTest extends MigrateProcessTestCase {
    * Test callback with a class method as callable.
    */
   public function testCallbackWithClassMethod() {
-    $this->plugin->setCallable(array('\Drupal\Component\Utility\Unicode', 'strtolower'));
+    $this->plugin->setCallable(['\Drupal\Component\Utility\Unicode', 'strtolower']);
     $value = $this->plugin->transform('FooBar', $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertSame($value, 'foobar');
   }

core/modules/migrate/tests/src/Unit/process/ConcatTest.php

@@ -7,6 +7,7 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+use Drupal\migrate\MigrateException;
 use Drupal\migrate\Plugin\migrate\process\Concat;
 
 /**
@@ -28,16 +29,15 @@ class ConcatTest extends MigrateProcessTestCase {
    * Test concat works without a delimiter.
    */
   public function testConcatWithoutDelimiter() {
-    $value = $this->plugin->transform(array('foo', 'bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $value = $this->plugin->transform(['foo', 'bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertSame($value, 'foobar');
   }
 
   /**
    * Test concat fails properly on non-arrays.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
    */
   public function testConcatWithNonArray() {
+    $this->setExpectedException(MigrateException::class);
     $this->plugin->transform('foo', $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
@@ -46,7 +46,7 @@ class ConcatTest extends MigrateProcessTestCase {
    */
   public function testConcatWithDelimiter() {
     $this->plugin->setDelimiter('_');
-    $value = $this->plugin->transform(array('foo', 'bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $value = $this->plugin->transform(['foo', 'bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertSame($value, 'foo_bar');
   }
 

core/modules/migrate/tests/src/Unit/process/DedupeEntityTest.php

@@ -2,6 +2,12 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+@trigger_error('The ' . __NAMESPACE__ . '\DedupeEntityTest is deprecated in
+Drupal 8.4.0 and will be removed before Drupal 9.0.0. Instead, use ' . __NAMESPACE__ . '\MakeUniqueEntityFieldTest', E_USER_DEPRECATED);
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\Query\QueryInterface;
 use Drupal\migrate\Plugin\migrate\process\DedupeEntity;
 use Drupal\Component\Utility\Unicode;
 
@@ -20,20 +26,20 @@ class DedupeEntityTest extends MigrateProcessTestCase {
   protected $entityQuery;
 
   /**
-   * The mock entity query factory.
+   * The mocked entity type manager.
    *
-   * @var \Drupal\Core\Entity\Query\QueryFactory|\PHPUnit_Framework_MockObject_MockObject
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface|\PHPUnit_Framework_MockObject_MockObject
    */
-  protected $entityQueryFactory;
+  protected $entityTypeManager;
 
   /**
    * The migration configuration, initialized to set the ID to test.
    *
    * @var array
    */
-  protected $migrationConfiguration = array(
+  protected $migrationConfiguration = [
     'id' => 'test',
-  );
+  ];
 
   /**
    * {@inheritdoc}
@@ -42,12 +48,16 @@ class DedupeEntityTest extends MigrateProcessTestCase {
     $this->entityQuery = $this->getMockBuilder('Drupal\Core\Entity\Query\QueryInterface')
       ->disableOriginalConstructor()
       ->getMock();
-    $this->entityQueryFactory = $this->getMockBuilder('Drupal\Core\Entity\Query\QueryFactory')
-      ->disableOriginalConstructor()
-      ->getMock();
-    $this->entityQueryFactory->expects($this->any())
-      ->method('get')
-      ->will($this->returnValue($this->entityQuery));
+    $this->entityTypeManager = $this->getMock(EntityTypeManagerInterface::class);
+
+    $storage = $this->getMock(EntityStorageInterface::class);
+    $storage->expects($this->any())
+      ->method('getQuery')
+      ->willReturn($this->entityQuery);
+    $this->entityTypeManager->expects($this->any())
+      ->method('getStorage')
+      ->with('test_entity_type')
+      ->willReturn($storage);
     parent::setUp();
   }
 
@@ -57,16 +67,16 @@ class DedupeEntityTest extends MigrateProcessTestCase {
    * @dataProvider providerTestDedupe
    */
   public function testDedupe($count, $postfix = '', $start = NULL, $length = NULL) {
-    $configuration = array(
+    $configuration = [
       'entity_type' => 'test_entity_type',
       'field' => 'test_field',
-    );
+    ];
     if ($postfix) {
       $configuration['postfix'] = $postfix;
     }
     $configuration['start'] = isset($start) ? $start : NULL;
     $configuration['length'] = isset($length) ? $length : NULL;
-    $plugin = new DedupeEntity($configuration, 'dedupe_entity', array(), $this->getMigration(), $this->entityQueryFactory);
+    $plugin = new DedupeEntity($configuration, 'dedupe_entity', [], $this->getMigration(), $this->entityTypeManager);
     $this->entityQueryExpects($count);
     $value = $this->randomMachineName(32);
     $actual = $plugin->transform($value, $this->migrateExecutable, $this->row, 'testproperty');
@@ -79,12 +89,12 @@ class DedupeEntityTest extends MigrateProcessTestCase {
    * Tests that invalid start position throws an exception.
    */
   public function testDedupeEntityInvalidStart() {
-    $configuration = array(
+    $configuration = [
       'entity_type' => 'test_entity_type',
       'field' => 'test_field',
       'start' => 'foobar',
-    );
-    $plugin = new DedupeEntity($configuration, 'dedupe_entity', array(), $this->getMigration(), $this->entityQueryFactory);
+    ];
+    $plugin = new DedupeEntity($configuration, 'dedupe_entity', [], $this->getMigration(), $this->entityTypeManager);
     $this->setExpectedException('Drupal\migrate\MigrateException', 'The start position configuration key should be an integer. Omit this key to capture from the beginning of the string.');
     $plugin->transform('test_start', $this->migrateExecutable, $this->row, 'testproperty');
   }
@@ -93,12 +103,12 @@ class DedupeEntityTest extends MigrateProcessTestCase {
    * Tests that invalid length option throws an exception.
    */
   public function testDedupeEntityInvalidLength() {
-    $configuration = array(
+    $configuration = [
       'entity_type' => 'test_entity_type',
       'field' => 'test_field',
       'length' => 'foobar',
-    );
-    $plugin = new DedupeEntity($configuration, 'dedupe_entity', array(), $this->getMigration(), $this->entityQueryFactory);
+    ];
+    $plugin = new DedupeEntity($configuration, 'dedupe_entity', [], $this->getMigration(), $this->entityTypeManager);
     $this->setExpectedException('Drupal\migrate\MigrateException', 'The character length configuration key should be an integer. Omit this key to capture the entire string.');
     $plugin->transform('test_length', $this->migrateExecutable, $this->row, 'testproperty');
   }
@@ -107,40 +117,40 @@ class DedupeEntityTest extends MigrateProcessTestCase {
    * Data provider for testDedupe().
    */
   public function providerTestDedupe() {
-    return array(
+    return [
       // Tests no duplication.
-      array(0),
+      [0],
       // Tests no duplication and start position.
-      array(0, NULL, 10),
+      [0, NULL, 10],
       // Tests no duplication, start position, and length.
-      array(0, NULL, 5, 10),
+      [0, NULL, 5, 10],
       // Tests no duplication and length.
-      array(0, NULL, NULL, 10),
+      [0, NULL, NULL, 10],
       // Tests duplication.
-      array(3),
+      [3],
       // Tests duplication and start position.
-      array(3, NULL, 10),
+      [3, NULL, 10],
       // Tests duplication, start position, and length.
-      array(3, NULL, 5, 10),
+      [3, NULL, 5, 10],
       // Tests duplication and length.
-      array(3, NULL, NULL, 10),
+      [3, NULL, NULL, 10],
       // Tests no duplication and postfix.
-      array(0, '_'),
+      [0, '_'],
       // Tests no duplication, postfix, and start position.
-      array(0, '_', 5),
+      [0, '_', 5],
       // Tests no duplication, postfix, start position, and length.
-      array(0, '_', 5, 10),
+      [0, '_', 5, 10],
       // Tests no duplication, postfix, and length.
-      array(0, '_', NULL, 10),
+      [0, '_', NULL, 10],
       // Tests duplication and postfix.
-      array(2, '_'),
+      [2, '_'],
       // Tests duplication, postfix, and start position.
-      array(2, '_', 5),
+      [2, '_', 5],
       // Tests duplication, postfix, start position, and length.
-      array(2, '_', 5, 10),
+      [2, '_', 5, 10],
       // Tests duplication, postfix, and length.
-      array(2, '_', NULL, 10),
-    );
+      [2, '_', NULL, 10],
+    ];
   }
 
   /**
@@ -161,4 +171,47 @@ class DedupeEntityTest extends MigrateProcessTestCase {
       ->will($this->returnCallback(function () use (&$count) { return $count--;}));
   }
 
+  /**
+   * Test deduplicating only migrated entities.
+   */
+  public function testDedupeMigrated() {
+    $configuration = [
+      'entity_type' => 'test_entity_type',
+      'field' => 'test_field',
+      'migrated' => TRUE,
+    ];
+    $plugin = new DedupeEntity($configuration, 'dedupe_entity', [], $this->getMigration(), $this->entityTypeManager);
+
+    // Setup the entityQuery used in DedupeEntity::exists. The map, $map, is
+    // an array consisting of the four input parameters to the query condition
+    // method and then the query to return. Both 'forum' and
+    // 'test_vocab' are existing entities. There is no 'test_vocab1'.
+    $map = [];
+    foreach (['forums', 'test_vocab', 'test_vocab1'] as $id) {
+      $query = $this->prophesize(QueryInterface::class);
+      $query->willBeConstructedWith([]);
+      $query->execute()->willReturn($id === 'test_vocab1' ? [] : [$id]);
+      $map[] = ['test_field', $id, NULL, NULL, $query->reveal()];
+    }
+    $this->entityQuery
+      ->method('condition')
+      ->will($this->returnValueMap($map));
+
+    // Entity 'forums' is pre-existing, entity 'test_vocab' was migrated.
+    $this->idMap
+      ->method('lookupSourceID')
+      ->will($this->returnValueMap([
+        [['test_field' => 'forums'], FALSE],
+        [['test_field' => 'test_vocab'], ['source_id' => 42]],
+      ]));
+
+    // Existing entity 'forums' was not migrated, it should not be deduplicated.
+    $actual = $plugin->transform('forums', $this->migrateExecutable, $this->row, 'testproperty');
+    $this->assertEquals('forums', $actual, 'Pre-existing name is re-used');
+
+    // Entity 'test_vocab' was migrated, should be deduplicated.
+    $actual = $plugin->transform('test_vocab', $this->migrateExecutable, $this->row, 'testproperty');
+    $this->assertEquals('test_vocab1', $actual, 'Migrated name is deduplicated');
+  }
+
 }

core/modules/migrate/tests/src/Unit/process/ExplodeTest.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+use Drupal\migrate\MigrateException;
 use Drupal\migrate\Plugin\migrate\process\Explode;
 use Drupal\migrate\Plugin\migrate\process\Concat;
 
@@ -53,23 +54,65 @@ class ExplodeTest extends MigrateProcessTestCase {
 
   /**
    * Test explode fails properly on non-strings.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   *
-   * @expectedExceptionMessage is not a string
    */
   public function testExplodeWithNonString() {
+    $this->setExpectedException(MigrateException::class, 'is not a string');
     $this->plugin->transform(['foo'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
+  /**
+   * Tests that explode works on non-strings but with strict set to FALSE.
+   *
+   * @dataProvider providerExplodeWithNonStrictAndEmptySource
+   */
+  public function testExplodeWithNonStrictAndEmptySource($value, $expected) {
+    $plugin = new Explode(['delimiter' => '|', 'strict' => FALSE], 'map', []);
+
+    $processed = $plugin->transform($value, $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->assertSame($expected, $processed);
+  }
+
+  /**
+   * Data provider for ::testExplodeWithNonStrictAndEmptySource().
+   */
+  public function providerExplodeWithNonStrictAndEmptySource() {
+    return [
+      'normal_string' => ['a|b|c', ['a', 'b', 'c']],
+      'integer_cast_to_string' => [123, ['123']],
+      'zero_integer_cast_to_string' => [0, ['0']],
+      'true_cast_to_string' => [TRUE, ['1']],
+      'null_empty_array' => [NULL, []],
+      'false_empty_array' => [FALSE, []],
+      'empty_string_empty_array' => ['', []],
+    ];
+  }
+
+  /**
+   * Tests that explode raises an exception when the value cannot be casted to
+   * string.
+   */
+  public function testExplodeWithNonStrictAndNonCastable() {
+    $plugin = new Explode(['delimiter' => '|', 'strict' => FALSE], 'map', []);
+    $this->setExpectedException(MigrateException::class, 'cannot be casted to a string');
+    $processed = $plugin->transform(['foo'], $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->assertSame(['foo'], $processed);
+  }
+
+  /**
+   * Tests that explode with an empty string and strict check returns a
+   * non-empty array.
+   */
+  public function testExplodeWithStrictAndEmptyString() {
+    $plugin = new Explode(['delimiter' => '|'], 'map', []);
+    $processed = $plugin->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->assertSame([''], $processed);
+  }
+
   /**
    * Test explode fails with empty delimiter.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   *
-   * @expectedExceptionMessage delimiter is empty
    */
   public function testExplodeWithEmptyDelimiter() {
+    $this->setExpectedException(MigrateException::class, 'delimiter is empty');
     $plugin = new Explode(['delimiter' => ''], 'map', []);
     $plugin->transform('foo,bar', $this->migrateExecutable, $this->row, 'destinationproperty');
   }

core/modules/migrate/tests/src/Unit/process/ExtractTest.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+use Drupal\migrate\MigrateException;
 use Drupal\migrate\Plugin\migrate\process\Extract;
 
 /**
@@ -14,8 +15,8 @@ class ExtractTest extends MigrateProcessTestCase {
    * {@inheritdoc}
    */
   protected function setUp() {
-    $configuration['index'] = array('foo');
-    $this->plugin = new Extract($configuration, 'map', array());
+    $configuration['index'] = ['foo'];
+    $this->plugin = new Extract($configuration, 'map', []);
     parent::setUp();
   }
 
@@ -23,28 +24,24 @@ class ExtractTest extends MigrateProcessTestCase {
    * Tests successful extraction.
    */
   public function testExtract() {
-    $value = $this->plugin->transform(array('foo' => 'bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $value = $this->plugin->transform(['foo' => 'bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertSame($value, 'bar');
   }
 
   /**
    * Tests invalid input.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage Input should be an array.
    */
   public function testExtractFromString() {
+    $this->setExpectedException(MigrateException::class, 'Input should be an array.');
     $this->plugin->transform('bar', $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
   /**
    * Tests unsuccessful extraction.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage Array index missing, extraction failed.
    */
   public function testExtractFail() {
-    $this->plugin->transform(array('bar' => 'foo'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->setExpectedException(MigrateException::class, 'Array index missing, extraction failed.');
+    $this->plugin->transform(['bar' => 'foo'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
   /**

core/modules/migrate/tests/src/Unit/process/FlattenTest.php

@@ -15,9 +15,9 @@ class FlattenTest extends MigrateProcessTestCase {
    * Test that various array flatten operations work properly.
    */
   public function testFlatten() {
-    $plugin = new Flatten(array(), 'flatten', array());
-    $flattened = $plugin->transform(array(1, 2, array(3, 4, array(5)), array(), array(7, 8)), $this->migrateExecutable, $this->row, 'destinationproperty');
-    $this->assertSame($flattened, array(1, 2, 3, 4, 5, 7, 8));
+    $plugin = new Flatten([], 'flatten', []);
+    $flattened = $plugin->transform([1, 2, [3, 4, [5]], [], [7, 8]], $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->assertSame($flattened, [1, 2, 3, 4, 5, 7, 8]);
   }
 
 }

core/modules/migrate/tests/src/Unit/process/FormatDateTest.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Plugin\migrate\process\FormatDate;
+
+/**
+ * Tests the format date process plugin.
+ *
+ * @group migrate
+ *
+ * @coversDefaultClass Drupal\migrate\Plugin\migrate\process\FormatDate
+ */
+class FormatDateTest extends MigrateProcessTestCase {
+
+  /**
+   * Tests that missing configuration will throw an exception.
+   */
+  public function testMigrateExceptionMissingFromFormat() {
+    $configuration = [
+      'from_format' => '',
+      'to_format' => 'Y-m-d',
+    ];
+
+    $this->setExpectedException(MigrateException::class, 'Format date plugin is missing from_format configuration.');
+    $this->plugin = new FormatDate($configuration, 'test_format_date', []);
+    $this->plugin->transform('01/05/1955', $this->migrateExecutable, $this->row, 'field_date');
+  }
+
+  /**
+   * Tests that missing configuration will throw an exception.
+   */
+  public function testMigrateExceptionMissingToFormat() {
+    $configuration = [
+      'from_format' => 'm/d/Y',
+      'to_format' => '',
+    ];
+
+    $this->setExpectedException(MigrateException::class, 'Format date plugin is missing to_format configuration.');
+    $this->plugin = new FormatDate($configuration, 'test_format_date', []);
+    $this->plugin->transform('01/05/1955', $this->migrateExecutable, $this->row, 'field_date');
+  }
+
+  /**
+   * Tests that date format mismatches will throw an exception.
+   */
+  public function testMigrateExceptionBadFormat() {
+    $configuration = [
+      'from_format' => 'm/d/Y',
+      'to_format' => 'Y-m-d',
+    ];
+
+    $this->setExpectedException(MigrateException::class, 'Format date plugin could not transform "January 5, 1955" using the format "m/d/Y". Error: The date cannot be created from a format.');
+    $this->plugin = new FormatDate($configuration, 'test_format_date', []);
+    $this->plugin->transform('January 5, 1955', $this->migrateExecutable, $this->row, 'field_date');
+  }
+
+  /**
+   * Tests transformation.
+   *
+   * @covers ::transform
+   *
+   * @dataProvider datesDataProvider
+   *
+   * @param $configuration
+   *   The configuration of the migration process plugin.
+   * @param $value
+   *   The source value for the migration process plugin.
+   * @param $expected
+   *   The expected value of the migration process plugin.
+   */
+  public function testTransform($configuration, $value, $expected) {
+    $this->plugin = new FormatDate($configuration, 'test_format_date', []);
+    $actual = $this->plugin->transform($value, $this->migrateExecutable, $this->row, 'field_date');
+
+    $this->assertEquals($expected, $actual);
+  }
+
+  /**
+   * Data provider of test dates.
+   *
+   * @return array
+   *   Array of date formats and actual/expected values.
+   */
+  public function datesDataProvider() {
+    return [
+      'datetime_date' => [
+        'configuration' => [
+          'from_format' => 'm/d/Y',
+          'to_format' => 'Y-m-d',
+        ],
+        'value' => '01/05/1955',
+        'expected' => '1955-01-05',
+      ],
+      'datetime_datetime' => [
+        'configuration' => [
+          'from_format' => 'm/d/Y H:i:s',
+          'to_format' => 'Y-m-d\TH:i:s',
+        ],
+        'value' => '01/05/1955 10:43:22',
+        'expected' => '1955-01-05T10:43:22',
+      ],
+      'empty_values' => [
+        'configuration' => [
+          'from_format' => 'm/d/Y',
+          'to_format' => 'Y-m-d',
+        ],
+        'value' => '',
+        'expected' => '',
+      ],
+      'timezone' => [
+        'configuration' => [
+          'from_format' => 'Y-m-d\TH:i:sO',
+          'to_format' => 'Y-m-d\TH:i:s',
+          'timezone' => 'America/Managua',
+        ],
+        'value' => '2004-12-19T10:19:42-0600',
+        'expected' => '2004-12-19T10:19:42',
+      ],
+    ];
+  }
+
+}

core/modules/migrate/tests/src/Unit/process/GetTest.php

@@ -1,4 +1,5 @@
 <?php
+
 /**
  * @file
  * Contains \Drupal\Tests\migrate\Unit\process\GetTest.
@@ -40,16 +41,16 @@ class GetTest extends MigrateProcessTestCase {
    * Tests the Get plugin when source is an array.
    */
   public function testTransformSourceArray() {
-    $map = array(
+    $map = [
       'test1' => 'source_value1',
       'test2' => 'source_value2',
-    );
-    $this->plugin->setSource(array('test1', 'test2'));
+    ];
+    $this->plugin->setSource(['test1', 'test2']);
     $this->row->expects($this->exactly(2))
       ->method('getSourceProperty')
       ->will($this->returnCallback(function ($argument)  use ($map) { return $map[$argument]; } ));
     $value = $this->plugin->transform(NULL, $this->migrateExecutable, $this->row, 'destinationproperty');
-    $this->assertSame($value, array('source_value1', 'source_value2'));
+    $this->assertSame($value, ['source_value1', 'source_value2']);
   }
 
   /**
@@ -69,18 +70,18 @@ class GetTest extends MigrateProcessTestCase {
    * Tests the Get plugin when source is an array pointing to destination.
    */
   public function testTransformSourceArrayAt() {
-    $map = array(
+    $map = [
       'test1' => 'source_value1',
       '@test2' => 'source_value2',
       '@test3' => 'source_value3',
       'test4' => 'source_value4',
-    );
-    $this->plugin->setSource(array('test1', '@@test2', '@@test3', 'test4'));
+    ];
+    $this->plugin->setSource(['test1', '@@test2', '@@test3', 'test4']);
     $this->row->expects($this->exactly(4))
       ->method('getSourceProperty')
       ->will($this->returnCallback(function ($argument)  use ($map) { return $map[$argument]; } ));
     $value = $this->plugin->transform(NULL, $this->migrateExecutable, $this->row, 'destinationproperty');
-    $this->assertSame($value, array('source_value1', 'source_value2', 'source_value3', 'source_value4'));
+    $this->assertSame($value, ['source_value1', 'source_value2', 'source_value3', 'source_value4']);
   }
 
   /**

core/modules/migrate/tests/src/Unit/process/IteratorTest.php

@@ -25,9 +25,9 @@ class IteratorTest extends MigrateTestCase {
   /**
    * @var array
    */
-  protected $migrationConfiguration = array(
+  protected $migrationConfiguration = [
     'id' => 'test',
-  );
+  ];
 
   /**
    * Tests the iterator process plugin.
@@ -35,24 +35,24 @@ class IteratorTest extends MigrateTestCase {
   public function testIterator() {
     $migration = $this->getMigration();
     // Set up the properties for the iterator.
-    $configuration = array(
-      'process' => array(
+    $configuration = [
+      'process' => [
         'foo' => 'source_foo',
         'id' => 'source_id',
-      ),
+      ],
       'key' => '@id',
-    );
-    $plugin = new Iterator($configuration, 'iterator', array());
+    ];
+    $plugin = new Iterator($configuration, 'iterator', []);
     // Manually create the plugins. Migration::getProcessPlugins does this
     // normally but the plugin system is not available.
     foreach ($configuration['process'] as $destination => $source) {
-      $iterator_plugins[$destination][] = new Get(array('source' => $source), 'get', array());
+      $iterator_plugins[$destination][] = new Get(['source' => $source], 'get', []);
     }
     $migration->expects($this->at(1))
       ->method('getProcessPlugins')
       ->will($this->returnValue($iterator_plugins));
     // Set up the key plugins.
-    $key_plugin['key'][] = new Get(array('source' => '@id'), 'get', array());
+    $key_plugin['key'][] = new Get(['source' => '@id'], 'get', []);
     $migration->expects($this->at(2))
       ->method('getProcessPlugins')
       ->will($this->returnValue($key_plugin));
@@ -60,14 +60,14 @@ class IteratorTest extends MigrateTestCase {
     $migrate_executable = new MigrateExecutable($migration, $this->getMock('Drupal\migrate\MigrateMessageInterface'), $event_dispatcher);
 
     // The current value of the pipeline.
-    $current_value = array(
-      array(
+    $current_value = [
+      [
         'source_foo' => 'test',
         'source_id' => 42,
-      ),
-    );
+      ],
+    ];
     // This is not used but the interface requires it, so create an empty row.
-    $row = new Row(array(), array());
+    $row = new Row();
 
     // After transformation, check to make sure that source_foo and source_id's
     // values ended up in the proper destinations, and that the value of the

core/modules/migrate/tests/src/Unit/process/MachineNameTest.php

@@ -53,7 +53,7 @@ class MachineNameTest extends MigrateProcessTestCase {
       ->with($human_name)
       ->will($this->returnValue($human_name_ascii . 'aeo'));
 
-    $plugin = new MachineName(array(), 'machine_name', array(), $this->transliteration);
+    $plugin = new MachineName([], 'machine_name', [], $this->transliteration);
     $value = $plugin->transform($human_name, $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertEquals($expected_result, $value);
   }

core/modules/migrate/tests/src/Unit/process/MakeUniqueEntityFieldTest.php

@@ -0,0 +1,214 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\Query\QueryInterface;
+use Drupal\migrate\Plugin\migrate\process\MakeUniqueEntityField;
+use Drupal\Component\Utility\Unicode;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\MakeUniqueEntityField
+ * @group migrate
+ */
+class MakeUniqueEntityFieldTest extends MigrateProcessTestCase {
+
+  /**
+   * The mock entity query.
+   *
+   * @var \Drupal\Core\Entity\Query\QueryInterface
+   * @var \Drupal\Core\Entity\Query\QueryFactory
+   */
+  protected $entityQuery;
+
+  /**
+   * The mocked entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $entityTypeManager;
+
+  /**
+   * The migration configuration, initialized to set the ID to test.
+   *
+   * @var array
+   */
+  protected $migrationConfiguration = [
+    'id' => 'test',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->entityQuery = $this->getMockBuilder('Drupal\Core\Entity\Query\QueryInterface')
+      ->disableOriginalConstructor()
+      ->getMock();
+    $this->entityTypeManager = $this->getMock(EntityTypeManagerInterface::class);
+
+    $storage = $this->getMock(EntityStorageInterface::class);
+    $storage->expects($this->any())
+      ->method('getQuery')
+      ->willReturn($this->entityQuery);
+    $this->entityTypeManager->expects($this->any())
+      ->method('getStorage')
+      ->with('test_entity_type')
+      ->willReturn($storage);
+    parent::setUp();
+  }
+
+  /**
+   * Tests making an entity field value unique.
+   *
+   * @dataProvider providerTestMakeUniqueEntityField
+   */
+  public function testMakeUniqueEntityField($count, $postfix = '', $start = NULL, $length = NULL) {
+    $configuration = [
+      'entity_type' => 'test_entity_type',
+      'field' => 'test_field',
+    ];
+    if ($postfix) {
+      $configuration['postfix'] = $postfix;
+    }
+    $configuration['start'] = isset($start) ? $start : NULL;
+    $configuration['length'] = isset($length) ? $length : NULL;
+    $plugin = new MakeUniqueEntityField($configuration, 'make_unique', [], $this->getMigration(), $this->entityTypeManager);
+    $this->entityQueryExpects($count);
+    $value = $this->randomMachineName(32);
+    $actual = $plugin->transform($value, $this->migrateExecutable, $this->row, 'testproperty');
+    $expected = Unicode::substr($value, $start, $length);
+    $expected .= $count ? $postfix . $count : '';
+    $this->assertSame($expected, $actual);
+  }
+
+  /**
+   * Tests that invalid start position throws an exception.
+   */
+  public function testMakeUniqueEntityFieldEntityInvalidStart() {
+    $configuration = [
+      'entity_type' => 'test_entity_type',
+      'field' => 'test_field',
+      'start' => 'foobar',
+    ];
+    $plugin = new MakeUniqueEntityField($configuration, 'make_unique', [], $this->getMigration(), $this->entityTypeManager);
+    $this->setExpectedException('Drupal\migrate\MigrateException', 'The start position configuration key should be an integer. Omit this key to capture from the beginning of the string.');
+    $plugin->transform('test_start', $this->migrateExecutable, $this->row, 'testproperty');
+  }
+
+  /**
+   * Tests that invalid length option throws an exception.
+   */
+  public function testMakeUniqueEntityFieldEntityInvalidLength() {
+    $configuration = [
+      'entity_type' => 'test_entity_type',
+      'field' => 'test_field',
+      'length' => 'foobar',
+    ];
+    $plugin = new MakeUniqueEntityField($configuration, 'make_unique', [], $this->getMigration(), $this->entityTypeManager);
+    $this->setExpectedException('Drupal\migrate\MigrateException', 'The character length configuration key should be an integer. Omit this key to capture the entire string.');
+    $plugin->transform('test_length', $this->migrateExecutable, $this->row, 'testproperty');
+  }
+
+  /**
+   * Data provider for testMakeUniqueEntityField().
+   */
+  public function providerTestMakeUniqueEntityField() {
+    return [
+      // Tests no duplication.
+      [0],
+      // Tests no duplication and start position.
+      [0, NULL, 10],
+      // Tests no duplication, start position, and length.
+      [0, NULL, 5, 10],
+      // Tests no duplication and length.
+      [0, NULL, NULL, 10],
+      // Tests duplication.
+      [3],
+      // Tests duplication and start position.
+      [3, NULL, 10],
+      // Tests duplication, start position, and length.
+      [3, NULL, 5, 10],
+      // Tests duplication and length.
+      [3, NULL, NULL, 10],
+      // Tests no duplication and postfix.
+      [0, '_'],
+      // Tests no duplication, postfix, and start position.
+      [0, '_', 5],
+      // Tests no duplication, postfix, start position, and length.
+      [0, '_', 5, 10],
+      // Tests no duplication, postfix, and length.
+      [0, '_', NULL, 10],
+      // Tests duplication and postfix.
+      [2, '_'],
+      // Tests duplication, postfix, and start position.
+      [2, '_', 5],
+      // Tests duplication, postfix, start position, and length.
+      [2, '_', 5, 10],
+      // Tests duplication, postfix, and length.
+      [2, '_', NULL, 10],
+    ];
+  }
+
+  /**
+   * Helper function to add expectations to the mock entity query object.
+   *
+   * @param int $count
+   *   The number of unique values to be set up.
+   */
+  protected function entityQueryExpects($count) {
+    $this->entityQuery->expects($this->exactly($count + 1))
+      ->method('condition')
+      ->will($this->returnValue($this->entityQuery));
+    $this->entityQuery->expects($this->exactly($count + 1))
+      ->method('count')
+      ->will($this->returnValue($this->entityQuery));
+    $this->entityQuery->expects($this->exactly($count + 1))
+      ->method('execute')
+      ->will($this->returnCallback(function () use (&$count) { return $count--;}));
+  }
+
+  /**
+   * Tests making an entity field value unique only for migrated entities.
+   */
+  public function testMakeUniqueEntityFieldMigrated() {
+    $configuration = [
+      'entity_type' => 'test_entity_type',
+      'field' => 'test_field',
+      'migrated' => TRUE,
+    ];
+    $plugin = new MakeUniqueEntityField($configuration, 'make_unique', [], $this->getMigration(), $this->entityTypeManager);
+
+    // Setup the entityQuery used in MakeUniqueEntityFieldEntity::exists. The
+    // map, $map, is an array consisting of the four input parameters to the
+    // query condition method and then the query to return. Both 'forum' and
+    // 'test_vocab' are existing entities. There is no 'test_vocab1'.
+    $map = [];
+    foreach (['forums', 'test_vocab', 'test_vocab1'] as $id) {
+      $query = $this->prophesize(QueryInterface::class);
+      $query->willBeConstructedWith([]);
+      $query->execute()->willReturn($id === 'test_vocab1' ? [] : [$id]);
+      $map[] = ['test_field', $id, NULL, NULL, $query->reveal()];
+    }
+    $this->entityQuery
+      ->method('condition')
+      ->will($this->returnValueMap($map));
+
+    // Entity 'forums' is pre-existing, entity 'test_vocab' was migrated.
+    $this->idMap
+      ->method('lookupSourceID')
+      ->will($this->returnValueMap([
+        [['test_field' => 'forums'], FALSE],
+        [['test_field' => 'test_vocab'], ['source_id' => 42]],
+      ]));
+
+    // Existing entity 'forums' was not migrated, value should not be unique.
+    $actual = $plugin->transform('forums', $this->migrateExecutable, $this->row, 'testproperty');
+    $this->assertEquals('forums', $actual, 'Pre-existing name is re-used');
+
+    // Entity 'test_vocab' was migrated, value should be unique.
+    $actual = $plugin->transform('test_vocab', $this->migrateExecutable, $this->row, 'testproperty');
+    $this->assertEquals('test_vocab1', $actual, 'Migrated name is deduplicated');
+  }
+
+}

core/modules/migrate/tests/src/Unit/process/MigrationLookupTest.php

@@ -0,0 +1,202 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\migrate\MigrateSkipProcessException;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Plugin\migrate\process\MigrationLookup;
+use Drupal\migrate\Plugin\MigrateDestinationInterface;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+use Drupal\migrate\Plugin\MigratePluginManager;
+use Drupal\migrate\Plugin\MigrateSourceInterface;
+use Drupal\migrate\Plugin\MigrationPluginManagerInterface;
+use Prophecy\Argument;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\MigrationLookup
+ * @group migrate
+ */
+class MigrationLookupTest extends MigrateProcessTestCase {
+
+  /**
+   * @covers ::transform
+   */
+  public function testTransformWithStubSkipping() {
+    $migration_plugin = $this->prophesize(MigrationInterface::class);
+    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
+    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
+
+    $destination_id_map = $this->prophesize(MigrateIdMapInterface::class);
+    $destination_migration = $this->prophesize(MigrationInterface::class);
+    $destination_migration->getIdMap()->willReturn($destination_id_map->reveal());
+    $destination_id_map->lookupDestinationId([1])->willReturn(NULL);
+
+    // Ensure the migration plugin manager returns our migration.
+    $migration_plugin_manager->createInstances(Argument::exact(['destination_migration']))
+      ->willReturn(['destination_migration' => $destination_migration->reveal()]);
+
+    $configuration = [
+      'no_stub' => TRUE,
+      'migration' => 'destination_migration',
+    ];
+
+    $migration_plugin->id()->willReturn('actual_migration');
+    $destination_migration->getDestinationPlugin(TRUE)->shouldNotBeCalled();
+
+    $migration = new MigrationLookup($configuration, '', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $result = $migration->transform(1, $this->migrateExecutable, $this->row, '');
+    $this->assertNull($result);
+  }
+
+  /**
+   * @covers ::transform
+   */
+  public function testTransformWithStubbing() {
+    $migration_plugin = $this->prophesize(MigrationInterface::class);
+    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
+    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
+
+    $destination_id_map = $this->prophesize(MigrateIdMapInterface::class);
+    $destination_migration = $this->prophesize('Drupal\migrate\Plugin\Migration');
+    $destination_migration->getIdMap()->willReturn($destination_id_map->reveal());
+    $migration_plugin_manager->createInstances(['destination_migration'])
+      ->willReturn(['destination_migration' => $destination_migration->reveal()]);
+    $destination_id_map->lookupDestinationId([1])->willReturn(NULL);
+    $destination_id_map->saveIdMapping(Argument::any(), Argument::any(), MigrateIdMapInterface::STATUS_NEEDS_UPDATE)->willReturn(NULL);
+
+    $configuration = [
+      'no_stub' => FALSE,
+      'migration' => 'destination_migration',
+    ];
+
+    $migration_plugin->id()->willReturn('actual_migration');
+    $destination_migration->id()->willReturn('destination_migration');
+    $destination_migration->getDestinationPlugin(TRUE)->shouldBeCalled();
+    $destination_migration->getProcess()->willReturn([]);
+    $destination_migration->getSourceConfiguration()->willReturn([]);
+
+    $source_plugin = $this->prophesize(MigrateSourceInterface::class);
+    $source_plugin->getIds()->willReturn(['nid']);
+    $destination_migration->getSourcePlugin()->willReturn($source_plugin->reveal());
+    $destination_plugin = $this->prophesize(MigrateDestinationInterface::class);
+    $destination_plugin->import(Argument::any())->willReturn([2]);
+    $destination_migration->getDestinationPlugin(TRUE)->willReturn($destination_plugin->reveal());
+
+    $migration = new MigrationLookup($configuration, '', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $result = $migration->transform(1, $this->migrateExecutable, $this->row, '');
+    $this->assertEquals(2, $result);
+  }
+
+  /**
+   * Tests that processing is skipped when the input value is empty.
+   */
+  public function testSkipOnEmpty() {
+    $migration_plugin = $this->prophesize(MigrationInterface::class);
+    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
+    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
+
+    $configuration = [
+      'migration' => 'foobaz',
+    ];
+    $migration_plugin->id()->willReturn(uniqid());
+    $migration = new MigrationLookup($configuration, 'migration_lookup', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $this->setExpectedException(MigrateSkipProcessException::class);
+    $migration->transform(0, $this->migrateExecutable, $this->row, 'foo');
+  }
+
+  /**
+   * Tests a successful lookup.
+   *
+   * @dataProvider successfulLookupDataProvider
+   *
+   * @param array $source_id_values
+   *   The source id(s) of the migration map.
+   * @param array $destination_id_values
+   *   The destination id(s) of the migration map.
+   * @param string|array $source_value
+   *   The source value(s) for the migration process plugin.
+   * @param string|array $expected_value
+   *   The expected value(s) of the migration process plugin.
+   */
+  public function testSuccessfulLookup($source_id_values, $destination_id_values, $source_value, $expected_value) {
+    $migration_plugin = $this->prophesize(MigrationInterface::class);
+    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
+    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
+
+    $configuration = [
+      'migration' => 'foobaz',
+    ];
+    $migration_plugin->id()->willReturn(uniqid());
+
+    $id_map = $this->prophesize(MigrateIdMapInterface::class);
+    $id_map->lookupDestinationId($source_id_values)->willReturn($destination_id_values);
+    $migration_plugin->getIdMap()->willReturn($id_map->reveal());
+
+    $migration_plugin_manager->createInstances(['foobaz'])
+      ->willReturn(['foobaz' => $migration_plugin->reveal()]);
+
+    $migrationStorage = $this->prophesize(EntityStorageInterface::class);
+    $migrationStorage
+      ->loadMultiple(['foobaz'])
+      ->willReturn([$migration_plugin->reveal()]);
+
+    $migration = new MigrationLookup($configuration, 'migration_lookup', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $this->assertSame($expected_value, $migration->transform($source_value, $this->migrateExecutable, $this->row, 'foo'));
+  }
+
+  /**
+   * Provides data for the successful lookup test.
+   *
+   * @return array
+   */
+  public function successfulLookupDataProvider() {
+    return [
+      // Test data for scalar to scalar.
+      [
+        // Source ID of the migration map.
+        [1],
+        // Destination ID of the migration map.
+        [3],
+        // Input value for the migration plugin.
+        1,
+        // Expected output value of the migration plugin.
+        3,
+      ],
+      // Test data for scalar to array.
+      [
+        // Source ID of the migration map.
+        [1],
+        // Destination IDs of the migration map.
+        [3, 'foo'],
+        // Input value for the migration plugin.
+        1,
+        // Expected output values of the migration plugin.
+        [3, 'foo'],
+      ],
+      // Test data for array to scalar.
+      [
+        // Source IDs of the migration map.
+        [1, 3],
+        // Destination ID of the migration map.
+        ['foo'],
+        // Input values for the migration plugin.
+        [1, 3],
+        // Expected output value of the migration plugin.
+        'foo',
+      ],
+      // Test data for array to array.
+      [
+        // Source IDs of the migration map.
+        [1, 3],
+        // Destination IDs of the migration map.
+        [3, 'foo'],
+        // Input values for the migration plugin.
+        [1, 3],
+        // Expected output values of the migration plugin.
+        [3, 'foo'],
+      ],
+    ];
+  }
+
+}

core/modules/migrate/tests/src/Unit/process/MigrationTest.php

@@ -2,7 +2,11 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+@trigger_error('The ' . __NAMESPACE__ . '\MigrationTest is deprecated in
+Drupal 8.4.0 and will be removed before Drupal 9.0.0. Instead, use ' . __NAMESPACE__ . '\MigrationLookupTest', E_USER_DEPRECATED);
+
 use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\migrate\MigrateSkipProcessException;
 use Drupal\migrate\Plugin\MigrationInterface;
 use Drupal\migrate\Plugin\migrate\process\Migration;
 use Drupal\migrate\Plugin\MigrateDestinationInterface;
@@ -13,26 +17,49 @@ use Drupal\migrate\Plugin\MigrationPluginManagerInterface;
 use Prophecy\Argument;
 
 /**
+ * @deprecated in Drupal 8.4.x, to be removed before Drupal 9.0.x. Use
+ *   \Drupal\Tests\migrate\Unit\process\MigrationLookupTest instead.
+ *
  * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\Migration
  * @group migrate
  */
 class MigrationTest extends MigrateProcessTestCase {
 
+  /**
+   * @var \Drupal\migrate\Plugin\MigrationInterface
+   */
+  protected $migration_plugin;
+
+  /**
+   * @var \Drupal\migrate\Plugin\MigrationPluginManagerInterface
+   */
+  protected $migration_plugin_manager;
+
+  /**
+   * @var \Drupal\migrate\Plugin\MigratePluginManager
+   */
+  protected $process_plugin_manager;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->migration_plugin = $this->prophesize(MigrationInterface::class);
+    $this->migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
+    $this->process_plugin_manager = $this->prophesize(MigratePluginManager::class);
+  }
+
   /**
    * @covers ::transform
    */
   public function testTransformWithStubSkipping() {
-    $migration_plugin = $this->prophesize(MigrationInterface::class);
-    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
-    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
-
-    $destination_id_map = $this->prophesize(MigrateIdMapInterface::class);
-    $destination_migration = $this->prophesize(MigrationInterface::class);
-    $destination_migration->getIdMap()->willReturn($destination_id_map->reveal());
-    $destination_id_map->lookupDestinationId([1])->willReturn(NULL);
+    $destination_migration = $this->getMigration();
+    $destination_migration->getDestinationPlugin(TRUE)->shouldNotBeCalled();
 
     // Ensure the migration plugin manager returns our migration.
-    $migration_plugin_manager->createInstances(Argument::exact(['destination_migration']))
+    $this->migration_plugin_manager->createInstances(Argument::exact(['destination_migration']))
       ->willReturn(['destination_migration' => $destination_migration->reveal()]);
 
     $configuration = [
@@ -40,10 +67,9 @@ class MigrationTest extends MigrateProcessTestCase {
       'migration' => 'destination_migration',
     ];
 
-    $migration_plugin->id()->willReturn('actual_migration');
-    $destination_migration->getDestinationPlugin(TRUE)->shouldNotBeCalled();
+    $this->migration_plugin->id()->willReturn('actual_migration');
 
-    $migration = new Migration($configuration, '', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $migration = new Migration($configuration, '', [], $this->migration_plugin->reveal(), $this->migration_plugin_manager->reveal(), $this->process_plugin_manager->reveal());
     $result = $migration->transform(1, $this->migrateExecutable, $this->row, '');
     $this->assertNull($result);
   }
@@ -52,24 +78,16 @@ class MigrationTest extends MigrateProcessTestCase {
    * @covers ::transform
    */
   public function testTransformWithStubbing() {
-    $migration_plugin = $this->prophesize(MigrationInterface::class);
-    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
-    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
-
-    $destination_id_map = $this->prophesize(MigrateIdMapInterface::class);
-    $destination_migration = $this->prophesize('Drupal\migrate\Plugin\Migration');
-    $destination_migration->getIdMap()->willReturn($destination_id_map->reveal());
-    $migration_plugin_manager->createInstances(['destination_migration'])
+    $destination_migration = $this->getMigration();
+    $this->migration_plugin_manager->createInstances(['destination_migration'])
       ->willReturn(['destination_migration' => $destination_migration->reveal()]);
-    $destination_id_map->lookupDestinationId([1])->willReturn(NULL);
-    $destination_id_map->saveIdMapping(Argument::any(), Argument::any(), MigrateIdMapInterface::STATUS_NEEDS_UPDATE)->willReturn(NULL);
 
     $configuration = [
       'no_stub' => FALSE,
       'migration' => 'destination_migration',
     ];
 
-    $migration_plugin->id()->willReturn('actual_migration');
+    $this->migration_plugin->id()->willReturn('actual_migration');
     $destination_migration->id()->willReturn('destination_migration');
     $destination_migration->getDestinationPlugin(TRUE)->shouldBeCalled();
     $destination_migration->getProcess()->willReturn([]);
@@ -82,56 +100,108 @@ class MigrationTest extends MigrateProcessTestCase {
     $destination_plugin->import(Argument::any())->willReturn([2]);
     $destination_migration->getDestinationPlugin(TRUE)->willReturn($destination_plugin->reveal());
 
-    $migration = new Migration($configuration, '', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $migration = new Migration($configuration, '', [], $this->migration_plugin->reveal(), $this->migration_plugin_manager->reveal(), $this->process_plugin_manager->reveal());
     $result = $migration->transform(1, $this->migrateExecutable, $this->row, '');
     $this->assertEquals(2, $result);
   }
 
+  /**
+   * Creates a mock Migration instance.
+   *
+   * @return \Prophecy\Prophecy\ObjectProphecy
+   *   A mock Migration instance.
+   */
+  protected function getMigration() {
+    $id_map = $this->prophesize(MigrateIdMapInterface::class);
+    $id_map->lookupDestinationId([1])->willReturn(NULL);
+    $id_map->saveIdMapping(Argument::any(), Argument::any(), MigrateIdMapInterface::STATUS_NEEDS_UPDATE)->willReturn(NULL);
+
+    $migration = $this->prophesize(MigrationInterface::class);
+    $migration->getIdMap()->willReturn($id_map->reveal());
+    return $migration;
+  }
+
   /**
    * Tests that processing is skipped when the input value is empty.
-  *
-   * @expectedException \Drupal\migrate\MigrateSkipProcessException
    */
   public function testSkipOnEmpty() {
-    $migration_plugin = $this->prophesize(MigrationInterface::class);
-    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
-    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
-
     $configuration = [
       'migration' => 'foobaz',
     ];
-    $migration_plugin->id()->willReturn(uniqid());
-    $migration = new Migration($configuration, 'migration', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
+    $this->migration_plugin->id()->willReturn(uniqid());
+    $migration = new Migration($configuration, 'migration', [], $this->migration_plugin->reveal(), $this->migration_plugin_manager->reveal(), $this->process_plugin_manager->reveal());
+    $this->setExpectedException(MigrateSkipProcessException::class);
     $migration->transform(0, $this->migrateExecutable, $this->row, 'foo');
   }
 
   /**
    * Tests a successful lookup.
+   *
+   * @dataProvider successfulLookupDataProvider
+   *
+   * @param array $source_id_values
+   *   The source id(s) of the migration map.
+   * @param array $destination_id_values
+   *   The destination id(s) of the migration map.
+   * @param string|array $source_value
+   *   The source value(s) for the migration process plugin.
+   * @param string|array $expected_value
+   *   The expected value(s) of the migration process plugin.
    */
-  public function testSuccessfulLookup() {
-    $migration_plugin = $this->prophesize(MigrationInterface::class);
-    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);
-    $process_plugin_manager = $this->prophesize(MigratePluginManager::class);
-
+  public function testSuccessfulLookup($source_id_values, $destination_id_values, $source_value, $expected_value) {
     $configuration = [
       'migration' => 'foobaz',
     ];
-    $migration_plugin->id()->willReturn(uniqid());
+    $this->migration_plugin->id()->willReturn(uniqid());
 
     $id_map = $this->prophesize(MigrateIdMapInterface::class);
-    $id_map->lookupDestinationId([1])->willReturn([3]);
-    $migration_plugin->getIdMap()->willReturn($id_map->reveal());
+    $id_map->lookupDestinationId($source_id_values)->willReturn($destination_id_values);
+    $this->migration_plugin->getIdMap()->willReturn($id_map->reveal());
 
-    $migration_plugin_manager->createInstances(['foobaz'])
-      ->willReturn(['foobaz' => $migration_plugin->reveal()]);
+    $this->migration_plugin_manager->createInstances(['foobaz'])
+      ->willReturn(['foobaz' => $this->migration_plugin->reveal()]);
 
     $migrationStorage = $this->prophesize(EntityStorageInterface::class);
     $migrationStorage
       ->loadMultiple(['foobaz'])
-      ->willReturn([$migration_plugin->reveal()]);
+      ->willReturn([$this->migration_plugin->reveal()]);
 
-    $migration = new Migration($configuration, 'migration', [], $migration_plugin->reveal(), $migration_plugin_manager->reveal(), $process_plugin_manager->reveal());
-    $this->assertSame(3, $migration->transform(1, $this->migrateExecutable, $this->row, 'foo'));
+    $migration = new Migration($configuration, 'migration', [], $this->migration_plugin->reveal(), $this->migration_plugin_manager->reveal(), $this->process_plugin_manager->reveal());
+    $this->assertSame($expected_value, $migration->transform($source_value, $this->migrateExecutable, $this->row, 'foo'));
+  }
+
+  /**
+   * Provides data for the successful lookup test.
+   *
+   * @return array
+   */
+  public function successfulLookupDataProvider() {
+    return [
+      'scalar_to_scalar' => [
+        'source_ids' => [1],
+        'destination_ids' => [3],
+        'input_value' => 1,
+        'expected_value' => 3,
+      ],
+      'scalar_to_array' => [
+        'source_ids' => [1],
+        'destination_ids' => [3, 'foo'],
+        'input_value' => 1,
+        'expected_value' => [3, 'foo'],
+      ],
+      'array_to_scalar' => [
+        'source_ids' => [1, 3],
+        'destination_ids' => ['foo'],
+        'input_value' => [1, 3],
+        'expected_value' => 'foo',
+      ],
+      'array_to_array' => [
+        'source_ids' => [1, 3],
+        'destination_ids' => [3, 'foo'],
+        'input_value' => [1, 3],
+        'expected_value' => [3, 'foo'],
+      ],
+    ];
   }
 
 }

core/modules/migrate/tests/src/Unit/process/SkipOnEmptyTest.php

@@ -1,6 +1,9 @@
 <?php
 
 namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\migrate\MigrateSkipProcessException;
+use Drupal\migrate\MigrateSkipRowException;
 use Drupal\migrate\Plugin\migrate\process\SkipOnEmpty;
 
 /**
@@ -13,10 +16,10 @@ class SkipOnEmptyTest extends MigrateProcessTestCase {
 
   /**
    * @covers ::process
-   * @expectedException \Drupal\migrate\MigrateSkipProcessException
    */
   public function testProcessSkipsOnEmpty() {
     $configuration['method'] = 'process';
+    $this->setExpectedException(MigrateSkipProcessException::class);
     (new SkipOnEmpty($configuration, 'skip_on_empty', []))
       ->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
   }
@@ -33,10 +36,10 @@ class SkipOnEmptyTest extends MigrateProcessTestCase {
 
   /**
    * @covers ::row
-   * @expectedException \Drupal\migrate\MigrateSkipRowException
    */
   public function testRowSkipsOnEmpty() {
     $configuration['method'] = 'row';
+    $this->setExpectedException(MigrateSkipRowException::class);
     (new SkipOnEmpty($configuration, 'skip_on_empty', []))
       ->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
   }
@@ -51,4 +54,33 @@ class SkipOnEmptyTest extends MigrateProcessTestCase {
     $this->assertSame($value, ' ');
   }
 
+  /**
+   * Tests that a skip row exception without a message is raised.
+   *
+   * @covers ::row
+   */
+  public function testRowSkipWithoutMessage() {
+    $configuration = [
+      'method' => 'row',
+    ];
+    $process = new SkipOnEmpty($configuration, 'skip_on_empty', []);
+    $this->setExpectedException(MigrateSkipRowException::class);
+    $process->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+  /**
+   * Tests that a skip row exception with a message is raised.
+   *
+   * @covers ::row
+   */
+  public function testRowSkipWithMessage() {
+    $configuration = [
+      'method' => 'row',
+      'message' => 'The value is empty',
+    ];
+    $process = new SkipOnEmpty($configuration, 'skip_on_empty', []);
+    $this->setExpectedException(MigrateSkipRowException::class, 'The value is empty');
+    $process->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
 }

core/modules/migrate/tests/src/Unit/process/SkipRowIfNotSetTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\migrate\MigrateSkipRowException;
+use Drupal\migrate\Plugin\migrate\process\SkipRowIfNotSet;
+
+/**
+ * Tests the skip row if not set process plugin.
+ *
+ * @group migrate
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\SkipRowIfNotSet
+ */
+class SkipRowIfNotSetTest extends MigrateProcessTestCase {
+
+  /**
+   * Tests that a skip row exception without a message is raised.
+   *
+   * @covers ::transform
+   */
+  public function testRowSkipWithoutMessage() {
+    $configuration = [
+      'index' => 'some_key',
+    ];
+    $process = new SkipRowIfNotSet($configuration, 'skip_row_if_not_set', []);
+    $this->setExpectedException(MigrateSkipRowException::class);
+    $process->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+  /**
+   * Tests that a skip row exception with a message is raised.
+   *
+   * @covers ::transform
+   */
+  public function testRowSkipWithMessage() {
+    $configuration = [
+      'index' => 'some_key',
+      'message' => "The 'some_key' key is not set",
+    ];
+    $process = new SkipRowIfNotSet($configuration, 'skip_row_if_not_set', []);
+    $this->setExpectedException(MigrateSkipRowException::class, "The 'some_key' key is not set");
+    $process->transform('', $this->migrateExecutable, $this->row, 'destinationproperty');
+  }
+
+}

core/modules/migrate/tests/src/Unit/process/StaticMapTest.php

@@ -2,6 +2,8 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\MigrateSkipRowException;
 use Drupal\migrate\Plugin\migrate\process\StaticMap;
 
 /**
@@ -16,7 +18,7 @@ class StaticMapTest extends MigrateProcessTestCase {
    */
   protected function setUp() {
     $configuration['map']['foo']['bar'] = 'baz';
-    $this->plugin = new StaticMap($configuration, 'map', array());
+    $this->plugin = new StaticMap($configuration, 'map', []);
     parent::setUp();
   }
 
@@ -25,33 +27,31 @@ class StaticMapTest extends MigrateProcessTestCase {
    */
   public function testMapWithSourceString() {
     $value = $this->plugin->transform('foo', $this->migrateExecutable, $this->row, 'destinationproperty');
-    $this->assertSame($value, array('bar' => 'baz'));
+    $this->assertSame($value, ['bar' => 'baz']);
   }
 
   /**
    * Tests map when the source is a list.
    */
   public function testMapWithSourceList() {
-    $value = $this->plugin->transform(array('foo', 'bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $value = $this->plugin->transform(['foo', 'bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertSame($value, 'baz');
   }
 
   /**
    * Tests when the source is empty.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
    */
   public function testMapwithEmptySource() {
-    $this->plugin->transform(array(), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->setExpectedException(MigrateException::class);
+    $this->plugin->transform([], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
   /**
    * Tests when the source is invalid.
-   *
-   * @expectedException \Drupal\migrate\MigrateSkipRowException
    */
   public function testMapwithInvalidSource() {
-    $this->plugin->transform(array('bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->setExpectedException(MigrateSkipRowException::class);
+    $this->plugin->transform(['bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
   /**
@@ -60,8 +60,8 @@ class StaticMapTest extends MigrateProcessTestCase {
   public function testMapWithInvalidSourceWithADefaultValue() {
     $configuration['map']['foo']['bar'] = 'baz';
     $configuration['default_value'] = 'test';
-    $this->plugin = new StaticMap($configuration, 'map', array());
-    $value = $this->plugin->transform(array('bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->plugin = new StaticMap($configuration, 'map', []);
+    $value = $this->plugin->transform(['bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertSame($value, 'test');
   }
 
@@ -72,22 +72,20 @@ class StaticMapTest extends MigrateProcessTestCase {
     $configuration['map']['foo']['bar'] = 'baz';
     $configuration['default_value'] = NULL;
     $this->plugin = new StaticMap($configuration, 'map', []);
-    $value = $this->plugin->transform(array('bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $value = $this->plugin->transform(['bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
     $this->assertNull($value);
   }
 
   /**
    * Tests when the source is invalid and bypass is enabled.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage Setting both default_value and bypass is invalid.
    */
   public function testMapWithInvalidSourceAndBypass() {
     $configuration['map']['foo']['bar'] = 'baz';
     $configuration['default_value'] = 'test';
     $configuration['bypass'] = TRUE;
-    $this->plugin = new StaticMap($configuration, 'map', array());
-    $this->plugin->transform(array('bar'), $this->migrateExecutable, $this->row, 'destinationproperty');
+    $this->plugin = new StaticMap($configuration, 'map', []);
+    $this->setExpectedException(MigrateException::class, 'Setting both default_value and bypass is invalid.');
+    $this->plugin->transform(['bar'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
 }

core/modules/migrate/tests/src/Unit/process/SubstrTest.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\Tests\migrate\Unit\process;
 
+use Drupal\migrate\MigrateException;
 use Drupal\migrate\Plugin\migrate\process\Substr;
 
 /**
@@ -55,37 +56,31 @@ class SubstrTest extends MigrateProcessTestCase {
 
   /**
    * Tests invalid input type.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage The input value must be a string.
    */
   public function testSubstrFail() {
     $configuration = [];
     $this->plugin = new Substr($configuration, 'map', []);
+    $this->setExpectedException(MigrateException::class, 'The input value must be a string.');
     $this->plugin->transform(['Captain Janeway'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
   /**
    * Tests that the start parameter is an integer.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage The start position configuration value should be an integer. Omit this key to capture from the beginning of the string.
    */
   public function testStartIsString() {
     $configuration['start'] = '2';
     $this->plugin = new Substr($configuration, 'map', []);
+    $this->setExpectedException(MigrateException::class, 'The start position configuration value should be an integer. Omit this key to capture from the beginning of the string.');
     $this->plugin->transform(['foo'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 
   /**
    * Tests that the length parameter is an integer.
-   *
-   * @expectedException \Drupal\migrate\MigrateException
-   * @expectedExceptionMessage The character length configuration value should be an integer. Omit this key to capture from the start position to the end of the string.
    */
   public function testLengthIsString() {
     $configuration['length'] = '1';
     $this->plugin = new Substr($configuration, 'map', []);
+    $this->setExpectedException(MigrateException::class, 'The character length configuration value should be an integer. Omit this key to capture from the start position to the end of the string.');
     $this->plugin->transform(['foo'], $this->migrateExecutable, $this->row, 'destinationproperty');
   }
 

core/modules/migrate/tests/src/Unit/process/UrlEncodeTest.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Drupal\Tests\migrate\Unit\process;
+
+use Drupal\migrate\Plugin\migrate\process\UrlEncode;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\MigrateMessage;
+use Drupal\migrate\Row;
+use Drupal\Tests\migrate\Unit\MigrateTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\process\UrlEncode
+ * @group file
+ */
+class UrlEncodeTest extends MigrateTestCase {
+
+  /**
+   * @inheritdoc
+   */
+  protected $migrationConfiguration = [
+    'id' => 'test',
+  ];
+
+  /**
+   * The data provider for testing URL encoding scenarios.
+   *
+   * @return array
+   *   An array of URLs to test.
+   */
+  public function urlDataProvider() {
+    return [
+      'A URL with no characters requiring encoding' => ['http://example.com/normal_url.html', 'http://example.com/normal_url.html'],
+      'The definitive use case - encoding spaces in URLs' => ['http://example.com/url with spaces.html', 'http://example.com/url%20with%20spaces.html'],
+      'Definitive use case 2 - spaces in directories' => ['http://example.com/dir with spaces/foo.html', 'http://example.com/dir%20with%20spaces/foo.html'],
+      'Local filespecs without spaces should not be transformed' => ['/tmp/normal.txt', '/tmp/normal.txt'],
+      'Local filespecs with spaces should not be transformed' => ['/tmp/with spaces.txt', '/tmp/with spaces.txt'],
+      'Make sure URL characters (:, ?, &) are not encoded but others are.' => ['https://example.com/?a=b@c&d=e+f%', 'https://example.com/?a%3Db%40c&d%3De%2Bf%25'],
+    ];
+  }
+
+  /**
+   * Cover various encoding scenarios.
+   * @dataProvider urlDataProvider
+   */
+  public function testUrls($input, $output) {
+    $this->assertEquals($output, $this->doTransform($input));
+  }
+
+  /**
+   * Perform the urlencode process plugin over the given value.
+   *
+   * @param string $value
+   *   URL to be encoded.
+   *
+   * @return string
+   *   Encoded URL.
+   */
+  protected function doTransform($value) {
+    $executable = new MigrateExecutable($this->getMigration(), new MigrateMessage());
+    $row = new Row();
+
+    return (new UrlEncode([], 'urlencode', []))
+      ->transform($value, $executable, $row, 'foobaz');
+  }
+
+}