<?php

/**

 * @file

 * Tests for taxonomy.module.

 */

/**

 * Provides common helper methods for Taxonomy module tests.

 */

class TaxonomyWebTestCase extends DrupalWebTestCase {

  /**

   * Returns a new vocabulary with random properties.

   */

  function createVocabulary() {

    // Create a vocabulary.

    $vocabulary = new stdClass();

    $vocabulary->name = $this->randomName();

    $vocabulary->description = $this->randomName();

    $vocabulary->machine_name = drupal_strtolower($this->randomName());

    $vocabulary->help = '';

    $vocabulary->nodes = array('article' => 'article');

    $vocabulary->weight = mt_rand(0, 10);

    taxonomy_vocabulary_save($vocabulary);

    return $vocabulary;

  }

  /**

   * Returns a new term with random properties in vocabulary $vid.

   */

  function createTerm($vocabulary) {

    $term = new stdClass();

    $term->name = $this->randomName();

    $term->description = $this->randomName();

    // Use the first available text format.

    $term->format = db_query_range('SELECT format FROM {filter_format}', 0, 1)->fetchField();

    $term->vid = $vocabulary->vid;

    taxonomy_term_save($term);

    return $term;

  }

}

/**

 * Tests the taxonomy vocabulary interface.

 */

class TaxonomyVocabularyFunctionalTest extends TaxonomyWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Taxonomy vocabulary interface',

      'description' => 'Test the taxonomy vocabulary interface.',

      'group' => 'Taxonomy',

    );

  }

  function setUp() {

    parent::setUp();

    $this->admin_user = $this->drupalCreateUser(array('administer taxonomy'));

    $this->drupalLogin($this->admin_user);

    $this->vocabulary = $this->createVocabulary();

  }

  /**

   * Create, edit and delete a vocabulary via the user interface.

   */

  function testVocabularyInterface() {

    // Visit the main taxonomy administration page.

    $this->drupalGet('admin/structure/taxonomy');

    // Create a new vocabulary.

    $this->clickLink(t('Add vocabulary'));

    $edit = array();

    $machine_name = drupal_strtolower($this->randomName());

    $edit['name'] = $this->randomName();

    $edit['description'] = $this->randomName();

    $edit['machine_name'] = $machine_name;

    $this->drupalPost(NULL, $edit, t('Save'));

    $this->assertRaw(t('Created new vocabulary %name.', array('%name' => $edit['name'])), 'Vocabulary created successfully.');

    // Edit the vocabulary.

    $this->drupalGet('admin/structure/taxonomy');

    $this->assertText($edit['name'], 'Vocabulary found in the vocabulary overview listing.');

    $this->clickLink(t('edit vocabulary'));

    $edit = array();

    $edit['name'] = $this->randomName();

    $this->drupalPost(NULL, $edit, t('Save'));

    $this->drupalGet('admin/structure/taxonomy');

    $this->assertText($edit['name'], 'Vocabulary found in the vocabulary overview listing.');

    // Try to submit a vocabulary with a duplicate machine name.

    $edit['machine_name'] = $machine_name;

    $this->drupalPost('admin/structure/taxonomy/add', $edit, t('Save'));

    $this->assertText(t('The machine-readable name is already in use. It must be unique.'));

    // Try to submit an invalid machine name.

    $edit['machine_name'] = '!&^%';

    $this->drupalPost('admin/structure/taxonomy/add', $edit, t('Save'));

    $this->assertText(t('The machine-readable name must contain only lowercase letters, numbers, and underscores.'));

    // Ensure that vocabulary titles are escaped properly.

    $edit = array();

    $edit['name'] = 'Don\'t Panic';

    $edit['description'] = $this->randomName();

    $edit['machine_name'] = 'don_t_panic';

    $this->drupalPost('admin/structure/taxonomy/add', $edit, t('Save'));

    $site_name = variable_get('site_name', 'Drupal');

    $this->drupalGet('admin/structure/taxonomy/don_t_panic');

    $this->assertTitle(t('Don\'t Panic | @site-name', array('@site-name' => $site_name)));

    $this->assertNoTitle(t('Don't Panic | @site-name', array('@site-name' => $site_name)));

  }

  /**

   * Changing weights on the vocabulary overview with two or more vocabularies.

   */

  function testTaxonomyAdminChangingWeights() {

    // Create some vocabularies.

    for ($i = 0; $i < 10; $i++) {

      $this->createVocabulary();

    }

    // Get all vocabularies and change their weights.

    $vocabularies = taxonomy_get_vocabularies();

    $edit = array();

    foreach ($vocabularies as $key => $vocabulary) {

      $vocabulary->weight = -$vocabulary->weight;

      $vocabularies[$key]->weight = $vocabulary->weight;

      $edit[$key . '[weight]'] = $vocabulary->weight;

    }

    // Saving the new weights via the interface.

    $this->drupalPost('admin/structure/taxonomy', $edit, t('Save'));

    // Load the vocabularies from the database.

    $new_vocabularies = taxonomy_get_vocabularies();

    // Check that the weights are saved in the database correctly.

    foreach ($vocabularies as $key => $vocabulary) {

      $this->assertEqual($new_vocabularies[$key]->weight, $vocabularies[$key]->weight, 'The vocabulary weight was changed.');

    }

  }

  /**

   * Test the vocabulary overview with no vocabularies.

   */

  function testTaxonomyAdminNoVocabularies() {

    // Delete all vocabularies.

    $vocabularies = taxonomy_get_vocabularies();

    foreach ($vocabularies as $key => $vocabulary) {

      taxonomy_vocabulary_delete($key);

    }

    // Confirm that no vocabularies are found in the database.

    $this->assertFalse(taxonomy_get_vocabularies(), 'No vocabularies found in the database.');

    $this->drupalGet('admin/structure/taxonomy');

    // Check the default message for no vocabularies.

    $this->assertText(t('No vocabularies available.'), 'No vocabularies were found.');

  }

  /**

   * Deleting a vocabulary.

   */

  function testTaxonomyAdminDeletingVocabulary() {

    // Create a vocabulary.

    $edit = array(

      'name' => $this->randomName(),

      'machine_name' => drupal_strtolower($this->randomName()),

    );

    $this->drupalPost('admin/structure/taxonomy/add', $edit, t('Save'));

    $this->assertText(t('Created new vocabulary'), 'New vocabulary was created.');

    // Check the created vocabulary.

    $vocabularies = taxonomy_get_vocabularies();

    $vocabularies_keys = array_keys($vocabularies);

    $vid = $vocabularies[end($vocabularies_keys)]->vid;

    entity_get_controller('taxonomy_vocabulary')->resetCache();

    $vocabulary = taxonomy_vocabulary_load($vid);

    $this->assertTrue($vocabulary, 'Vocabulary found in database.');

    // Delete the vocabulary.

    $edit = array();

    $this->drupalPost('admin/structure/taxonomy/' . $vocabulary->machine_name . '/edit', $edit, t('Delete'));

    $this->assertRaw(t('Are you sure you want to delete the vocabulary %name?', array('%name' => $vocabulary->name)), '[confirm deletion] Asks for confirmation.');

    $this->assertText(t('Deleting a vocabulary will delete all the terms in it. This action cannot be undone.'), '[confirm deletion] Inform that all terms will be deleted.');

    // Confirm deletion.

    $this->drupalPost(NULL, NULL, t('Delete'));

    $this->assertRaw(t('Deleted vocabulary %name.', array('%name' => $vocabulary->name)), 'Vocabulary deleted.');

    entity_get_controller('taxonomy_vocabulary')->resetCache();

    $this->assertFalse(taxonomy_vocabulary_load($vid), 'Vocabulary is not found in the database.');

  }

}

/**

 * Tests for taxonomy vocabulary functions.

 */

class TaxonomyVocabularyTestCase extends TaxonomyWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Taxonomy vocabularies',

      'description' => 'Test loading, saving and deleting vocabularies.',

      'group' => 'Taxonomy',

    );

  }

  function setUp() {

    parent::setUp('taxonomy', 'field_test');

    $admin_user = $this->drupalCreateUser(array('create article content', 'administer taxonomy'));

    $this->drupalLogin($admin_user);

    $this->vocabulary = $this->createVocabulary();

  }

  /**

   * Ensure that when an invalid vocabulary vid is loaded, it is possible

   * to load the same vid successfully if it subsequently becomes valid.

   */

  function testTaxonomyVocabularyLoadReturnFalse() {

    // Load a vocabulary that doesn't exist.

    $vocabularies = taxonomy_get_vocabularies();

    $vid = count($vocabularies) + 1;

    $vocabulary = taxonomy_vocabulary_load($vid);

    // This should not return an object because no such vocabulary exists.

    $this->assertTrue(empty($vocabulary), 'No object loaded.');

    // Create a new vocabulary.

    $this->createVocabulary();

    // Load the vocabulary with the same $vid from earlier.

    // This should return a vocabulary object since it now matches a real vid.

    $vocabulary = taxonomy_vocabulary_load($vid);

    $this->assertTrue(!empty($vocabulary) && is_object($vocabulary), 'Vocabulary is an object.');

    $this->assertEqual($vocabulary->vid, $vid, 'Valid vocabulary vid is the same as our previously invalid one.');

  }

  /**

   * Test deleting a taxonomy that contains terms.

   */

  function testTaxonomyVocabularyDeleteWithTerms() {

    // Delete any existing vocabularies.

    foreach (taxonomy_get_vocabularies() as $vocabulary) {

      taxonomy_vocabulary_delete($vocabulary->vid);

    }

    // Assert that there are no terms left.

    $this->assertEqual(0, db_query('SELECT COUNT(*) FROM {taxonomy_term_data}')->fetchField());

    // Create a new vocabulary and add a few terms to it.

    $vocabulary = $this->createVocabulary();

    $terms = array();

    for ($i = 0; $i < 5; $i++) {

      $terms[$i] = $this->createTerm($vocabulary);

    }

    // Set up hierarchy. term 2 is a child of 1 and 4 a child of 1 and 2.

    $terms[2]->parent = array($terms[1]->tid);

    taxonomy_term_save($terms[2]);

    $terms[4]->parent = array($terms[1]->tid, $terms[2]->tid);

    taxonomy_term_save($terms[4]);

    // Assert that there are now 5 terms.

    $this->assertEqual(5, db_query('SELECT COUNT(*) FROM {taxonomy_term_data}')->fetchField());

    taxonomy_vocabulary_delete($vocabulary->vid);

    // Assert that there are no terms left.

    $this->assertEqual(0, db_query('SELECT COUNT(*) FROM {taxonomy_term_data}')->fetchField());

  }

  /**

   * Ensure that the vocabulary static reset works correctly.

   */

  function testTaxonomyVocabularyLoadStaticReset() {

    $original_vocabulary = taxonomy_vocabulary_load($this->vocabulary->vid);

    $this->assertTrue(is_object($original_vocabulary), 'Vocabulary loaded successfully.');

    $this->assertEqual($this->vocabulary->name, $original_vocabulary->name, 'Vocabulary loaded successfully.');

    // Change the name and description.

    $vocabulary = $original_vocabulary;

    $vocabulary->name = $this->randomName();

    $vocabulary->description = $this->randomName();

    taxonomy_vocabulary_save($vocabulary);

    // Load the vocabulary.

    $new_vocabulary = taxonomy_vocabulary_load($original_vocabulary->vid);

    $this->assertEqual($new_vocabulary->name, $vocabulary->name);

    $this->assertEqual($new_vocabulary->name, $vocabulary->name);

    // Delete the vocabulary.

    taxonomy_vocabulary_delete($this->vocabulary->vid);

    $vocabularies = taxonomy_get_vocabularies();

    $this->assertTrue(!isset($vocabularies[$this->vocabulary->vid]), 'The vocabulary was deleted.');

  }

  /**

   * Tests for loading multiple vocabularies.

   */

  function testTaxonomyVocabularyLoadMultiple() {

    // Delete any existing vocabularies.

    foreach (taxonomy_get_vocabularies() as $vocabulary) {

      taxonomy_vocabulary_delete($vocabulary->vid);

    }

    // Create some vocabularies and assign weights.

    $vocabulary1 = $this->createVocabulary();

    $vocabulary1->weight = 0;

    taxonomy_vocabulary_save($vocabulary1);

    $vocabulary2 = $this->createVocabulary();

    $vocabulary2->weight = 1;

    taxonomy_vocabulary_save($vocabulary2);

    $vocabulary3 = $this->createVocabulary();

    $vocabulary3->weight = 2;

    taxonomy_vocabulary_save($vocabulary3);

    // Fetch the names for all vocabularies, confirm that they are keyed by

    // machine name.

    $names = taxonomy_vocabulary_get_names();

    $this->assertEqual($names[$vocabulary1->machine_name]->name, $vocabulary1->name, 'Vocabulary 1 name found.');

    // Fetch all of the vocabularies using taxonomy_get_vocabularies().

    // Confirm that the vocabularies are ordered by weight.

    $vocabularies = taxonomy_get_vocabularies();

    $this->assertEqual(array_shift($vocabularies)->vid, $vocabulary1->vid, 'Vocabulary was found in the vocabularies array.');

    $this->assertEqual(array_shift($vocabularies)->vid, $vocabulary2->vid, 'Vocabulary was found in the vocabularies array.');

    $this->assertEqual(array_shift($vocabularies)->vid, $vocabulary3->vid, 'Vocabulary was found in the vocabularies array.');

    // Fetch the vocabularies with taxonomy_vocabulary_load_multiple(), specifying IDs.

    // Ensure they are returned in the same order as the original array.

    $vocabularies = taxonomy_vocabulary_load_multiple(array($vocabulary3->vid, $vocabulary2->vid, $vocabulary1->vid));

    $this->assertEqual(array_shift($vocabularies)->vid, $vocabulary3->vid, 'Vocabulary loaded successfully by ID.');

    $this->assertEqual(array_shift($vocabularies)->vid, $vocabulary2->vid, 'Vocabulary loaded successfully by ID.');

    $this->assertEqual(array_shift($vocabularies)->vid, $vocabulary1->vid, 'Vocabulary loaded successfully by ID.');

    // Fetch vocabulary 1 by name.

    $vocabulary = current(taxonomy_vocabulary_load_multiple(array(), array('name' => $vocabulary1->name)));

    $this->assertEqual($vocabulary->vid, $vocabulary1->vid, 'Vocabulary loaded successfully by name.');

    // Fetch vocabulary 1 by name and ID.

    $this->assertEqual(current(taxonomy_vocabulary_load_multiple(array($vocabulary1->vid), array('name' => $vocabulary1->name)))->vid, $vocabulary1->vid, 'Vocabulary loaded successfully by name and ID.');

  }

  /**

   * Tests that machine name changes are properly reflected.

   */

  function testTaxonomyVocabularyChangeMachineName() {

    // Add a field instance to the vocabulary.

    $field = array(

      'field_name' => 'field_test',

      'type' => 'test_field',

    );

    field_create_field($field);

    $instance = array(

      'field_name' => 'field_test',

      'entity_type' => 'taxonomy_term',

      'bundle' => $this->vocabulary->machine_name,

    );

    field_create_instance($instance);

    // Change the machine name.

    $new_name = drupal_strtolower($this->randomName());

    $this->vocabulary->machine_name = $new_name;

    taxonomy_vocabulary_save($this->vocabulary);

    // Check that the field instance is still attached to the vocabulary.

    $this->assertTrue(field_info_instance('taxonomy_term', 'field_test', $new_name), 'The bundle name was updated correctly.');

  }

  /**

   * Test uninstall and reinstall of the taxonomy module.

   */

  function testUninstallReinstall() {

    // Fields and field instances attached to taxonomy term bundles should be

    // removed when the module is uninstalled.

    $this->field_name = drupal_strtolower($this->randomName() . '_field_name');

    $this->field = array('field_name' => $this->field_name, 'type' => 'text', 'cardinality' => 4);

    $this->field = field_create_field($this->field);

    $this->instance = array(

      'field_name' => $this->field_name,

      'entity_type' => 'taxonomy_term',

      'bundle' => $this->vocabulary->machine_name,

      'label' => $this->randomName() . '_label',

    );

    field_create_instance($this->instance);

    module_disable(array('taxonomy'));

    require_once DRUPAL_ROOT . '/includes/install.inc';

    drupal_uninstall_modules(array('taxonomy'));

    module_enable(array('taxonomy'));

    // Now create a vocabulary with the same name. All field instances

    // connected to this vocabulary name should have been removed when the

    // module was uninstalled. Creating a new field with the same name and

    // an instance of this field on the same bundle name should be successful.

    unset($this->vocabulary->vid);

    taxonomy_vocabulary_save($this->vocabulary);

    unset($this->field['id']);

    field_create_field($this->field);

    field_create_instance($this->instance);

  }

}

