function EntityTranslationTest::testMultilingualProperties

Tests multilingual properties.

File

drupal/core/modules/system/lib/Drupal/system/Tests/Entity/EntityTranslationTest.php, line 177

Definition of Drupal\system\Tests\Entity\EntityTranslationTest.

Class

EntityTranslationTest

Tests entity translation.

Namespace

Code

function testMultilingualProperties() {
  $name = $this
    ->randomName();
  $uid = mt_rand(0, 127);
  $langcode = $this->langcodes[0];

  // Create a language neutral entity and check that properties are stored
  // as language neutral.
  $entity = entity_create('entity_test', array(
    'name' => $name,
    'user_id' => $uid,
  ));
  $entity
    ->save();
  $entity = entity_test_load($entity
    ->id());
  $this
    ->assertEqual($entity
    ->language()->langcode, LANGUAGE_NOT_SPECIFIED, 'Entity created as language neutral.');
  $this
    ->assertEqual($name, $entity
    ->getTranslation(LANGUAGE_DEFAULT)
    ->get('name')->value, 'The entity name has been correctly stored as language neutral.');
  $this
    ->assertEqual($uid, $entity
    ->getTranslation(LANGUAGE_DEFAULT)
    ->get('user_id')->value, 'The entity author has been correctly stored as language neutral.');

  // As fields, translatable properties should ignore the given langcode and
  // use neutral language if the entity is not translatable.
  $this
    ->assertEqual($name, $entity
    ->getTranslation($langcode)
    ->get('name')->value, 'The entity name defaults to neutral language.');
  $this
    ->assertEqual($uid, $entity
    ->getTranslation($langcode)
    ->get('user_id')->value, 'The entity author defaults to neutral language.');
  $this
    ->assertEqual($name, $entity
    ->get('name')->value, 'The entity name can be retrieved without specifying a language.');
  $this
    ->assertEqual($uid, $entity
    ->get('user_id')->value, 'The entity author can be retrieved without specifying a language.');

  // Create a language-aware entity and check that properties are stored
  // as language-aware.
  $entity = entity_create('entity_test', array(
    'name' => $name,
    'user_id' => $uid,
    'langcode' => $langcode,
  ));
  $entity
    ->save();
  $entity = entity_test_load($entity
    ->id());
  $this
    ->assertEqual($entity
    ->language()->langcode, $langcode, 'Entity created as language specific.');
  $this
    ->assertEqual($name, $entity
    ->getTranslation($langcode)
    ->get('name')->value, 'The entity name has been correctly stored as a language-aware property.');
  $this
    ->assertEqual($uid, $entity
    ->getTranslation($langcode)
    ->get('user_id')->value, 'The entity author has been correctly stored as a language-aware property.');

  // Translatable properties on a translatable entity should use default
  // language if LANGUAGE_NOT_SPECIFIED is passed.
  $this
    ->assertEqual($name, $entity
    ->getTranslation(LANGUAGE_NOT_SPECIFIED)
    ->get('name')->value, 'The entity name defaults to the default language.');
  $this
    ->assertEqual($uid, $entity
    ->getTranslation(LANGUAGE_NOT_SPECIFIED)
    ->get('user_id')->value, 'The entity author defaults to the default language.');
  $this
    ->assertEqual($name, $entity
    ->get('name')->value, 'The entity name can be retrieved without specifying a language.');
  $this
    ->assertEqual($uid, $entity
    ->get('user_id')->value, 'The entity author can be retrieved without specifying a language.');

  // Create property translations.
  $properties = array();
  $default_langcode = $langcode;
  foreach ($this->langcodes as $langcode) {
    if ($langcode != $default_langcode) {
      $properties[$langcode] = array(
        'name' => array(
          0 => $this
            ->randomName(),
        ),
        'user_id' => array(
          0 => mt_rand(0, 127),
        ),
      );
    }
    else {
      $properties[$langcode] = array(
        'name' => array(
          0 => $name,
        ),
        'user_id' => array(
          0 => $uid,
        ),
      );
    }
    $entity
      ->getTranslation($langcode)
      ->setPropertyValues($properties[$langcode]);
  }
  $entity
    ->save();

  // Check that property translation were correctly stored.
  $entity = entity_test_load($entity
    ->id());
  foreach ($this->langcodes as $langcode) {
    $args = array(
      '%langcode' => $langcode,
    );
    $this
      ->assertEqual($properties[$langcode]['name'][0], $entity
      ->getTranslation($langcode)
      ->get('name')->value, format_string('The entity name has been correctly stored for language %langcode.', $args));
    $this
      ->assertEqual($properties[$langcode]['user_id'][0], $entity
      ->getTranslation($langcode)
      ->get('user_id')->value, format_string('The entity author has been correctly stored for language %langcode.', $args));
  }

  // Test query conditions (cache is reset at each call).
  $translated_id = $entity
    ->id();

  // Create an additional entity with only the uid set. The uid for the
  // original language is the same of one used for a translation.
  $langcode = $this->langcodes[1];
  entity_create('entity_test', array(
    'user_id' => $properties[$langcode]['user_id'],
    'name' => 'some name',
  ))
    ->save();
  $entities = entity_test_load_multiple();
  $this
    ->assertEqual(count($entities), 3, 'Three entities were created.');
  $entities = entity_test_load_multiple(array(
    $translated_id,
  ));
  $this
    ->assertEqual(count($entities), 1, 'One entity correctly loaded by id.');
  $entities = entity_load_multiple_by_properties('entity_test', array(
    'name' => $name,
  ));
  $this
    ->assertEqual(count($entities), 2, 'Two entities correctly loaded by name.');

  // @todo The default language condition should go away in favor of an
  // explicit parameter.
  $entities = entity_load_multiple_by_properties('entity_test', array(
    'name' => $properties[$langcode]['name'][0],
    'default_langcode' => 0,
  ));
  $this
    ->assertEqual(count($entities), 1, 'One entity correctly loaded by name translation.');
  $entities = entity_load_multiple_by_properties('entity_test', array(
    'langcode' => $default_langcode,
    'name' => $name,
  ));
  $this
    ->assertEqual(count($entities), 1, 'One entity correctly loaded by name and language.');
  $entities = entity_load_multiple_by_properties('entity_test', array(
    'langcode' => $langcode,
    'name' => $properties[$langcode]['name'][0],
  ));
  $this
    ->assertEqual(count($entities), 0, 'No entity loaded by name translation specifying the translation language.');
  $entities = entity_load_multiple_by_properties('entity_test', array(
    'langcode' => $langcode,
    'name' => $properties[$langcode]['name'][0],
    'default_langcode' => 0,
  ));
  $this
    ->assertEqual(count($entities), 1, 'One entity loaded by name translation and language specifying to look for translations.');
  $entities = entity_load_multiple_by_properties('entity_test', array(
    'user_id' => $properties[$langcode]['user_id'][0],
    'default_langcode' => NULL,
  ));
  $this
    ->assertEqual(count($entities), 2, 'Two entities loaded by uid without caring about property translatability.');

  // Test property conditions and orders with multiple languages in the same
  // query.
  $query = entity_query('entity_test');
  $group = $query
    ->andConditionGroup()
    ->condition('user_id', $properties[$default_langcode]['user_id'], '=', $default_langcode)
    ->condition('name', $properties[$default_langcode]['name'], '=', $default_langcode);
  $result = $query
    ->condition($group)
    ->condition('name', $properties[$langcode]['name'], '=', $langcode)
    ->execute();
  $this
    ->assertEqual(count($result), 1, 'One entity loaded by name and uid using different language meta conditions.');

  // Test mixed property and field conditions.
  $entity = entity_load('entity_test', reset($result), TRUE);
  $field_value = $this
    ->randomString();
  $entity
    ->getTranslation($langcode)
    ->set($this->field_name, array(
    array(
      'value' => $field_value,
    ),
  ));
  $entity
    ->save();
  $query = entity_query('entity_test');
  $default_langcode_group = $query
    ->andConditionGroup()
    ->condition('user_id', $properties[$default_langcode]['user_id'], '=', $default_langcode)
    ->condition('name', $properties[$default_langcode]['name'], '=', $default_langcode);
  $langcode_group = $query
    ->andConditionGroup()
    ->condition('name', $properties[$langcode]['name'], '=', $langcode)
    ->condition("{$this->field_name}.value", $field_value, '=', $langcode);
  $result = $query
    ->condition('langcode', $default_langcode)
    ->condition($default_langcode_group)
    ->condition($langcode_group)
    ->execute();
  $this
    ->assertEqual(count($result), 1, 'One entity loaded by name, uid and field value using different language meta conditions.');
}