tagadelic_taxonomy.test in Tagadelic 7.2

File

tests/tagadelic_taxonomy.test

<?php

class TagadelicTaxonomyTestCase extends DrupalWebTestCase {
  protected $vocabulary;
  protected $tags = array();
  protected $nodes = array();
  protected $admin_user;

  /**
   * getInfo sets information about this test
   *
   * @scope public static
   * @returns Array  Descriptive array for this test
   */
  public static function getInfo() {
    return array(
      "name" => "Tagadelic Taxonomy Test",
      "description" => "Tests tagclouds from Tagadelic Taxonomy",
      "group" => "Tagadelic",
    );
  }

  /**
   * @scope public
   * @returns Type  Description of return value
   */
  public function setUp() {
    parent::setUp(array(
      'tagadelic_taxonomy',
      'block',
    ));

    // Create an admin user allowed to edit block settings
    $this->admin_user = $this
      ->drupalCreateUser(array(
      'administer blocks',
      'access administration pages',
    ));
  }
  public function testHasTagcloudPage() {
    $this
      ->drupalGet("tagadelic_taxonomy");
    $this
      ->assertResponse(200, "Can Access Page");
    $this
      ->assertText(t("Tag Cloud"), "Title of page is Tag Cloud");
  }
  public function testOnlyAccessContentAccessible() {

    # Remove access content permission from anonymous user.

    # As per http://drupal.stackexchange.com/a/70478/787
    user_role_revoke_permissions(1, array(
      'access content',
    ));
    $this
      ->drupalGet("tagadelic_taxonomy");
    $this
      ->assertResponse(403);
  }
  public function testTagsWithoutNodesNotOnPage() {
    $this
      ->createVocAndTags(3, FALSE);
    $this
      ->drupalGet("tagadelic_taxonomy");
    foreach ($this->tags as $tag) {
      $this
        ->assertNoText($tag->name);
    }
  }
  public function testHasTagsOnPage() {
    $this
      ->createVocAndTags(1);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $tag = $this->tags[0];
    $this
      ->assertText($tag->name);
  }
  public function testHasClickableLink() {
    $this
      ->createVocAndTags(1);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $link = "/taxonomy/term/{$this->tags[0]->tid}";
    $this
      ->assertHasXpath("//*/ul[@class='tag-cloud']/li/a[@href='{$link}']");
  }
  public function testHasFiveTags() {
    $this
      ->createVocAndTags(5);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $amount = count($this
      ->xpath("//*/ul[@class='tag-cloud']/li"));
    $this
      ->assertEqual(5, $amount);
  }
  public function testHasMaxsixtyTags() {
    $this
      ->createVocAndTags(61);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $this
      ->assertAmountTagsOnPage(60);
  }
  public function testOrdersTagsByUsage() {
    $this
      ->createVocAndTags(3, FALSE);
    $this
      ->createNodesWithTags(3);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $tags = $this
      ->xpath("//*/ul[@class='tag-cloud']/li/a");
    $found = array();
    foreach ($tags as $tag) {
      $attributes = $tag
        ->attributes();
      $found[] = (string) $attributes["href"];
    }
    $this
      ->assertEqual($found, [
      "/taxonomy/term/3",
      "/taxonomy/term/2",
      "/taxonomy/term/1",
    ]);
  }
  public function testOnlyHasTagsFromSelectedVocabularies() {
    $this
      ->createVocsAndTags(3, 3);
    $this
      ->createNodesWithTags(100);
    $disabled_voc = $this->vocabularies[0];
    foreach ($this->vocabularies as $vocabulary) {
      if ($disabled_voc->vid == $vocabulary->vid) {
        $setting[$vocabulary->vid] = 0;
      }
      else {
        $setting[$vocabulary->vid] = $vocabulary->vid;
      }
    }
    variable_set("tagadelic_taxonomy_vocabularies", $setting);
    $this
      ->refreshVariables();
    $this
      ->drupalGet("tagadelic_taxonomy");
    foreach ($this->tags_by_voc[$disabled_voc->vid] as $term) {
      $this
        ->assertNoText($term->name);
    }
  }
  public function testHasWeightedTags() {
    $this
      ->createVocAndTags(10);
    $this
      ->createNodesWithTags(100);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $weights = array(
      1,
      2,
      3,
      4,
      4,
      5,
      5,
      6,
      6,
      6,
    );
    $i = 0;
    foreach ($this->tags as $tag) {
      $weight = $weights[$i++];
      $this
        ->assertTagHasWeight($tag->name, $weight);
    }
  }
  public function testAttachesCssToPage() {
    $this
      ->createVocAndTags(1);
    $this
      ->drupalGet("tagadelic_taxonomy");
    $this
      ->assertRaw('/tagadelic.css', "Tagadelic CSS added to styles");
  }
  public function testAttachesCssOnlyToCloudPages() {
    $this
      ->createVocAndTags(1);
    $this
      ->drupalGet("node");
    $this
      ->assertNotRaw('/tagadelic.css', "Tagadelic CSS added to styles");
  }
  public function testBlockRendering() {
    $this
      ->enableBlock();
    $this
      ->createNodesWithTags(10);
    $this
      ->drupalGet('node');
    $this
      ->assertText(t("Tag Cloud"), "Title of block is Tag Cloud");
  }
  public function testBlockHasMoreLinkToPage() {
    $this
      ->enableBlock();
    $this
      ->createVocAndTags(11);
    $this
      ->drupalGet('node');
    $this
      ->assertHasXpath('//*/a[@class="more"]');
    $this
      ->assertLink("More tags");

    # This will cause a false-positive, as we have a link to tagadelic_taxonomy in the main-menu too!
    $this
      ->assertLinkByHref("tagadelic_taxonomy");
  }
  public function testBlockHasMaxTwelveTags() {
    $this
      ->enableBlock();
    $this
      ->createVocAndTags(13);
    $this
      ->drupalGet('node');
    $this
      ->assertAmountTagsOnPage(12);
  }

