Definition of Drupal\system\Tests\Entity\EntityTranslationTest.
<?php
/**
* @file
* Definition of Drupal\system\Tests\Entity\EntityTranslationTest.
*/
namespace Drupal\system\Tests\Entity;
use InvalidArgumentException;
use Drupal\Core\Language\Language;
/**
* Tests entity translation.
*/
class EntityTranslationTest extends EntityUnitTestBase {
protected $langcodes;
public static $modules = array(
'language',
'locale',
);
public static function getInfo() {
return array(
'name' => 'Entity Translation',
'description' => 'Tests entity translation functionality.',
'group' => 'Entity API',
);
}
function setUp() {
parent::setUp();
$this
->installSchema('system', 'variable');
$this
->installSchema('language', 'language');
$this
->installSchema('entity_test', array(
'entity_test_mul',
'entity_test_mul_property_data',
'entity_test_rev',
'entity_test_rev_revision',
'entity_test_mulrev',
'entity_test_mulrev_property_data',
'entity_test_mulrev_property_revision',
));
// Create the test field.
entity_test_install();
// Enable translations for the test entity type.
\Drupal::state()
->set('entity_test.translation', TRUE);
// Create a translatable test field.
$this->field_name = drupal_strtolower($this
->randomName() . '_field_name');
$field = array(
'field_name' => $this->field_name,
'type' => 'text',
'cardinality' => 4,
'translatable' => TRUE,
);
field_create_field($field);
$this->field = field_read_field($this->field_name);
// Create instance in all entity variations.
foreach (entity_test_entity_types() as $entity_type) {
$instance = array(
'field_name' => $this->field_name,
'entity_type' => $entity_type,
'bundle' => $entity_type,
);
field_create_instance($instance);
$this->instance[$entity_type] = field_read_instance($entity_type, $this->field_name, $entity_type);
}
// Create the default languages.
$default_language = language_save(language_default());
$languages = language_default_locked_languages($default_language->weight);
foreach ($languages as $language) {
language_save($language);
}
// Create test languages.
$this->langcodes = array();
for ($i = 0; $i < 3; ++$i) {
$language = new Language(array(
'langcode' => 'l' . $i,
'name' => $this
->randomString(),
));
$this->langcodes[$i] = $language->langcode;
language_save($language);
}
}
/**
* Tests language related methods of the Entity class.
*/
public function testEntityLanguageMethods() {
// All entity variations have to have the same results.
foreach (entity_test_entity_types() as $entity_type) {
$this
->assertEntityLanguageMethods($entity_type);
}
}
/**
* Executes the entity language method tests for the given entity type.
*
* @param string $entity_type
* The entity type to run the tests with.
*/
protected function assertEntityLanguageMethods($entity_type) {
$entity = entity_create($entity_type, array(
'name' => 'test',
'user_id' => $GLOBALS['user']->uid,
));
$this
->assertEqual($entity
->language()->langcode, Language::LANGCODE_NOT_SPECIFIED, format_string('%entity_type: Entity language not specified.', array(
'%entity_type' => $entity_type,
)));
$this
->assertFalse($entity
->getTranslationLanguages(FALSE), format_string('%entity_type: No translations are available', array(
'%entity_type' => $entity_type,
)));
// Set the value in default language.
$entity
->set($this->field_name, array(
0 => array(
'value' => 'default value',
),
));
// Get the value.
$this
->assertEqual($entity
->getTranslation(Language::LANGCODE_DEFAULT)
->get($this->field_name)->value, 'default value', format_string('%entity_type: Untranslated value retrieved.', array(
'%entity_type' => $entity_type,
)));
// Set the value in a certain language. As the entity is not
// language-specific it should use the default language and so ignore the
// specified language.
$entity
->getTranslation($this->langcodes[1])
->set($this->field_name, array(
0 => array(
'value' => 'default value2',
),
));
$this
->assertEqual($entity
->get($this->field_name)->value, 'default value2', format_string('%entity_type: Untranslated value updated.', array(
'%entity_type' => $entity_type,
)));
$this
->assertFalse($entity
->getTranslationLanguages(FALSE), format_string('%entity_type: No translations are available', array(
'%entity_type' => $entity_type,
)));
// Test getting a field value using a specific language for a not
// language-specific entity.
$this
->assertEqual($entity
->getTranslation($this->langcodes[1])
->get($this->field_name)->value, 'default value2', format_string('%entity_type: Untranslated value retrieved.', array(
'%entity_type' => $entity_type,
)));
// Now, make the entity language-specific by assigning a language and test
// translating it.
$entity->langcode->value = $this->langcodes[0];
$entity->{$this->field_name} = array();
$this
->assertEqual($entity
->language(), language_load($this->langcodes[0]), format_string('%entity_type: Entity language retrieved.', array(
'%entity_type' => $entity_type,
)));
$this
->assertFalse($entity
->getTranslationLanguages(FALSE), format_string('%entity_type: No translations are available', array(
'%entity_type' => $entity_type,
)));
// Set the value in default language.
$entity
->set($this->field_name, array(
0 => array(
'value' => 'default value',
),
));
// Get the value.
$this
->assertEqual($entity
->get($this->field_name)->value, 'default value', format_string('%entity_type: Untranslated value retrieved.', array(
'%entity_type' => $entity_type,
)));
// Set a translation.
$entity
->getTranslation($this->langcodes[1])
->set($this->field_name, array(
0 => array(
'value' => 'translation 1',
),
));
$this
->assertEqual($entity
->getTranslation($this->langcodes[1])->{$this->field_name}->value, 'translation 1', format_string('%entity_type: Translated value set.', array(
'%entity_type' => $entity_type,
)));
// Make sure the untranslated value stays.
$this
->assertEqual($entity
->get($this->field_name)->value, 'default value', 'Untranslated value stays.');
$translations[$this->langcodes[1]] = language_load($this->langcodes[1]);
$this
->assertEqual($entity
->getTranslationLanguages(FALSE), $translations, 'Translations retrieved.');
// Try to get a not available translation.
$this
->assertNull($entity
->getTranslation($this->langcodes[2])
->get($this->field_name)->value, format_string('%entity_type: A translation that is not available is NULL.', array(
'%entity_type' => $entity_type,
)));
// Try to get a value using an invalid language code.
try {
$entity
->getTranslation('invalid')
->get($this->field_name)->value;
$this
->fail('Getting a translation for an invalid language is NULL.');
} catch (InvalidArgumentException $e) {
$this
->pass('A translation for an invalid language is NULL.');
}
// Try to get an untranslatable value from a translation in strict mode.
try {
$field_name = 'field_test_text';
$value = $entity
->getTranslation($this->langcodes[1])
->get($field_name);
$this
->fail(format_string('%entity_type: Getting an untranslatable value from a translation in strict mode throws an exception.', array(
'%entity_type' => $entity_type,
)));
} catch (InvalidArgumentException $e) {
$this
->pass(format_string('%entity_type: Getting an untranslatable value from a translation in strict mode throws an exception.', array(
'%entity_type' => $entity_type,
)));
}
// Try to get an untranslatable value from a translation in non-strict
// mode.
$entity
->set($field_name, array(
0 => array(
'value' => 'default value',
),
));
$value = $entity
->getTranslation($this->langcodes[1], FALSE)
->get($field_name)->value;
$this
->assertEqual($value, 'default value', format_string('%entity_type: Untranslated value retrieved from translation in non-strict mode.', array(
'%entity_type' => $entity_type,
)));
// Try to set a value using an invalid language code.
try {
$entity
->getTranslation('invalid')
->set($this->field_name, NULL);
$this
->fail(format_string('%entity_type: Setting a translation for an invalid language throws an exception.', array(
'%entity_type' => $entity_type,
)));
} catch (InvalidArgumentException $e) {
$this
->pass(format_string('%entity_type: Setting a translation for an invalid language throws an exception.', array(
'%entity_type' => $entity_type,
)));
}
// Try to set an untranslatable value into a translation in strict mode.
try {
$entity
->getTranslation($this->langcodes[1])
->set($field_name, NULL);
$this
->fail(format_string('%entity_type: Setting an untranslatable value into a translation in strict mode throws an exception.', array(
'%entity_type' => $entity_type,
)));
} catch (InvalidArgumentException $e) {
$this
->pass(format_string('%entity_type: Setting an untranslatable value into a translation in strict mode throws an exception.', array(
'%entity_type' => $entity_type,
)));
}
// Set the value in default language.
$entity
->getTranslation($this->langcodes[1], FALSE)
->set($field_name, array(
0 => array(
'value' => 'default value2',
),
));
// Get the value.
$this
->assertEqual($entity
->get($field_name)->value, 'default value2', format_string('%entity_type: Untranslated value set into a translation in non-strict mode.', array(
'%entity_type' => $entity_type,
)));
}
/**
* Tests multilingual properties.
*/
public function testMultilingualProperties() {
// Test all entity variations with data table support.
foreach (entity_test_entity_types(ENTITY_TEST_TYPES_MULTILINGUAL) as $entity_type) {
$this
->assertMultilingualProperties($entity_type);
}
}
/**
* Executes the multilingual property tests for the given entity type.
*
* @param string $entity_type
* The entity type to run the tests with.
*/
protected function assertMultilingualProperties($entity_type) {
$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_type, array(
'name' => $name,
'user_id' => $uid,
));
$entity
->save();
$entity = entity_load($entity_type, $entity
->id());
$this
->assertEqual($entity
->language()->langcode, Language::LANGCODE_NOT_SPECIFIED, format_string('%entity_type: Entity created as language neutral.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($name, $entity
->getTranslation(Language::LANGCODE_DEFAULT)
->get('name')->value, format_string('%entity_type: The entity name has been correctly stored as language neutral.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($uid, $entity
->getTranslation(Language::LANGCODE_DEFAULT)
->get('user_id')->target_id, format_string('%entity_type: The entity author has been correctly stored as language neutral.', array(
'%entity_type' => $entity_type,
)));
// 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, format_string('%entity_type: The entity name defaults to neutral language.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($uid, $entity
->getTranslation($langcode)
->get('user_id')->target_id, format_string('%entity_type: The entity author defaults to neutral language.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($name, $entity
->get('name')->value, format_string('%entity_type: The entity name can be retrieved without specifying a language.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($uid, $entity
->get('user_id')->target_id, format_string('%entity_type: The entity author can be retrieved without specifying a language.', array(
'%entity_type' => $entity_type,
)));
// Create a language-aware entity and check that properties are stored
// as language-aware.
$entity = entity_create($entity_type, array(
'name' => $name,
'user_id' => $uid,
'langcode' => $langcode,
));
$entity
->save();
$entity = entity_load($entity_type, $entity
->id());
$this
->assertEqual($entity
->language()->langcode, $langcode, format_string('%entity_type: Entity created as language specific.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($name, $entity
->getTranslation($langcode)
->get('name')->value, format_string('%entity_type: The entity name has been correctly stored as a language-aware property.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($uid, $entity
->getTranslation($langcode)
->get('user_id')->target_id, format_string('%entity_type: The entity author has been correctly stored as a language-aware property.', array(
'%entity_type' => $entity_type,
)));
// Translatable properties on a translatable entity should use default
// language if Language::LANGCODE_NOT_SPECIFIED is passed.
$this
->assertEqual($name, $entity
->getTranslation(Language::LANGCODE_NOT_SPECIFIED)
->get('name')->value, format_string('%entity_type: The entity name defaults to the default language.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($uid, $entity
->getTranslation(Language::LANGCODE_NOT_SPECIFIED)
->get('user_id')->target_id, format_string('%entity_type: The entity author defaults to the default language.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($name, $entity
->get('name')->value, format_string('%entity_type: The entity name can be retrieved without specifying a language.', array(
'%entity_type' => $entity_type,
)));
$this
->assertEqual($uid, $entity
->get('user_id')->target_id, format_string('%entity_type: The entity author can be retrieved without specifying a language.', array(
'%entity_type' => $entity_type,
)));
// 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(128, 256),
),
);
}
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_load($entity_type, $entity
->id());
foreach ($this->langcodes as $langcode) {
$args = array(
'%entity_type' => $entity_type,
'%langcode' => $langcode,
);
$this
->assertEqual($properties[$langcode]['name'][0], $entity
->getTranslation($langcode)
->get('name')->value, format_string('%entity_type: The entity name has been correctly stored for language %langcode.', $args));
$this
->assertEqual($properties[$langcode]['user_id'][0], $entity
->getTranslation($langcode)
->get('user_id')->target_id, format_string('%entity_type: 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_type, array(
'user_id' => $properties[$langcode]['user_id'],
'name' => 'some name',
))
->save();
$entities = entity_load_multiple($entity_type);
$this
->assertEqual(count($entities), 3, format_string('%entity_type: Three entities were created.', array(
'%entity_type' => $entity_type,
)));
$entities = entity_load_multiple($entity_type, array(
$translated_id,
));
$this
->assertEqual(count($entities), 1, format_string('%entity_type: One entity correctly loaded by id.', array(
'%entity_type' => $entity_type,
)));
$entities = entity_load_multiple_by_properties($entity_type, array(
'name' => $name,
));
$this
->assertEqual(count($entities), 2, format_string('%entity_type: Two entities correctly loaded by name.', array(
'%entity_type' => $entity_type,
)));
// @todo The default language condition should go away in favor of an
// explicit parameter.
$entities = entity_load_multiple_by_properties($entity_type, array(
'name' => $properties[$langcode]['name'][0],
'default_langcode' => 0,
));
$this
->assertEqual(count($entities), 1, format_string('%entity_type: One entity correctly loaded by name translation.', array(
'%entity_type' => $entity_type,
)));
$entities = entity_load_multiple_by_properties($entity_type, array(
'langcode' => $default_langcode,
'name' => $name,
));
$this
->assertEqual(count($entities), 1, format_string('%entity_type: One entity correctly loaded by name and language.', array(
'%entity_type' => $entity_type,
)));
$entities = entity_load_multiple_by_properties($entity_type, array(
'langcode' => $langcode,
'name' => $properties[$langcode]['name'][0],
));
$this
->assertEqual(count($entities), 0, format_string('%entity_type: No entity loaded by name translation specifying the translation language.', array(
'%entity_type' => $entity_type,
)));
$entities = entity_load_multiple_by_properties($entity_type, array(
'langcode' => $langcode,
'name' => $properties[$langcode]['name'][0],
'default_langcode' => 0,
));
$this
->assertEqual(count($entities), 1, format_string('%entity_type: One entity loaded by name translation and language specifying to look for translations.', array(
'%entity_type' => $entity_type,
)));
$entities = entity_load_multiple_by_properties($entity_type, array(
'user_id' => $properties[$langcode]['user_id'][0],
'default_langcode' => NULL,
));
$this
->assertEqual(count($entities), 2, format_string('%entity_type: Two entities loaded by uid without caring about property translatability.', array(
'%entity_type' => $entity_type,
)));
// Test property conditions and orders with multiple languages in the same
// query.
$query = \Drupal::entityQuery($entity_type);
$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, format_string('%entity_type: One entity loaded by name and uid using different language meta conditions.', array(
'%entity_type' => $entity_type,
)));
// Test mixed property and field conditions.
$entity = entity_load($entity_type, reset($result), TRUE);
$field_value = $this
->randomString();
$entity
->getTranslation($langcode)
->set($this->field_name, array(
array(
'value' => $field_value,
),
));
$entity
->save();
$query = \Drupal::entityQuery($entity_type);
$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, format_string('%entity_type: One entity loaded by name, uid and field value using different language meta conditions.', array(
'%entity_type' => $entity_type,
)));
}
}
Name | Description |
---|---|
EntityTranslationTest | Tests entity translation. |