i18n_taxonomy.test in Internationalization 7

Test case for multilingual taxonomy

File

i18n_taxonomy/i18n_taxonomy.test

<?php

/**
 * @file
 * Test case for multilingual taxonomy
 */
class i18nTaxonomyTestCase extends Drupali18nTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Taxonomy translation',
      'group' => 'Internationalization',
      'description' => 'Taxonomy translation functions',
    );
  }
  function setUp() {
    parent::setUp(array(
      'i18n_taxonomy',
      'field_test',
    ));
    parent::setUpLanguages();

    // Create users.
    $filtered_html_format = filter_format_load('filtered_html');
    $full_html_format = filter_format_load('full_html');
    $this->admin_user = $this
      ->drupalCreateUser(array(
      'access field_test content',
      'administer field_test content',
      'administer taxonomy',
      'administer languages',
      'administer site configuration',
      filter_permission_name($filtered_html_format),
      filter_permission_name($full_html_format),
    ));
    $this->translator = $this
      ->drupalCreateUser(array(
      'translate interface',
      'translate user-defined strings',
    ));
  }
  function testTaxonomyTermLocalize() {
    $this
      ->drupalLogin($this->admin_user);

    // Make Input Format "Filter Text" translatable
    $edit = array(
      'i18n_string_allowed_formats[filtered_html]' => 'filtered_html',
      'i18n_string_allowed_formats[plain_text]' => 'plain_text',
    );
    $this
      ->drupalPost('admin/config/regional/i18n/strings', $edit, t('Save configuration'));

    // Create a localizable vocabulary.
    $vocab = $this
      ->createVocabulary(array(
      'i18n_mode' => I18N_MODE_LOCALIZE,
    ));
    $this
      ->assertEqual(i18n_taxonomy_vocabulary_mode($vocab->vid), I18N_MODE_LOCALIZE, 'A vocabulary has been created and it is localizable.');
    $this->field_name = $this
      ->createTermField($vocab->machine_name);

    // Create a term to be localized. We use a common prefix to facilitate the testing of autocomplete suggestions.
    $prefix = $this
      ->randomName() . '_';
    $term = $this
      ->createTerm(array(
      'vid' => $vocab->vid,
      'name' => $prefix . $this
        ->randomName(),
    ));
    $this
      ->drupalLogin($this->translator);

    // Create and Save Spanish translation, again using the same prefix.
    $term_translation = array(
      'name' => $this
        ->createStringTranslation('taxonomy', $term->name, array(
        $this->secondary_language => $prefix . $this
          ->randomName(),
      )),
      'description' => $this
        ->createStringTranslation('taxonomy', $term->description, array(
        $this->secondary_language => $prefix . $this
          ->randomName(),
      )),
    );
    $this
      ->drupalLogin($this->admin_user);
    $langcode = LANGUAGE_NONE;
    $edit = array(
      "{$this->field_name}[{$langcode}]" => array(
        $term->tid,
      ),
    );

    // Test the widgets in the original language.
    $this
      ->drupalGet('test-entity/add/test-bundle');
    $this
      ->assertText($term->name, 'Widget values are displayed correctly in default language.');
    $this
      ->drupalPost(NULL, $edit, t('Save'));
    $this
      ->assertText($term->name, 'Field values are displayed correctly in default language.');

    // Terms should be localized in the field widget.
    $this
      ->drupalGet($this->secondary_language . '/test-entity/add/test-bundle');
    $this
      ->assertText($term_translation['name'][$this->secondary_language], 'Widget values are displayed correctly in non-default languages.');
    $this
      ->drupalPost(NULL, $edit, t('Save'));
    $this
      ->assertText($term_translation['name'][$this->secondary_language], 'Field values are displayed correctly in non-default languages.');

    // Term name and term description should be localized
    $this
      ->drupalGet('taxonomy/term/' . $term->tid, array(
      'language' => i18n_language_object($this->default_language),
    ));
    $this
      ->assertText($term->name, 'Term title is displayed correctly in default language.');
    $this
      ->assertText($term->description, 'Term description is displayed correctly in default language.');

    // Term name and term description should be localized
    $this
      ->drupalGet('taxonomy/term/' . $term->tid, array(
      'language' => i18n_language_object($this->secondary_language),
    ));
    $this
      ->assertText($term_translation['name'][$this->secondary_language], 'Term title is displayed correctly in non-default language.');
    $this
      ->assertText($term_translation['description'][$this->secondary_language], 'Term description is displayed correctly in non-default language.');

    // Autocomplete should respect localization.
    $autocomplete_path = 'taxonomy/autocomplete/' . $this->field_name . '/' . $prefix;
    $autocomplete_values = $this
      ->drupalGetAJAX($autocomplete_path);
    $this
      ->assertTrue(isset($autocomplete_values[$term->name]), 'Correct autocomplete suggestions in default language.');
    $this
      ->assertFalse(isset($autocomplete_values[$term_translation['name'][$this->secondary_language]]), 'No incorrect autocomplete suggestions in non-default languages');

    // Autocomplete should respect localization, but doesn't.
    //   $autocomplete_path = $this->secondary_language . '/taxonomy/autocomplete/' . $this->field_name . '/' . $prefix;
    //   $autocomplete_values = $this->drupalGetAJAX($autocomplete_path);
    //   $this->assertFalse(isset($autocomplete_values[$term->name]), 'Correct autocomplete suggestions in non-default languages.');
    //   $this->assertTrue(isset($autocomplete_values[$term_translation[$this->secondary_language]]), 'No incorrect autocomplete suggestions in non-default languages.');
  }
  function testTaxonomyTermTranslate() {

    // Create a translateable vocabulary.
    $vocab = $this
      ->createVocabulary(array(
      'i18n_mode' => I18N_MODE_TRANSLATE,
    ));
    $this
      ->assertEqual(i18n_taxonomy_vocabulary_mode($vocab->vid), I18N_MODE_TRANSLATE, 'A vocabulary has been created and it is translateable.');
    $this->field_select = $this
      ->createTermField($vocab->machine_name);
    $this->field_autocomplete = $this
      ->createTermField($vocab->machine_name, 'taxonomy_autocomplete');

    // Create a term to be translated.
    $en_term = $this
      ->createTerm(array(
      'vid' => $vocab->vid,
      'language' => $this->default_language,
    ));
    $es_term = $this
      ->createTerm(array(
      'vid' => $vocab->vid,
      'language' => $this->secondary_language,
    ));
    $this
      ->drupalLogin($this->admin_user);

    // Set terms as translations of each other.
    $edit = array(
      'translations[' . $this->default_language . ']' => $en_term->name,
      'translations[' . $this->secondary_language . ']' => $es_term->name,
    );
    $this
      ->drupalPost('admin/structure/taxonomy/' . $vocab->machine_name . '/list/sets/add', $edit, t('Save'));
    $this
      ->drupalGet('admin/structure/taxonomy/' . $vocab->machine_name . '/list/sets');

    // Freetagging creates terms with the correct language.
    $new_term_name = $this
      ->randomName();
    $langcode = LANGUAGE_NONE;
    $edit = array(
      "{$this->field_autocomplete}[{$langcode}]" => $new_term_name,
    );
    $this
      ->drupalPost($this->secondary_language . '/test-entity/add/test-bundle', $edit, t('Save'));
    $new_term = current(taxonomy_get_term_by_name($new_term_name));
    $this
      ->assertEqual($new_term->language, $this->secondary_language, 'Freetagging creates terms with the correct language.');

    // Term translations are used for language switching.
    $language_switcher = language_negotiation_get_switch_links(LANGUAGE_TYPE_INTERFACE, 'taxonomy/term/' . $en_term->tid);
    $this
      ->assertEqual($language_switcher->links[$this->secondary_language]['href'], 'taxonomy/term/' . $es_term->tid, 'Term translations are used for language switching.');
  }

  /**
   * Tests the implementation of 'options_list_callback' for term reference fields.
   * Enable and disable the callback properly. Avoid WSOD!
   */
  function testTaxonomyFieldCallback() {
    $field_name = 'taxonomy_term_test_field';
    $field = field_create_field(array(
      'field_name' => $field_name,
      'type' => 'taxonomy_term_reference',
    ));
    $field = field_info_field($field_name);
    $callback = 'i18n_taxonomy_allowed_values';
    $this
      ->assertTrue(function_exists($callback), "Function {$callback} exists.");
    $this
      ->assertEqual($field['settings']['options_list_callback'], $callback, "{$callback} ist option list callback.");
    module_disable(array(
      'i18n_taxonomy',
    ));
    $field = field_info_field($field_name);
    $this
      ->assertNotEqual($field['settings']['options_list_callback'], $callback, "{$callback} ist option list callback.");
  }

  // Create vocabulary with given fields
  function drupalCreateVocabulary($vocab = array()) {
    $vocab += array(
      'name' => $this
        ->randomName(10),
      'description' => $this
        ->randomName(20),
    );
    taxonomy_vocabulary_save($vocab);
    return (object) $vocab;
  }

  // Create term with given fields
  function drupalCreateTerms($number = 1, $data = array()) {
    $list = array();
    for ($i = 1; $i <= $number; $i++) {
      $term = $this
        ->createTerm($data);
      $list[$term->tid] = $term;
    }
    return $list;
  }

  /**
   * Returns a new vocabulary with random properties.
   */
  function createVocabulary($data = array()) {

    // Create a vocabulary.
    $data += array(
      'i18n_mode' => I18N_MODE_LOCALIZE,
      'name' => $this
        ->randomName(),
      'description' => $this
        ->randomName(),
      'machine_name' => drupal_strtolower($this
        ->randomName()),
      'help' => '',
      'nodes' => array(
        'article' => 'article',
      ),
      'weight' => mt_rand(0, 10),
    );
    $vocabulary = (object) $data;
    taxonomy_vocabulary_save($vocabulary);
    return $vocabulary;
  }

  /**
   * Returns a new term with random properties in vocabulary $vid.
   */
  function createTerm($data = array()) {
    $data += array(
      'name' => $this
        ->randomName(),
      'description' => $this
        ->randomName(),
      // Use the first available text format and vocabulary.
      'format' => filter_default_format(),
      'vid' => 1,
    );
    $term = (object) $data;
    taxonomy_term_save($term);
    return $term;
  }

  /**
   * Setup a field and instance.
   */
  function createTermField($machine_name, $widget = 'options_select') {
    $field_name = drupal_strtolower($this
      ->randomName());
    $this->field = array(
      'field_name' => $field_name,
      'type' => 'taxonomy_term_reference',
      'settings' => array(
        'allowed_values' => array(
          array(
            'vocabulary' => $machine_name,
            'parent' => '0',
          ),
        ),
      ),
    );
    field_create_field($this->field);
    $this->instance = array(
      'field_name' => $field_name,
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
      'widget' => array(
        'type' => $widget,
      ),
      'display' => array(
        'full' => array(
          'type' => 'taxonomy_term_reference_link',
        ),
      ),
    );
    field_create_instance($this->instance);
    return $field_name;
  }

}

Classes

Name	Description
i18nTaxonomyTestCase	@file Test case for multilingual taxonomy