Update to drupal-org-drupal 8.0.0-rc2. For more information, see https://www.drupal.org/node/2598668

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

@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\migrate\Kernel\Entity\MigrationTest.
+ */
+
+namespace Drupal\Tests\migrate\Kernel\Entity;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\Entity\Migration;
+
+/**
+ * Tests the Migration entity.
+ *
+ * @coversDefaultClass \Drupal\migrate\Entity\Migration
+ * @group migrate
+ */
+class MigrationTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['migrate'];
+
+  /**
+   * @covers ::calculateDependencies
+   */
+  public function testCalculateDependencies() {
+    $fixture_migrations = [
+      'd6_node__article' => 'd6_node',
+      'd6_node__page' => 'd6_node',
+      'd6_variables' => 'd6_variables',
+    ];
+
+    foreach ($fixture_migrations as $id => $template) {
+      $values = [
+        'id' => $id,
+        'template' => $template,
+        'source' => [
+          'plugin' => 'empty',
+        ],
+        'destination' => [
+          'plugin' => 'null',
+        ],
+        'migration_tags' => []
+      ];
+      Migration::create($values)->save();
+    }
+
+    $values = [
+      'migration_dependencies' => [
+        'required' => [
+          'd6_node:*',
+          'd6_variables'
+        ]
+      ],
+      'source' => [
+        'plugin' => 'empty',
+      ],
+      'destination' => [
+        'plugin' => 'null',
+      ],
+    ];
+
+    $migration = new Migration($values, 'migration');
+    $expected = [
+      'migrate.migration.d6_node__article',
+      'migrate.migration.d6_node__page',
+      'migrate.migration.d6_variables'
+    ];
+    $migration->calculateDependencies();
+    $this->assertEquals($expected, $migration->getDependencies()['config']);
+  }
+
+}

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

