modules/hidden/hidden.test

<?php
// $Id: hidden.test,v 1.2 2008/12/13 18:42:43 ekes Exp $

/**
 * @file
 * Tests for hidden module.
 *
 * @todo XSS tests.
 */

/**
 * Hidden test case.
 */
class HiddenHelperCase extends DrupalWebTestCase {
  protected $web_user;
  protected $view_user;
  protected $report_user;
  protected $hide_user;
  protected $admin_user;
  protected $text_filter;
  protected $preg_filter;

  function setUp() {
    parent::setUp('hidden', 'comment');
    // @todo enabling comment is causing simpletest to fail

    $this->web_user = $this->drupalCreateUser();
    $this->view_user = $this->drupalCreateUser(array('access hidden'));
    $this->report_user = $this->drupalCreateUser(array('report for hiding'));
    // Yes untested edge case able to hide but not see hidden. Make sense?
    $this->hide_user = $this->drupalCreateUser(array('mark as hidden', 'access hidden'));
    $this->admin_user = $this->drupalCreateUser(array('administer hidden'));

    $this->text_filter = array(
      'title' => 'new filter name',
      'filter' => 'text to filter',
      'type' => HIDDEN_FILTER_PLAIN,
      'delay' => 0,
      'weight' => 0,
      'enabled' => 1,
      'uid' => $this->hide_user->uid,
      'rid' => 0,
      'publicnote' => 'Public reason for hiding',
      'privatenote' => 'Filter notes as the reason for hidden',
    );
    $this->preg_filter = array(
      'title' => 'preg filter name',
      'filter' => '/With \w+/',
      'type' => HIDDEN_FILTER_PREG,
      'delay' => 30,
      'weight' => -5,
      'enabled' => 1,
      'uid' => $this->admin_user->uid,
      'rid' => 1,
    );
  }

  /**
   * Hide a node or comment.
   *
   * Frequently required
   * @see HiddenHideUnitCase::testHiddenHiddenHide() for the first testing.
   *
   * @param $settings
   *   array of settings
   *   defaults ... 'type' 'node' but can be node type ....
   * 
   * @return object
   *   object without delay, only id (not nid|cid), or reason title.
   */
  function hiddenCreateHidden($settings = array()) {
    $defaults = array(
      'type' => 'node',
      'rid' => 1,
      'publicnote' => $this->randomName(52),
      'privatenote' => $this->randomName(34),
      'filter' => FALSE,
    );
    // a specific node type is passed rather than 'node' or 'comment'
    if (isset($settings['node_type'])) {
      $node_type = $settings['node_type'];
    }
    else {
      $node_type = 'story';
    }
    if (empty($settings['id'])) {
      if (isset($settings['type']) && $settings['type'] == 'comment') {
        $comment = $this->hiddenCreateComment(array('type' => $node_type));
        $defaults['id'] = $comment->cid;
      }
      else {
        $new_user = $this->drupalCreateUser(array("create $node_type content"));
        $node = $this->drupalCreateNode(array('uid' => $new_user->uid, 'type' => $node_type));
        $defaults['id'] = $node->nid;
      }
    }
    if (empty($settings['uid'])) {
      global $user;
      $defaults['uid'] = $user->uid;
    }
    $hide = ($settings + $defaults);
    $result = hidden_hidden_hide($hide['type'], $hide['id'], $hide['uid'], $hide['rid'], $hide['publicnote'], $hide['privatenote'], $hide['filter']);
    $this->assertTrue($result, t('Hidden %type record created.', array('%type' => $hide['type'])));
    return (object) $hide;
  }

  /**
   * Report a node or comment.
   *
   * @see HiddenHideUnitCase::testHiddenReportedHide() for first testing.
   *
   * @return object
   */
  function hiddenCreateReported($settings = array()) {
    $defaults = array(
      'type' => 'node',
      'rid' => 1,
      'publicnote' => $this->randomName(73),
    );
    // a specific node type is passed rather than 'node' or 'comment'
    if (isset($settings['node_type'])) {
      $node_type = $settings['type'];
    }
    else {
      $node_type = 'story';
    }
    if (empty($settings['id'])) {
      $new_user = $this->drupalCreateUser(array('create '. $node_type .' content'));
      $node = $this->drupalCreateNode(array('uid' => $new_user->uid, 'type' => $node_type));
      $defaults['id'] = $node->nid;
    }
    if (empty($settings['uid'])) {
      global $user;
      $defaults['uid'] = $user->uid;
    }
    $reported = ($settings + $defaults);
    $result = _hidden_reported_hide($reported['type'], $reported['id'], $reported['uid'], $reported['rid'], $reported['publicnote']);
    $this->assertTrue($result, t('Report for %type created.', array('%type' => $reported['type'])));
    return (object) $reported;
  }