  /*************************************************************************
   *                     Test Helpers
   *************************************************************************/
  private function createVocAndTags($amount_of_tags, $create_node = TRUE) {
    $tx_test = new TaxonomyWebTestCase();
    $this->tags = array();
    $this->vocabulary = $tx_test
      ->createVocabulary();
    for ($i = 0; $i < $amount_of_tags; $i++) {
      $this->tags[] = $tx_test
        ->createTerm($this->vocabulary);
    }
    if ($create_node) {
      $this
        ->createNodesWithTags(1);
    }
    return $this;
  }
  private function createVocsAndTags($amount_of_vocs, $amount_of_tags_per_voc) {
    $tx_test = new TaxonomyWebTestCase();
    $this->tags = array();
    $this->tags_by_voc = array();
    for ($v = 0; $v < $amount_of_vocs; $v++) {
      $voc = $tx_test
        ->createVocabulary();
      $this->vocabularies[] = $voc;
      $this->tags_by_voc[$voc->vid] = array();
      for ($t = 0; $t < $amount_of_tags_per_voc; $t++) {
        $tag = $tx_test
          ->createTerm($voc);
        $this->tags[] = $tag;
        $this->tags_by_voc[$voc->vid][] = $tag;
      }
    }
    return $this;
  }

  /**
   * Creates $amount nodes with terms attached.
   *
   *
   * Fuck it, I am poking around in the database directly instead of testing
   * and preparing all this field, entity, admin-user and whatnot. I am not
   * interested in whether or not we can store nodes with tags, only that they
   * are there. By adding them to the database, we achieve that.
   */
  private function createNodesWithTags($amount) {
    $this->nodes = array();
    $attachable = $this->tags;
    for ($i = 0; $i < $amount; $i++) {

      // Post an article.
      $node = new StdClass();
      $node->title = $this
        ->randomName();
      $node->type = "story";
      node_save($node);
      $this->nodes[] = $node;

      // Attach the terms
      $query = db_insert('taxonomy_index')
        ->fields(array(
        'nid',
        'tid',
        'sticky',
        'created',
      ));
      foreach ($attachable as $tag) {
        $query
          ->values(array(
          'nid' => $node->nid,
          'tid' => $tag->tid,
          'sticky' => TRUE,
          'created' => $node->created,
        ));
      }
      $query
        ->execute();

      //remove one tag, so the next node gets one less tag attached.
      array_shift($attachable);
    }
    return $this;
  }
  private function enableBlock() {
    theme_enable(array(
      'seven',
    ));
    $region = 'content';
    $module = 'tagadelic_taxonomy';

    // set the block to a theme region, taken from block.test
    $delta = db_query("SELECT delta FROM {block} WHERE module = :module AND theme = :theme", array(
      ':module' => $module,
      ':theme' => 'seven',
    ))
      ->fetchField();
    $edit = array();
    $edit['blocks[' . $module . '_' . $delta . '][region]'] = $region;
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->drupalPost('admin/structure/block', $edit, t('Save blocks'));
    $this
      ->drupalLogout();
  }

  /**
   * assertHasXpath Asserts the existence of an xpath
   *
   * @scope private
   * @returns Boolean Boolean Assertion-result
   */
  private function assertHasXpath($xpath, $message = '', $group = 'Other') {
    if (empty($message)) {
      $message = "xpath '{$xpath}' not found.";
    }
    $xpath = $this
      ->xpath($xpath);
    $truthiness = count($xpath) > 0;
    return $this
      ->assertTrue($truthiness, $message, $group);
  }
  private function assertHasTag($name, $message = '', $group = 'Other') {
    $xpath = "//ul[@class='tag-cloud']/li/a";
    return $this
      ->assertHasXpath($xpath, $message, $group);
  }
  private function assertAmountTagsOnPage($expected_amount, $message = '', $group = 'Other') {
    $amount = count($this
      ->xpath("//*/ul[@class='tag-cloud']/li"));
    if (!$message) {
      $message = t("Expected {$expected_amount} Tags, found {$amount}");
    }
    $this
      ->assertEqual($expected_amount, $amount, $message);
  }
  private function assertTagHasWeight($name, $weight, $message = '', $group = 'Other') {
    $truthiness = FALSE;
    $class = '';
    $xpath = $this
      ->xpath("//*/ul[@class='tag-cloud']/li/a[contains(text(),'{$name}')]");
    if (!empty($xpath)) {
      $attributes = $xpath[0]
        ->attributes();
      $class = $attributes["class"];
      if ($class == "level{$weight}") {
        $truthiness = TRUE;
      }
    }
    if (empty($message)) {
      $message = "No tag with name '{$name}' and class 'level{$weight}' found. Tag with '{$name}' has class '{$class}'";
    }
    return $this
      ->assertTrue($truthiness, $message, $group = 'Other');
  }

  // Inverse of http://api.drupal.org/api/drupal/modules!simpletest!drupal_web_test_case.php/function/DrupalWebTestCase%3A%3AassertRaw/7
  private function assertNotRaw($raw, $message = '', $group = 'Other') {
    if (!$message) {
      $message = t('Raw "@raw" not found', array(
        '@raw' => $raw,
      ));
    }
    return $this
      ->assert(strpos($this
      ->drupalGetContent(), $raw) === FALSE, $message, $group);
  }

}

Classes

Name	Description
TagadelicTaxonomyTestCase