materio-base-d7/sites/all/modules/contrib/localisation/tmgmt/tests/tmgmt.base.entity.test

<?php

/*
 * @file
 * Contains tests for Translation management
 */

/**
 * Utility test case class with helper methods to create entities and their
 * fields with populated translatable content. Extend this class if you create
 * tests in which you need Drupal entities and/or fields.
 */
abstract class TMGMTEntityTestCaseUtility extends TMGMTBaseTestCase {

  public $field_names = array();

  /**
   * Creates node type with several text fields with different cardinality.
   *
   * Internally it calls TMGMTEntityTestCaseUtility::attachFields() to create
   * and attach fields to newly created bundle. You can than use
   * $this->field_names['node']['YOUR_BUNDLE_NAME'] to access them.
   *
   * @param string $machine_name
   *   Machine name of the node type.
   * @param string $human_name
   *   Human readable name of the node type.
   * @param int $language_content_type
   *   Either 0 (disabled), 1 (language enabled but no translations),
   *   TRANSLATION_ENABLED or ENTITY_TRANSLATION_ENABLED.
   * pparam bool $attach_fields
   *   (optional) If fields with the same translatability should automatically
   *   be attached to the node type.
   */
  function createNodeType($machine_name, $human_name, $language_content_type = 0, $attach_fields = TRUE) {

    // Create new bundle.
    $type = array(
      'type' => $machine_name,
      'name' => $human_name,
      'base' => 'node_content',
      'description' => '',
      'custom' => 1,
      'modified' => 1,
      'locked' => 0,
    );
    $type = node_type_set_defaults($type);
    node_type_save($type);
    node_add_body_field($type);
    node_types_rebuild();

    // Set content type to be translatable as specified by
    // $language_content_type.
    $edit = array();
    $edit['language_content_type'] = $language_content_type;
    $this->drupalPost('admin/structure/types/manage/' . $machine_name, $edit, t('Save content type'));

    $translatable = FALSE;
    if (defined('ENTITY_TRANSLATION_ENABLED') && $language_content_type == ENTITY_TRANSLATION_ENABLED) {
      $translatable = TRUE;
    }

    // Push in also the body field.
    $this->field_names['node'][$machine_name][] = 'body';

    if ($attach_fields) {
      $this->attachFields('node', $machine_name, $translatable);
    }

    // Change body field to be translatable.
    $body = field_info_field('body');
    $body['translatable'] = $translatable;
    field_update_field($body);
  }

  /**
   * Creates taxonomy vocabulary with custom fields.
   *
   * To create and attach fields it internally calls
   * TMGMTEntityTestCaseUtility::attachFields(). You can than access these
   * fields calling $this->field_names['node']['YOUR_BUNDLE_NAME'].
   *
   * @param string $machine_name
   *   Vocabulary machine name.
   * @param string $human_name
   *   Vocabulary human readable name.
   * @param bool|array $fields_translatable
   *   Flag or definition array to determine which or all fields should be
   *   translatable.
   *
   * @return stdClass
   *   Created vocabulary object.
   */
  function createTaxonomyVocab($machine_name, $human_name, $fields_translatable = TRUE) {
    $vocabulary = new stdClass();
    $vocabulary->name = $human_name;
    $vocabulary->machine_name = $machine_name;
    taxonomy_vocabulary_save($vocabulary);

    $this->attachFields('taxonomy_term', $vocabulary->machine_name, $fields_translatable);

    return $vocabulary;
  }