  /**
   * Create a comment.
   *
   * A first attempt at creating drupalCreateNode() like programatic comment creation.
   *  - comment_save() does user access checks
   *
   * @param $settings
   *   array all optional ('subject', 'comment', 'nid', 'cid', 'pid', 'format', 'status', 'uid', 'name'
   *     'homepage', 'mail', 'timestamp')
   */
  function hiddenCreateComment($settings = array()) {
    $defaults = array(
      'cid' => 0,
      'subject' => $this->randomName(12),
      'comment' => $this->randomName(53),
      'pid' => 0,
      'format' => FILTER_FORMAT_DEFAULT,
      'status' => COMMENT_PUBLISHED,
    );
    if (empty($settings['uid'])) {
      $posting_user = $this->drupalCreateUser(array("post comments without approval"));
      $defaults['uid'] = $posting_user->uid;
    }
    if (empty($settings['nid'])) {
      if (! isset($settings['type'])) {
        $settings['type'] = 'story';
      }
      $posting_user = $this->drupalCreateUser(array("create {$settings['type']} content"));
      $node = $this->drupalCreateNode(array('type' => $settings['type'], 'uid' => $posting_user->uid, 'comment' => COMMENT_NODE_READ_WRITE));
      $defaults['nid'] = $node->nid;
    }
    $settings += $defaults;
    $cid = comment_save($settings);
    $comment = _comment_load($cid);
    $this->assertEqual($comment->cid, $cid, t('Comment created'));
    return $comment;
  }

  /**
   * Create hidden reason.
   *
   * @see HiddenCoreUnitCase::testHiddenReason() for first test
   * 
   * @param $settings
   *   array 'title' 'description' 'enabled'
   * @return
   *   array as $settings plus 'rid'
   */
  function hiddenCreateReason($settings = array()) {
    $defaults = array(
      'title' => $this->randomName(11),
      'description' => $this->randomName(42),
      'enabled' => 1,
    );
    $settings += $defaults;
    $settings['rid'] = hidden_reason_create($settings['title'], $settings['description'], $settings['enabled']);
    return $settings;
  }
}

/**
 * 'Unit' test: un/hiding nodes comments, add/remove/edit reasons
 */
class HiddenCoreUnitCase extends HiddenHelperCase {
  /**
   * Implementation of getInfo().
   */
  function getInfo() {
    return array(
      'name' => t('Main functions test'),
      'description' => t('Test main functions for hiding, reasons, filters.'),
      'group' => t('Hidden'),
    );
  }

  /**
   * Testing unpublishing and republishing of comments and nodes.
   */
  function testHiddenHiddenHideUnpublish() {
    $node = $this->drupalCreateNode();
    $this->assertTrue(node_load($node->nid), t('Node created.'));

    // node - unpublish
    $result = _hidden_hidden_hide_unpublish('node', $node->nid);
    $this->assertTrue($result, t('No error unpublishing'));
    $node = node_load($node->nid, NULL, TRUE);
    $this->assertEqual($node->status, 0, t('Node unpublished'));
    $this->assertEqual($node->comment, 1, t('Node commenting switched off'));
    // node - republish
    $result = _hidden_hidden_publish('node', $node->nid);
    $this->assertTrue($result, t('No error publishing'));
    $node = node_load($node->nid, NULL, TRUE);
    $this->assertEqual($node->status, 1, t('Node published'));
    // @todo comment settings may change see code
    $this->assertEqual($node->comment, 2, t('Node commenting switched on'));

    // comment - unpublish
    $comment = $this->hiddenCreateComment();
    $result = _hidden_hidden_hide_unpublish('comment', $comment->cid);
    $this->assertTrue($result, 'No error unpublishing');
    $comment = _comment_load($comment->cid);
    $this->assertEqual($comment->status, COMMENT_NOT_PUBLISHED, t('Comment unpublished'));
    // comment - republish
    $result = _hidden_hidden_publish('comment', $comment->cid);
    $this->assertTrue($result, t('No error publishing'));
    $comment = _comment_load($comment->cid);
    $this->assertEqual($comment->status, COMMENT_PUBLISHED, t('Comment published'));
  }

