You are here

Home » API reference » SimpleTest 6

taxonomy.module.test in SimpleTest 6

Same filename and directory in other branches
  1. 5 tests/taxonomy.module.test

File

tests/taxonomy.module.test
View source 
<?php

class TaxonomyVocabularyFunctions extends DrupalTestCase {
  function get_info() {
    return array(
      'name' => 'Vocabulary functions',
      'desc' => "Create/Edit/Delete a vocabulary and assert that all fields were properly saved",
      'group' => 'Taxonomy',
    );
  }
  function testVocabularyFunctions() {

    //preparing data
    $vid = 0;
    $name = $this
      ->randomName(200);
    $description = $this
      ->randomName(200);
    $help = $this
      ->randomName(200);
    $hierarchy = rand(0, 2);

    // Hierarchy 0,1,2
    $multiple = rand(0, 1);

    // multiple 0,1
    $required = rand(0, 1);

    // required 0,1
    $relations = rand(0, 1);
    $tags = rand(0, 1);
    $weight = rand(-9, 9);
    $module = 'taxonomy';
    $nodesList = array_keys(node_get_types());
    $maxNodes = rand(1, count($nodesList));
    $nodes = array();
    for ($i = 0; $i < $maxNodes; $i++) {
      $nodes[$nodesList[$i]] = $nodesList[$i];
      $nodesBak[$nodesList[$i]] = $nodesList[$i];
    }
    $_t = array(
      'vid',
      'name',
      'description',
      'help',
      'relations',
      'hierarchy',
      'multiple',
      'required',
      'tags',
      'module',
      'weight',
      'nodes',
    );
    $edit = array();
    foreach ($_t as $key) {
      $edit[$key] = ${$key};
    }

    // exec save function
    taxonomy_save_vocabulary($edit);

    //after save we use $nodesBak
    ksort($nodesBak);
    $edit['nodes'] = $nodesBak;
    $vocabularies = taxonomy_get_vocabularies();
    foreach ($vocabularies as $voc) {
      if ($voc->name == $name) {
        $vid = $voc->vid;
        break;
      }
    }
    $edit['vid'] = $vid;

    // get data using function
    $getEdit = taxonomy_vocabulary_load($vid);
    foreach ($getEdit as $key => $value) {
      $this
        ->assertEqual($value, $edit[$key], "Checking value of {$key}");
    }

    // delete vocabulary
    // to avoid exception messages we create array with empty fields
    $deleteArray = array();
    foreach ($getEdit as $key => $v) {
      $deleteArray[$key] = 0;
    }
    $deleteArray['vid'] = $vid;
    taxonomy_save_vocabulary($deleteArray);

    // checking if we deleted voc.
    $vocabularies = taxonomy_get_vocabularies();
    $vid = 0;
    foreach ($vocabularies as $voc) {
      if ($voc->name == $name) {
        $vid = $voc->vid;
        break;
      }
    }
    $this
      ->assertEqual($vid, 0, "Deleted vocabulary ({$vid})");
  }

}
class TaxonomyTermFunctions extends DrupalTestCase {
  function get_info() {
    return array(
      'name' => 'Term functions',
      'desc' => "Testing save/update/delete terms",
      'group' => 'Taxonomy',
    );
  }
  function testTermsFunctions() {

    //preparing data

    // vocabulary, hierarchy -> disabled, related terms = on;
    $edit = array();
    $_t = array(
      'vid',
      'name',
      'description',
      'help',
      'relations',
      'hierarchy',
      'multiple',
      'required',
      'tags',
      'module',
      'weight',
      'nodes',
    );
    foreach ($_t as $key) {
      $edit[$key] = 0;
    }
    $name = $this
      ->randomName(20);
    $relation = 1;
    $edit['name'] = $name;
    taxonomy_save_vocabulary($edit);

    // create term
    $termname = $this
      ->randomName(20);
    $termdesc = $this
      ->randomName(200);
    $termweight = rand(-9, 9);
    $randSyn = rand(0, 9);
    $synonyms = array();
    for ($i = 0; $i < $randSyn; $i++) {
      $synonyms[] = $this
        ->randomName(20);
    }
    $termsyn = implode("\n", $synonyms);
    $data = array(
      'name' => $termname,
      'description' => $termdesc,
      'weight' => $termweight,
      'synonyms' => $termsyn,
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);

    // retrieve term and check all fields
    $_tArray = taxonomy_get_term_by_name($termname);
    $getTerm = $_tArray[0];
    $checkField = array(
      'name',
      'description',
      'weight',
      'vid',
    );
    foreach ($checkField as $v) {
      $this
        ->assertEqual($data[$v], $getTerm->{$v}, "Checking value of the term ({$v})");
    }
    $getSynonyms = taxonomy_get_synonyms($getTerm->tid);
    $this
      ->assertEqual(sort($synonyms), sort($getSynonyms), 'Checking synonyms');

    // creating related terms
    $relations = array();
    $staryTid = $getTerm->tid;
    $relations[] = $staryTid;
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => 0,
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => array(
        $staryTid,
      ),
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $getTerm = $_tArray[0];
    $relations[] = $getTerm->tid;

    // Creating another term related to 2 terms above;
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => 0,
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => array(
        $staryTid,
        $getTerm->tid,
      ),
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $getTerm = $_tArray[0];

    // check related terms
    $related = taxonomy_get_related($getTerm->tid);
    foreach ($relations as $rTid) {
      $this
        ->assertTrue(array_key_exists($rTid, $related), "Checking relations ({$rTid})");
    }

    // delete vocabulary
    $edit['name'] = 0;
    taxonomy_save_vocabulary($edit);
  }
  function testTermsFunctionsSingleHierarchy() {

    //preparing data

    // vocabulary hierarchy->single
    $edit = array();
    $_t = array(
      'vid',
      'name',
      'description',
      'help',
      'relations',
      'hierarchy',
      'multiple',
      'required',
      'tags',
      'module',
      'weight',
      'nodes',
    );
    foreach ($_t as $key) {
      $edit[$key] = 0;
    }

    // create vocab
    $name = $this
      ->randomName(20);
    $edit['hierarchy'] = 1;
    $edit['name'] = $name;
    taxonomy_save_vocabulary($edit);

    // create 1st term
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent = $_tArray[0];

    // create 2nd term as a child
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => 0,
      'parent' => array(
        $parent->tid,
      ),
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $children = $_tArray[0];

    // check hierarchy
    $getChildren = taxonomy_get_children($parent->tid);
    $getParent = taxonomy_get_parents($children->tid);
    $this
      ->assertEqual($parent, $getParent[$parent->tid], 'Checking parents');
    $this
      ->assertEqual($children, $getChildren[$children->tid], 'Checking children');

    // delete vocabulary
    $edit['name'] = 0;
    taxonomy_save_vocabulary($edit);
  }
  function testTermsFunctionsMultipleHierarchy() {

    //preparing data

    // vocabulary hierarchy->single
    $edit = array();
    $_t = array(
      'vid',
      'name',
      'description',
      'help',
      'relations',
      'hierarchy',
      'multiple',
      'required',
      'tags',
      'module',
      'weight',
      'nodes',
    );
    foreach ($_t as $key) {
      $edit[$key] = 0;
    }
    $name = $this
      ->randomName(20);
    $edit['hierarchy'] = 1;
    $edit['name'] = $name;
    taxonomy_save_vocabulary($edit);

    // create 1st term
    $parent = array();
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent[] = $_tArray[0]->tid;

    // create 2nd term
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent[] = $_tArray[0]->tid;

    // create 3rd term as a child
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $edit['vid'],
      'tid' => 0,
      'relations' => 0,
      'parent' => array(
        $parent,
      ),
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $children = $_tArray[0];
    $getParent = taxonomy_get_parents($children->tid);
    foreach ($parent as $p) {
      $this
        ->assertTrue(array_key_exists($p, $getParent), "Checking parents ({$p})");

      //$this->assertEqual($parent,$getParent[$parent->tid], 'Checking parents');
    }

    // delete vocabulary
    $edit['name'] = 0;
    taxonomy_save_vocabulary($edit);
  }

}
class TaxonomyTestNodeApi extends DrupalTestCase {
  function get_info() {
    return array(
      'name' => 'Taxonomy nodeapi',
      'desc' => "Save & edit a node and assert that taxonomy terms are saved/loaded properly.",
      'group' => 'Taxonomy',
    );
  }
  function testTaxonomyNode() {

    //preparing data

    // vocabulary hierarchy->single, multiple -> on
    $edit = array();
    $_t = array(
      'vid',
      'name',
      'description',
      'help',
      'relations',
      'hierarchy',
      'multiple',
      'required',
      'tags',
      'module',
      'weight',
      'nodes',
    );
    foreach ($_t as $key) {
      $edit[$key] = 0;
    }
    $name = $this
      ->randomName(20);
    $edit['hierarchy'] = 1;
    $edit['multiple'] = 1;
    $edit['name'] = $name;
    $edit['nodes'] = array(
      'story' => 'story',
    );
    taxonomy_save_vocabulary($edit);
    $vid = $edit['vid'];

    // we need to persist vid after $edit is unset()
    $parent = array();
    $patternArray = array();

    // create 1st term
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $vid,
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent[$_tArray[0]->tid] = $_tArray[0]->tid;
    $patternArray['term name 1'] = $termname;

    // create 2nd term
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $vid,
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent[$_tArray[0]->tid] = $_tArray[0]->tid;
    $patternArray['term name 2'] = $termname;

    // create test user and login
    $perm = array(
      'access content',
      'create story content',
      'edit own story content',
      'delete own story content',
    );
    $account = $this
      ->drupalCreateUserRolePerm($perm);
    $this
      ->drupalLoginUser($account);

    // why is this printing out the user profile page?
    // go to node/add/story
    $this
      ->drupalGet('node/add/story');
    $req = $this->_browser
      ->getRequest();
    $headers = $this->_browser
      ->getHeaders();
    $content = $this
      ->drupalGetContent();

    //    print($content). "\n\n\n all done \n\n";
    // try to create story
    $title = $this
      ->randomName();
    $body = $this
      ->randomName(100);
    $edit = array(
      'title' => $title,
      'body' => $body,
      'taxonomy-' . $vid => $parent,
    );

    // multiple slect box was failing through drupalPost. Use raw POST instead
    // Failing because they were being sent/handled wrong (earnest.berry@gmail.com <Souvent22>)
    $action = url('node/add/story', array(
      'absolute' => TRUE,
    ));
    $this
      ->drupalPost($action, $edit, 'Save');
    $content = $this
      ->drupalGetContent();
    $patternArray['body text'] = $body;
    $patternArray['title'] = $title;

    //    $node = array2object(node_load(array('title' => $title)));
    $node = node_load(array(
      'title' => $title,
    ));
    $this->_browser
      ->get(url("node/{$node->nid}"));
    foreach ($patternArray as $name => $termPattern) {
      $this
        ->assertText($termPattern, "Checking {$name}");
    }

    // checking database fields
    $result = db_query('SELECT tid FROM {term_node} WHERE nid = %d', $node->nid);
    while ($nodeRow = db_fetch_array($result)) {
      $this
        ->assertTrue(in_array($nodeRow['tid'], $parent), 'Checking database record');
    }

    // ok, lets create new terms, and change this node

    //pop array
    array_pop($parent);

    // create 1st term
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $vid,
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent[] = $_tArray[0]->tid;
    $patternArray['term name 2'] = $termname;

    // create 2nd term
    $termname = $this
      ->randomName(20);
    $data = array(
      'name' => $termname,
      'description' => '',
      'weight' => 0,
      'synonyms' => '',
      'vid' => $vid,
      'tid' => 0,
      'relations' => 0,
    );
    taxonomy_save_term($data);
    $_tArray = taxonomy_get_term_by_name($termname);
    $parent[] = $_tArray[0]->tid;
    $patternArray['term name 3'] = $termname;
    $edit = array(
      'title' => $title,
      'body' => $body,
      'taxonomy-' . $vid => $parent,
    );
    $this
      ->drupalPost('node/' . $node->nid . '/edit', $edit, 'Save');

    // TODO Do a MUCH better check here of the information msg
    $patternArray['information message'] = 'been updated';
    foreach ($patternArray as $name => $termPattern) {
      $this
        ->assertText($termPattern, "Checking {$name}");
    }

    // checking database fields
    $result = db_query('SELECT tid FROM {term_node} WHERE nid = %d', $node->nid);
    while ($nodeRow = db_fetch_array($result)) {
      $this
        ->assertTrue(in_array($nodeRow['tid'], $parent), 'Checking database field');
    }

    // delete node through browser
    $this
      ->drupalPost('node/' . $node->nid . '/delete', array(), 'Delete');

    // checking after delete
    $this->_browser
      ->get(url("node/" . $node->nid));
    $this
      ->assertNoUnwantedText($termname, "Checking if node exists");

    // checking database fields
    $num_rows = db_result(db_query('SELECT COUNT(*) FROM {term_node} WHERE nid = %d', $node->nid));
    $this
      ->assertEqual($num_rows, 0, 'Checking database field after deletion');

    // delete vocabulary
    // to avoid exception messages create array with empty fields
    $edit = array();
    foreach ($_t as $key) {
      $edit[$key] = 0;
    }
    $edit['name'] = 0;
    $edit['vid'] = $vid;
    taxonomy_save_vocabulary($edit);

    // restoring status
    $this
      ->drupalModuleDisable('story');
  }

}

Classes

Namesort descending Description
TaxonomyTermFunctions
TaxonomyTestNodeApi
TaxonomyVocabularyFunctions