3292 lines
128 KiB
Plaintext
3292 lines
128 KiB
Plaintext
<?php
|
|
|
|
/**
|
|
* @file
|
|
* Tests for locale.module.
|
|
*
|
|
* The test file includes:
|
|
* - a functional test for the language configuration forms;
|
|
* - functional tests for the translation functionalities, including searching;
|
|
* - a functional test for the PO files import feature, including validation;
|
|
* - functional tests for translations and templates export feature;
|
|
* - functional tests for the uninstall process;
|
|
* - a functional test for the language switching feature;
|
|
* - a functional test for a user's ability to change their default language;
|
|
* - a functional test for configuring a different path alias per language;
|
|
* - a functional test for configuring a different path alias per language;
|
|
* - a functional test for multilingual support by content type and on nodes.
|
|
* - a functional test for multilingual fields.
|
|
* - a functional test for comment language.
|
|
* - a functional test fot language types/negotiation info.
|
|
*/
|
|
|
|
|
|
/**
|
|
* Functional tests for language configuration's effect on negotiation setup.
|
|
*/
|
|
class LocaleConfigurationTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Language negotiation autoconfiguration',
|
|
'description' => 'Adds and configures languages to check negotiation changes.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
}
|
|
|
|
/**
|
|
* Functional tests for adding, editing and deleting languages.
|
|
*/
|
|
function testLanguageConfiguration() {
|
|
global $base_url;
|
|
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages'));
|
|
$this->drupalLogin($admin_user);
|
|
|
|
// Check if the Default English language has no path prefix.
|
|
$this->drupalGet('admin/config/regional/language/detection/url');
|
|
$this->assertFieldByXPath('//input[@name="prefix[en]"]', '', t('Default English has no path prefix.'));
|
|
|
|
// Add predefined language.
|
|
$edit = array(
|
|
'predefined_langcode' => 'fr',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
$this->assertText('French');
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/language', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
|
|
// Check if the Default English language has no path prefix.
|
|
$this->drupalGet('admin/config/regional/language/detection/url');
|
|
$this->assertFieldByXPath('//input[@name="prefix[en]"]', '', t('Default English has no path prefix.'));
|
|
// Check if French has a path prefix.
|
|
$this->drupalGet('admin/config/regional/language/detection/url');
|
|
$this->assertFieldByXPath('//input[@name="prefix[fr]"]', 'fr', t('French has a path prefix.'));
|
|
|
|
// Check if we can change the default language.
|
|
$this->drupalGet('admin/config/regional/language');
|
|
$this->assertFieldChecked('edit-site-default-en', t('English is the default language.'));
|
|
// Change the default language.
|
|
$edit = array(
|
|
'site_default' => 'fr',
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save configuration'));
|
|
$this->assertNoFieldChecked('edit-site-default-en', t('Default language updated.'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/language', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
|
|
// Check if a valid language prefix is added afrer changing the default
|
|
// language.
|
|
$this->drupalGet('admin/config/regional/language/detection/url');
|
|
$this->assertFieldByXPath('//input[@name="prefix[en]"]', 'en', t('A valid path prefix has been added to the previous default language.'));
|
|
// Check if French still has a path prefix.
|
|
$this->drupalGet('admin/config/regional/language/detection/url');
|
|
$this->assertFieldByXPath('//input[@name="prefix[fr]"]', 'fr', t('French still has a path prefix.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for JavaScript parsing for translatable strings.
|
|
*/
|
|
class LocaleJavascriptTranslationTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Javascript translation',
|
|
'description' => 'Tests parsing js files for translatable strings',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale', 'locale_test');
|
|
}
|
|
|
|
function testFileParsing() {
|
|
|
|
$filename = drupal_get_path('module', 'locale_test') . '/locale_test.js';
|
|
|
|
// Parse the file to look for source strings.
|
|
_locale_parse_js_file($filename);
|
|
|
|
// Get all of the source strings that were found.
|
|
$source_strings = db_select('locales_source', 's')
|
|
->fields('s', array('source', 'context'))
|
|
->condition('s.location', $filename)
|
|
->execute()
|
|
->fetchAllKeyed();
|
|
|
|
// List of all strings that should be in the file.
|
|
$test_strings = array(
|
|
"Standard Call t" => '',
|
|
"Whitespace Call t" => '',
|
|
|
|
"Single Quote t" => '',
|
|
"Single Quote \\'Escaped\\' t" => '',
|
|
"Single Quote Concat strings t" => '',
|
|
|
|
"Double Quote t" => '',
|
|
"Double Quote \\\"Escaped\\\" t" => '',
|
|
"Double Quote Concat strings t" => '',
|
|
|
|
"Context !key Args t" => "Context string",
|
|
|
|
"Context Unquoted t" => "Context string unquoted",
|
|
"Context Single Quoted t" => "Context string single quoted",
|
|
"Context Double Quoted t" => "Context string double quoted",
|
|
|
|
"Standard Call plural" => '',
|
|
"Standard Call @count plural" => '',
|
|
"Whitespace Call plural" => '',
|
|
"Whitespace Call @count plural" => '',
|
|
|
|
"Single Quote plural" => '',
|
|
"Single Quote @count plural" => '',
|
|
"Single Quote \\'Escaped\\' plural" => '',
|
|
"Single Quote \\'Escaped\\' @count plural" => '',
|
|
|
|
"Double Quote plural" => '',
|
|
"Double Quote @count plural" => '',
|
|
"Double Quote \\\"Escaped\\\" plural" => '',
|
|
"Double Quote \\\"Escaped\\\" @count plural" => '',
|
|
|
|
"Context !key Args plural" => "Context string",
|
|
"Context !key Args @count plural" => "Context string",
|
|
|
|
"Context Unquoted plural" => "Context string unquoted",
|
|
"Context Unquoted @count plural" => "Context string unquoted",
|
|
"Context Single Quoted plural" => "Context string single quoted",
|
|
"Context Single Quoted @count plural" => "Context string single quoted",
|
|
"Context Double Quoted plural" => "Context string double quoted",
|
|
"Context Double Quoted @count plural" => "Context string double quoted",
|
|
);
|
|
|
|
// Assert that all strings were found properly.
|
|
foreach ($test_strings as $str => $context) {
|
|
$args = array('%source' => $str, '%context' => $context);
|
|
|
|
// Make sure that the string was found in the file.
|
|
$this->assertTrue(isset($source_strings[$str]), t("Found source string: %source", $args));
|
|
|
|
// Make sure that the proper context was matched.
|
|
$this->assertTrue(isset($source_strings[$str]) && $source_strings[$str] === $context, strlen($context) > 0 ? t("Context for %source is %context", $args) : t("Context for %source is blank", $args));
|
|
}
|
|
|
|
$this->assertEqual(count($source_strings), count($test_strings), t("Found correct number of source strings."));
|
|
}
|
|
}
|
|
/**
|
|
* Functional test for string translation and validation.
|
|
*/
|
|
class LocaleTranslationFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'String translate, search and validate',
|
|
'description' => 'Adds a new locale and translates its name. Checks the validation of translation strings and search results.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
}
|
|
|
|
/**
|
|
* Adds a language and tests string translation by users with the appropriate permissions.
|
|
*/
|
|
function testStringTranslation() {
|
|
global $base_url;
|
|
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages'));
|
|
// User to translate and delete string.
|
|
$translate_user = $this->drupalCreateUser(array('translate interface', 'access administration pages'));
|
|
// Code for the language.
|
|
$langcode = 'xx';
|
|
// The English name for the language. This will be translated.
|
|
$name = $this->randomName(16);
|
|
// This is the language indicator on the translation search screen for
|
|
// untranslated strings.
|
|
$language_indicator = "<em class=\"locale-untranslated\">$langcode</em> ";
|
|
// This will be the translation of $name.
|
|
$translation = $this->randomName(16);
|
|
$translation_to_en = $this->randomName(16);
|
|
|
|
// Add custom language.
|
|
$this->drupalLogin($admin_user);
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
// Add string.
|
|
t($name, array(), array('langcode' => $langcode));
|
|
// Reset locale cache.
|
|
locale_reset();
|
|
$this->assertRaw('"edit-site-default-' . $langcode .'"', t('Language code found.'));
|
|
$this->assertText(t($name), t('Test language added.'));
|
|
$this->drupalLogout();
|
|
|
|
// Search for the name and translate it.
|
|
$this->drupalLogin($translate_user);
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// assertText() seems to remove the input field where $name always could be
|
|
// found, so this is not a false assert. See how assertNoText succeeds
|
|
// later.
|
|
$this->assertText($name, t('Search found the name.'));
|
|
$this->assertRaw($language_indicator, t('Name is untranslated.'));
|
|
// Assume this is the only result, given the random name.
|
|
$this->clickLink(t('edit'));
|
|
// We save the lid from the path.
|
|
$matches = array();
|
|
preg_match('!admin/config/regional/translate/edit/(\d+)!', $this->getUrl(), $matches);
|
|
$lid = $matches[1];
|
|
// No t() here, it's surely not translated yet.
|
|
$this->assertText($name, t('name found on edit screen.'));
|
|
$this->assertNoText('English', t('No way to translate the string to English.'));
|
|
$this->drupalLogout();
|
|
$this->drupalLogin($admin_user);
|
|
$this->drupalPost('admin/config/regional/language/edit/en', array('locale_translate_english' => TRUE), t('Save language'));
|
|
$this->drupalLogout();
|
|
$this->drupalLogin($translate_user);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// assertText() seems to remove the input field where $name always could be
|
|
// found, so this is not a false assert. See how assertNoText succeeds
|
|
// later.
|
|
$this->assertText($name, t('Search found the name.'));
|
|
$this->assertRaw($language_indicator, t('Name is untranslated.'));
|
|
// Assume this is the only result, given the random name.
|
|
$this->clickLink(t('edit'));
|
|
$string_edit_url = $this->getUrl();
|
|
$edit = array(
|
|
"translations[$langcode][0]" => $translation,
|
|
'translations[en][0]' => $translation_to_en,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save translations'));
|
|
$this->assertText(t('The string has been saved.'), t('The string has been saved.'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/translate/translate', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->drupalGet($string_edit_url);
|
|
$this->assertRaw($translation, t('Non-English translation properly saved.'));
|
|
$this->assertRaw($translation_to_en, t('English translation properly saved.'));
|
|
$this->assertTrue($name != $translation && t($name, array(), array('langcode' => $langcode)) == $translation, t('t() works for non-English.'));
|
|
// Refresh the locale() cache to get fresh data from t() below. We are in
|
|
// the same HTTP request and therefore t() is not refreshed by saving the
|
|
// translation above.
|
|
locale_reset();
|
|
// Now we should get the proper fresh translation from t().
|
|
$this->assertTrue($name != $translation_to_en && t($name, array(), array('langcode' => 'en')) == $translation_to_en, t('t() works for English.'));
|
|
$this->assertTrue(t($name, array(), array('langcode' => LANGUAGE_SYSTEM)) == $name, t('t() works for LANGUAGE_SYSTEM.'));
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// The indicator should not be here.
|
|
$this->assertNoRaw($language_indicator, t('String is translated.'));
|
|
|
|
// Try to edit a non-existent string and ensure we're redirected correctly.
|
|
// Assuming we don't have 999,999 strings already.
|
|
$random_lid = 999999;
|
|
$this->drupalGet('admin/config/regional/translate/edit/' . $random_lid);
|
|
$this->assertText(t('String not found'), t('String not found.'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/translate/translate', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->drupalLogout();
|
|
|
|
// Delete the language.
|
|
$this->drupalLogin($admin_user);
|
|
$path = 'admin/config/regional/language/delete/' . $langcode;
|
|
// This a confirm form, we do not need any fields changed.
|
|
$this->drupalPost($path, array(), t('Delete'));
|
|
// We need raw here because %language and %langcode will add HTML.
|
|
$t_args = array('%language' => $name, '%langcode' => $langcode);
|
|
$this->assertRaw(t('The %language (%langcode) language has been removed.', $t_args), t('The test language has been removed.'));
|
|
// Reload to remove $name.
|
|
$this->drupalGet($path);
|
|
// Verify that language is no longer found.
|
|
$this->assertResponse(404, t('Language no longer found.'));
|
|
$this->drupalLogout();
|
|
|
|
// Delete the string.
|
|
$this->drupalLogin($translate_user);
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// Assume this is the only result, given the random name.
|
|
$this->clickLink(t('delete'));
|
|
$this->assertText(t('Are you sure you want to delete the string'), t('"delete" link is correct.'));
|
|
// Delete the string.
|
|
$path = 'admin/config/regional/translate/delete/' . $lid;
|
|
$this->drupalGet($path);
|
|
// First test the 'cancel' link.
|
|
$this->clickLink(t('Cancel'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/translate/translate', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertRaw($name, t('The string was not deleted.'));
|
|
// Delete the name string.
|
|
$this->drupalPost('admin/config/regional/translate/delete/' . $lid, array(), t('Delete'));
|
|
$this->assertText(t('The string has been removed.'), t('The string has been removed message.'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/translate/translate', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText($name, t('Search now can not find the name.'));
|
|
}
|
|
|
|
/*
|
|
* Adds a language and checks that the JavaScript translation files are
|
|
* properly created and rebuilt on deletion.
|
|
*/
|
|
function testJavaScriptTranslation() {
|
|
$user = $this->drupalCreateUser(array('translate interface', 'administer languages', 'access administration pages'));
|
|
$this->drupalLogin($user);
|
|
|
|
$langcode = 'xx';
|
|
// The English name for the language. This will be translated.
|
|
$name = $this->randomName(16);
|
|
|
|
// Add custom language.
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
drupal_static_reset('language_list');
|
|
|
|
// Build the JavaScript translation file.
|
|
$this->drupalGet('admin/config/regional/translate/translate');
|
|
|
|
// Retrieve the id of the first string available in the {locales_source}
|
|
// table and translate it.
|
|
$query = db_select('locales_source', 'l');
|
|
$query->addExpression('min(l.lid)', 'lid');
|
|
$result = $query->condition('l.location', '%.js%', 'LIKE')->execute();
|
|
$url = 'admin/config/regional/translate/edit/' . $result->fetchObject()->lid;
|
|
$edit = array('translations['. $langcode .'][0]' => $this->randomName());
|
|
$this->drupalPost($url, $edit, t('Save translations'));
|
|
|
|
// Trigger JavaScript translation parsing and building.
|
|
_locale_rebuild_js($langcode);
|
|
|
|
$locale_javascripts = variable_get('locale_translation_javascript', array());
|
|
$js_file = 'public://' . variable_get('locale_js_directory', 'languages') . '/' . $langcode . '_' . $locale_javascripts[$langcode] . '.js';
|
|
$this->assertTrue($result = file_exists($js_file), t('JavaScript file created: %file', array('%file' => $result ? $js_file : t('not found'))));
|
|
|
|
// Test JavaScript translation rebuilding.
|
|
file_unmanaged_delete($js_file);
|
|
$this->assertTrue($result = !file_exists($js_file), t('JavaScript file deleted: %file', array('%file' => $result ? $js_file : t('found'))));
|
|
cache_clear_all();
|
|
_locale_rebuild_js($langcode);
|
|
$this->assertTrue($result = file_exists($js_file), t('JavaScript file rebuilt: %file', array('%file' => $result ? $js_file : t('not found'))));
|
|
}
|
|
|
|
/**
|
|
* Tests the validation of the translation input.
|
|
*/
|
|
function testStringValidation() {
|
|
global $base_url;
|
|
|
|
// User to add language and strings.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages', 'translate interface'));
|
|
$this->drupalLogin($admin_user);
|
|
$langcode = 'xx';
|
|
// The English name for the language. This will be translated.
|
|
$name = $this->randomName(16);
|
|
// This is the language indicator on the translation search screen for
|
|
// untranslated strings.
|
|
$language_indicator = "<em class=\"locale-untranslated\">$langcode</em> ";
|
|
// These will be the invalid translations of $name.
|
|
$key = $this->randomName(16);
|
|
$bad_translations[$key] = "<script>alert('xss');</script>" . $key;
|
|
$key = $this->randomName(16);
|
|
$bad_translations[$key] = '<img SRC="javascript:alert(\'xss\');">' . $key;
|
|
$key = $this->randomName(16);
|
|
$bad_translations[$key] = '<<SCRIPT>alert("xss");//<</SCRIPT>' . $key;
|
|
$key = $this->randomName(16);
|
|
$bad_translations[$key] ="<BODY ONLOAD=alert('xss')>" . $key;
|
|
|
|
// Add custom language.
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
// Add string.
|
|
t($name, array(), array('langcode' => $langcode));
|
|
// Reset locale cache.
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// Find the edit path.
|
|
$content = $this->drupalGetContent();
|
|
$this->assertTrue(preg_match('@(admin/config/regional/translate/edit/[0-9]+)@', $content, $matches), t('Found the edit path.'));
|
|
$path = $matches[0];
|
|
foreach ($bad_translations as $key => $translation) {
|
|
$edit = array(
|
|
"translations[$langcode][0]" => $translation,
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save translations'));
|
|
// Check for a form error on the textarea.
|
|
$form_class = $this->xpath('//form[@id="locale-translate-edit-form"]//textarea/@class');
|
|
$this->assertNotIdentical(FALSE, strpos($form_class[0], 'error'), t('The string was rejected as unsafe.'));
|
|
$this->assertNoText(t('The string has been saved.'), t('The string was not saved.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests translation search form.
|
|
*/
|
|
function testStringSearch() {
|
|
global $base_url;
|
|
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages'));
|
|
// User to translate and delete string.
|
|
$translate_user = $this->drupalCreateUser(array('translate interface', 'access administration pages'));
|
|
|
|
// Code for the language.
|
|
$langcode = 'xx';
|
|
// The English name for the language. This will be translated.
|
|
$name = $this->randomName(16);
|
|
// This is the language indicator on the translation search screen for
|
|
// untranslated strings.
|
|
$language_indicator = "<em class=\"locale-untranslated\">$langcode</em> ";
|
|
// This will be the translation of $name.
|
|
$translation = $this->randomName(16);
|
|
|
|
// Add custom language.
|
|
$this->drupalLogin($admin_user);
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
// Add string.
|
|
t($name, array(), array('langcode' => $langcode));
|
|
// Reset locale cache.
|
|
locale_reset();
|
|
$this->drupalLogout();
|
|
|
|
// Search for the name.
|
|
$this->drupalLogin($translate_user);
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// assertText() seems to remove the input field where $name always could be
|
|
// found, so this is not a false assert. See how assertNoText succeeds
|
|
// later.
|
|
$this->assertText($name, t('Search found the string.'));
|
|
|
|
// Ensure untranslated string doesn't appear if searching on 'only
|
|
// translated strings'.
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t("Search didn't find the string."));
|
|
|
|
// Ensure untranslated string appears if searching on 'only untranslated
|
|
// strings'.
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'untranslated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText(t('No strings available.'), t('Search found the string.'));
|
|
|
|
// Add translation.
|
|
// Assume this is the only result, given the random name.
|
|
$this->clickLink(t('edit'));
|
|
// We save the lid from the path.
|
|
$matches = array();
|
|
preg_match('!admin/config/regional/translate/edit/(\d)+!', $this->getUrl(), $matches);
|
|
$lid = $matches[1];
|
|
$edit = array(
|
|
"translations[$langcode][0]" => $translation,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save translations'));
|
|
|
|
// Ensure translated string does appear if searching on 'only
|
|
// translated strings'.
|
|
$search = array(
|
|
'string' => $translation,
|
|
'language' => 'all',
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText(t('No strings available.'), t('Search found the translation.'));
|
|
|
|
// Ensure translated source string doesn't appear if searching on 'only
|
|
// untranslated strings'.
|
|
$search = array(
|
|
'string' => $name,
|
|
'language' => 'all',
|
|
'translation' => 'untranslated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t("Search didn't find the source string."));
|
|
|
|
// Ensure translated string doesn't appear if searching on 'only
|
|
// untranslated strings'.
|
|
$search = array(
|
|
'string' => $translation,
|
|
'language' => 'all',
|
|
'translation' => 'untranslated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t("Search didn't find the translation."));
|
|
|
|
// Ensure translated string does appear if searching on the custom language.
|
|
$search = array(
|
|
'string' => $translation,
|
|
'language' => $langcode,
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText(t('No strings available.'), t('Search found the translation.'));
|
|
|
|
// Ensure translated string doesn't appear if searching in System (English).
|
|
$search = array(
|
|
'string' => $translation,
|
|
'language' => LANGUAGE_SYSTEM,
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t("Search didn't find the translation."));
|
|
|
|
// Search for a string that isn't in the system.
|
|
$unavailable_string = $this->randomName(16);
|
|
$search = array(
|
|
'string' => $unavailable_string,
|
|
'language' => 'all',
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t("Search didn't find the invalid string."));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests plural format handling functionality.
|
|
*/
|
|
class LocalePluralFormatTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Plural handling',
|
|
'description' => 'Tests plural handling for various languages.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'translate interface', 'access administration pages'));
|
|
$this->drupalLogin($admin_user);
|
|
}
|
|
|
|
/**
|
|
* Tests locale_get_plural() and format_plural() functionality.
|
|
*/
|
|
function testGetPluralFormat() {
|
|
// Import some .po files with formulas to set up the environment.
|
|
// These will also add the languages to the system and enable them.
|
|
$this->importPoFile($this->getPoFileWithSimplePlural(), array(
|
|
'langcode' => 'fr',
|
|
));
|
|
$this->importPoFile($this->getPoFileWithComplexPlural(), array(
|
|
'langcode' => 'hr',
|
|
));
|
|
|
|
// Attempt to import some broken .po files as well to prove that these
|
|
// will not overwrite the proper plural formula imported above.
|
|
$this->importPoFile($this->getPoFileWithMissingPlural(), array(
|
|
'langcode' => 'fr',
|
|
'overwrite_options[not_customized]' => TRUE,
|
|
));
|
|
$this->importPoFile($this->getPoFileWithBrokenPlural(), array(
|
|
'langcode' => 'hr',
|
|
'overwrite_options[not_customized]' => TRUE,
|
|
));
|
|
|
|
// Reset static caches from locale_get_plural() to ensure we get fresh data.
|
|
drupal_static_reset('locale_get_plural');
|
|
drupal_static_reset('locale_get_plural:plurals');
|
|
drupal_static_reset('locale');
|
|
|
|
// Expected plural translation strings for each plural index.
|
|
$plural_strings = array(
|
|
// English is not imported in this case, so we assume built-in text
|
|
// and formulas.
|
|
'en' => array(
|
|
0 => '1 hour',
|
|
1 => '@count hours',
|
|
),
|
|
'fr' => array(
|
|
0 => '1 heure',
|
|
1 => '@count heures',
|
|
),
|
|
'hr' => array(
|
|
0 => '@count sat',
|
|
1 => '@count sata',
|
|
2 => '@count sati',
|
|
),
|
|
// Hungarian is not imported, so it should assume the same text as
|
|
// English, but it will always pick the plural form as per the built-in
|
|
// logic, so only index -1 is relevant with the plural value.
|
|
'hu' => array(
|
|
0 => '1 hour',
|
|
-1 => '@count hours',
|
|
),
|
|
);
|
|
|
|
// Expected plural indexes precomputed base on the plural formulas with
|
|
// given $count value.
|
|
$plural_tests = array(
|
|
'en' => array(
|
|
1 => 0,
|
|
0 => 1,
|
|
5 => 1,
|
|
),
|
|
'fr' => array(
|
|
1 => 0,
|
|
0 => 0,
|
|
5 => 1,
|
|
),
|
|
'hr' => array(
|
|
1 => 0,
|
|
21 => 0,
|
|
0 => 2,
|
|
2 => 1,
|
|
8 => 2,
|
|
),
|
|
'hu' => array(
|
|
1 => -1,
|
|
21 => -1,
|
|
0 => -1,
|
|
),
|
|
);
|
|
|
|
foreach ($plural_tests as $langcode => $tests) {
|
|
foreach ($tests as $count => $expected_plural_index) {
|
|
// Assert that the we get the right plural index.
|
|
$this->assertIdentical(locale_get_plural($count, $langcode), $expected_plural_index, 'Computed plural index for ' . $langcode . ' for count ' . $count . ' is ' . $expected_plural_index);
|
|
// Assert that the we get the right translation for that. Change the
|
|
// expected index as per the logic for translation lookups.
|
|
$expected_plural_index = ($count == 1) ? 0 : $expected_plural_index;
|
|
$expected_plural_string = str_replace('@count', $count, $plural_strings[$langcode][$expected_plural_index]);
|
|
$this->assertIdentical(format_plural($count, '1 hour', '@count hours', array(), array('langcode' => $langcode)), $expected_plural_string, 'Plural translation of 1 hours / @count hours for count ' . $count . ' in ' . $langcode . ' is ' . $expected_plural_string);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests plural editing and export functionality.
|
|
*/
|
|
function testPluralEditExport() {
|
|
// Import some .po files with formulas to set up the environment.
|
|
// These will also add the languages to the system and enable them.
|
|
$this->importPoFile($this->getPoFileWithSimplePlural(), array(
|
|
'langcode' => 'fr',
|
|
));
|
|
$this->importPoFile($this->getPoFileWithComplexPlural(), array(
|
|
'langcode' => 'hr',
|
|
));
|
|
|
|
// Get the French translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'fr',
|
|
), t('Export'));
|
|
// Ensure we have a translation file.
|
|
$this->assertRaw('# French translation of Drupal', t('Exported French translation file.'));
|
|
// Ensure our imported translations exist in the file.
|
|
$this->assertRaw("msgid \"Monday\"\nmsgstr \"lundi\"", t('French translations present in exported file.'));
|
|
// Check for plural export specifically.
|
|
$this->assertRaw("msgid \"1 hour\"\nmsgid_plural \"@count hours\"\nmsgstr[0] \"1 heure\"\nmsgstr[1] \"@count heures\"", t('Plural translations exported properly.'));
|
|
|
|
// Get the Croatian translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'hr',
|
|
), t('Export'));
|
|
// Ensure we have a translation file.
|
|
$this->assertRaw('# Croatian translation of Drupal', t('Exported Croatian translation file.'));
|
|
// Ensure our imported translations exist in the file.
|
|
$this->assertRaw("msgid \"Monday\"\nmsgstr \"Ponedjeljak\"", t('Croatian translations present in exported file.'));
|
|
// Check for plural export specifically.
|
|
$this->assertRaw("msgid \"1 hour\"\nmsgid_plural \"@count hours\"\nmsgstr[0] \"@count sat\"\nmsgstr[1] \"@count sata\"\nmsgstr[2] \"@count sati\"", t('Plural translations exported properly.'));
|
|
|
|
// Check if the source appears on the translation page.
|
|
$this->drupalGet('admin/config/regional/translate');
|
|
$this->assertText("1 hour, @count hours");
|
|
|
|
// Look up editing page for this plural string and check fields.
|
|
$lid = db_query("SELECT lid FROM {locales_source} WHERE source = :source AND context = ''", array(':source' => "1 hour" . LOCALE_PLURAL_DELIMITER . "@count hours"))->fetchField();
|
|
$path = 'admin/config/regional/translate/edit/' . $lid;
|
|
$this->drupalGet($path);
|
|
// Labels for plural editing elements.
|
|
$this->assertText('Singular form');
|
|
$this->assertText('First plural form');
|
|
$this->assertText('2. plural form');
|
|
// Plural values for both languages.
|
|
$this->assertFieldById('edit-translations-hr-0', '@count sat');
|
|
$this->assertFieldById('edit-translations-hr-1', '@count sata');
|
|
$this->assertFieldById('edit-translations-hr-2', '@count sati');
|
|
$this->assertNoFieldById('edit-translations-hr-3');
|
|
$this->assertFieldById('edit-translations-fr-0', '1 heure');
|
|
$this->assertFieldById('edit-translations-fr-1', '@count heures');
|
|
$this->assertNoFieldById('edit-translations-fr-2');
|
|
|
|
// Edit some translations and see if that took effect.
|
|
$edit = array(
|
|
'translations[fr][0]' => '1 heure edited',
|
|
'translations[hr][1]' => '@count sata edited',
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save translations'));
|
|
|
|
// Inject a plural source string to the database. We need to use a specific
|
|
// langcode here because the language will be English by default and will
|
|
// not save our source string for performance optimization if we do not ask
|
|
// specifically for a language.
|
|
format_plural(1, '1 day', '@count days', array(), array('langcode' => 'fr'));
|
|
// Look up editing page for this plural string and check fields.
|
|
$lid = db_query("SELECT lid FROM {locales_source} WHERE source = :source AND context = ''", array(':source' => "1 day" . LOCALE_PLURAL_DELIMITER . "@count days"))->fetchField();
|
|
$path = 'admin/config/regional/translate/edit/' . $lid;
|
|
|
|
// Save complete translations for the string in both languages.
|
|
$edit = array(
|
|
'translations[fr][0]' => '1 jour',
|
|
'translations[fr][1]' => '@count jours',
|
|
'translations[hr][0]' => '@count dan',
|
|
'translations[hr][1]' => '@count dana',
|
|
'translations[hr][2]' => '@count dana',
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save translations'));
|
|
|
|
// Get the French translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'fr',
|
|
), t('Export'));
|
|
// Check for plural export specifically.
|
|
$this->assertRaw("msgid \"1 hour\"\nmsgid_plural \"@count hours\"\nmsgstr[0] \"1 heure edited\"\nmsgstr[1] \"@count heures\"", t('Edited French plural translations for hours exported properly.'));
|
|
$this->assertRaw("msgid \"1 day\"\nmsgid_plural \"@count days\"\nmsgstr[0] \"1 jour\"\nmsgstr[1] \"@count jours\"", t('Added French plural translations for days exported properly.'));
|
|
|
|
// Get the Croatian translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'hr',
|
|
), t('Export'));
|
|
// Check for plural export specifically.
|
|
$this->assertRaw("msgid \"1 hour\"\nmsgid_plural \"@count hours\"\nmsgstr[0] \"@count sat\"\nmsgstr[1] \"@count sata edited\"\nmsgstr[2] \"@count sati\"", t('Edited Croatian plural translations exported properly.'));
|
|
$this->assertRaw("msgid \"1 day\"\nmsgid_plural \"@count days\"\nmsgstr[0] \"@count dan\"\nmsgstr[1] \"@count dana\"\nmsgstr[2] \"@count dana\"", t('Added Croatian plural translations exported properly.'));
|
|
}
|
|
|
|
|
|
/**
|
|
* Imports a standalone .po file in a given language.
|
|
*
|
|
* @param $contents
|
|
* Contents of the .po file to import.
|
|
* @param $options
|
|
* Additional options to pass to the translation import form.
|
|
*/
|
|
function importPoFile($contents, array $options = array()) {
|
|
$name = tempnam('temporary://', "po_") . '.po';
|
|
file_put_contents($name, $contents);
|
|
$options['files[file]'] = $name;
|
|
$this->drupalPost('admin/config/regional/translate/import', $options, t('Import'));
|
|
drupal_unlink($name);
|
|
}
|
|
|
|
/**
|
|
* Returns a .po file with a simple plural formula.
|
|
*/
|
|
function getPoFileWithSimplePlural() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "1 hour"
|
|
msgid_plural "@count hours"
|
|
msgstr[0] "1 heure"
|
|
msgstr[1] "@count heures"
|
|
|
|
msgid "Monday"
|
|
msgstr "lundi"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Returns a .po file with a complex plural formula.
|
|
*/
|
|
function getPoFileWithComplexPlural() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\\n"
|
|
|
|
msgid "1 hour"
|
|
msgid_plural "@count hours"
|
|
msgstr[0] "@count sat"
|
|
msgstr[1] "@count sata"
|
|
msgstr[2] "@count sati"
|
|
|
|
msgid "Monday"
|
|
msgstr "Ponedjeljak"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Returns a .po file with a missing plural formula.
|
|
*/
|
|
function getPoFileWithMissingPlural() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
|
|
msgid "Monday"
|
|
msgstr "lundi"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Returns a .po file with a broken plural formula.
|
|
*/
|
|
function getPoFileWithBrokenPlural() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: broken, will not parse\\n"
|
|
|
|
msgid "Monday"
|
|
msgstr "Ponedjeljak"
|
|
EOF;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for the import of translation files.
|
|
*/
|
|
class LocaleImportFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Translation import',
|
|
'description' => 'Tests the import of locale files.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user able to create languages and import translations.
|
|
*/
|
|
protected $admin_user = NULL;
|
|
|
|
function setUp() {
|
|
parent::setUp(array('locale', 'locale_test', 'dblog'));
|
|
|
|
// Set the translation file directory.
|
|
variable_set('locale_translate_file_directory', drupal_get_path('module', 'locale_test'));
|
|
|
|
$this->admin_user = $this->drupalCreateUser(array('administer languages', 'translate interface', 'access administration pages'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
/**
|
|
* Test import of standalone .po files.
|
|
*/
|
|
function testStandalonePoFile() {
|
|
// Try importing a .po file.
|
|
$this->importPoFile($this->getPoFile(), array(
|
|
'langcode' => 'fr',
|
|
));
|
|
|
|
// The import should automatically create the corresponding language.
|
|
$this->assertRaw(t('The language %language has been created.', array('%language' => 'French')), t('The language has been automatically created.'));
|
|
|
|
// The import should have created 8 strings.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 8, '%update' => 0, '%delete' => 0)), t('The translation file was successfully imported.'));
|
|
|
|
// This import should have saved plural forms to have 2 variants.
|
|
$locale_plurals = variable_get('locale_translation_plurals', array());
|
|
$this->assert($locale_plurals['fr']['plurals'] == 2, t('Plural number initialized.'));
|
|
|
|
// Ensure we were redirected correctly.
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/translate', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
|
|
|
|
// Try importing a .po file with invalid tags.
|
|
$this->importPoFile($this->getBadPoFile(), array(
|
|
'langcode' => 'fr',
|
|
));
|
|
|
|
// The import should have created 1 string and rejected 2.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 1, '%update' => 0, '%delete' => 0)), t('The translation file was successfully imported.'));
|
|
$skip_message = format_plural(2, 'A translation string was skipped because of disallowed or malformed HTML. <a href="@url">See the log</a> for details.', '@count translation strings were skipped because of disallowed or malformed HTML. <a href="@url">See the log</a> for details.', array('@url' => url('admin/reports/dblog')));
|
|
$this->assertRaw($skip_message, t('Unsafe strings were skipped.'));
|
|
|
|
|
|
// Try importing a .po file which doesn't exist.
|
|
$name = $this->randomName(16);
|
|
$this->drupalPost('admin/config/regional/translate/import', array(
|
|
'langcode' => 'fr',
|
|
'files[file]' => $name,
|
|
), t('Import'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/translate/import', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertText(t('File to import not found.'), t('File to import not found message.'));
|
|
|
|
|
|
// Try importing a .po file with overriding strings, and ensure existing
|
|
// strings are kept.
|
|
$this->importPoFile($this->getOverwritePoFile(), array(
|
|
'langcode' => 'fr',
|
|
));
|
|
|
|
// The import should have created 1 string.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 1, '%update' => 0, '%delete' => 0)), t('The translation file was successfully imported.'));
|
|
// Ensure string wasn't overwritten.
|
|
$search = array(
|
|
'string' => 'Montag',
|
|
'language' => 'fr',
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t('String not overwritten by imported string.'));
|
|
|
|
// This import should not have changed number of plural forms.
|
|
$locale_plurals = variable_get('locale_translation_plurals', array());
|
|
$this->assert($locale_plurals['fr']['plurals'] == 2, t('Plural numbers untouched.'));
|
|
|
|
// Try importing a .po file with overriding strings, and ensure existing
|
|
// strings are overwritten.
|
|
$this->importPoFile($this->getOverwritePoFile(), array(
|
|
'langcode' => 'fr',
|
|
'overwrite_options[not_customized]' => TRUE,
|
|
));
|
|
|
|
// The import should have updated 2 strings.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 0, '%update' => 2, '%delete' => 0)), t('The translation file was successfully imported.'));
|
|
// Ensure string was overwritten.
|
|
$search = array(
|
|
'string' => 'Montag',
|
|
'language' => 'fr',
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText(t('No strings available.'), t('String overwritten by imported string.'));
|
|
// This import should have changed number of plural forms.
|
|
$locale_plurals = variable_get('locale_translation_plurals', array());
|
|
$this->assert($locale_plurals['fr']['plurals'] == 3, t('Plural numbers changed.'));
|
|
|
|
// Importing a .po file and mark its strings as customized strings.
|
|
$this->importPoFile($this->getCustomPoFile(), array(
|
|
'langcode' => 'fr',
|
|
'customized' => TRUE,
|
|
));
|
|
|
|
// The import should have created 6 strings.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 6, '%update' => 0, '%delete' => 0)), t('The customized translation file was successfully imported.'));
|
|
|
|
// The database should now contain 6 customized strings (two imported
|
|
// strings are not translated).
|
|
$count = db_query('SELECT lid FROM {locales_target} WHERE customized = :custom', array(':custom' => 1))->rowCount();
|
|
$this->assertEqual($count, 6, t('Customized translations succesfully imported.'));
|
|
|
|
// Try importing a .po file with overriding strings, and ensure existing
|
|
// customized strings are kept.
|
|
$this->importPoFile($this->getCustomOverwritePoFile(), array(
|
|
'langcode' => 'fr',
|
|
'overwrite_options[not_customized]' => TRUE,
|
|
'overwrite_options[customized]' => FALSE,
|
|
));
|
|
|
|
// The import should have created 1 string.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 1, '%update' => 0, '%delete' => 0)), t('The customized translation file was successfully imported.'));
|
|
// Ensure string wasn't overwritten.
|
|
$search = array(
|
|
'string' => 'januari',
|
|
'language' => 'fr',
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertText(t('No strings available.'), t('Customized string not overwritten by imported string.'));
|
|
|
|
// Try importing a .po file with overriding strings, and ensure existing
|
|
// customized strings are overwritten.
|
|
$this->importPoFile($this->getCustomOverwritePoFile(), array(
|
|
'langcode' => 'fr',
|
|
'overwrite_options[not_customized]' => FALSE,
|
|
'overwrite_options[customized]' => TRUE,
|
|
));
|
|
|
|
// The import should have updated 2 strings.
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 0, '%update' => 2, '%delete' => 0)), t('The customized translation file was successfully imported.'));
|
|
// Ensure string was overwritten.
|
|
$search = array(
|
|
'string' => 'januari',
|
|
'language' => 'fr',
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText(t('No strings available.'), t('Customized string overwritten by imported string.'));
|
|
|
|
}
|
|
|
|
/**
|
|
* Test automatic import of a module's translation files.
|
|
*/
|
|
function testAutomaticModuleTranslationImportLanguageEnable() {
|
|
// Code for the language - manually set to match the test translation file.
|
|
$langcode = 'xx';
|
|
// The English name for the language.
|
|
$name = $this->randomName(16);
|
|
|
|
// Create a custom language.
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
|
|
// Ensure the translation file was automatically imported when language was
|
|
// added.
|
|
$this->assertText(t('One translation file imported.'), t('Language file automatically imported.'));
|
|
|
|
// Ensure strings were successfully imported.
|
|
$search = array(
|
|
'string' => 'lundi',
|
|
'language' => $langcode,
|
|
'translation' => 'translated',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
$this->assertNoText(t('No strings available.'), t('String successfully imported.'));
|
|
}
|
|
|
|
/**
|
|
* Test msgctxt context support.
|
|
*/
|
|
function testLanguageContext() {
|
|
// Try importing a .po file.
|
|
$this->importPoFile($this->getPoFileWithContext(), array(
|
|
'langcode' => 'hr',
|
|
));
|
|
|
|
$this->assertIdentical(t('May', array(), array('langcode' => 'hr', 'context' => 'Long month name')), 'Svibanj', t('Long month name context is working.'));
|
|
$this->assertIdentical(t('May', array(), array('langcode' => 'hr')), 'Svi.', t('Default context is working.'));
|
|
}
|
|
|
|
/**
|
|
* Test empty msgstr at end of .po file see #611786.
|
|
*/
|
|
function testEmptyMsgstr() {
|
|
$langcode = 'hu';
|
|
|
|
// Try importing a .po file.
|
|
$this->importPoFile($this->getPoFileWithMsgstr(), array(
|
|
'langcode' => $langcode,
|
|
));
|
|
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 1, '%update' => 0, '%delete' => 0)), t('The translation file was successfully imported.'));
|
|
$this->assertIdentical(t('Operations', array(), array('langcode' => $langcode)), 'Műveletek', t('String imported and translated.'));
|
|
|
|
// Try importing a .po file.
|
|
$this->importPoFile($this->getPoFileWithEmptyMsgstr(), array(
|
|
'langcode' => $langcode,
|
|
'overwrite_options[not_customized]' => TRUE,
|
|
));
|
|
$this->assertRaw(t('The translation was successfully imported. There are %number newly created translated strings, %update strings were updated and %delete strings were removed.', array('%number' => 0, '%update' => 0, '%delete' => 1)), t('The translation file was successfully imported.'));
|
|
// This is the language indicator on the translation search screen for
|
|
// untranslated strings.
|
|
$language_indicator = "<em class=\"locale-untranslated\">$langcode</em> ";
|
|
$str = "Operations";
|
|
$search = array(
|
|
'string' => $str,
|
|
'language' => 'all',
|
|
'translation' => 'all',
|
|
);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $search, t('Filter'));
|
|
// assertText() seems to remove the input field where $str always could be
|
|
// found, so this is not a false assert.
|
|
$this->assertText($str, t('Search found the string.'));
|
|
$this->assertRaw($language_indicator, t('String is untranslated again.'));
|
|
}
|
|
|
|
/**
|
|
* Helper function: import a standalone .po file in a given language.
|
|
*
|
|
* @param $contents
|
|
* Contents of the .po file to import.
|
|
* @param $options
|
|
* Additional options to pass to the translation import form.
|
|
*/
|
|
function importPoFile($contents, array $options = array()) {
|
|
$name = tempnam('temporary://', "po_") . '.po';
|
|
file_put_contents($name, $contents);
|
|
$options['files[file]'] = $name;
|
|
$this->drupalPost('admin/config/regional/translate/import', $options, t('Import'));
|
|
drupal_unlink($name);
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a proper .po file.
|
|
*/
|
|
function getPoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "One sheep"
|
|
msgid_plural "@count sheep"
|
|
msgstr[0] "un mouton"
|
|
msgstr[1] "@count moutons"
|
|
|
|
msgid "Monday"
|
|
msgstr "lundi"
|
|
|
|
msgid "Tuesday"
|
|
msgstr "mardi"
|
|
|
|
msgid "Wednesday"
|
|
msgstr "mercredi"
|
|
|
|
msgid "Thursday"
|
|
msgstr "jeudi"
|
|
|
|
msgid "Friday"
|
|
msgstr "vendredi"
|
|
|
|
msgid "Saturday"
|
|
msgstr "samedi"
|
|
|
|
msgid "Sunday"
|
|
msgstr "dimanche"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a bad .po file.
|
|
*/
|
|
function getBadPoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "Save configuration"
|
|
msgstr "Enregistrer la configuration"
|
|
|
|
msgid "edit"
|
|
msgstr "modifier<img SRC="javascript:alert(\'xss\');">"
|
|
|
|
msgid "delete"
|
|
msgstr "supprimer<script>alert('xss');</script>"
|
|
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a proper .po file for testing.
|
|
*/
|
|
function getOverwritePoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\\n"
|
|
|
|
msgid "Monday"
|
|
msgstr "Montag"
|
|
|
|
msgid "Day"
|
|
msgstr "Jour"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a .po file which strings will be marked
|
|
* as customized.
|
|
*/
|
|
function getCustomPoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "One dog"
|
|
msgid_plural "@count dogs"
|
|
msgstr[0] "un chien"
|
|
msgstr[1] "@count chiens"
|
|
|
|
msgid "January"
|
|
msgstr "janvier"
|
|
|
|
msgid "February"
|
|
msgstr "février"
|
|
|
|
msgid "March"
|
|
msgstr "mars"
|
|
|
|
msgid "April"
|
|
msgstr "avril"
|
|
|
|
msgid "June"
|
|
msgstr "juin"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a .po file for testing customized strings.
|
|
*/
|
|
function getCustomOverwritePoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "January"
|
|
msgstr "januari"
|
|
|
|
msgid "February"
|
|
msgstr "februari"
|
|
|
|
msgid "July"
|
|
msgstr "juillet"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a .po file with context.
|
|
*/
|
|
function getPoFileWithContext() {
|
|
// Croatian (code hr) is one the the languages that have a different
|
|
// form for the full name and the abbreviated name for the month May.
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\\n"
|
|
|
|
msgctxt "Long month name"
|
|
msgid "May"
|
|
msgstr "Svibanj"
|
|
|
|
msgid "May"
|
|
msgstr "Svi."
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a .po file with an empty last item.
|
|
*/
|
|
function getPoFileWithEmptyMsgstr() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "Operations"
|
|
msgstr ""
|
|
|
|
EOF;
|
|
}
|
|
/**
|
|
* Helper function that returns a .po file with an empty last item.
|
|
*/
|
|
function getPoFileWithMsgstr() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "Operations"
|
|
msgstr "Műveletek"
|
|
|
|
msgid "Will not appear in Drupal core, so we can ensure the test passes"
|
|
msgstr ""
|
|
|
|
EOF;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Functional tests for the export of translation files.
|
|
*/
|
|
class LocaleExportFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Translation export',
|
|
'description' => 'Tests the exportation of locale files.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user able to create languages and export translations.
|
|
*/
|
|
protected $admin_user = NULL;
|
|
|
|
function setUp() {
|
|
parent::setUp('locale', 'locale_test');
|
|
|
|
$this->admin_user = $this->drupalCreateUser(array('administer languages', 'translate interface', 'access administration pages'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
/**
|
|
* Test exportation of translations.
|
|
*/
|
|
function testExportTranslation() {
|
|
// First import some known translations.
|
|
// This will also automatically enable the 'fr' language.
|
|
$name = tempnam('temporary://', "po_") . '.po';
|
|
file_put_contents($name, $this->getPoFile());
|
|
$this->drupalPost('admin/config/regional/translate/import', array(
|
|
'langcode' => 'fr',
|
|
'files[file]' => $name,
|
|
), t('Import'));
|
|
drupal_unlink($name);
|
|
|
|
// Get the French translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'fr',
|
|
), t('Export'));
|
|
|
|
// Ensure we have a translation file.
|
|
$this->assertRaw('# French translation of Drupal', t('Exported French translation file.'));
|
|
// Ensure our imported translations exist in the file.
|
|
$this->assertRaw('msgstr "lundi"', t('French translations present in exported file.'));
|
|
|
|
// Import some more French translations which will be marked as customized.
|
|
$name = tempnam('temporary://', "po2_") . '.po';
|
|
file_put_contents($name, $this->getCustomPoFile());
|
|
$this->drupalPost('admin/config/regional/translate/import', array(
|
|
'langcode' => 'fr',
|
|
'files[file]' => $name,
|
|
'customized' => 1,
|
|
), t('Import'));
|
|
drupal_unlink($name);
|
|
|
|
// We can't import a string with an empty translation, but calling
|
|
// locale() for an new string creates an entry in the locales_source table.
|
|
locale('February', NULL, 'fr');
|
|
|
|
// Export only customized French translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'fr',
|
|
'content_options[not_customized]' => FALSE,
|
|
'content_options[customized]' => TRUE,
|
|
'content_options[not_translated]' => FALSE,
|
|
), t('Export'));
|
|
|
|
// Ensure we have a translation file.
|
|
$this->assertRaw('# French translation of Drupal', t('Exported French translation file with only customized strings.'));
|
|
// Ensure the customized translations exist in the file.
|
|
$this->assertRaw('msgstr "janvier"', t('French custom translation present in exported file.'));
|
|
// Ensure no untranslated strings exist in the file.
|
|
$this->assertNoRaw('msgid "February"', t('Untranslated string not present in exported file.'));
|
|
|
|
// Export only untranslated French translations.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(
|
|
'langcode' => 'fr',
|
|
'content_options[not_customized]' => FALSE,
|
|
'content_options[customized]' => FALSE,
|
|
'content_options[not_translated]' => TRUE,
|
|
), t('Export'));
|
|
|
|
// Ensure we have a translation file.
|
|
$this->assertRaw('# French translation of Drupal', t('Exported French translation file with only untranslated strings.'));
|
|
// Ensure no customized translations exist in the file.
|
|
$this->assertNoRaw('msgstr "janvier"', t('French custom translation not present in exported file.'));
|
|
// Ensure the untranslated strings exist in the file.
|
|
$this->assertRaw('msgid "February"', t('Untranslated string present in exported file.'));
|
|
}
|
|
|
|
/**
|
|
* Test exportation of translation template file.
|
|
*/
|
|
function testExportTranslationTemplateFile() {
|
|
// Get the translation template file.
|
|
$this->drupalPost('admin/config/regional/translate/export', array(), t('Export'));
|
|
// Ensure we have a translation file.
|
|
$this->assertRaw('# LANGUAGE translation of PROJECT', t('Exported translation template file.'));
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a proper .po file.
|
|
*/
|
|
function getPoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "Monday"
|
|
msgstr "lundi"
|
|
EOF;
|
|
}
|
|
|
|
/**
|
|
* Helper function that returns a .po file which strings will be marked
|
|
* as customized.
|
|
*/
|
|
function getCustomPoFile() {
|
|
return <<< EOF
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Drupal 8\\n"
|
|
"MIME-Version: 1.0\\n"
|
|
"Content-Type: text/plain; charset=UTF-8\\n"
|
|
"Content-Transfer-Encoding: 8bit\\n"
|
|
"Plural-Forms: nplurals=2; plural=(n > 1);\\n"
|
|
|
|
msgid "January"
|
|
msgstr "janvier"
|
|
EOF;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Tests for the st() function.
|
|
*/
|
|
class LocaleInstallTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'String translation using st()',
|
|
'description' => 'Tests that st() works like t().',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
|
|
// st() lives in install.inc, so ensure that it is loaded for all tests.
|
|
require_once DRUPAL_ROOT . '/core/includes/install.inc';
|
|
}
|
|
|
|
/**
|
|
* Verify that function signatures of t() and st() are equal.
|
|
*/
|
|
function testFunctionSignatures() {
|
|
$reflector_t = new ReflectionFunction('t');
|
|
$reflector_st = new ReflectionFunction('st');
|
|
$this->assertEqual($reflector_t->getParameters(), $reflector_st->getParameters(), t('Function signatures of t() and st() are equal.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Locale uninstall with English UI functional test.
|
|
*/
|
|
class LocaleUninstallFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Locale uninstall (EN)',
|
|
'description' => 'Tests the uninstall process using the built-in UI language.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* The default language set for the UI before uninstall.
|
|
*/
|
|
protected $language;
|
|
|
|
function setUp() {
|
|
parent::setUp(array('node', 'locale'));
|
|
$this->langcode = 'en';
|
|
|
|
// Create Article node type.
|
|
$this->drupalCreateContentType(array('type' => 'article', 'name' => 'Article'));
|
|
}
|
|
|
|
/**
|
|
* Check if the values of the Locale variables are correct after uninstall.
|
|
*/
|
|
function testUninstallProcess() {
|
|
$locale_module = array('locale', 'language');
|
|
|
|
$language = (object) array(
|
|
'langcode' => 'fr',
|
|
'name' => 'French',
|
|
'default' => $this->langcode == 'fr',
|
|
);
|
|
language_save($language);
|
|
|
|
// Check the UI language.
|
|
drupal_language_initialize();
|
|
$this->assertEqual($GLOBALS['language_interface']->langcode, $this->langcode, t('Current language: %lang', array('%lang' => $GLOBALS['language_interface']->langcode)));
|
|
|
|
// Enable multilingual workflow option for articles.
|
|
variable_set('node_type_language_article', 1);
|
|
|
|
// Change JavaScript translations directory.
|
|
variable_set('locale_js_directory', 'js_translations');
|
|
|
|
// Build the JavaScript translation file for French.
|
|
$user = $this->drupalCreateUser(array('translate interface', 'access administration pages'));
|
|
$this->drupalLogin($user);
|
|
$this->drupalGet('admin/config/regional/translate/translate');
|
|
$string = db_query('SELECT min(lid) AS lid FROM {locales_source} WHERE location LIKE :location', array(
|
|
':location' => '%.js%',
|
|
))->fetchObject();
|
|
$edit = array('translations[fr][0]' => 'french translation');
|
|
$this->drupalPost('admin/config/regional/translate/edit/' . $string->lid, $edit, t('Save translations'));
|
|
_locale_rebuild_js('fr');
|
|
$locale_javascripts = variable_get('locale_translation_javascript', array());
|
|
$js_file = 'public://' . variable_get('locale_js_directory', 'languages') . '/fr_' . $locale_javascripts['fr'] . '.js';
|
|
$this->assertTrue($result = file_exists($js_file), t('JavaScript file created: %file', array('%file' => $result ? $js_file : t('none'))));
|
|
|
|
// Disable string caching.
|
|
variable_set('locale_cache_strings', 0);
|
|
|
|
// Change language negotiation options.
|
|
drupal_load('module', 'locale');
|
|
variable_set('language_types', language_types_get_default() + array('language_custom' => TRUE));
|
|
variable_set('language_negotiation_' . LANGUAGE_TYPE_INTERFACE, language_language_negotiation_info());
|
|
variable_set('language_negotiation_' . LANGUAGE_TYPE_CONTENT, language_language_negotiation_info());
|
|
variable_set('language_negotiation_' . LANGUAGE_TYPE_URL, language_language_negotiation_info());
|
|
|
|
// Change language negotiation settings.
|
|
variable_set('language_negotiation_url_part', LANGUAGE_NEGOTIATION_URL_PREFIX);
|
|
variable_set('language_negotiation_session_param', TRUE);
|
|
|
|
// Uninstall Locale.
|
|
module_disable($locale_module);
|
|
drupal_uninstall_modules($locale_module);
|
|
|
|
// Visit the front page.
|
|
$this->drupalGet('');
|
|
|
|
// Check the init language logic.
|
|
drupal_language_initialize();
|
|
$this->assertEqual($GLOBALS['language_interface']->langcode, 'en', t('Language after uninstall: %lang', array('%lang' => $GLOBALS['language_interface']->langcode)));
|
|
|
|
// Check JavaScript files deletion.
|
|
$this->assertTrue($result = !file_exists($js_file), t('JavaScript file deleted: %file', array('%file' => $result ? $js_file : t('found'))));
|
|
|
|
// Check language count.
|
|
$language_count = variable_get('language_count', 1);
|
|
$this->assertEqual($language_count, 1, t('Language count: %count', array('%count' => $language_count)));
|
|
|
|
// Check language negotiation.
|
|
require_once DRUPAL_ROOT . '/core/includes/language.inc';
|
|
$this->assertTrue(count(language_types_get_all()) == count(language_types_get_default()), t('Language types reset'));
|
|
$language_negotiation = language_negotiation_method_get_first(LANGUAGE_TYPE_INTERFACE) == LANGUAGE_NEGOTIATION_DEFAULT;
|
|
$this->assertTrue($language_negotiation, t('Interface language negotiation: %setting', array('%setting' => t($language_negotiation ? 'none' : 'set'))));
|
|
$language_negotiation = language_negotiation_method_get_first(LANGUAGE_TYPE_CONTENT) == LANGUAGE_NEGOTIATION_DEFAULT;
|
|
$this->assertTrue($language_negotiation, t('Content language negotiation: %setting', array('%setting' => t($language_negotiation ? 'none' : 'set'))));
|
|
$language_negotiation = language_negotiation_method_get_first(LANGUAGE_TYPE_URL) == LANGUAGE_NEGOTIATION_DEFAULT;
|
|
$this->assertTrue($language_negotiation, t('URL language negotiation: %setting', array('%setting' => t($language_negotiation ? 'none' : 'set'))));
|
|
|
|
// Check language negotiation method settings.
|
|
$this->assertFalse(variable_get('language_negotiation_url_part', FALSE), t('URL language negotiation method indicator settings cleared.'));
|
|
$this->assertFalse(variable_get('language_negotiation_session_param', FALSE), t('Visit language negotiation method settings cleared.'));
|
|
|
|
// Check JavaScript parsed.
|
|
$javascript_parsed_count = count(variable_get('javascript_parsed', array()));
|
|
$this->assertEqual($javascript_parsed_count, 0, t('JavaScript parsed count: %count', array('%count' => $javascript_parsed_count)));
|
|
|
|
// Check JavaScript translations directory.
|
|
$locale_js_directory = variable_get('locale_js_directory', 'languages');
|
|
$this->assertEqual($locale_js_directory, 'languages', t('JavaScript translations directory: %dir', array('%dir' => $locale_js_directory)));
|
|
|
|
// Check string caching.
|
|
$locale_cache_strings = variable_get('locale_cache_strings', 1);
|
|
$this->assertEqual($locale_cache_strings, 1, t('String caching: %status', array('%status' => t($locale_cache_strings ? 'enabled': 'disabled'))));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Locale uninstall with French UI functional test.
|
|
*
|
|
* Because this class extends LocaleUninstallFunctionalTest, it doesn't require a new
|
|
* test of its own. Rather, it switches the default UI language in setUp and then
|
|
* runs the testUninstallProcess (which it inherits from LocaleUninstallFunctionalTest)
|
|
* to test with this new language.
|
|
*/
|
|
class LocaleUninstallFrenchFunctionalTest extends LocaleUninstallFunctionalTest {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Locale uninstall (FR)',
|
|
'description' => 'Tests the uninstall process using French as interface language.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp();
|
|
$this->langcode = 'fr';
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Functional tests for the language switching feature.
|
|
*/
|
|
class LocaleLanguageSwitchingFunctionalTest extends DrupalWebTestCase {
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Language switching',
|
|
'description' => 'Tests for the language switching feature.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('locale', 'block'));
|
|
|
|
// Create and login user.
|
|
$admin_user = $this->drupalCreateUser(array('administer blocks', 'administer languages', 'translate interface', 'access administration pages'));
|
|
$this->drupalLogin($admin_user);
|
|
}
|
|
|
|
/**
|
|
* Functional tests for the language switcher block.
|
|
*/
|
|
function testLanguageBlock() {
|
|
// Enable the language switching block.
|
|
$language_type = LANGUAGE_TYPE_INTERFACE;
|
|
$edit = array(
|
|
"blocks[language_{$language_type}][region]" => 'sidebar_first',
|
|
);
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
|
|
// Add language.
|
|
$edit = array(
|
|
'predefined_langcode' => 'fr',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Enable URL language detection and selection.
|
|
$edit = array('language_interface[enabled][language-url]' => '1');
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Assert that the language switching block is displayed on the frontpage.
|
|
$this->drupalGet('');
|
|
$this->assertText(t('Languages'), t('Language switcher block found.'));
|
|
|
|
// Assert that only the current language is marked as active.
|
|
list($language_switcher) = $this->xpath('//div[@id=:id]/div[@class="content"]', array(':id' => 'block-language-' . str_replace('_', '-', $language_type)));
|
|
$links = array(
|
|
'active' => array(),
|
|
'inactive' => array(),
|
|
);
|
|
$anchors = array(
|
|
'active' => array(),
|
|
'inactive' => array(),
|
|
);
|
|
foreach ($language_switcher->ul->li as $link) {
|
|
$classes = explode(" ", (string) $link['class']);
|
|
list($langcode) = array_intersect($classes, array('en', 'fr'));
|
|
if (in_array('active', $classes)) {
|
|
$links['active'][] = $langcode;
|
|
}
|
|
else {
|
|
$links['inactive'][] = $langcode;
|
|
}
|
|
$anchor_classes = explode(" ", (string) $link->a['class']);
|
|
if (in_array('active', $anchor_classes)) {
|
|
$anchors['active'][] = $langcode;
|
|
}
|
|
else {
|
|
$anchors['inactive'][] = $langcode;
|
|
}
|
|
}
|
|
$this->assertIdentical($links, array('active' => array('en'), 'inactive' => array('fr')), t('Only the current language list item is marked as active on the language switcher block.'));
|
|
$this->assertIdentical($anchors, array('active' => array('en'), 'inactive' => array('fr')), t('Only the current language anchor is marked as active on the language switcher block.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test browser language detection.
|
|
*/
|
|
class LocaleBrowserDetectionTest extends DrupalUnitTestCase {
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Browser language detection',
|
|
'description' => 'Tests for the browser language detection.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Unit tests for the language_from_browser() function.
|
|
*/
|
|
function testLanguageFromBrowser() {
|
|
// Load the required functions.
|
|
require_once DRUPAL_ROOT . '/core/modules/language/language.negotiation.inc';
|
|
|
|
$languages = array(
|
|
// In our test case, 'en' has priority over 'en-US'.
|
|
'en' => (object) array(
|
|
'langcode' => 'en',
|
|
),
|
|
'en-US' => (object) array(
|
|
'langcode' => 'en-US',
|
|
),
|
|
// But 'fr-CA' has priority over 'fr'.
|
|
'fr-CA' => (object) array(
|
|
'langcode' => 'fr-CA',
|
|
),
|
|
'fr' => (object) array(
|
|
'langcode' => 'fr',
|
|
),
|
|
// 'es-MX' is alone.
|
|
'es-MX' => (object) array(
|
|
'langcode' => 'es-MX',
|
|
),
|
|
// 'pt' is alone.
|
|
'pt' => (object) array(
|
|
'langcode' => 'pt',
|
|
),
|
|
// Language codes with more then one dash are actually valid.
|
|
// eh-oh-laa-laa is the official language code of the Teletubbies.
|
|
'eh-oh-laa-laa' => (object) array(
|
|
'langcode' => 'eh-oh-laa-laa',
|
|
),
|
|
);
|
|
|
|
$test_cases = array(
|
|
// Equal qvalue for each language, choose the site prefered one.
|
|
'en,en-US,fr-CA,fr,es-MX' => 'en',
|
|
'en-US,en,fr-CA,fr,es-MX' => 'en',
|
|
'fr,en' => 'en',
|
|
'en,fr' => 'en',
|
|
'en-US,fr' => 'en',
|
|
'fr,en-US' => 'en',
|
|
'fr,fr-CA' => 'fr-CA',
|
|
'fr-CA,fr' => 'fr-CA',
|
|
'fr' => 'fr-CA',
|
|
'fr;q=1' => 'fr-CA',
|
|
'fr,es-MX' => 'fr-CA',
|
|
'fr,es' => 'fr-CA',
|
|
'es,fr' => 'fr-CA',
|
|
'es-MX,de' => 'es-MX',
|
|
'de,es-MX' => 'es-MX',
|
|
|
|
// Different cases and whitespace.
|
|
'en' => 'en',
|
|
'En' => 'en',
|
|
'EN' => 'en',
|
|
' en' => 'en',
|
|
'en ' => 'en',
|
|
'en, fr' => 'en',
|
|
|
|
// A less specific language from the browser matches a more specific one
|
|
// from the website, and the other way around for compatibility with
|
|
// some versions of Internet Explorer.
|
|
'es' => 'es-MX',
|
|
'es-MX' => 'es-MX',
|
|
'pt' => 'pt',
|
|
'pt-PT' => 'pt',
|
|
'pt-PT;q=0.5,pt-BR;q=1,en;q=0.7' => 'en',
|
|
'pt-PT;q=1,pt-BR;q=0.5,en;q=0.7' => 'en',
|
|
'pt-PT;q=0.4,pt-BR;q=0.1,en;q=0.7' => 'en',
|
|
'pt-PT;q=0.1,pt-BR;q=0.4,en;q=0.7' => 'en',
|
|
|
|
// Language code with several dashes are valid. The less specific language
|
|
// from the browser matches the more specific one from the website.
|
|
'eh-oh-laa-laa' => 'eh-oh-laa-laa',
|
|
'eh-oh-laa' => 'eh-oh-laa-laa',
|
|
'eh-oh' => 'eh-oh-laa-laa',
|
|
'eh' => 'eh-oh-laa-laa',
|
|
|
|
// Different qvalues.
|
|
'en-US,en;q=0.5,fr;q=0.25' => 'en-US',
|
|
'fr,en;q=0.5' => 'fr-CA',
|
|
'fr,en;q=0.5,fr-CA;q=0.25' => 'fr',
|
|
|
|
// Silly wildcards are also valid.
|
|
'*,fr-CA;q=0.5' => 'en',
|
|
'*,en;q=0.25' => 'fr-CA',
|
|
'en,en-US;q=0.5,fr;q=0.25' => 'en',
|
|
'en-US,en;q=0.5,fr;q=0.25' => 'en-US',
|
|
|
|
// Unresolvable cases.
|
|
'' => FALSE,
|
|
'de,pl' => FALSE,
|
|
'iecRswK4eh' => FALSE,
|
|
$this->randomName(10) => FALSE,
|
|
);
|
|
|
|
foreach ($test_cases as $accept_language => $expected_result) {
|
|
$_SERVER['HTTP_ACCEPT_LANGUAGE'] = $accept_language;
|
|
$result = language_from_browser($languages);
|
|
$this->assertIdentical($result, $expected_result, t("Language selection '@accept-language' selects '@result', result = '@actual'", array('@accept-language' => $accept_language, '@result' => $expected_result, '@actual' => isset($result) ? $result : 'none')));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for a user's ability to change their default language.
|
|
*/
|
|
class LocaleUserLanguageFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'User language settings',
|
|
'description' => "Tests user's ability to change their default language.",
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
}
|
|
|
|
/**
|
|
* Test if user can change their default language.
|
|
*/
|
|
function testUserLanguageConfiguration() {
|
|
global $base_url;
|
|
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages'));
|
|
// User to change their default language.
|
|
$web_user = $this->drupalCreateUser();
|
|
|
|
// Add custom language.
|
|
$this->drupalLogin($admin_user);
|
|
// Code for the language.
|
|
$langcode = 'xx';
|
|
// The English name for the language.
|
|
$name = $this->randomName(16);
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
|
|
// Add custom language and disable it.
|
|
// Code for the language.
|
|
$langcode_disabled = 'xx-yy';
|
|
// The English name for the language. This will be translated.
|
|
$name_disabled = $this->randomName(16);
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode_disabled,
|
|
'name' => $name_disabled,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
// Disable the language.
|
|
$edit = array(
|
|
'languages[' . $langcode_disabled . '][enabled]' => FALSE,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language', $edit, t('Save configuration'));
|
|
$this->drupalLogout();
|
|
|
|
// Login as normal user and edit account settings.
|
|
$this->drupalLogin($web_user);
|
|
$path = 'user/' . $web_user->uid . '/edit';
|
|
$this->drupalGet($path);
|
|
// Ensure language settings fieldset is available.
|
|
$this->assertText(t('Language'), t('Language selector available.'));
|
|
// Ensure custom language is present.
|
|
$this->assertText($name, t('Language present on form.'));
|
|
// Ensure disabled language isn't present.
|
|
$this->assertNoText($name_disabled, t('Disabled language not present on form.'));
|
|
// Switch to our custom language.
|
|
$edit = array(
|
|
'preferred_langcode' => $langcode,
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save'));
|
|
// Ensure form was submitted successfully.
|
|
$this->assertText(t('The changes have been saved.'), t('Changes were saved.'));
|
|
// Check if language was changed.
|
|
$elements = $this->xpath('//input[@id=:id]', array(':id' => 'edit-preferred-langcode-' . $langcode));
|
|
$this->assertTrue(isset($elements[0]) && !empty($elements[0]['checked']), t('Default language successfully updated.'));
|
|
|
|
$this->drupalLogout();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional test for language handling during user creation.
|
|
*/
|
|
class LocaleUserCreationTest extends DrupalWebTestCase {
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'User creation',
|
|
'description' => 'Tests whether proper language is stored for new users and access to language selector.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
variable_set('user_register', USER_REGISTER_VISITORS);
|
|
}
|
|
|
|
/**
|
|
* Functional test for language handling during user creation.
|
|
*/
|
|
function testLocalUserCreation() {
|
|
// User to add and remove language and create new users.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages', 'administer users'));
|
|
$this->drupalLogin($admin_user);
|
|
|
|
// Add predefined language.
|
|
$langcode = 'fr';
|
|
$edit = array(
|
|
'predefined_langcode' => 'fr',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
$this->assertText('French', t('Language added successfully.'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/language', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
|
|
// Set language negotiation.
|
|
$edit = array(
|
|
'language_interface[enabled][language-url]' => TRUE,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
$this->assertText(t('Language negotiation configuration saved.'), t('Set language negotiation.'));
|
|
|
|
// Check if the language selector is available on admin/people/create and
|
|
// set to the currently active language.
|
|
$this->drupalGet($langcode . '/admin/people/create');
|
|
$this->assertFieldChecked("edit-preferred-langcode-$langcode", t('Global language set in the language selector.'));
|
|
|
|
// Create a user with the admin/people/create form and check if the correct
|
|
// language is set.
|
|
$username = $this->randomName(10);
|
|
$edit = array(
|
|
'name' => $username,
|
|
'mail' => $this->randomName(4) . '@example.com',
|
|
'pass[pass1]' => $username,
|
|
'pass[pass2]' => $username,
|
|
);
|
|
|
|
$this->drupalPost($langcode . '/admin/people/create', $edit, t('Create new account'));
|
|
|
|
$user = user_load_by_name($username);
|
|
$this->assertEqual($user->preferred_langcode, $langcode, t('New user has correct preferred language set.'));
|
|
$this->assertEqual($user->langcode, $langcode, t('New user has correct profile language set.'));
|
|
|
|
// Register a new user and check if the language selector is hidden.
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet($langcode . '/user/register');
|
|
$this->assertNoFieldByName('language[fr]', t('Language selector is not accessible.'));
|
|
|
|
$username = $this->randomName(10);
|
|
$edit = array(
|
|
'name' => $username,
|
|
'mail' => $this->randomName(4) . '@example.com',
|
|
);
|
|
|
|
$this->drupalPost($langcode . '/user/register', $edit, t('Create new account'));
|
|
|
|
$user = user_load_by_name($username);
|
|
$this->assertEqual($user->preferred_langcode, $langcode, t('New user has correct preferred language set.'));
|
|
$this->assertEqual($user->langcode, $langcode, t('New user has correct profile language set.'));
|
|
|
|
// Test if the admin can use the language selector and if the
|
|
// correct language is was saved.
|
|
$user_edit = $langcode . '/user/' . $user->uid . '/edit';
|
|
|
|
$this->drupalLogin($admin_user);
|
|
$this->drupalGet($user_edit);
|
|
$this->assertFieldChecked("edit-preferred-langcode-$langcode", t('Language selector is accessible and correct language is selected.'));
|
|
|
|
// Set pass_raw so we can login the new user.
|
|
$user->pass_raw = $this->randomName(10);
|
|
$edit = array(
|
|
'pass[pass1]' => $user->pass_raw,
|
|
'pass[pass2]' => $user->pass_raw,
|
|
);
|
|
|
|
$this->drupalPost($user_edit, $edit, t('Save'));
|
|
|
|
$this->drupalLogin($user);
|
|
$this->drupalGet($user_edit);
|
|
$this->assertFieldChecked("edit-preferred-langcode-$langcode", t('Language selector is accessible and correct language is selected.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for configuring a different path alias per language.
|
|
*/
|
|
class LocalePathFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Path language settings',
|
|
'description' => 'Checks you can configure a language for individual url aliases.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('node', 'locale', 'path'));
|
|
|
|
$this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
|
|
variable_set('site_frontpage', 'node');
|
|
}
|
|
|
|
/**
|
|
* Test if a language can be associated with a path alias.
|
|
*/
|
|
function testPathLanguageConfiguration() {
|
|
global $base_url;
|
|
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'create page content', 'administer url aliases', 'create url aliases', 'access administration pages'));
|
|
|
|
// Add custom language.
|
|
$this->drupalLogin($admin_user);
|
|
// Code for the language.
|
|
$langcode = 'xx';
|
|
// The English name for the language.
|
|
$name = $this->randomName(16);
|
|
// The domain prefix.
|
|
$prefix = $langcode;
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
|
|
// Set path prefix.
|
|
$edit = array( "prefix[$langcode]" => $prefix );
|
|
$this->drupalPost('admin/config/regional/language/detection/url', $edit, t('Save configuration'));
|
|
|
|
// Check that the "xx" front page is readily available because path prefix
|
|
// negotiation is pre-configured.
|
|
$this->drupalGet($prefix);
|
|
$this->assertText(t('Welcome to Drupal'), t('The "xx" front page is readibly available.'));
|
|
|
|
// Create a node.
|
|
$node = $this->drupalCreateNode(array('type' => 'page'));
|
|
|
|
// Create a path alias in default language (English).
|
|
$path = 'admin/config/search/path/add';
|
|
$english_path = $this->randomName(8);
|
|
$edit = array(
|
|
'source' => 'node/' . $node->nid,
|
|
'alias' => $english_path,
|
|
'langcode' => 'en',
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save'));
|
|
|
|
// Create a path alias in new custom language.
|
|
$custom_language_path = $this->randomName(8);
|
|
$edit = array(
|
|
'source' => 'node/' . $node->nid,
|
|
'alias' => $custom_language_path,
|
|
'langcode' => $langcode,
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save'));
|
|
|
|
// Confirm English language path alias works.
|
|
$this->drupalGet($english_path);
|
|
$this->assertText($node->title, t('English alias works.'));
|
|
|
|
// Confirm custom language path alias works.
|
|
$this->drupalGet($prefix . '/' . $custom_language_path);
|
|
$this->assertText($node->title, t('Custom language alias works.'));
|
|
|
|
// Create a custom path.
|
|
$custom_path = $this->randomName(8);
|
|
|
|
// Check priority of language for alias by source path.
|
|
$edit = array(
|
|
'source' => 'node/' . $node->nid,
|
|
'alias' => $custom_path,
|
|
'langcode' => LANGUAGE_NOT_SPECIFIED,
|
|
);
|
|
path_save($edit);
|
|
$lookup_path = drupal_lookup_path('alias', 'node/' . $node->nid, 'en');
|
|
$this->assertEqual($english_path, $lookup_path, t('English language alias has priority.'));
|
|
// Same check for language 'xx'.
|
|
$lookup_path = drupal_lookup_path('alias', 'node/' . $node->nid, $prefix);
|
|
$this->assertEqual($custom_language_path, $lookup_path, t('Custom language alias has priority.'));
|
|
path_delete($edit);
|
|
|
|
// Create language nodes to check priority of aliases.
|
|
$first_node = $this->drupalCreateNode(array('type' => 'page', 'promote' => 1));
|
|
$second_node = $this->drupalCreateNode(array('type' => 'page', 'promote' => 1));
|
|
|
|
// Assign a custom path alias to the first node with the English language.
|
|
$edit = array(
|
|
'source' => 'node/' . $first_node->nid,
|
|
'alias' => $custom_path,
|
|
'langcode' => 'en',
|
|
);
|
|
path_save($edit);
|
|
|
|
// Assign a custom path alias to second node with LANGUAGE_NOT_SPECIFIED.
|
|
$edit = array(
|
|
'source' => 'node/' . $second_node->nid,
|
|
'alias' => $custom_path,
|
|
'langcode' => LANGUAGE_NOT_SPECIFIED,
|
|
);
|
|
path_save($edit);
|
|
|
|
// Test that both node titles link to our path alias.
|
|
$this->drupalGet('<front>');
|
|
$custom_path_url = base_path() . (variable_get('clean_url', 0) ? $custom_path : '?q=' . $custom_path);
|
|
$elements = $this->xpath('//a[@href=:href and .=:title]', array(':href' => $custom_path_url, ':title' => $first_node->title));
|
|
$this->assertTrue(!empty($elements), t('First node links to the path alias.'));
|
|
$elements = $this->xpath('//a[@href=:href and .=:title]', array(':href' => $custom_path_url, ':title' => $second_node->title));
|
|
$this->assertTrue(!empty($elements), t('Second node links to the path alias.'));
|
|
|
|
// Confirm that the custom path leads to the first node.
|
|
$this->drupalGet($custom_path);
|
|
$this->assertText($first_node->title, t('Custom alias returns first node.'));
|
|
|
|
// Confirm that the custom path with prefix leads to the second node.
|
|
$this->drupalGet($prefix . '/' . $custom_path);
|
|
$this->assertText($second_node->title, t('Custom alias with prefix returns second node.'));
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for multilingual support on nodes.
|
|
*/
|
|
class LocaleContentFunctionalTest extends DrupalWebTestCase {
|
|
protected $profile = 'standard';
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Content language settings',
|
|
'description' => 'Checks you can enable multilingual support on content types and configure a language for a node.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
}
|
|
|
|
/**
|
|
* Verifies that machine name fields are always LTR.
|
|
*/
|
|
function testMachineNameLTR() {
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'administer content types', 'access administration pages'));
|
|
|
|
// Log in as admin.
|
|
$this->drupalLogin($admin_user);
|
|
|
|
// Verify that the machine name field is LTR for a new content type.
|
|
$this->drupalGet('admin/structure/types/add');
|
|
$this->assertFieldByXpath('//input[@name="type" and @dir="ltr"]', NULL, 'The machine name field is LTR when no additional language is configured.');
|
|
|
|
// Install the Arabic language (which is RTL) and configure as the default.
|
|
$edit = array();
|
|
$edit['predefined_langcode'] = 'ar';
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
$edit = array();
|
|
$edit['site_default'] = 'ar';
|
|
$this->drupalPost(NULL, $edit, t('Save configuration'));
|
|
|
|
// Verify that the machine name field is still LTR for a new content type.
|
|
$this->drupalGet('admin/structure/types/add');
|
|
$this->assertFieldByXpath('//input[@name="type" and @dir="ltr"]', NULL, 'The machine name field is LTR when the default language is RTL.');
|
|
}
|
|
|
|
/**
|
|
* Test if a content type can be set to multilingual and language is present.
|
|
*/
|
|
function testContentTypeLanguageConfiguration() {
|
|
global $base_url;
|
|
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'administer content types', 'access administration pages'));
|
|
// User to create a node.
|
|
$web_user = $this->drupalCreateUser(array('create article content', 'create page content', 'edit any page content'));
|
|
|
|
// Add custom language.
|
|
$this->drupalLogin($admin_user);
|
|
// Code for the language.
|
|
$langcode = 'xx';
|
|
// The English name for the language.
|
|
$name = $this->randomName(16);
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode,
|
|
'name' => $name,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
|
|
// Add disabled custom language.
|
|
// Code for the language.
|
|
$langcode_disabled = 'xx-yy';
|
|
// The English name for the language.
|
|
$name_disabled = $this->randomName(16);
|
|
$edit = array(
|
|
'predefined_langcode' => 'custom',
|
|
'langcode' => $langcode_disabled,
|
|
'name' => $name_disabled,
|
|
'direction' => '0',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add custom language'));
|
|
// Disable second custom language.
|
|
$path = 'admin/config/regional/language';
|
|
$edit = array(
|
|
'languages[' . $langcode_disabled . '][enabled]' => FALSE,
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save configuration'));
|
|
|
|
// Set "Basic page" content type to use multilingual support.
|
|
$this->drupalGet('admin/structure/types/manage/page');
|
|
$this->assertText(t('Multilingual support'), t('Multilingual support fieldset present on content type configuration form.'));
|
|
$edit = array(
|
|
'node_type_language' => 1,
|
|
);
|
|
$this->drupalPost('admin/structure/types/manage/page', $edit, t('Save content type'));
|
|
$this->assertRaw(t('The content type %type has been updated.', array('%type' => 'Basic page')), t('Basic page content type has been updated.'));
|
|
$this->drupalLogout();
|
|
|
|
// Verify language selection is not present on add article form.
|
|
$this->drupalLogin($web_user);
|
|
$this->drupalGet('node/add/article');
|
|
// Verify language select list is not present.
|
|
$this->assertNoFieldByName('language', NULL, t('Language select not present on add article form.'));
|
|
|
|
// Verify language selection appears on add "Basic page" form.
|
|
$this->drupalGet('node/add/page');
|
|
// Verify language select list is present.
|
|
$this->assertFieldByName('langcode', NULL, t('Language select present on add Basic page form.'));
|
|
// Ensure enabled language appears.
|
|
$this->assertText($name, t('Enabled language present.'));
|
|
// Ensure disabled language doesn't appear.
|
|
$this->assertNoText($name_disabled, t('Disabled language not present.'));
|
|
|
|
// Create "Basic page" content.
|
|
$node_title = $this->randomName();
|
|
$node_body = $this->randomName();
|
|
$edit = array(
|
|
'type' => 'page',
|
|
'title' => $node_title,
|
|
'body' => array($langcode => array(array('value' => $node_body))),
|
|
'langcode' => $langcode,
|
|
);
|
|
$node = $this->drupalCreateNode($edit);
|
|
// Edit the content and ensure correct language is selected.
|
|
$path = 'node/' . $node->nid . '/edit';
|
|
$this->drupalGet($path);
|
|
$this->assertRaw('<option value="' . $langcode . '" selected="selected">' . $name . '</option>', t('Correct language selected.'));
|
|
// Ensure we can change the node language.
|
|
$edit = array(
|
|
'langcode' => 'en',
|
|
);
|
|
$this->drupalPost($path, $edit, t('Save'));
|
|
$this->assertRaw(t('%title has been updated.', array('%title' => $node_title)), t('Basic page content updated.'));
|
|
|
|
$this->drupalLogout();
|
|
}
|
|
|
|
/**
|
|
* Test if a dir and lang tags exist in node's attributes.
|
|
*/
|
|
function testContentTypeDirLang() {
|
|
// User to add and remove language.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'administer content types', 'access administration pages'));
|
|
// User to create a node.
|
|
$web_user = $this->drupalCreateUser(array('create article content', 'edit own article content'));
|
|
|
|
// Login as admin.
|
|
$this->drupalLogin($admin_user);
|
|
|
|
// Install Arabic language.
|
|
$edit = array();
|
|
$edit['predefined_langcode'] = 'ar';
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Install Spanish language.
|
|
$edit = array();
|
|
$edit['predefined_langcode'] = 'es';
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Set "Article" content type to use multilingual support.
|
|
$this->drupalGet('admin/structure/types/manage/article');
|
|
$edit = array(
|
|
'node_type_language' => 1,
|
|
);
|
|
$this->drupalPost('admin/structure/types/manage/article', $edit, t('Save content type'));
|
|
$this->assertRaw(t('The content type %type has been updated.', array('%type' => 'Article')), t('Article content type has been updated.'));
|
|
$this->drupalLogout();
|
|
|
|
// Login as web user to add new article.
|
|
$this->drupalLogin($web_user);
|
|
|
|
// Create three nodes: English, Arabic and Spanish.
|
|
$node_en = $this->createNodeArticle('en');
|
|
$node_ar = $this->createNodeArticle('ar');
|
|
$node_es = $this->createNodeArticle('es');
|
|
|
|
$this->drupalGet('node');
|
|
|
|
// Check if English node does not have lang tag.
|
|
$pattern = '|id="node-' . $node_en->nid . '"[^<>]*lang="en"|';
|
|
$this->assertNoPattern($pattern, t('The lang tag has not been assigned to the English node.'));
|
|
|
|
// Check if English node does not have dir tag.
|
|
$pattern = '|id="node-' . $node_en->nid . '"[^<>]*dir="ltr"|';
|
|
$this->assertNoPattern($pattern, t('The dir tag has not been assigned to the English node.'));
|
|
|
|
// Check if Arabic node has lang="ar" & dir="rtl" tags.
|
|
$pattern = '|id="node-' . $node_ar->nid . '"[^<>]*lang="ar" dir="rtl"|';
|
|
$this->assertPattern($pattern, t('The lang and dir tags have been assigned correctly to the Arabic node.'));
|
|
|
|
// Check if Spanish node has lang="es" tag.
|
|
$pattern = '|id="node-' . $node_es->nid . '"[^<>]*lang="es"|';
|
|
$this->assertPattern($pattern, t('The lang tag has been assigned correctly to the Spanish node.'));
|
|
|
|
// Check if Spanish node does not have dir="ltr" tag.
|
|
$pattern = '|id="node-' . $node_es->nid . '"[^<>]*lang="es" dir="ltr"|';
|
|
$this->assertNoPattern($pattern, t('The dir tag has not been assigned to the Spanish node.'));
|
|
|
|
$this->drupalLogout();
|
|
}
|
|
|
|
/**
|
|
* Create node in a specific language.
|
|
*/
|
|
protected function createNodeArticle($langcode) {
|
|
$this->drupalGet('node/add/article');
|
|
$node_title = $this->randomName();
|
|
$node_body = $this->randomName();
|
|
$edit = array(
|
|
'type' => 'article',
|
|
'title' => $node_title,
|
|
'body' => array($langcode => array(array('value' => $node_body))),
|
|
'langcode' => $langcode,
|
|
'promote' => 1,
|
|
);
|
|
return $this->drupalCreateNode($edit);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test UI language negotiation
|
|
*
|
|
* 1. URL (PATH) > DEFAULT
|
|
* UI Language base on URL prefix, browser language preference has no
|
|
* influence:
|
|
* admin/config
|
|
* UI in site default language
|
|
* zh-hans/admin/config
|
|
* UI in Chinese
|
|
* blah-blah/admin/config
|
|
* 404
|
|
* 2. URL (PATH) > BROWSER > DEFAULT
|
|
* admin/config
|
|
* UI in user's browser language preference if the site has that
|
|
* language enabled, if not, the default language
|
|
* zh-hans/admin/config
|
|
* UI in Chinese
|
|
* blah-blah/admin/config
|
|
* 404
|
|
* 3. URL (DOMAIN) > DEFAULT
|
|
* http://example.com/admin/config
|
|
* UI language in site default
|
|
* http://example.cn/admin/config
|
|
* UI language in Chinese
|
|
*/
|
|
class LocaleUILanguageNegotiationTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'UI language negotiation',
|
|
'description' => 'Test UI language switching by url path prefix and domain.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('locale', 'locale_test', 'block'));
|
|
require_once DRUPAL_ROOT . '/core/includes/language.inc';
|
|
drupal_load('module', 'locale');
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'translate interface', 'access administration pages', 'administer blocks'));
|
|
$this->drupalLogin($admin_user);
|
|
}
|
|
|
|
/**
|
|
* Tests for language switching by URL path.
|
|
*/
|
|
function testUILanguageNegotiation() {
|
|
// A few languages to switch to.
|
|
// This one is unknown, should get the default lang version.
|
|
$langcode_unknown = 'blah-blah';
|
|
// For testing browser lang preference.
|
|
$langcode_browser_fallback = 'vi';
|
|
// For testing path prefix.
|
|
$langcode = 'zh-hans';
|
|
// For setting browser language preference to 'vi'.
|
|
$http_header_browser_fallback = array("Accept-Language: $langcode_browser_fallback;q=1");
|
|
// For setting browser language preference to some unknown.
|
|
$http_header_blah = array("Accept-Language: blah;q=1");
|
|
|
|
// This domain should switch the UI to Chinese.
|
|
$language_domain = 'example.cn';
|
|
|
|
// Setup the site languages by installing two languages.
|
|
$language = (object) array(
|
|
'langcode' => $langcode_browser_fallback,
|
|
);
|
|
language_save($language);
|
|
$language = (object) array(
|
|
'langcode' => $langcode,
|
|
);
|
|
language_save($language);
|
|
|
|
// We will look for this string in the admin/config screen to see if the
|
|
// corresponding translated string is shown.
|
|
$default_string = 'Configure languages for content and the user interface';
|
|
|
|
// Set the default language in order for the translated string to be registered
|
|
// into database when seen by t(). Without doing this, our target string
|
|
// is for some reason not found when doing translate search. This might
|
|
// be some bug.
|
|
drupal_static_reset('language_list');
|
|
$languages = language_list(TRUE);
|
|
variable_set('language_default', $languages['vi']);
|
|
// First visit this page to make sure our target string is searchable.
|
|
$this->drupalGet('admin/config');
|
|
// Now the t()'ed string is in db so switch the language back to default.
|
|
variable_del('language_default');
|
|
|
|
// Translate the string.
|
|
$language_browser_fallback_string = "In $langcode_browser_fallback In $langcode_browser_fallback In $langcode_browser_fallback";
|
|
$language_string = "In $langcode In $langcode In $langcode";
|
|
// Do a translate search of our target string.
|
|
$edit = array( 'string' => $default_string);
|
|
$this->drupalPost('admin/config/regional/translate/translate', $edit, t('Filter'));
|
|
// Should find the string and now click edit to post translated string.
|
|
$this->clickLink('edit');
|
|
$edit = array(
|
|
"translations[$langcode_browser_fallback][0]" => $language_browser_fallback_string,
|
|
"translations[$langcode][0]" => $language_string,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save translations'));
|
|
|
|
// Configure URL language rewrite.
|
|
variable_set('language_negotiation_url_type', LANGUAGE_TYPE_INTERFACE);
|
|
|
|
$tests = array(
|
|
// Default, browser preference should have no influence.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_DEFAULT),
|
|
'path' => 'admin/config',
|
|
'expect' => $default_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_DEFAULT,
|
|
'http_header' => $http_header_browser_fallback,
|
|
'message' => 'URL (PATH) > DEFAULT: no language prefix, UI language is default and the browser language preference setting is not used.',
|
|
),
|
|
// Language prefix.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_DEFAULT),
|
|
'path' => "$langcode/admin/config",
|
|
'expect' => $language_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_URL,
|
|
'http_header' => $http_header_browser_fallback,
|
|
'message' => 'URL (PATH) > DEFAULT: with language prefix, UI language is switched based on path prefix',
|
|
),
|
|
// Default, go by browser preference.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_BROWSER),
|
|
'path' => 'admin/config',
|
|
'expect' => $language_browser_fallback_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_BROWSER,
|
|
'http_header' => $http_header_browser_fallback,
|
|
'message' => 'URL (PATH) > BROWSER: no language prefix, UI language is determined by browser language preference',
|
|
),
|
|
// Prefix, switch to the language.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_BROWSER),
|
|
'path' => "$langcode/admin/config",
|
|
'expect' => $language_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_URL,
|
|
'http_header' => $http_header_browser_fallback,
|
|
'message' => 'URL (PATH) > BROWSER: with langage prefix, UI language is based on path prefix',
|
|
),
|
|
// Default, browser language preference is not one of site's lang.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_BROWSER, LANGUAGE_NEGOTIATION_DEFAULT),
|
|
'path' => 'admin/config',
|
|
'expect' => $default_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_DEFAULT,
|
|
'http_header' => $http_header_blah,
|
|
'message' => 'URL (PATH) > BROWSER > DEFAULT: no language prefix and browser language preference set to unknown language should use default language',
|
|
),
|
|
);
|
|
|
|
foreach ($tests as $test) {
|
|
$this->runTest($test);
|
|
}
|
|
|
|
// Unknown language prefix should return 404.
|
|
variable_set('language_negotiation_' . LANGUAGE_TYPE_INTERFACE, language_language_negotiation_info());
|
|
$this->drupalGet("$langcode_unknown/admin/config", array(), $http_header_browser_fallback);
|
|
$this->assertResponse(404, "Unknown language path prefix should return 404");
|
|
|
|
// Setup for domain negotiation, first configure the language to have domain
|
|
// URL.
|
|
$edit = array("domain[$langcode]" => $language_domain);
|
|
$this->drupalPost("admin/config/regional/language/detection/url", $edit, t('Save configuration'));
|
|
// Set the site to use domain language negotiation.
|
|
|
|
$tests = array(
|
|
// Default domain, browser preference should have no influence.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_DEFAULT),
|
|
'language_negotiation_url_part' => LANGUAGE_NEGOTIATION_URL_DOMAIN,
|
|
'path' => 'admin/config',
|
|
'expect' => $default_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_DEFAULT,
|
|
'http_header' => $http_header_browser_fallback,
|
|
'message' => 'URL (DOMAIN) > DEFAULT: default domain should get default language',
|
|
),
|
|
// Language domain specific URL, we set the $_SERVER['HTTP_HOST'] in
|
|
// locale_test.module hook_boot() to simulate this.
|
|
array(
|
|
'language_negotiation' => array(LANGUAGE_NEGOTIATION_URL, LANGUAGE_NEGOTIATION_DEFAULT),
|
|
'language_negotiation_url_part' => LANGUAGE_NEGOTIATION_URL_DOMAIN,
|
|
'locale_test_domain' => $language_domain,
|
|
'path' => 'admin/config',
|
|
'expect' => $language_string,
|
|
'expected_method_id' => LANGUAGE_NEGOTIATION_URL,
|
|
'http_header' => $http_header_browser_fallback,
|
|
'message' => 'URL (DOMAIN) > DEFAULT: domain example.cn should switch to Chinese',
|
|
),
|
|
);
|
|
|
|
foreach ($tests as $test) {
|
|
$this->runTest($test);
|
|
}
|
|
}
|
|
|
|
protected function runTest($test) {
|
|
if (!empty($test['language_negotiation'])) {
|
|
$method_weights = array_flip($test['language_negotiation']);
|
|
language_negotiation_set(LANGUAGE_TYPE_INTERFACE, $method_weights);
|
|
}
|
|
if (!empty($test['language_negotiation_url_part'])) {
|
|
variable_set('language_negotiation_url_part', $test['language_negotiation_url_part']);
|
|
}
|
|
if (!empty($test['locale_test_domain'])) {
|
|
variable_set('locale_test_domain', $test['locale_test_domain']);
|
|
}
|
|
$this->drupalGet($test['path'], array(), $test['http_header']);
|
|
$this->assertText($test['expect'], $test['message']);
|
|
$this->assertText(t('Language negotiation method: @name', array('@name' => $test['expected_method_id'])));
|
|
}
|
|
|
|
/**
|
|
* Test URL language detection when the requested URL has no language.
|
|
*/
|
|
function testUrlLanguageFallback() {
|
|
// Add the Italian language.
|
|
$langcode_browser_fallback = 'it';
|
|
$language = (object) array(
|
|
'langcode' => $langcode_browser_fallback,
|
|
);
|
|
language_save($language);
|
|
$languages = language_list();
|
|
|
|
// Enable the path prefix for the default language: this way any unprefixed
|
|
// URL must have a valid fallback value.
|
|
$edit = array('prefix[en]' => 'en');
|
|
$this->drupalPost('admin/config/regional/language/detection/url', $edit, t('Save configuration'));
|
|
|
|
// Enable browser and URL language detection.
|
|
$edit = array(
|
|
'language_interface[enabled][language-browser]' => TRUE,
|
|
'language_interface[enabled][language-url]' => TRUE,
|
|
'language_interface[weight][language-browser]' => -8,
|
|
'language_interface[weight][language-url]' => -10,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
$this->drupalGet('admin/config/regional/language/detection');
|
|
|
|
// Enable the language switcher block.
|
|
$edit = array('blocks[language_language_interface][region]' => 'sidebar_first');
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
|
|
// Access the front page without specifying any valid URL language prefix
|
|
// and having as browser language preference a non-default language.
|
|
$http_header = array("Accept-Language: $langcode_browser_fallback;q=1");
|
|
$language = (object) array('langcode' => '');
|
|
$this->drupalGet('', array('language' => $language), $http_header);
|
|
|
|
// Check that the language switcher active link matches the given browser
|
|
// language.
|
|
$args = array(':url' => base_path() . (!empty($GLOBALS['conf']['clean_url']) ? $langcode_browser_fallback : "?q=$langcode_browser_fallback"));
|
|
$fields = $this->xpath('//div[@id="block-language-language-interface"]//a[@class="language-link active" and starts-with(@href, :url)]', $args);
|
|
$this->assertTrue($fields[0] == $languages[$langcode_browser_fallback]->name, t('The browser language is the URL active language'));
|
|
|
|
// Check that URLs are rewritten using the given browser language.
|
|
$fields = $this->xpath('//p[@id="site-name"]/strong/a[@rel="home" and @href=:url]', $args);
|
|
$this->assertTrue($fields[0] == 'Drupal', t('URLs are rewritten using the browser language.'));
|
|
}
|
|
|
|
/**
|
|
* Tests url() when separate domains are used for multiple languages.
|
|
*/
|
|
function testLanguageDomain() {
|
|
// Add the Italian language.
|
|
$langcode = 'it';
|
|
$language = (object) array(
|
|
'langcode' => $langcode,
|
|
);
|
|
language_save($language);
|
|
$languages = language_list();
|
|
|
|
// Enable browser and URL language detection.
|
|
$edit = array(
|
|
'language_interface[enabled][language-url]' => TRUE,
|
|
'language_interface[weight][language-url]' => -10,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Change the domain for the Italian language.
|
|
$edit = array(
|
|
'language_negotiation_url_part' => 1,
|
|
'domain[it]' => 'it.example.com',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection/url', $edit, t('Save configuration'));
|
|
|
|
// Build the link we're going to test based on the clean url setting.
|
|
$link = (!empty($GLOBALS['conf']['clean_url'])) ? 'it.example.com/admin' : 'it.example.com/?q=admin';
|
|
|
|
global $is_https;
|
|
// Test URL in another language: http://it.example.com/?q=admin.
|
|
// Base path gives problems on the testbot, so $correct_link is hard-coded.
|
|
// @see UrlAlterFunctionalTest::assertUrlOutboundAlter (path.test).
|
|
$italian_url = url('admin', array('language' => $languages['it']));
|
|
$url_scheme = ($is_https) ? 'https://' : 'http://';
|
|
$correct_link = $url_scheme . $link;
|
|
$this->assertTrue($italian_url == $correct_link, t('The url() function returns the right url (@url) in accordance with the chosen language', array('@url' => $italian_url)));
|
|
|
|
// Test https via options.
|
|
variable_set('https', TRUE);
|
|
$italian_url = url('admin', array('https' => TRUE, 'language' => $languages['it']));
|
|
$correct_link = 'https://' . $link;
|
|
$this->assertTrue($italian_url == $correct_link, t('The url() function returns the right https url (via options) (@url) in accordance with the chosen language', array('@url' => $italian_url)));
|
|
variable_set('https', FALSE);
|
|
|
|
// Test https via current url scheme.
|
|
$temp_https = $is_https;
|
|
$is_https = TRUE;
|
|
$italian_url = url('admin', array('language' => $languages['it']));
|
|
$correct_link = 'https://' . $link;
|
|
$this->assertTrue($italian_url == $correct_link, t('The url() function returns the right url (via current url scheme) (@url) in accordance with the chosen language', array('@url' => $italian_url)));
|
|
$is_https = $temp_https;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test that URL rewriting works as expected.
|
|
*/
|
|
class LocaleUrlRewritingTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'URL rewriting',
|
|
'description' => 'Test that URL rewriting works as expected.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
|
|
// Create and login user.
|
|
$this->web_user = $this->drupalCreateUser(array('administer languages', 'access administration pages'));
|
|
$this->drupalLogin($this->web_user);
|
|
|
|
// Install French language.
|
|
$edit = array();
|
|
$edit['predefined_langcode'] = 'fr';
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Install Italian language.
|
|
$edit = array();
|
|
$edit['predefined_langcode'] = 'it';
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Disable Italian language.
|
|
$edit = array('languages[it][enabled]' => FALSE);
|
|
$this->drupalPost('admin/config/regional/language', $edit, t('Save configuration'));
|
|
|
|
// Enable URL language detection and selection.
|
|
$edit = array('language_interface[enabled][language-url]' => 1);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Reset static caching.
|
|
drupal_static_reset('language_list');
|
|
drupal_static_reset('language_url_outbound_alter');
|
|
drupal_static_reset('language_url_rewrite_url');
|
|
}
|
|
|
|
/**
|
|
* Check that disabled or non-installed languages are not considered.
|
|
*/
|
|
function testUrlRewritingEdgeCases() {
|
|
// Check URL rewriting with a disabled language.
|
|
$languages = language_list();
|
|
$this->checkUrl($languages['it'], t('Path language is ignored if language is disabled.'), t('URL language negotiation does not work with disabled languages'));
|
|
|
|
// Check URL rewriting with a non-installed language.
|
|
$non_existing = language_default();
|
|
$non_existing->langcode = $this->randomName();
|
|
$this->checkUrl($non_existing, t('Path language is ignored if language is not installed.'), t('URL language negotiation does not work with non-installed languages'));
|
|
}
|
|
|
|
/**
|
|
* Check URL rewriting for the given language.
|
|
*
|
|
* The test is performed with a fixed URL (the default front page) to simply
|
|
* check that language prefixes are not added to it and that the prefixed URL
|
|
* is actually not working.
|
|
*/
|
|
private function checkUrl($language, $message1, $message2) {
|
|
$options = array('language' => $language);
|
|
$base_path = trim(base_path(), '/');
|
|
$rewritten_path = trim(str_replace(array('?q=', $base_path), '', url('node', $options)), '/');
|
|
$segments = explode('/', $rewritten_path, 2);
|
|
$prefix = $segments[0];
|
|
$path = isset($segments[1]) ? $segments[1] : $prefix;
|
|
|
|
// If the rewritten URL has not a language prefix we pick a random prefix so
|
|
// we can always check the prefixed URL.
|
|
$prefixes = language_negotiation_url_prefixes();
|
|
$stored_prefix = isset($prefixes[$language->langcode]) ? $prefixes[$language->langcode] : $this->randomName();
|
|
if ($this->assertNotEqual($stored_prefix, $prefix, $message1)) {
|
|
$prefix = $stored_prefix;
|
|
}
|
|
|
|
$this->drupalGet("$prefix/$path");
|
|
$this->assertResponse(404, $message2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional test for multilingual fields.
|
|
*/
|
|
class LocaleMultilingualFieldsFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Multilingual fields',
|
|
'description' => 'Test multilingual support for fields.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('node', 'locale'));
|
|
|
|
// Create Basic page node type.
|
|
$this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
|
|
|
|
// Setup users.
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'administer content types', 'access administration pages', 'create page content', 'edit own page content'));
|
|
$this->drupalLogin($admin_user);
|
|
|
|
// Add a new language.
|
|
$language = (object) array(
|
|
'langcode' => 'it',
|
|
'name' => 'Italian',
|
|
);
|
|
language_save($language);
|
|
|
|
// Enable URL language detection and selection.
|
|
$edit = array('language_interface[enabled][language-url]' => '1');
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Set "Basic page" content type to use multilingual support.
|
|
$edit = array(
|
|
'node_type_language' => 1,
|
|
);
|
|
$this->drupalPost('admin/structure/types/manage/page', $edit, t('Save content type'));
|
|
$this->assertRaw(t('The content type %type has been updated.', array('%type' => 'Basic page')), t('Basic page content type has been updated.'));
|
|
|
|
// Make node body translatable.
|
|
$field = field_info_field('body');
|
|
$field['translatable'] = TRUE;
|
|
field_update_field($field);
|
|
}
|
|
|
|
/**
|
|
* Test if field languages are correctly set through the node form.
|
|
*/
|
|
function testMultilingualNodeForm() {
|
|
// Create "Basic page" content.
|
|
$langcode = LANGUAGE_NOT_SPECIFIED;
|
|
$title_key = "title";
|
|
$title_value = $this->randomName(8);
|
|
$body_key = "body[$langcode][0][value]";
|
|
$body_value = $this->randomName(16);
|
|
|
|
// Create node to edit.
|
|
$edit = array();
|
|
$edit[$title_key] = $title_value;
|
|
$edit[$body_key] = $body_value;
|
|
$edit['langcode'] = 'en';
|
|
$this->drupalPost('node/add/page', $edit, t('Save'));
|
|
|
|
// Check that the node exists in the database.
|
|
$node = $this->drupalGetNodeByTitle($edit[$title_key]);
|
|
$this->assertTrue($node, t('Node found in database.'));
|
|
|
|
$assert = isset($node->body['en']) && !isset($node->body[LANGUAGE_NOT_SPECIFIED]) && $node->body['en'][0]['value'] == $body_value;
|
|
$this->assertTrue($assert, t('Field language correctly set.'));
|
|
|
|
// Change node language.
|
|
$this->drupalGet("node/$node->nid/edit");
|
|
$edit = array(
|
|
$title_key => $this->randomName(8),
|
|
'langcode' => 'it'
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save'));
|
|
$node = $this->drupalGetNodeByTitle($edit[$title_key]);
|
|
$this->assertTrue($node, t('Node found in database.'));
|
|
|
|
$assert = isset($node->body['it']) && !isset($node->body['en']) && $node->body['it'][0]['value'] == $body_value;
|
|
$this->assertTrue($assert, t('Field language correctly changed.'));
|
|
|
|
// Enable content language URL detection.
|
|
language_negotiation_set(LANGUAGE_TYPE_CONTENT, array(LANGUAGE_NEGOTIATION_URL => 0));
|
|
|
|
// Test multilingual field language fallback logic.
|
|
$this->drupalGet("it/node/$node->nid");
|
|
$this->assertRaw($body_value, t('Body correctly displayed using Italian as requested language'));
|
|
|
|
$this->drupalGet("node/$node->nid");
|
|
$this->assertRaw($body_value, t('Body correctly displayed using English as requested language'));
|
|
}
|
|
|
|
/*
|
|
* Test multilingual field display settings.
|
|
*/
|
|
function testMultilingualDisplaySettings() {
|
|
// Create "Basic page" content.
|
|
$langcode = LANGUAGE_NOT_SPECIFIED;
|
|
$title_key = "title";
|
|
$title_value = $this->randomName(8);
|
|
$body_key = "body[$langcode][0][value]";
|
|
$body_value = $this->randomName(16);
|
|
|
|
// Create node to edit.
|
|
$edit = array();
|
|
$edit[$title_key] = $title_value;
|
|
$edit[$body_key] = $body_value;
|
|
$edit['langcode'] = 'en';
|
|
$this->drupalPost('node/add/page', $edit, t('Save'));
|
|
|
|
// Check that the node exists in the database.
|
|
$node = $this->drupalGetNodeByTitle($edit[$title_key]);
|
|
$this->assertTrue($node, t('Node found in database.'));
|
|
|
|
// Check if node body is showed.
|
|
$this->drupalGet("node/$node->nid");
|
|
$body = $this->xpath('//article[@id=:id]//div[@class=:class]/descendant::p', array(
|
|
':id' => 'node-' . $node->nid,
|
|
':class' => 'content',
|
|
));
|
|
$this->assertEqual(current($body), $node->body['en'][0]['value'], 'Node body found.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for comment language.
|
|
*/
|
|
class LocaleCommentLanguageFunctionalTest extends DrupalWebTestCase {
|
|
protected $profile = 'standard';
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Comment language',
|
|
'description' => 'Tests for comment language.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale', 'locale_test');
|
|
|
|
// Create and login user.
|
|
$admin_user = $this->drupalCreateUser(array('administer site configuration', 'administer languages', 'access administration pages', 'administer content types', 'create article content'));
|
|
$this->drupalLogin($admin_user);
|
|
|
|
// Add language.
|
|
$edit = array('predefined_langcode' => 'fr');
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Set "Article" content type to use multilingual support.
|
|
$edit = array('node_type_language' => 1);
|
|
$this->drupalPost('admin/structure/types/manage/article', $edit, t('Save content type'));
|
|
|
|
// Enable content language negotiation UI.
|
|
variable_set('locale_test_content_language_type', TRUE);
|
|
|
|
// Set interface language detection to user and content language detection
|
|
// to URL. Disable inheritance from interface language to ensure content
|
|
// language will fall back to the default language if no URL language can be
|
|
// detected.
|
|
$edit = array(
|
|
'language_interface[enabled][language-user]' => TRUE,
|
|
'language_content[enabled][language-url]' => TRUE,
|
|
'language_content[enabled][language-interface]' => FALSE,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Change user language preference, this way interface language is always
|
|
// French no matter what path prefix the URLs have.
|
|
$edit = array('preferred_langcode' => 'fr');
|
|
$this->drupalPost("user/{$admin_user->uid}/edit", $edit, t('Save'));
|
|
}
|
|
|
|
/**
|
|
* Test that comment language is properly set.
|
|
*/
|
|
function testCommentLanguage() {
|
|
drupal_static_reset('language_list');
|
|
|
|
// Create two nodes, one for english and one for french, and comment each
|
|
// node using both english and french as content language by changing URL
|
|
// language prefixes. Meanwhile interface language is always French, which
|
|
// is the user language preference. This way we can ensure that node
|
|
// language and interface language do not influence comment language, as
|
|
// only content language has to.
|
|
foreach (language_list() as $node_langcode => $node_language) {
|
|
$langcode_not_specified = LANGUAGE_NOT_SPECIFIED;
|
|
|
|
// Create "Article" content.
|
|
$title = $this->randomName();
|
|
$edit = array(
|
|
"title" => $title,
|
|
"body[$langcode_not_specified][0][value]" => $this->randomName(),
|
|
"langcode" => $node_langcode,
|
|
);
|
|
$this->drupalPost("node/add/article", $edit, t('Save'));
|
|
$node = $this->drupalGetNodeByTitle($title);
|
|
|
|
$prefixes = language_negotiation_url_prefixes();
|
|
foreach (language_list() as $langcode => $language) {
|
|
// Post a comment with content language $langcode.
|
|
$prefix = empty($prefixes[$langcode]) ? '' : $prefixes[$langcode] . '/';
|
|
$edit = array("comment_body[$langcode_not_specified][0][value]" => $this->randomName());
|
|
$this->drupalPost("{$prefix}node/{$node->nid}", $edit, t('Save'));
|
|
|
|
// Check that comment language matches the current content language.
|
|
$comment = db_select('comment', 'c')
|
|
->fields('c')
|
|
->condition('nid', $node->nid)
|
|
->orderBy('cid', 'DESC')
|
|
->execute()
|
|
->fetchObject();
|
|
$args = array('%node_language' => $node_langcode, '%comment_language' => $comment->langcode, '%langcode' => $langcode);
|
|
$this->assertEqual($comment->langcode, $langcode, t('The comment posted with content language %langcode and belonging to the node with language %node_language has language %comment_language', $args));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for localizing date formats.
|
|
*/
|
|
class LocaleDateFormatsFunctionalTest extends DrupalWebTestCase {
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Localize date formats',
|
|
'description' => 'Tests for the localization of date formats.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('node', 'locale'));
|
|
|
|
// Create Article node type.
|
|
$this->drupalCreateContentType(array('type' => 'article', 'name' => 'Article'));
|
|
|
|
// Create and login user.
|
|
$admin_user = $this->drupalCreateUser(array('administer site configuration', 'administer languages', 'access administration pages', 'create article content'));
|
|
$this->drupalLogin($admin_user);
|
|
}
|
|
|
|
/**
|
|
* Functional tests for localizing date formats.
|
|
*/
|
|
function testLocalizeDateFormats() {
|
|
// Add language.
|
|
$edit = array(
|
|
'predefined_langcode' => 'fr',
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));
|
|
|
|
// Set language negotiation.
|
|
$language_type = LANGUAGE_TYPE_INTERFACE;
|
|
$edit = array(
|
|
"{$language_type}[enabled][language-url]" => TRUE,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Configure date formats.
|
|
$this->drupalGet('admin/config/regional/date-time/locale');
|
|
$this->assertText('French', 'Configured languages appear.');
|
|
$edit = array(
|
|
'date_format_long' => 'd.m.Y - H:i',
|
|
'date_format_medium' => 'd.m.Y - H:i',
|
|
'date_format_short' => 'd.m.Y - H:i',
|
|
);
|
|
$this->drupalPost('admin/config/regional/date-time/locale/fr/edit', $edit, t('Save configuration'));
|
|
$this->assertText(t('Configuration saved.'), 'French date formats updated.');
|
|
$edit = array(
|
|
'date_format_long' => 'j M Y - g:ia',
|
|
'date_format_medium' => 'j M Y - g:ia',
|
|
'date_format_short' => 'j M Y - g:ia',
|
|
);
|
|
$this->drupalPost('admin/config/regional/date-time/locale/en/edit', $edit, t('Save configuration'));
|
|
$this->assertText(t('Configuration saved.'), 'English date formats updated.');
|
|
|
|
// Create node content.
|
|
$node = $this->drupalCreateNode(array('type' => 'article'));
|
|
|
|
// Configure format for the node posted date changes with the language.
|
|
$this->drupalGet('node/' . $node->nid);
|
|
$english_date = format_date($node->created, 'custom', 'j M Y');
|
|
$this->assertText($english_date, t('English date format appears'));
|
|
$this->drupalGet('fr/node/' . $node->nid);
|
|
$french_date = format_date($node->created, 'custom', 'd.m.Y');
|
|
$this->assertText($french_date, t('French date format appears'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional test for language types/negotiation info.
|
|
*/
|
|
class LocaleLanguageNegotiationInfoFunctionalTest extends DrupalWebTestCase {
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Language negotiation info',
|
|
'description' => 'Tests alterations to language types/negotiation info.',
|
|
'group' => 'Locale',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('locale');
|
|
require_once DRUPAL_ROOT .'/core/includes/language.inc';
|
|
$admin_user = $this->drupalCreateUser(array('administer languages', 'access administration pages', 'view the administration theme'));
|
|
$this->drupalLogin($admin_user);
|
|
$this->drupalPost('admin/config/regional/language/add', array('predefined_langcode' => 'it'), t('Add language'));
|
|
}
|
|
|
|
/**
|
|
* Tests alterations to language types/negotiation info.
|
|
*/
|
|
function testInfoAlterations() {
|
|
// Enable language type/negotiation info alterations.
|
|
variable_set('locale_test_language_types', TRUE);
|
|
variable_set('locale_test_language_negotiation_info', TRUE);
|
|
$this->languageNegotiationUpdate();
|
|
|
|
// Check that fixed language types are properly configured without the need
|
|
// of saving the language negotiation settings.
|
|
$this->checkFixedLanguageTypes();
|
|
|
|
// Make the content language type configurable by updating the language
|
|
// negotiation settings with the proper flag enabled.
|
|
variable_set('locale_test_content_language_type', TRUE);
|
|
$this->languageNegotiationUpdate();
|
|
$type = LANGUAGE_TYPE_CONTENT;
|
|
$language_types = variable_get('language_types', language_types_get_default());
|
|
$this->assertTrue($language_types[$type], t('Content language type is configurable.'));
|
|
|
|
// Enable some core and custom language negotiation methods. The test
|
|
// language type is supposed to be configurable.
|
|
$test_type = 'test_language_type';
|
|
$interface_method_id = LANGUAGE_NEGOTIATION_INTERFACE;
|
|
$test_method_id = 'test_language_negotiation_method';
|
|
$form_field = $type . '[enabled]['. $interface_method_id .']';
|
|
$edit = array(
|
|
$form_field => TRUE,
|
|
$type . '[enabled][' . $test_method_id . ']' => TRUE,
|
|
$test_type . '[enabled][' . $test_method_id . ']' => TRUE,
|
|
);
|
|
$this->drupalPost('admin/config/regional/language/detection', $edit, t('Save settings'));
|
|
|
|
// Remove the interface language negotiation method by updating the language
|
|
// negotiation settings with the proper flag enabled.
|
|
variable_set('locale_test_language_negotiation_info_alter', TRUE);
|
|
$this->languageNegotiationUpdate();
|
|
$negotiation = variable_get("language_negotiation_$type", array());
|
|
$this->assertFalse(isset($negotiation[$interface_method_id]), t('Interface language negotiation method removed from the stored settings.'));
|
|
$this->assertNoFieldByXPath("//input[@name=\"$form_field\"]", NULL, t('Interface language negotiation method unavailable.'));
|
|
|
|
// Check that type-specific language negotiation methods can be assigned
|
|
// only to the corresponding language types.
|
|
foreach (language_types_get_configurable() as $type) {
|
|
$form_field = $type . '[enabled][test_language_negotiation_method_ts]';
|
|
if ($type == $test_type) {
|
|
$this->assertFieldByXPath("//input[@name=\"$form_field\"]", NULL, t('Type-specific test language negotiation method available for %type.', array('%type' => $type)));
|
|
}
|
|
else {
|
|
$this->assertNoFieldByXPath("//input[@name=\"$form_field\"]", NULL, t('Type-specific test language negotiation method unavailable for %type.', array('%type' => $type)));
|
|
}
|
|
}
|
|
|
|
// Check language negotiation results.
|
|
$this->drupalGet('');
|
|
$last = variable_get('locale_test_language_negotiation_last', array());
|
|
foreach (language_types_get_all() as $type) {
|
|
$langcode = $last[$type];
|
|
$value = $type == LANGUAGE_TYPE_CONTENT || strpos($type, 'test') !== FALSE ? 'it' : 'en';
|
|
$this->assertEqual($langcode, $value, t('The negotiated language for %type is %language', array('%type' => $type, '%language' => $langcode)));
|
|
}
|
|
|
|
// Disable locale_test and check that everything is set back to the original
|
|
// status.
|
|
$this->languageNegotiationUpdate('disable');
|
|
|
|
// Check that only the core language types are available.
|
|
foreach (language_types_get_all() as $type) {
|
|
$this->assertTrue(strpos($type, 'test') === FALSE, t('The %type language is still available', array('%type' => $type)));
|
|
}
|
|
|
|
// Check that fixed language types are properly configured, even those
|
|
// previously set to configurable.
|
|
$this->checkFixedLanguageTypes();
|
|
|
|
// Check that unavailable language negotiation methods are not present in
|
|
// the negotiation settings.
|
|
$negotiation = variable_get("language_negotiation_$type", array());
|
|
$this->assertFalse(isset($negotiation[$test_method_id]), t('The disabled test language negotiation method is not part of the content language negotiation settings.'));
|
|
|
|
// Check that configuration page presents the correct options and settings.
|
|
$this->assertNoRaw(t('Test language detection'), t('No test language type configuration available.'));
|
|
$this->assertNoRaw(t('This is a test language negotiation method'), t('No test language negotiation method available.'));
|
|
}
|
|
|
|
/**
|
|
* Update language types/negotiation information.
|
|
*
|
|
* Manually invoke locale_modules_enabled()/locale_modules_disabled() since
|
|
* they would not be invoked after enabling/disabling locale_test the first
|
|
* time.
|
|
*/
|
|
protected function languageNegotiationUpdate($op = 'enable') {
|
|
static $last_op = NULL;
|
|
$modules = array('locale_test');
|
|
|
|
// Enable/disable locale_test only if we did not already before.
|
|
if ($last_op != $op) {
|
|
$function = "module_{$op}";
|
|
$function($modules);
|
|
// Reset hook implementation cache.
|
|
module_implements_reset();
|
|
}
|
|
|
|
drupal_static_reset('language_types_info');
|
|
drupal_static_reset('language_negotiation_info');
|
|
$function = "language_modules_{$op}d";
|
|
if (function_exists($function)) {
|
|
$function($modules);
|
|
}
|
|
|
|
$this->drupalGet('admin/config/regional/language/detection');
|
|
}
|
|
|
|
/**
|
|
* Check that language negotiation for fixed types matches the stored one.
|
|
*/
|
|
protected function checkFixedLanguageTypes() {
|
|
drupal_static_reset('language_types_info');
|
|
foreach (language_types_info() as $type => $info) {
|
|
if (isset($info['fixed'])) {
|
|
$negotiation = variable_get("language_negotiation_$type", array());
|
|
$equal = count($info['fixed']) == count($negotiation);
|
|
while ($equal && list($id) = each($negotiation)) {
|
|
list(, $info_id) = each($info['fixed']);
|
|
$equal = $info_id == $id;
|
|
}
|
|
$this->assertTrue($equal, t('language negotiation for %type is properly set up', array('%type' => $type)));
|
|
}
|
|
}
|
|
}
|
|
}
|