  /**
   * Test hiding and retrieving of hidden comments and nodes.
   */
  function testHiddenHiddenHide() {
    // node - hide
    $hidden_original = $this->hiddenCreateHidden();
    $node = node_load($hidden_original->id, NULL, TRUE);
    $hidden_retrieved = _hidden_hidden_get('node', $node->nid);
    $this->assertTrue(is_object($hidden_retrieved), t('Hidden node record retrieved.'));
    $this->assertEqual($hidden_retrieved->type, 'node', t('Correct type recorded.'));
    $this->assertEqual($hidden_original->id, $hidden_retrieved->nid, t('Correct nid recorded'));
    $this->assertEqual($hidden_retrieved->id, $node->nid, t('Correct id reported'));
    $this->assertEqual($hidden_original->rid, $hidden_retrieved->rid, t('Correct reason recorded'));
    $this->assertEqual($hidden_original->publicnote, $hidden_retrieved->publicnote, t('Correct public note recorded'));
    $this->assertEqual($hidden_original->privatenote, $hidden_retrieved->privatenote, t('Correct private note recorded'));
    // node - unhide
    _hidden_hidden_unhide('node', $hidden_retrieved->id);
    $this->assertFalse(_hidden_hidden_get('node', $hidden_retrieved->id), t('Node removed from hidden table'));

    // comment - hide, different rid checked too (it's the only non changing)
    $hidden_original = $this->hiddenCreateHidden(array('type' => 'comment', 'rid' => 18));
    $comment = _comment_load($hidden_original->id);
    $hidden_retrieved = _hidden_hidden_get('comment', $comment->cid);
    $this->assertTrue(is_object($hidden_retrieved), t('Hidden node record retrieved.'));
    $this->assertEqual($hidden_retrieved->type, 'comment', t('Correct type recorded.'));
    $this->assertEqual($hidden_original->id, $hidden_retrieved->cid, t('Correct cid recorded'));
    $this->assertEqual($hidden_retrieved->id, $comment->cid, t('Correct id reported'));
    $this->assertEqual($hidden_original->rid, $hidden_retrieved->rid, t('Correct reason recorded'));
    $this->assertEqual($hidden_original->publicnote, $hidden_retrieved->publicnote, t('Correct public note recorded'));
    $this->assertEqual($hidden_original->privatenote, $hidden_retrieved->privatenote, t('Correct private note recorded'));
    // comment - unhide
    _hidden_hidden_unhide('comment', $hidden_retrieved->id);
    $this->assertFalse(_hidden_hidden_get('comment', $hidden_retrieved->id), t('Comment removed from hidden table'));

    // @todo variations - already hidden, timelapsed,
  }

  /**
   * Test reporting and retrieving of reports of comments and nodes.
   */
  function testHiddenReportedHide() {
    $reported_orginal = $this->hiddenCreateReported();
    // @todo when there is an individual inteface for editing/viewing reported or query it
  }

  /**
   * Test creating, editing and removing reasons.
   */
  function testHiddenReason() {
    // Create reason and check it with retrieval functions
    $reason_original = $this->hiddenCreateReason();
    $this->assertTrue($reason_original['rid'] > 0, t('Reason rid created'));
    $this->assertTrue(hidden_reason_check($reason_original['rid']), t('Reason check confirms a valid reason'));
    $reason_retrieved = hidden_reason_get($reason_original['rid']);
    foreach ($reason_original as $key => $value) {
      $this->assertEqual($value, $reason_retrieved->$key, t('Correct %key retrieved', array('%key' => $key)));
    }

    // Disable reason and check
    hidden_reason_disable($reason_original['rid']);
    $reason_retrieved = hidden_reason_get($reason_original['rid'], FALSE, FALSE);
    $this->assertFalse($reason_retrieved->enabled, t('Reason disabled'));
    // And enable again
    hidden_reason_enable($reason_original['rid']);
    $reason_retrieved = hidden_reason_get($reason_original['rid'], FALSE, FALSE);
    $this->assertTrue($reason_retrieved->enabled, t('Reason enabled'));

    // Update reason and check
    $reason_original['title'] = 'New title';
    $reason_original['description'] = 'New description';
    $update_rid = hidden_reason_update($reason_original['title'], $reason_original['description'], $reason_original['enabled'], $reason_original['rid']);
    $this->assertEqual($reason_original['rid'], $update_rid, t('Reason updated'));
    $reason_retrieved = hidden_reason_get($reason_original['rid'], FALSE, FALSE);
    foreach ($reason_original as $key => $value) {
      $this->assertEqual($value, $reason_retrieved->$key, t('Correct updated %key retrieved', array('%key' => $key)));
    }

    // Check next non-existing reason isn't reported as existing
    $update_rid++;
    $this->assertFalse(hidden_reason_check($update_rid), t('Non existing reason not found'));
    $this->assertFalse(hidden_reason_get($update_rid, FALSE, FALSE), t('Non exisitng reason not retrieved'));
  }