  /**
   * Creates fields of type text and text_with_summary of different cardinality.
   *
   * It will attach created fields to provided entity name and bundle.
   *
   * Field names will be stored in $this->field_names['entity']['bundle']
   * through which you can access them.
   *
   * @param string $entity_name
   *   Entity name to which fields should be attached.
   * @param string $bundle
   *   Bundle name to which fields should be attached.
   * @param bool|array $translatable
   *   Flag or definition array to determine which or all fields should be
   *   translatable.
   */
  function attachFields($entity_name, $bundle, $translatable = TRUE) {
    // Create several text fields.
    $field_types = array('text', 'text_with_summary');

    for ($i = 0 ; $i <= 5; $i++) {
      $field_type = $field_types[array_rand($field_types, 1)];
      $field_name = drupal_strtolower($this->randomName());

      // Create a field.
      $field = array(
        'field_name' => $field_name,
        'type' => $field_type,
        'cardinality' => mt_rand(1, 5),
        'translatable' => is_array($translatable) && isset($translatable[$i]) ? $translatable[$i] : (boolean) $translatable,
      );
      field_create_field($field);

      // Create an instance of the previously created field.
      $instance = array(
        'field_name' => $field_name,
        'entity_type' => $entity_name,
        'bundle' => $bundle,
        'label' => $this->randomName(10),
        'description' => $this->randomString(30),
        'widget' => array(
          'type' => $field_type == 'text' ? 'text_textfield' : 'text_textarea_with_summary',
          'label' => $this->randomString(10),
        ),
      );
      field_create_instance($instance);

      // Store field names in case there are needed outside this method.
      $this->field_names[$entity_name][$bundle][] = $field_name;
    }
  }

  /**
   * Creates a node of a given bundle.
   *
   * It uses $this->field_names to populate content of attached fields.
   *
   * @param string $bundle
   *   Node type name.
   * @param string $sourcelang
   *   Source lang of the node to be created.
   *
   * @return object
   *   Newly created node object.
   */
  function createNode($bundle, $sourcelang = 'en') {
    $node = array(
      'type' => $bundle,
      'language' => $sourcelang,
      // Ensure that the body field is defined for the node language.
      'body' => array($sourcelang => array(0 => array())),
    );

    foreach ($this->field_names['node'][$bundle] as $field_name) {
      $field_info = field_info_field($field_name);
      $cardinality = $field_info['cardinality'] == FIELD_CARDINALITY_UNLIMITED ? 1 : $field_info['cardinality'];
      $field_langcode = field_is_translatable('node', $field_info) ? $sourcelang : LANGUAGE_NONE;

      // Create two deltas for each field.
      for ($delta = 0; $delta <= $cardinality; $delta++) {
        $node[$field_name][$field_langcode][$delta]['value'] = $this->randomName(20);
        if ($field_info['type'] == 'text_with_summary') {
          $node[$field_name][$field_langcode][$delta]['summary'] = $this->randomName(10);
        }
      }
    }

    return $this->drupalCreateNode($node);
  }

  /**
   * Creates a taxonomy term of a given vocabulary.
   *
   * It uses $this->field_names to populate content of attached fields. You can
   * access fields values using
   * $this->field_names['taxonomy_term'][$vocabulary->machine_name].
   *
   * @param object $vocabulary
   *   Vocabulary object for which the term should be created.
   *
   * @param string $langcode
   *   The language code to be set as the entity source language.
   *
   * @return object
   *   Newly created node object.
   */
  function createTaxonomyTerm($vocabulary, $langcode = 'en') {

    // When an entity is being saved, the entity_translation module initializes
    // a translation fetching the language from an entity. But the taxonomy
    // terms have no entity language key, so its langcode will be the set to the
    // default one.
    /* @see entity_translation_field_attach_insert() */
    /* @see EntityTranslationDefaultHandler::initTranslations() */
    /* @see EntityTranslationDefaultHandler::getLanguage() */
    $settings_variable_name = 'entity_translation_settings_taxonomy_term__' . $vocabulary->machine_name;
    variable_set($settings_variable_name, array('default_language' => $langcode));

    $term = new stdClass();
    $term->name = $this->randomName();
    $term->description = $this->randomName();
    $term->vid = $vocabulary->vid;

    foreach ($this->field_names['taxonomy_term'][$vocabulary->machine_name] as $field_name) {
      $field_info = field_info_field($field_name);
      $cardinality = $field_info['cardinality'] == FIELD_CARDINALITY_UNLIMITED ? 1 : $field_info['cardinality'];
      $field_lang = $field_info['translatable'] ? $langcode : LANGUAGE_NONE;

      // Create two deltas for each field.
      for ($delta = 0; $delta <= $cardinality; $delta++) {
        $term->{$field_name}[$field_lang][$delta]['value'] = $this->randomName(20);
        if ($field_info['type'] == 'text_with_summary') {
          $term->{$field_name}[$field_lang][$delta]['summary'] = $this->randomName(10);
        }
      }
    }

    taxonomy_term_save($term);
    return taxonomy_term_load($term->tid);
  }
}