@@ -0,0 +1,219 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\migrate\Unit\destination\EntityRevisionTest.
+ */
+
+namespace Drupal\Tests\migrate\Unit\destination;
+
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\migrate\Plugin\migrate\destination\EntityRevision as RealEntityRevision;
+use Drupal\migrate\Row;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Tests entity revision destination.
+ *
+ * @group migrate
+ * @coversDefaultClass \Drupal\migrate\Plugin\migrate\destination\EntityRevision
+ */
+class EntityRevisionTest extends UnitTestCase {
+
+  /**
+   * @var \Drupal\migrate\Entity\MigrationInterface
+   */
+  protected $migration;
+
+  /**
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $storage;
+
+  /**
+   * @var \Drupal\Core\Entity\EntityManagerInterface
+   */
+  protected $entityManager;
+
+  public function setUp() {
+    parent::setUp();
+
+    // Setup mocks to be used when creating a revision destination.
+    $this->migration = $this->prophesize('\Drupal\migrate\Entity\MigrationInterface');
+    $this->storage = $this->prophesize('\Drupal\Core\Entity\EntityStorageInterface');
+    $this->entityManager = $this->prophesize('\Drupal\Core\Entity\EntityManagerInterface');
+  }
+
+  /**
+   * Test that passed old destination values are used by default.
+   *
+   * @covers ::getEntity
+   */
+  public function testGetEntityDestinationValues() {
+    $destination = $this->getEntityRevisionDestination([]);
+    // Return a dummy because we don't care what gets called.
+    $entity = $this->prophesize('\Drupal\Core\Entity\EntityInterface')
+      ->willImplement('\Drupal\Core\Entity\RevisionableInterface');
+    // Assert that the first ID from the destination values is used to load the
+    // entity.
+    $this->storage->loadRevision(12)
+      ->shouldBeCalled()
+      ->willReturn($entity->reveal());
+    $row = new Row([], []);
+    $this->assertEquals($entity->reveal(), $destination->getEntity($row, [12, 13]));
+  }
+
+  /**
+   * Test that revision updates update.
+   *
+   * @covers ::getEntity
+   */
+  public function testGetEntityUpdateRevision() {
+    $destination = $this->getEntityRevisionDestination([]);
+    $entity = $this->prophesize('\Drupal\Core\Entity\EntityInterface')
+      ->willImplement('\Drupal\Core\Entity\RevisionableInterface');
+
+    $entity_type = $this->prophesize('\Drupal\Core\Entity\EntityTypeInterface');
+    $entity_type->getKey('id')->willReturn('nid');
+    $entity_type->getKey('revision')->willReturn('vid');
+    $this->storage->getEntityType()->willReturn($entity_type->reveal());
+
+    // Assert we load the correct revision.
+    $this->storage->loadRevision(2)
+      ->shouldBeCalled()
+      ->willReturn($entity->reveal());
+    // Make sure its set as an update and not the default revision.
+    $entity->setNewRevision(FALSE)->shouldBeCalled();
+    $entity->isDefaultRevision(FALSE)->shouldBeCalled();
+
+    $row = new Row(['nid' => 1, 'vid' => 2], ['nid' => 1, 'vid' => 2]);
+    $row->setDestinationProperty('vid', 2);
+    $this->assertEquals($entity->reveal(), $destination->getEntity($row, []));
+  }
+
+  /**
+   * Test that new revisions are flagged to be written as new.
+   *
+   * @covers ::getEntity
+   */
+  public function testGetEntityNewRevision() {
+    $destination = $this->getEntityRevisionDestination([]);
+    $entity = $this->prophesize('\Drupal\Core\Entity\EntityInterface')
+      ->willImplement('\Drupal\Core\Entity\RevisionableInterface');
+
+    $entity_type = $this->prophesize('\Drupal\Core\Entity\EntityTypeInterface');
+    $entity_type->getKey('id')->willReturn('nid');
+    $entity_type->getKey('revision')->willReturn('vid');
+    $this->storage->getEntityType()->willReturn($entity_type->reveal());
+
+    // Enforce is new should be disabled.
+    $entity->enforceIsNew(FALSE)->shouldBeCalled();
+    // And toggle this as new revision but not the default revision.
+    $entity->setNewRevision(TRUE)->shouldBeCalled();
+    $entity->isDefaultRevision(FALSE)->shouldBeCalled();
+
+    // Assert we load the correct revision.
+    $this->storage->load(1)
+      ->shouldBeCalled()
+      ->willReturn($entity->reveal());
+
+    $row = new Row(['nid' => 1, 'vid' => 2], ['nid' => 1, 'vid' => 2]);
+    $row->setDestinationProperty('nid', 1);
+    $this->assertEquals($entity->reveal(), $destination->getEntity($row, []));
+  }
+
+  /**
+   * Test entity load failure.
+   *
+   * @covers ::getEntity
+   */
+  public function testGetEntityLoadFailure() {
+    $destination = $this->getEntityRevisionDestination([]);
+
+    $entity_type = $this->prophesize('\Drupal\Core\Entity\EntityTypeInterface');
+    $entity_type->getKey('id')->willReturn('nid');
+    $entity_type->getKey('revision')->willReturn('vid');
+    $this->storage->getEntityType()->willReturn($entity_type->reveal());
+
+    // Return a failed load and make sure we don't fail and we return FALSE.
+    $this->storage->load(1)
+      ->shouldBeCalled()
+      ->willReturn(FALSE);
+
+    $row = new Row(['nid' => 1, 'vid' => 2], ['nid' => 1, 'vid' => 2]);
+    $row->setDestinationProperty('nid', 1);
+    $this->assertFalse($destination->getEntity($row, []));
+  }
+
+  /**
+   * Test entity revision save.
+   *
+   * @covers ::save
+   */
+  public function testSave() {
+    $entity = $this->prophesize('\Drupal\Core\Entity\ContentEntityInterface');
+    $entity->save()
+      ->shouldBeCalled();
+    $entity->getRevisionId()
+      ->shouldBeCalled()
+      ->willReturn(1234);
+    $destination = $this->getEntityRevisionDestination();
+    $this->assertEquals([1234], $destination->save($entity->reveal(), []));
+  }
+
+
+  /**
+   * Helper method to create an entity revision destination with mock services.
+   *
+   * @see \Drupal\Tests\migrate\Unit\Destination\EntityRevision
+   *
+   * @param $configuration
+   *   Configuration for the destination.
+   * @param string $plugin_id
+   *   The plugin id.
+   * @param array $plugin_definition
+   *   The plugin definition.
+   *
+   * @return \Drupal\Tests\migrate\Unit\destination\EntityRevision
+   *   Mocked destination.
+   */
+  protected function getEntityRevisionDestination(array $configuration = [], $plugin_id = 'entity_revision', array $plugin_definition = []) {
+    return new EntityRevision($configuration, $plugin_id, $plugin_definition,
+      $this->migration->reveal(),
+      $this->storage->reveal(),
+      [],
+      $this->entityManager->reveal());
+  }
+
+}
+
+/**
+ * Mock that exposes from internal methods for testing.
+ */
+class EntityRevision extends RealEntityRevision {
+
+  /**
+   * Allow public access for testing.
+   */
+  public function getEntity(Row $row, array $old_destination_id_values) {
+    return parent::getEntity($row, $old_destination_id_values);
+  }
+
+  /**
+   * Allow public access for testing.
+   */
+  public function save(ContentEntityInterface $entity, array $old_destination_id_values = array()) {
+    return parent::save($entity, $old_destination_id_values);
+  }
+
+  /**
+   * Don't test method from base class.
+   *
+   * This method is from the parent and we aren't concerned with the inner
+   * workings of its implementation which would trickle into mock assertions. An
+   * empty implementation avoids this.
+   */
+  protected function updateEntity(EntityInterface $entity, Row $row) {}
+
+}

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

@@ -7,7 +7,6 @@
 namespace Drupal\Tests\migrate\Unit\process;
 
 use Drupal\migrate\Plugin\migrate\process\TestGet;
-use Drupal\migrate\Row;
 
 /**
  * Tests the get process plugin.

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

@@ -9,7 +9,6 @@ namespace Drupal\Tests\migrate\Unit\process;
 use Drupal\migrate\MigrateExecutable;
 use Drupal\migrate\Plugin\migrate\process\Get;
 use Drupal\migrate\Plugin\migrate\process\Iterator;
-use Drupal\migrate\Plugin\migrate\process\StaticMap;
 use Drupal\migrate\Row;
 use Drupal\Tests\migrate\Unit\MigrateTestCase;