  /**
   * Test retrieving multiple reasons.
   */
  function testHiddenReasonMultiple() {
    // Adds a set or reasons
    $reasons_original = array();
    for ($i = 0; $i < 11; $i++) {
      $reason = $this->hiddenCreateReason();
      $reasons_original[$reason['rid']] = $reason;
    }

    // Retrieve all and ensure all new reasons saved
    //   (there is also the previous test ones, and the default...)
    $reasons_retrieved = hidden_reason_get_all(FALSE, FALSE);
    $equal = TRUE;
    foreach ($reasons_original as $rid => $reason) {
      foreach ($reason as $key => $value) {
        if ($reasons_retrieved[$rid]->$key != $value) {
          $equal = FALSE;
        }
      }
    }
    $this->assertTrue($equal, t('All reasons retrieved as originals'));

    // disable one of the reasons
    reset($reasons_original);
    $reason = next($reasons_original);
    // and check not returned when only want enabled ones
    hidden_reason_disable($reason['rid']);
    $reasons_retrieved = hidden_reason_get_all(TRUE, FALSE);
    $this->assertFalse(isset($reasons_retrieved[$reason['rid']]), t('Disabled reason not retrieved'));
    $this->assertTrue(isset($reasons_retrieved[++$reason['rid']]), t('Enabled reason retrieved'));
  }

  /**
   * Test saving and loading filters.
   */
  function testHiddenFilterSave() {
    $original_preg = $sent_preg = (object) $this->preg_filter;
    $original_text = $sent_text = (object) $this->text_filter;

    $this->assertEqual(hidden_filter_save($sent_text), SAVED_NEW, t('New filter reported saved'));
    $retrieved_text = hidden_filter_load($sent_text->hfid);
    $equal = TRUE;
    foreach ($original_text as $var => $value) {
      if ($retrieved_text->$var != $value) {
        $equal = FALSE;
      }
    }
    $this->assertTrue($equal, t('Saved and retrieved filters equal'));

    $this->assertEqual(hidden_filter_save($sent_preg), SAVED_NEW, t('New filter reported saved'));
    $retrieved_preg = hidden_filter_load($sent_preg->hfid);
    $equal = TRUE;
    foreach ($original_preg as $var => $value) {
      if ($retrieved_preg->$var != $value) {
        $equal = FALSE;
      }
    }
    $this->assertTrue($equal, t('Saved and retrieved filters equal'));

    // Disable and enable a filter using function
    hidden_filter_enable($sent_preg->hfid, FALSE);
    $retrieved_preg = hidden_filter_load($sent_preg->hfid);
    $this->assertFalse($retrieved_preg->enabled, t('Filter successfully disabled'));
    hidden_filter_enable($sent_preg->hfid);
    $retrieved_preg = hidden_filter_load($sent_preg->hfid);
    $this->assertTrue($retrieved_preg->enabled, t('Filter successfully enabled'));

    // Change and add some values
    $sent_preg->title = 'updated preg filter title';
    $sent_preg->rid = 0;
    $sent_preg->privatenote = 'New filter hidden note';
    hidden_filter_save($sent_preg);
    $retrieved_preg = hidden_filter_load($sent_preg->hfid);
    $equal = TRUE;
    foreach ($sent_preg as $var => $value) {
      if ($retrieved_preg->$var != $value) {
        $equal = FALSE;
      }
    }
    $this->assertTrue($equal, t('Edited and retrieved filters equal'));

    $this->assertTrue(hidden_filter_delete($sent_preg->hfid), t('Filter reported deleted'));
    $this->assertTrue(hidden_filter_delete($sent_text->hfid), t('Filter reported deleted'));
    $this->assertFalse(hidden_filter_load($sent_preg->hfid), t('Deleted filter not retrieved'));
    $this->assertFalse(hidden_filter_load($sent_text->hfid), t('Deleted filter not retrieved'));
  }