/**

 * Unit tests for taxonomy term functions.

 */

class TaxonomyTermFunctionTestCase extends TaxonomyWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Taxonomy term unit tests',

      'description' => 'Unit tests for taxonomy term functions.',

      'group' => 'Taxonomy',

    );

  }

  function testTermDelete() {

    $vocabulary = $this->createVocabulary();

    $valid_term = $this->createTerm($vocabulary);

    // Delete a valid term.

    taxonomy_term_delete($valid_term->tid);

    $terms = taxonomy_term_load_multiple(array(), array('vid' => $vocabulary->vid));

    $this->assertTrue(empty($terms), 'Vocabulary is empty after deletion.');

    // Delete an invalid term. Should not throw any notices.

    taxonomy_term_delete(42);

  }

  /**

   * Test a taxonomy with terms that have multiple parents of different depths.

   */

  function testTaxonomyVocabularyTree() {

    // Create a new vocabulary with 6 terms.

    $vocabulary = $this->createVocabulary();

    $term = array();

    for ($i = 0; $i < 6; $i++) {

      $term[$i] = $this->createTerm($vocabulary);

    }

    // $term[2] is a child of 1 and 5.

    $term[2]->parent = array($term[1]->tid, $term[5]->tid);

    taxonomy_term_save($term[2]);

    // $term[3] is a child of 2.

    $term[3]->parent = array($term[2]->tid);

    taxonomy_term_save($term[3]);

    // $term[5] is a child of 4.

    $term[5]->parent = array($term[4]->tid);

    taxonomy_term_save($term[5]);

    /**

     * Expected tree:

     * term[0] | depth: 0

     * term[1] | depth: 0

     * -- term[2] | depth: 1

     * ---- term[3] | depth: 2

     * term[4] | depth: 0

     * -- term[5] | depth: 1

     * ---- term[2] | depth: 2

     * ------ term[3] | depth: 3

     */

    // Count $term[1] parents with $max_depth = 1.

    $tree = taxonomy_get_tree($vocabulary->vid, $term[1]->tid, 1);

    $this->assertEqual(1, count($tree), 'We have one parent with depth 1.');

    // Count all vocabulary tree elements.

    $tree = taxonomy_get_tree($vocabulary->vid);

    $this->assertEqual(8, count($tree), 'We have all vocabulary tree elements.');

    // Count elements in every tree depth.

    foreach ($tree as $element) {

      if (!isset($depth_count[$element->depth])) {

        $depth_count[$element->depth] = 0;

      }

      $depth_count[$element->depth]++;

    }

    $this->assertEqual(3, $depth_count[0], 'Three elements in taxonomy tree depth 0.');

    $this->assertEqual(2, $depth_count[1], 'Two elements in taxonomy tree depth 1.');

    $this->assertEqual(2, $depth_count[2], 'Two elements in taxonomy tree depth 2.');

    $this->assertEqual(1, $depth_count[3], 'One element in taxonomy tree depth 3.');

  }

}

