MigrateUserTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\user\Kernel\Migrate\d7;

use Drupal\Core\Database\Database;
use Drupal\Tests\migrate_drupal\Kernel\d7\MigrateDrupal7TestBase;
use Drupal\user\Entity\User;
use Drupal\user\RoleInterface;
use Drupal\user\UserInterface;

/**
 * Users migration.
 *
 * @group user
 */
class MigrateUserTest extends MigrateDrupal7TestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'comment',
    'content_translation',
    'datetime',
    'datetime_range',
    'image',
    'language',
    'link',
    'menu_ui',
    'node',
    'phpass',
    'taxonomy',
    'telephone',
    'text',
  ];

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this
      ->installEntitySchema('comment');
    $this
      ->installEntitySchema('taxonomy_term');
    $this
      ->executeMigration('language');
    $this
      ->migrateFields();
    $this
      ->migrateUsers();
    $this
      ->executeMigrations([
      'd7_entity_translation_settings',
      'd7_user_entity_translation',
    ]);
  }

  /**
   * Asserts various aspects of a user account.
   *
   * @param string $id
   *   The user ID.
   * @param string $label
   *   The username.
   * @param string $mail
   *   The user's email address.
   * @param string $password
   *   The password for this user.
   * @param int $created
   *   The user's creation time.
   * @param int $access
   *   The last access time.
   * @param int $login
   *   The last login time.
   * @param bool $blocked
   *   Whether or not the account is blocked.
   * @param string $entity_langcode
   *   The user entity language code.
   * @param string $prefered_langcode
   *   The user prefered language code.
   * @param string $timezone
   *   The user account's timezone name.
   * @param string $init
   *   The user's initial email address.
   * @param string[] $roles
   *   Role IDs the user account is expected to have.
   * @param array|null $field_integer
   *   The value of the integer field.
   * @param int|false $field_file_target_id
   *   (optional) The target ID of the file field.
   * @param bool $has_picture
   *   (optional) Whether the user is expected to have a picture attached.
   *
   * @internal
   */
  protected function assertEntity(string $id, string $label, string $mail, string $password, int $created, int $access, int $login, bool $blocked, string $entity_langcode, string $prefered_langcode, string $timezone, string $init, array $roles, ?array $field_integer, $field_file_target_id = FALSE, bool $has_picture = FALSE) : void {

    /** @var \Drupal\user\UserInterface $user */
    $user = User::load($id);
    $this
      ->assertInstanceOf(UserInterface::class, $user);
    $this
      ->assertSame($label, $user
      ->label());
    $this
      ->assertSame($mail, $user
      ->getEmail());
    $this
      ->assertSame($password, $user
      ->getPassword());
    $this
      ->assertSame($created, (int) $user
      ->getCreatedTime());
    $this
      ->assertSame($access, (int) $user
      ->getLastAccessedTime());
    $this
      ->assertSame($login, (int) $user
      ->getLastLoginTime());
    $this
      ->assertNotSame($blocked, (bool) $user
      ->isBlocked());

    // Ensure the user's langcode, preferred_langcode and
    // preferred_admin_langcode are valid.
    // $user->getPreferredLangcode() might fallback to default language if the
    // user preferred language is not configured on the site. We just want to
    // test if the value was imported correctly.
    $language_manager = $this->container
      ->get('language_manager');
    $default_langcode = $language_manager
      ->getDefaultLanguage()
      ->getId();
    if ($prefered_langcode == '') {
      $this
        ->assertSame('en', $user->langcode->value);
      $this
        ->assertSame($default_langcode, $user->preferred_langcode->value);
      $this
        ->assertSame($default_langcode, $user->preferred_admin_langcode->value);
    }
    elseif ($language_manager
      ->getLanguage($prefered_langcode) === NULL) {
      $this
        ->assertSame($default_langcode, $user->langcode->value);
      $this
        ->assertSame($default_langcode, $user->preferred_langcode->value);
      $this
        ->assertSame($default_langcode, $user->preferred_admin_langcode->value);
    }
    else {
      $this
        ->assertSame($entity_langcode, $user->langcode->value);
      $this
        ->assertSame($prefered_langcode, $user->preferred_langcode->value);
      $this
        ->assertSame($prefered_langcode, $user->preferred_admin_langcode->value);
    }
    $this
      ->assertSame($timezone, $user
      ->getTimeZone());
    $this
      ->assertSame($init, $user
      ->getInitialEmail());
    $this
      ->assertSame($roles, $user
      ->getRoles());
    $this
      ->assertSame($has_picture, !$user->user_picture
      ->isEmpty());
    if (!is_null($field_integer)) {
      $this
        ->assertTrue($user
        ->hasField('field_integer'));
      $this
        ->assertEquals($field_integer[0], $user->field_integer->value);
    }
    if (!empty($field_file_target_id)) {
      $this
        ->assertTrue($user
        ->hasField('field_file'));
      $this
        ->assertSame($field_file_target_id, $user->field_file->target_id);
    }
  }

  /**
   * Tests the Drupal 7 user to Drupal 8 migration.
   */
  public function testUser() {
    $users = Database::getConnection('default', 'migrate')
      ->select('users', 'u')
      ->fields('u')
      ->condition('uid', 1, '>')
      ->execute()
      ->fetchAll();
    foreach ($users as $source) {
      $rids = Database::getConnection('default', 'migrate')
        ->select('users_roles', 'ur')
        ->fields('ur', [
        'rid',
      ])
        ->condition('ur.uid', $source->uid)
        ->execute()
        ->fetchCol();
      $roles = [
        RoleInterface::AUTHENTICATED_ID,
      ];
      $id_map = $this
        ->getMigration('d7_user_role')
        ->getIdMap();
      foreach ($rids as $rid) {
        $role = $id_map
          ->lookupDestinationIds([
          $rid,
        ])[0];
        $roles[] = reset($role);
      }
      $entity_translation = Database::getConnection('default', 'migrate')
        ->select('entity_translation', 'et')
        ->fields('et', [
        'language',
      ])
        ->condition('et.entity_type', 'user')
        ->condition('et.entity_id', $source->uid)
        ->condition('et.source', '')
        ->execute()
        ->fetchField();
      $entity_language = $entity_translation ?: $source->language;
      $field_integer = Database::getConnection('default', 'migrate')
        ->select('field_data_field_integer', 'fi')
        ->fields('fi', [
        'field_integer_value',
      ])
        ->condition('fi.entity_id', $source->uid)
        ->condition('fi.language', $entity_language)
        ->execute()
        ->fetchCol();
      $field_integer = !empty($field_integer) ? $field_integer : NULL;
      $field_file = Database::getConnection('default', 'migrate')
        ->select('field_data_field_file', 'ff')
        ->fields('ff', [
        'field_file_fid',
      ])
        ->condition('ff.entity_id', $source->uid)
        ->execute()
        ->fetchField();
      $this
        ->assertEntity($source->uid, $source->name, $source->mail, $source->pass, (int) $source->created, (int) $source->access, (int) $source->login, (bool) $source->status, $entity_language, $source->language, $source->timezone, $source->init, $roles, $field_integer, $field_file);

      // Ensure that the user can authenticate.
      $this
        ->assertEquals($source->uid, $this->container
        ->get('user.auth')
        ->authenticate($source->name, 'a password'));

      // After authenticating the password will be rehashed because the password
      // stretching iteration count has changed from 15 in Drupal 7 to 16 in
      // Drupal 8.
      $user = User::load($source->uid);
      $rehash = $user
        ->getPassword();
      $this
        ->assertNotEquals($source->pass, $rehash);

      // Authenticate again and there should be no re-hash.
      $this
        ->assertEquals($source->uid, $this->container
        ->get('user.auth')
        ->authenticate($source->name, 'a password'));
      $user = User::load($source->uid);
      $this
        ->assertEquals($rehash, $user
        ->getPassword());
    }

    // Tests the Drupal 7 user entity translations to Drupal 8 migration.
    $manager = $this->container
      ->get('content_translation.manager');

    // Get the user and its translations.
    $user = User::load(2);
    $user_fr = $user
      ->getTranslation('fr');
    $user_is = $user
      ->getTranslation('is');

    // Test that fields translated with Entity Translation are migrated.
    $this
      ->assertSame('99', $user->field_integer->value);
    $this
      ->assertSame('9', $user_fr->field_integer->value);
    $this
      ->assertSame('1', $user_is->field_integer->value);

    // Test that the French translation metadata is correctly migrated.
    $metadata_fr = $manager
      ->getTranslationMetadata($user_fr);
    $this
      ->assertSame('en', $metadata_fr
      ->getSource());
    $this
      ->assertSame('1', $metadata_fr
      ->getAuthor()->uid->value);
    $this
      ->assertSame('1531663916', $metadata_fr
      ->getCreatedTime());
    $this
      ->assertFalse($metadata_fr
      ->isOutdated());
    $this
      ->assertFalse($metadata_fr
      ->isPublished());

    // Test that the Icelandic translation metadata is correctly migrated.
    $metadata_is = $manager
      ->getTranslationMetadata($user_is);
    $this
      ->assertSame('en', $metadata_is
      ->getSource());
    $this
      ->assertSame('2', $metadata_is
      ->getAuthor()->uid->value);
    $this
      ->assertSame('1531663925', $metadata_is
      ->getCreatedTime());
    $this
      ->assertTrue($metadata_is
      ->isOutdated());
    $this
      ->assertTrue($metadata_is
      ->isPublished());

    // Test that untranslatable properties are the same as the source language.
    $this
      ->assertSame($user
      ->label(), $user_fr
      ->label());
    $this
      ->assertSame($user
      ->label(), $user_is
      ->label());
    $this
      ->assertSame($user
      ->getEmail(), $user_fr
      ->getEmail());
    $this
      ->assertSame($user
      ->getEmail(), $user_is
      ->getEmail());
    $this
      ->assertSame($user
      ->getPassword(), $user_fr
      ->getPassword());
    $this
      ->assertSame($user
      ->getPassword(), $user_is
      ->getPassword());
  }

}