  /**
   * Test running filters against content
   */
  function testHiddenFilterContentTest() {
    $no_match = 'This is text that should not match with any filter. With';
    $first_match = 'This is some text to filter that should match With both of the filters.';
    $preg_match = 'This should match only With the preg filter.';
    $text_match = 'This text to filter should only match the text filter.';
    $text_filter = (object) $this->text_filter;
    $preg_filter = (object) $this->preg_filter;
    
    hidden_filter_save($text_filter);
    hidden_filter_save($preg_filter);

    $result = _hidden_filter_content_test($no_match);
    $this->assertFalse($result, t('Filter did not no_match text correctly'));
    $result = _hidden_filter_content_test($first_match);
    $this->assertTrue($result != FALSE, t('Filter matched first_match correctly'));
    $this->assertEqual($preg_filter->hfid, $result->hfid, t('Preg filter correctly matched first by weight'));
    $result = _hidden_filter_content_test($preg_match);
    $this->assertTrue($result != FALSE, t('Filter matched preg_match correctly'));
    $this->assertEqual($preg_filter->hfid, $result->hfid, t('Preg filter correctly matched'));
    $result = _hidden_filter_content_test($text_match);
    $this->assertTrue($result != FALSE, t('Filter matched text_match correctly'));
    $this->assertEqual($text_filter->hfid, $result->hfid, t('Text filter correctly matched'));
  }

  /**
   * Test hiding by filters
   */
  function testHiddenFilterContent() {
    $text_filter = (object) $this->text_filter;
    $preg_filter = (object) $this->preg_filter;
    hidden_filter_save($text_filter);
    hidden_filter_save($preg_filter);

    $text_node = $this->drupalCreateNode(array('body' => "A first simpler text to filter that should get hidden automatically when passed through the filter function"));
    $preg_node = $this->drupalCreateNode(array('body' => "Another set of text some of which will match the preg test.\nWith this we can check to see if the node is unpublished and has the correct hidden information attached to it and also if the gets set correctly."));

    // Text node first
    $this->assertTrue(hidden_filter_content($text_node->body, 'node', $text_node->nid), t('Node reported as hidden'));
    $hidden = _hidden_hidden_get('node', $text_node->nid);
    $this->assertEqual($hidden->rid, $text_filter->rid, t('Text filter reason recorded'));
    $this->assertEqual($hidden->publicnote, $text_filter->publicnote, t('Text filter publicnote recorded'));
    $this->assertEqual($hidden->privatenote, $text_filter->privatenote, t('Text filter privatenote recorded'));
    $this->assertEqual($hidden->uid, $text_filter->uid, t('Text filter user recorded'));
    $text_node = node_load($text_node->nid, NULL, TRUE);
    $this->assertEqual($text_node->status, 0, t('Node unpublished'));

    // Then the preg text
    $this->assertTrue(hidden_filter_content($preg_node->body, 'node', $preg_node->nid), t('Node reported as hidden'));
    $hidden = _hidden_hidden_get('node', $preg_node->nid);
    $this->assertEqual($hidden->rid, $preg_filter->rid, t('Preg filter reason recorded'));
    $this->assertEqual($hidden->publicnote, '', t('Preg filter lack of public note recorded'));
    $this->assertTrue($hidden->delay > time(), t('Hide delay time set'));
    $preg_node = node_load($preg_node->nid, NULL, TRUE);
    $this->assertEqual($preg_node->status, 1, t('Node not yet unpublished'));
  }
}

/**
 * Functional test: hiding nodes and comments.
 *
 * Also tests the hide_user view of the hidden item page, may move to Pages class
 * if further seperation of actions and ui is wanted.
 */
class HiddenHideTestCase extends HiddenHelperCase {
  /**
   * Implementation of getInfo().
   */
  function getInfo() {
    return array(
      'name' => t('Hide node and comments'),
      'description' => t('Hide a node and a comment, check unpublished and in hidden database.'),
      'group' => t('Hidden'),
    );
  }