/**

 * Test for legacy node bug.

 */

class TaxonomyLegacyTestCase extends TaxonomyWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Test for legacy node bug.',

      'description' => 'Posts an article with a taxonomy term and a date prior to 1970.',

      'group' => 'Taxonomy',

    );

  }

  function setUp() {

    parent::setUp('taxonomy');

    $this->admin_user = $this->drupalCreateUser(array('administer taxonomy', 'administer nodes', 'bypass node access'));

    $this->drupalLogin($this->admin_user);

  }

  /**

   * Test taxonomy functionality with nodes prior to 1970.

   */

  function testTaxonomyLegacyNode() {

    // Posts an article with a taxonomy term and a date prior to 1970.

    $langcode = LANGUAGE_NONE;

    $edit = array();

    $edit['title'] = $this->randomName();

    $edit['date'] = '1969-01-01 00:00:00 -0500';

    $edit["body[$langcode][0][value]"] = $this->randomName();

    $edit["field_tags[$langcode]"] = $this->randomName();

    $this->drupalPost('node/add/article', $edit, t('Save'));

    // Checks that the node has been saved.

    $node = $this->drupalGetNodeByTitle($edit['title']);

    $this->assertEqual($node->created, strtotime($edit['date']), 'Legacy node was saved with the right date.');

  }

}

/**

 * Tests for taxonomy term functions.

 */

class TaxonomyTermTestCase extends TaxonomyWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Taxonomy term functions and forms.',

      'description' => 'Test load, save and delete for taxonomy terms.',