  function testPageView() {
    $node = $this->drupalCreateNode();
    $this->assertTrue(node_load($node->nid), t('Node created.'));
    $hidden = $this->hiddenCreateHidden();

    $this->drupalLogin($this->web_user);
    $this->drupalGet(hidden_path('node', $hidden->id, 'view'));
    $this->assertResponse(403, t('Unprivileged user cannot access hidden view page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'hide'));
    $this->assertResponse(403, t('Unprivileged user cannot access node hide page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'report'));
    $this->assertResponse(403, t('Unprivileged user cannot access node report page'));
    $this->drupalLogout();

    $this->drupalLogin($this->view_user);
    $this->drupalGet(hidden_path('node', $hidden->id, 'view'));
    $this->assertResponse(200, t('View user can access hidden view page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'hide'));
    $this->assertResponse(403, t('View user cannot access node hide page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'report'));
    $this->assertResponse(403, t('View user cannot access node report page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'view'));
    $this->assertResponse(404, t('View user cannot view unhidden node on hidden view page'));
    $this->drupalLogout();

    $this->drupalLogin($this->report_user);
    $this->drupalGet(hidden_path('node', $hidden->id, 'view'));
    $this->assertResponse(403, t('Report user cannot access hidden view page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'hide'));
    $this->assertResponse(403, t('Report user cannot access node hide page'));
    $this->drupalGet(hidden_path('node', $node->nid, 'report'));
    $this->assertResponse(200, t('Report user can access node report page'));
    $this->drupalGet(hidden_path('node', $hidden->id, 'report'));
    $this->assertText(t('Item is already hidden.'), t('Already hidden message displayed'));
    $this->drupalLogout();

    $this->drupalLogin($this->hide_user);
    $this->drupalGet(hidden_path('node', $node->nid, 'hide'));
    $this->assertResponse(200, t('User can access hide page'));
    $this->drupalGet(hidden_path('node', $hidden->id, 'hide'));
    $this->assertText(t('Item is already hidden.'), t('Already hidden message displayed'));
    $this->drupalGet('node/'. $hidden->id);
    $this->assertResponse(403, t('Hidden cannot be accessed at original url'));
    $this->drupalLogout();
  }


  function testHiddenHide() {
    // Create user to hide content.
    $this->drupalLogin($this->hide_user);

    // make node to hide
    $node = $this->drupalCreateNode(array('type' => 'article'));

    // Submit hide form
    $hide = array(
    //  'user' => $hide_user->name, // @todo test administer hidden where it can be set
      'reason' => 1,
      // @todo length restriction 128 - correct or not
      'publictext' => $this->randomName(108),
      'privatetext' => $this->randomName(33),
    );
    $this->drupalPost(hidden_path('node', $node->nid, 'hide'), $hide, t('Hide'));
    $this->assertText(t('Hidden node'), t('Node reported hidden'));
    $this->assertText($hide['publictext'], t('Public text posted'));
    $this->assertText($hide['privatetext'], t('Private text posted'));
    // @todo check reason is displayed in words
    // note view_user check is HiddenUserPagesTestCase::testHiddenViewPage() 

    // Click the unhide link
    $this->clickLink(t('unhide'));
    $this->assertText(t('Hidden node unhidden'));
    $this->assertNoText($hide['publictext'], t('Hidden text not shown'));
    $this->assertText($node->title, t('On page with node title %title visible', array('%title' => $node->title)));

    // make comment to hide
    $comment = $this->hiddenCreateComment();
    $hide = array(
      'reason' => 1,
      'publictext' => $this->randomName(82),
      'privatetext' => $this->randomName(12),
    );
    $this->drupalPost(hidden_path('comment', $comment->cid, 'hide'), $hide, t('Hide'));
    $this->assertText(t('Hidden comment.'), t('Comment reported hidden'));
    $this->assertText($hide['publictext'], t('Public text posted'));
    $this->assertText($hide['privatetext'], t('Private text posted'));

    $this->clickLink(t('unhide'));
    $this->assertText(t('Hidden comment unhidden'));
    $this->assertNoText($hide['publictext'], t('Hidden text not shown'));
    $this->asserttext($comment->subject, t('On page with comment title %title visible', array('%title' => $comment->subject)));
  }

  function testHiddenReport() {
    $this->drupalLogin($this->report_user);
    $node = $this->drupalCreateNode(array('type' => 'article'));

    // Submit report form
    $report = array(
      'reason' => 1,
      'publictext' => $this->randomName(23),
    );
    $this->drupalPost(hidden_path('node', $node->nid, 'report'), $report, t('Report'));
    $this->assertText(t('Reported node'), t('Node reported as reported'));

    // @todo hide_user (?) to check the report
  }  
}

/**
 * Functional test: User pages
 */
class HiddenUserPagesTestCase extends HiddenHelperCase {
  /**
   * Implementation of getInfo().
   */
  function getInfo() {
    return array(
      'name' => t('View hidden node and comments user pages'),
      'description' => t('View hidden nodes and comments on user pages.'),
      'group' => t('Hidden'),
    );
  }

  function testPageView() {
    $node = $this->drupalCreateNode();
    $this->assertTrue(node_load($node->nid), t('Node created.'));
    $hidden = $this->hiddenCreateHidden();

    $this->drupalLogin($this->web_user);
    $this->drupalGet('hidden');
    $this->assertResponse(403, t('Unprivileged user cannot access hidden node index'));
    $this->drupalGet('hidden/node');
    $this->assertResponse(403, t('Unprivileged user cannot access hidden node index'));
    $this->drupalGet('hidden/comment');
    $this->assertResponse(403, t('Unprivileged user cannot access hidden comment index'));

    $this->drupalLogin($this->view_user);
    $this->drupalGet('hidden');
    $this->assertResponse(200, t('View user can access hidden node index'));
    $this->drupalGet('hidden/node');
    $this->assertResponse(200, t('View user can access hidden node index'));
    $this->drupalGet('hidden/comment');
    $this->assertResponse(200, t('View user can access hidden node index'));
  }

  function testHiddenViewPage() {
/*  // Just one
    $hidden = $this->hiddenCreateHidden();
    $this->drupalLogin($this->view_user);
    $this->drupalGet('hidden');
    $node = node_load($hidden->id, NULL, TRUE);
    $this->assertText($node->title);
    $this->drupalGet(hidden_path('node', $hidden->id, 'view'));
    $this->assertText($node->title);
    $this->drupalLogout(); */

    $hiddens = array();
    // @todo what about testing page two
    for ($i = 0; $i < 9; $i++) {
      $hiddens[$i] = $this->hiddenCreateHidden();
      $nothiddens[$i] = $this->drupalCreateNode();
    }

    // using theme('username', ) this cuts long usernames and changes on permissions so:
    $view_user = $this->drupalCreateUser(array('access hidden', 'access user profiles'));
    $this->drupalLogin($view_user);
    // and check lots of hidden pages as well 
    foreach ($hiddens as $hidden) {
      $this->drupalGet('hidden');
      // @todo is there a simpletest way of bundling up these asserts?
      $node = node_load($hidden->id, NULL, TRUE);
      $this->assertText($node->title);
      $user = user_load(array('uid' => $node->uid));
      $this->assertRaw(theme('username', $user));
      // @todo reasons again
      $this->clickLink($node->title); // don't really need to run this everytime
      $this->assertText($node->title, t('Node title visible on node hidden page'));
      $this->assertText($hidden->publicnote, t('Public text posted'));
      $this->assertNoText($hidden->privatenote, t('Private text not visible to view only user'));
      $this->assertNoText(t('Unhide'), t('No unhide link visible to view only user'));
    }
    foreach ($nothiddens as $nothidden) {
      // @todo is there a simpletest way of bundling up these asserts?
      $node = node_load($nothidden->nid, NULL, TRUE);
      $this->assertNoText($node->title);
      $user = user_load(array('uid' => $node->uid));
      $this->assertNoRaw(theme('username', $user));
    }
    $this->drupalLogout();

    $hiddens = array();
    // @todo what about testing page two
    for ($i = 0; $i < 9; $i++) {
      $hiddens[$i] = $this->hiddenCreateHidden(array('type' => 'comment'));
    }

    $this->drupalLogin($view_user); 
    foreach ($hiddens as $hidden) {
      $this->drupalGet('hidden/comment');
      // @todo is there a simpletest way of bundling up these asserts?
      $comment = _comment_load($hidden->id);
      $this->assertText($comment->subject);
      $user = user_load(array('uid' => $comment->uid));
      $this->assertRaw(theme('username', $user));
      // @todo reasons again
      $this->clickLink($comment->subject); // don't really need to run this everytime
      $this->assertText($comment->subject, t('Node title visible on node hidden page'));
      $this->assertText($hidden->publicnote, t('Public text posted'));
      $this->assertNoText($hidden->privatenote, t('Private text not visible to view only user'));
      $this->assertNoText(t('Unhide'), t('No unhide link visible to view only user'));
    }
    $this->drupalLogout();
  }
}

/**
 * Function test: Admin pages
 */
class HiddenAdminPagesTestCase extends HiddenHelperCase {
  /**
   * Implementation of getInfo().
   */
  function getInfo() {
    return array(
      'name' => t('View and update module settings'),
      'description' => t('View and change basic settings, reasons and filters on admin pages'),
      'group' => t('Hidden'),
    );
  }

  /**
   * Test if correct users can view pages.
   */
  function testPageView() {
    $this->drupalLogin($this->hide_user);
    // trivial but a quick run down
    $this->drupalGet('admin/content/hidden');
    $this->assertResponse(403);
    // there should always be a reason 1, and by default it is enabled
    $this->drupalGet('admin/content/hidden/reasons/edit/1');
    $this->assertResponse(403);
    $this->drupalGet('admin/content/hidden/reasons/disable/1');
    $this->assertResponse(403);
    $this->drupalGet('admin/content/hidden/reasons/enable/1');
    $this->assertResponse(403);
    $this->drupalGet('admin/content/hidden/filters');
    $this->assertResponse(403);
    $this->drupalLogout();

    $this->drupalLogin($this->admin_user);
    $this->drupalGet('admin/content/hidden');
    $this->assertResponse(200);
    $this->drupalGet('admin/content/hidden/reasons/edit/1');
    $this->assertResponse(200);
    $this->drupalGet('admin/content/hidden/reasons/disable/1');
    $this->assertResponse(200, t('Admin can disable reason'));
    $this->drupalGet('admin/content/hidden/reasons/enable/1');
    $this->assertResponse(200, t('Admin can enable reason'));
    $this->drupalGet('admin/content/hidden/filters');
    $this->drupalLogout();
  }

  function testReasonViewPage() {
    $this->drupalLogin($this->admin_user);
    $this->drupalGet('admin/content/hidden');
    $this->assertText(t('Policy Violation'), t('Default reason visible'));
    // only default reason created so far, so there should be no other reasons
    // so can easily just click enable disable links to check and test
    $enable = '<a href="'. url('admin/content/hidden/reasons/enable/1') .'">';
    $disable = '<a href="'. url('admin/content/hidden/reasons/disable/1') .'">';
    $this->assertRaw($disable, t('Disable link visible'));
    $this->assertNoRaw($enable, t('No enable link visible'));
    $this->clickLink(t('disable'));
    $this->assertText(t('Reason disabled'), t('Reason reported disabled'));
    $this->assertRaw($enable, t('Enable link visible'));
    $this->assertNoRaw($disable, t('No disable link visible'));
    $this->clickLink(t('enable'));
    $this->assertText(t('Reason enabled'), t('Reason reported enabled'));
    $this->assertNoRaw($enable, t('No enable link visible'));
    $this->assertRaw($disable, t('Disable link visible'));

    $reasons = array();
    // edit the default reason
    $this->clickLink(t('edit'));
    $edit = array(
      'title' => $this->randomName(12),
      'description' => $this->randomName(63),
      'enabled' => 0,
    );
    $this->drupalPost(NULL, $edit, t('Submit'));
    $this->assertRaw(t('%title has been updated.', array('%title' => $edit['title'])), t('Reason reported updated'));
    // save reason for later
    $reasons[] = $edit;

    // add some more reasons and check if all can be seen
    for ($i = 1; $i < 4; $i++) {
      // create a new reason
      $this->clickLink(t('Add new reason'));
      $edit = array(
        'title' => $this->randomName(21),
        'description' => $this->randomName(57),
      );
      $this->drupalPost(NULL, $edit, t('Submit'));
      $this->assertRaw(t('%title has been added.', array('%title' => $edit['title'])), t('Reason reported added')); 
      $reasons[$i] = $edit;
    }
    $this->drupalGet('admin/content/hidden');
    foreach ($reasons as $reason) {
      $this->assertText($reason['title'], t('%title listed', array('%title' => $reason['title'])));
    }
  }

  function testHiddenFiltersViewPage() {
    $this->drupalLogin($this->admin_user);

    $this->drupalGet('admin/content/hidden/filters');
    $this->clickLink(t('Add new filter'));

    $text_filter = $this->text_filter;
    $user = user_load($text_filter['uid']);
    $text_filter['user'] = $user->name;
    unset($text_filter['uid']);
    $text_filter['reason'] = $text_filter['rid'];
    unset($text_filter['rid']);
    $text_filter['publictext'] = $text_filter['publicnote'];
    unset($text_filter['publicnote']);
    $text_filter['privatetext'] = $text_filter['privatenote'];
    unset($text_filter['privatenote']);

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

    $this->assertText($text_filter['title']);
    // not certain of hfid but there is only one
    $enable = '<a href="'. url('admin/content/hidden/filters/enable/') .'\d+">';
    $disable = '<a href="'. url('admin/content/hidden/filters/disable/') .'\d+">';
    $edit = '<a href="'. url('admin/content/hidden/filters/edit/'). '\d+">';
    // check links as enabling and disabling sole filter
    $this->assertPattern($disable, t('Disable link visible'));
    $this->assertPattern($edit, t('Edit link visible'));
    $this->assertNoPattern($enable, t('No enable link visible'));
    $this->clickLink(t('disable'));
    $this->assertPattern($enable, t('Enable link visible'));
    $this->assertNoPattern($disable, t('No disable link visible'));
    $this->assertPattern($edit, t('Edit link visible'));
    $this->clickLink(t('enable'));
    $this->assertNoPattern($enable, t('No enable link visible'));
    $this->clickLink(t('edit'));
    // change title
    $text_filter['title'] = $this->randomName(17);
    $this->drupalPost(NULL, array('title' => $text_filter['title']), t('Submit'));
    $this->assertText($text_filter['title']);
    // @todo weights
  }
}