Club Drupal

<?php

/**

 * @file

 * Tests for comment.module.

 */

class CommentHelperCase extends DrupalWebTestCase {

  protected $admin_user;

  protected $web_user;

  protected $node;

  function setUp() {

    $modules = func_get_args();

    if (isset($modules[0]) && is_array($modules[0])) {

      $modules = $modules[0];

    }

    $modules[] = 'comment';

    parent::setUp($modules);

    // Create users and test node.

    $this->admin_user = $this->drupalCreateUser(array('administer content types', 'administer comments', 'administer blocks', 'administer actions', 'administer fields'));

    $this->web_user = $this->drupalCreateUser(array('access comments', 'post comments', 'create article content', 'edit own comments'));

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1, 'uid' => $this->web_user->uid));

  }

  /**

   * Post comment.

   *

   * @param $node

   *   Node to post comment on.

   * @param $comment

   *   Comment body.

   * @param $subject

   *   Comment subject.

   * @param $contact

   *   Set to NULL for no contact info, TRUE to ignore success checking, and

   *   array of values to set contact info.

   */

  function postComment($node, $comment, $subject = '', $contact = NULL) {

    $langcode = LANGUAGE_NONE;

    $edit = array();

    $edit['comment_body[' . $langcode . '][0][value]'] = $comment;

    $preview_mode = variable_get('comment_preview_article', DRUPAL_OPTIONAL);

    $subject_mode = variable_get('comment_subject_field_article', 1);

    // Must get the page before we test for fields.

    if ($node !== NULL) {

      $this->drupalGet('comment/reply/' . $node->nid);

    }

    if ($subject_mode == TRUE) {

      $edit['subject'] = $subject;

    }

    else {

      $this->assertNoFieldByName('subject', '', 'Subject field not found.');

    }

    if ($contact !== NULL && is_array($contact)) {

      $edit += $contact;

    }

    switch ($preview_mode) {

      case DRUPAL_REQUIRED:

        // Preview required so no save button should be found.

        $this->assertNoFieldByName('op', t('Save'), 'Save button not found.');

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

        // Don't break here so that we can test post-preview field presence and

        // function below.

      case DRUPAL_OPTIONAL:

        $this->assertFieldByName('op', t('Preview'), 'Preview button found.');

        $this->assertFieldByName('op', t('Save'), 'Save button found.');

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

        break;

      case DRUPAL_DISABLED:

        $this->assertNoFieldByName('op', t('Preview'), 'Preview button not found.');

        $this->assertFieldByName('op', t('Save'), 'Save button found.');

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

        break;

    }

    $match = array();

    // Get comment ID

    preg_match('/#comment-([0-9]+)/', $this->getURL(), $match);

    // Get comment.

    if ($contact !== TRUE) { // If true then attempting to find error message.

      if ($subject) {

        $this->assertText($subject, 'Comment subject posted.');

      }

      $this->assertText($comment, 'Comment body posted.');

      $this->assertTrue((!empty($match) && !empty($match[1])), 'Comment id found.');

    }

    if (isset($match[1])) {

      return (object) array('id' => $match[1], 'subject' => $subject, 'comment' => $comment);

    }

  }

  /**

   * Checks current page for specified comment.

   *

   * @param object $comment Comment object.

   * @param boolean $reply The comment is a reply to another comment.

   * @return boolean Comment found.

   */

  function commentExists($comment, $reply = FALSE) {

    if ($comment && is_object($comment)) {

      $regex = '/' . ($reply ? '<div class="indented">(.*?)' : '');

      $regex .= '<a id="comment-' . $comment->id . '"(.*?)'; // Comment anchor.

      $regex .= '<div(.*?)'; // Begin in comment div.

      $regex .= $comment->subject . '(.*?)'; // Match subject.

      $regex .= $comment->comment . '(.*?)'; // Match comment.

      $regex .= '/s';

      return (boolean)preg_match($regex, $this->drupalGetContent());

    }

    else {

      return FALSE;

    }

  }

  /**

   * Delete comment.

   *

   * @param object $comment

   *   Comment to delete.

   */

  function deleteComment($comment) {

    $this->drupalPost('comment/' . $comment->id . '/delete', array(), t('Delete'));

    $this->assertText(t('The comment and all its replies have been deleted.'), 'Comment deleted.');

  }

  /**

   * Set comment subject setting.

   *

   * @param boolean $enabled

   *   Subject value.

   */

  function setCommentSubject($enabled) {

    $this->setCommentSettings('comment_subject_field', ($enabled ? '1' : '0'), 'Comment subject ' . ($enabled ? 'enabled' : 'disabled') . '.');

  }

  /**

   * Set comment preview setting.

   *

   * @param int $mode

   *   Preview value.

   */

  function setCommentPreview($mode) {

    switch ($mode) {

      case DRUPAL_DISABLED:

        $mode_text = 'disabled';

        break;

      case DRUPAL_OPTIONAL:

        $mode_text = 'optional';

        break;

      case DRUPAL_REQUIRED:

        $mode_text = 'required';

        break;

    }

    $this->setCommentSettings('comment_preview', $mode, format_string('Comment preview @mode_text.', array('@mode_text' => $mode_text)));

  }

  /**

   * Set comment form location setting.

   *

   * @param boolean $enabled

   *   Form value.

   */

  function setCommentForm($enabled) {

    $this->setCommentSettings('comment_form_location', ($enabled ? COMMENT_FORM_BELOW : COMMENT_FORM_SEPARATE_PAGE), 'Comment controls ' . ($enabled ? 'enabled' : 'disabled') . '.');

  }

  /**

   * Set comment anonymous level setting.

   *

   * @param integer $level

   *   Anonymous level.

   */

  function setCommentAnonymous($level) {

    $this->setCommentSettings('comment_anonymous', $level, format_string('Anonymous commenting set to level @level.', array('@level' => $level)));

  }

  /**

   * Set the default number of comments per page.

   *

   * @param integer $comments

   *   Comments per page value.

   */

  function setCommentsPerPage($number) {

    $this->setCommentSettings('comment_default_per_page', $number, format_string('Number of comments per page set to @number.', array('@number' => $number)));

  }

  /**

   * Set comment setting for article content type.

   *

   * @param string $name

   *   Name of variable.

   * @param string $value

   *   Value of variable.

   * @param string $message

   *   Status message to display.

   */

  function setCommentSettings($name, $value, $message) {

    variable_set($name . '_article', $value);

    // Display status message.

    $this->pass($message);

  }

  /**

   * Check for contact info.

   *

   * @return boolean Contact info is available.

   */

  function commentContactInfoAvailable() {

    return preg_match('/(input).*?(name="name").*?(input).*?(name="mail").*?(input).*?(name="homepage")/s', $this->drupalGetContent());

  }

  /**

   * Perform the specified operation on the specified comment.

   *

   * @param object $comment

   *   Comment to perform operation on.

   * @param string $operation

   *   Operation to perform.

   * @param boolean $aproval

   *   Operation is found on approval page.

   */

  function performCommentOperation($comment, $operation, $approval = FALSE) {

    $edit = array();

    $edit['operation'] = $operation;

    $edit['comments[' . $comment->id . ']'] = TRUE;

    $this->drupalPost('admin/content/comment' . ($approval ? '/approval' : ''), $edit, t('Update'));

    if ($operation == 'delete') {

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

      $this->assertRaw(format_plural(1, 'Deleted 1 comment.', 'Deleted @count comments.'), format_string('Operation @operation was performed on comment.', array('@operation' => $operation)));

    }

    else {

      $this->assertText(t('The update has been performed.'), format_string('Operation @operation was performed on comment.', array('@operation' => $operation)));

    }

  }

  /**

   * Get the comment ID for an unapproved comment.

   *

   * @param string $subject

   *   Comment subject to find.

   * @return integer

   *   Comment id.

   */

  function getUnapprovedComment($subject) {

    $this->drupalGet('admin/content/comment/approval');

    preg_match('/href="(.*?)#comment-([^"]+)"(.*?)>(' . $subject . ')/', $this->drupalGetContent(), $match);

    return $match[2];

  }

}

class CommentInterfaceTest extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Comment interface',

      'description' => 'Test comment user interfaces.',

      'group' => 'Comment',

    );

  }

  /**

   * Test comment interface.

   */

  function testCommentInterface() {

    $langcode = LANGUAGE_NONE;

    // Set comments to have subject and preview disabled.

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

    $this->setCommentPreview(DRUPAL_DISABLED);

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(FALSE);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');

    $this->drupalLogout();

    // Post comment #1 without subject or preview.

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

    $comment_text = $this->randomName();

    $comment = $this->postComment($this->node, $comment_text);

    $comment_loaded = comment_load($comment->id);

    $this->assertTrue($this->commentExists($comment), 'Comment found.');

    // Set comments to have subject and preview to required.

    $this->drupalLogout();

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

    $this->setCommentSubject(TRUE);

    $this->setCommentPreview(DRUPAL_REQUIRED);

    $this->drupalLogout();

    // Create comment #2 that allows subject and requires preview.

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

    $subject_text = $this->randomName();

    $comment_text = $this->randomName();

    $comment = $this->postComment($this->node, $comment_text, $subject_text, TRUE);

    $comment_loaded = comment_load($comment->id);

    $this->assertTrue($this->commentExists($comment), 'Comment found.');

    // Check comment display.

    $this->drupalGet('node/' . $this->node->nid . '/' . $comment->id);

    $this->assertText($subject_text, 'Individual comment subject found.');

    $this->assertText($comment_text, 'Individual comment body found.');

    // Set comments to have subject and preview to optional.

    $this->drupalLogout();

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

    $this->setCommentSubject(TRUE);

    $this->setCommentPreview(DRUPAL_OPTIONAL);

    // Test changing the comment author to "Anonymous".

    $this->drupalGet('comment/' . $comment->id . '/edit');

    $comment = $this->postComment(NULL, $comment->comment, $comment->subject, array('name' => ''));

    $comment_loaded = comment_load($comment->id);

    $this->assertTrue(empty($comment_loaded->name) && $comment_loaded->uid == 0, 'Comment author successfully changed to anonymous.');

    // Test changing the comment author to an unverified user.

    $random_name = $this->randomName();

    $this->drupalGet('comment/' . $comment->id . '/edit');

    $comment = $this->postComment(NULL, $comment->comment, $comment->subject, array('name' => $random_name));

    $this->drupalGet('node/' . $this->node->nid);

    $this->assertText($random_name . ' (' . t('not verified') . ')', 'Comment author successfully changed to an unverified user.');

    // Test changing the comment author to a verified user.

    $this->drupalGet('comment/' . $comment->id . '/edit');

    $comment = $this->postComment(NULL, $comment->comment, $comment->subject, array('name' => $this->web_user->name));

    $comment_loaded = comment_load($comment->id);

    $this->assertTrue($comment_loaded->name == $this->web_user->name && $comment_loaded->uid == $this->web_user->uid, 'Comment author successfully changed to a registered user.');

    $this->drupalLogout();

    // Reply to comment #2 creating comment #3 with optional preview and no

    // subject though field enabled.

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

    $this->drupalGet('comment/reply/' . $this->node->nid . '/' . $comment->id);

    $this->assertText($subject_text, 'Individual comment-reply subject found.');

    $this->assertText($comment_text, 'Individual comment-reply body found.');

    $reply = $this->postComment(NULL, $this->randomName(), '', TRUE);

    $reply_loaded = comment_load($reply->id);

    $this->assertTrue($this->commentExists($reply, TRUE), 'Reply found.');

    $this->assertEqual($comment->id, $reply_loaded->pid, 'Pid of a reply to a comment is set correctly.');

    $this->assertEqual(rtrim($comment_loaded->thread, '/') . '.00/', $reply_loaded->thread, 'Thread of reply grows correctly.');

    // Second reply to comment #3 creating comment #4.

    $this->drupalGet('comment/reply/' . $this->node->nid . '/' . $comment->id);

    $this->assertText($subject_text, 'Individual comment-reply subject found.');

    $this->assertText($comment_text, 'Individual comment-reply body found.');

    $reply = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    $reply_loaded = comment_load($reply->id);

    $this->assertTrue($this->commentExists($reply, TRUE), 'Second reply found.');

    $this->assertEqual(rtrim($comment_loaded->thread, '/') . '.01/', $reply_loaded->thread, 'Thread of second reply grows correctly.');

    // Edit reply.

    $this->drupalGet('comment/' . $reply->id . '/edit');

    $reply = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    $this->assertTrue($this->commentExists($reply, TRUE), 'Modified reply found.');

    // Correct link count

    $this->drupalGet('node');

    $this->assertRaw('4 comments', 'Link to the 4 comments exist.');

    // Confirm a new comment is posted to the correct page.

    $this->setCommentsPerPage(2);

    $comment_new_page = $this->postComment($this->node, $this->randomName(), $this->randomName(), TRUE);

    $this->assertTrue($this->commentExists($comment_new_page), 'Page one exists. %s');

    $this->drupalGet('node/' . $this->node->nid, array('query' => array('page' => 1)));

    $this->assertTrue($this->commentExists($reply, TRUE), 'Page two exists. %s');

    $this->setCommentsPerPage(50);

    // Attempt to post to node with comments disabled.

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1, 'comment' => COMMENT_NODE_HIDDEN));

    $this->assertTrue($this->node, 'Article node created.');

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $this->assertText('This discussion is closed', 'Posting to node with comments disabled');

    $this->assertNoField('edit-comment', 'Comment body field found.');

    // Attempt to post to node with read-only comments.

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1, 'comment' => COMMENT_NODE_CLOSED));

    $this->assertTrue($this->node, 'Article node created.');

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $this->assertText('This discussion is closed', 'Posting to node with comments read-only');

    $this->assertNoField('edit-comment', 'Comment body field found.');

    // Attempt to post to node with comments enabled (check field names etc).

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1, 'comment' => COMMENT_NODE_OPEN));

    $this->assertTrue($this->node, 'Article node created.');

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $this->assertNoText('This discussion is closed', 'Posting to node with comments enabled');

    $this->assertField('edit-comment-body-' . $langcode . '-0-value', 'Comment body field found.');

    // Delete comment and make sure that reply is also removed.

    $this->drupalLogout();

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

    $this->deleteComment($comment);

    $this->deleteComment($comment_new_page);

    $this->drupalGet('node/' . $this->node->nid);

    $this->assertFalse($this->commentExists($comment), 'Comment not found.');

    $this->assertFalse($this->commentExists($reply, TRUE), 'Reply not found.');

    // Enabled comment form on node page.

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

    $this->setCommentForm(TRUE);

    $this->drupalLogout();

    // Submit comment through node form.

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

    $this->drupalGet('node/' . $this->node->nid);

    $form_comment = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    $this->assertTrue($this->commentExists($form_comment), 'Form comment found.');

    // Disable comment form on node page.

    $this->drupalLogout();

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

    $this->setCommentForm(FALSE);

  }

  /**

   * Tests new comment marker.

   */

  public function testCommentNewCommentsIndicator() {

    // Test if the right links are displayed when no comment is present for the

    // node.

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

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1, 'comment' => COMMENT_NODE_OPEN));

    $this->drupalGet('node');

    $this->assertNoLink(t('@count comments', array('@count' => 0)));

    $this->assertNoLink(t('@count new comments', array('@count' => 0)));

    $this->assertLink(t('Read more'));

    $count = $this->xpath('//div[@id=:id]/div[@class=:class]/ul/li', array(':id' => 'node-' . $this->node->nid, ':class' => 'link-wrapper'));

    $this->assertTrue(count($count) == 1, 'One child found');

    // Create a new comment. This helper function may be run with different

    // comment settings so use comment_save() to avoid complex setup.

    $comment = (object) array(

      'cid' => NULL,

      'nid' => $this->node->nid,

      'node_type' => $this->node->type,

      'pid' => 0,

      'uid' => $this->loggedInUser->uid,

      'status' => COMMENT_PUBLISHED,

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

      'hostname' => ip_address(),

      'language' => LANGUAGE_NONE,

      'comment_body' => array(LANGUAGE_NONE => array($this->randomName())),

    );

    comment_save($comment);

    $this->drupalLogout();

    // Log in with 'web user' and check comment links.

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

    $this->drupalGet('node');

    $this->assertLink(t('1 new comment'));

    $this->clickLink(t('1 new comment'));

    $this->assertRaw('<a id="new"></a>', 'Found "new" marker.');

    $this->assertTrue($this->xpath('//a[@id=:new]/following-sibling::a[1][@id=:comment_id]', array(':new' => 'new', ':comment_id' => 'comment-1')), 'The "new" anchor is positioned at the right comment.');

    // Test if "new comment" link is correctly removed.

    $this->drupalGet('node');

    $this->assertLink(t('1 comment'));

    $this->assertLink(t('Read more'));

    $this->assertNoLink(t('1 new comment'));

    $this->assertNoLink(t('@count new comments', array('@count' => 0)));

    $count = $this->xpath('//div[@id=:id]/div[@class=:class]/ul/li', array(':id' => 'node-' . $this->node->nid, ':class' => 'link-wrapper'));

    $this->assertTrue(count($count) == 2, print_r($count, TRUE));

  }

  /**

   * Tests CSS classes on comments.

   */

  function testCommentClasses() {

    // Create all permutations for comments, users, and nodes.

    $parameters = array(

      'node_uid' => array(0, $this->web_user->uid),

      'comment_uid' => array(0, $this->web_user->uid, $this->admin_user->uid),

      'comment_status' => array(COMMENT_PUBLISHED, COMMENT_NOT_PUBLISHED),

      'user' => array('anonymous', 'authenticated', 'admin'),

    );

    $permutations = $this->generatePermutations($parameters);

    foreach ($permutations as $case) {

      // Create a new node.

      $node = $this->drupalCreateNode(array('type' => 'article', 'uid' => $case['node_uid']));

      // Add a comment.

      $comment = (object) array(

        'cid' => NULL,

        'nid' => $node->nid,

        'pid' => 0,

        'uid' => $case['comment_uid'],

        'status' => $case['comment_status'],

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

        'language' => LANGUAGE_NONE,

        'comment_body' => array(LANGUAGE_NONE => array($this->randomName())),

      );

      comment_save($comment);

      // Adjust the current/viewing user.

      switch ($case['user']) {

        case 'anonymous':

          $this->drupalLogout();

          $case['user_uid'] = 0;

          break;

        case 'authenticated':

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

          $case['user_uid'] = $this->web_user->uid;

          break;

        case 'admin':

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

          $case['user_uid'] = $this->admin_user->uid;

          break;

      }

      // Request the node with the comment.

      $this->drupalGet('node/' . $node->nid);

      // Verify classes if the comment is visible for the current user.

      if ($case['comment_status'] == COMMENT_PUBLISHED || $case['user'] == 'admin') {

        // Verify the comment-by-anonymous class.

        $comments = $this->xpath('//*[contains(@class, "comment-by-anonymous")]');

        if ($case['comment_uid'] == 0) {

          $this->assertTrue(count($comments) == 1, 'comment-by-anonymous class found.');

        }

        else {

          $this->assertFalse(count($comments), 'comment-by-anonymous class not found.');

        }

        // Verify the comment-by-node-author class.

        $comments = $this->xpath('//*[contains(@class, "comment-by-node-author")]');

        if ($case['comment_uid'] > 0 && $case['comment_uid'] == $case['node_uid']) {

          $this->assertTrue(count($comments) == 1, 'comment-by-node-author class found.');

        }

        else {

          $this->assertFalse(count($comments), 'comment-by-node-author class not found.');

        }

        // Verify the comment-by-viewer class.

        $comments = $this->xpath('//*[contains(@class, "comment-by-viewer")]');

        if ($case['comment_uid'] > 0 && $case['comment_uid'] == $case['user_uid']) {

          $this->assertTrue(count($comments) == 1, 'comment-by-viewer class found.');

        }

        else {

          $this->assertFalse(count($comments), 'comment-by-viewer class not found.');

        }

      }

      // Verify the comment-unpublished class.

      $comments = $this->xpath('//*[contains(@class, "comment-unpublished")]');

      if ($case['comment_status'] == COMMENT_NOT_PUBLISHED && $case['user'] == 'admin') {

        $this->assertTrue(count($comments) == 1, 'comment-unpublished class found.');

      }

      else {

        $this->assertFalse(count($comments), 'comment-unpublished class not found.');

      }

      // Verify the comment-new class.

      if ($case['comment_status'] == COMMENT_PUBLISHED || $case['user'] == 'admin') {

        $comments = $this->xpath('//*[contains(@class, "comment-new")]');

        if ($case['user'] != 'anonymous') {

          $this->assertTrue(count($comments) == 1, 'comment-new class found.');

          // Request the node again. The comment-new class should disappear.

          $this->drupalGet('node/' . $node->nid);

          $comments = $this->xpath('//*[contains(@class, "comment-new")]');

          $this->assertFalse(count($comments), 'comment-new class not found.');

        }

        else {

          $this->assertFalse(count($comments), 'comment-new class not found.');

        }

      }

    }

  }

  /**

   * Tests the node comment statistics.

   */

  function testCommentNodeCommentStatistics() {

    $langcode = LANGUAGE_NONE;

    // Set comments to have subject and preview disabled.

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

    $this->setCommentPreview(DRUPAL_DISABLED);

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(FALSE);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');

    $this->drupalLogout();

    // Creates a second user to post comments.

    $this->web_user2 = $this->drupalCreateUser(array('access comments', 'post comments', 'create article content', 'edit own comments'));

    // Checks the initial values of node comment statistics with no comment.

    $node = node_load($this->node->nid);

    $this->assertEqual($node->last_comment_timestamp, $this->node->created, 'The initial value of node last_comment_timestamp is the node created date.');

    $this->assertEqual($node->last_comment_name, NULL, 'The initial value of node last_comment_name is NULL.');

    $this->assertEqual($node->last_comment_uid, $this->web_user->uid, 'The initial value of node last_comment_uid is the node uid.');

    $this->assertEqual($node->comment_count, 0, 'The initial value of node comment_count is zero.');

    // Post comment #1 as web_user2.

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

    $comment_text = $this->randomName();

    $comment = $this->postComment($this->node, $comment_text);

    $comment_loaded = comment_load($comment->id);

    // Checks the new values of node comment statistics with comment #1.

    // The node needs to be reloaded with a node_load_multiple cache reset.

    $node = node_load($this->node->nid, NULL, TRUE);

    $this->assertEqual($node->last_comment_name, NULL, 'The value of node last_comment_name is NULL.');

    $this->assertEqual($node->last_comment_uid, $this->web_user2->uid, 'The value of node last_comment_uid is the comment #1 uid.');

    $this->assertEqual($node->comment_count, 1, 'The value of node comment_count is 1.');

    // Prepare for anonymous comment submission (comment approval enabled).

    variable_set('user_register', USER_REGISTER_VISITORS);

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

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => TRUE,

      'post comments' => TRUE,

      'skip comment approval' => FALSE,

    ));

    // Ensure that the poster can leave some contact info.

    $this->setCommentAnonymous('1');

    $this->drupalLogout();

    // Post comment #2 as anonymous (comment approval enabled).

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $anonymous_comment = $this->postComment($this->node, $this->randomName(), '', TRUE);

    $comment_unpublished_loaded = comment_load($anonymous_comment->id);

    // Checks the new values of node comment statistics with comment #2 and

    // ensure they haven't changed since the comment has not been moderated.

    // The node needs to be reloaded with a node_load_multiple cache reset.

    $node = node_load($this->node->nid, NULL, TRUE);

    $this->assertEqual($node->last_comment_name, NULL, 'The value of node last_comment_name is still NULL.');

    $this->assertEqual($node->last_comment_uid, $this->web_user2->uid, 'The value of node last_comment_uid is still the comment #1 uid.');

    $this->assertEqual($node->comment_count, 1, 'The value of node comment_count is still 1.');

    // Prepare for anonymous comment submission (no approval required).

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

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => TRUE,

      'post comments' => TRUE,

      'skip comment approval' => TRUE,

    ));

    $this->drupalLogout();

    // Post comment #3 as anonymous.

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $anonymous_comment = $this->postComment($this->node, $this->randomName(), '', array('name' => $this->randomName()));

    $comment_loaded = comment_load($anonymous_comment->id);

    // Checks the new values of node comment statistics with comment #3.

    // The node needs to be reloaded with a node_load_multiple cache reset.

    $node = node_load($this->node->nid, NULL, TRUE);

    $this->assertEqual($node->last_comment_name, $comment_loaded->name, 'The value of node last_comment_name is the name of the anonymous user.');

    $this->assertEqual($node->last_comment_uid, 0, 'The value of node last_comment_uid is zero.');

    $this->assertEqual($node->comment_count, 2, 'The value of node comment_count is 2.');

  }

  /**

   * Tests comment links.

   *

   * The output of comment links depends on various environment conditions:

   * - Various Comment module configuration settings, user registration

   *   settings, and user access permissions.

   * - Whether the user is authenticated or not, and whether any comments exist.

   *

   * To account for all possible cases, this test creates permutations of all

   * possible conditions and tests the expected appearance of comment links in

   * each environment.

   */

  function testCommentLinks() {

    // Bartik theme alters comment links, so use a different theme.

    theme_enable(array('garland'));

    variable_set('theme_default', 'garland');

    // Remove additional user permissions from $this->web_user added by setUp(),

    // since this test is limited to anonymous and authenticated roles only.

    user_role_delete(key($this->web_user->roles));

    // Matrix of possible environmental conditions and configuration settings.

    // See setEnvironment() for details.

    $conditions = array(

      'authenticated'   => array(FALSE, TRUE),

      'comment count'   => array(FALSE, TRUE),

      'access comments' => array(0, 1),

      'post comments'   => array(0, 1),

      'form'            => array(COMMENT_FORM_BELOW, COMMENT_FORM_SEPARATE_PAGE),

      // USER_REGISTER_VISITORS_ADMINISTRATIVE_APPROVAL is irrelevant for this

      // test; there is only a difference between open and closed registration.

      'user_register'   => array(USER_REGISTER_VISITORS, USER_REGISTER_ADMINISTRATORS_ONLY),

      // @todo Complete test coverage for:

      //'comments'        => array(COMMENT_NODE_OPEN, COMMENT_NODE_CLOSED, COMMENT_NODE_HIDDEN),

      //// COMMENT_ANONYMOUS_MUST_CONTACT is irrelevant for this test.

      //'contact '        => array(COMMENT_ANONYMOUS_MAY_CONTACT, COMMENT_ANONYMOUS_MAYNOT_CONTACT),

    );

    $environments = $this->generatePermutations($conditions);

    foreach ($environments as $info) {

      $this->assertCommentLinks($info);

    }

  }

  /**

   * Re-configures the environment, module settings, and user permissions.

   *

   * @param $info

   *   An associative array describing the environment to setup:

   *   - Environment conditions:

   *     - authenticated: Boolean whether to test with $this->web_user or

   *       anonymous.

   *     - comment count: Boolean whether to test with a new/unread comment on

   *       $this->node or no comments.

   *   - Configuration settings:

   *     - form: COMMENT_FORM_BELOW or COMMENT_FORM_SEPARATE_PAGE.

   *     - user_register: USER_REGISTER_ADMINISTRATORS_ONLY or

   *       USER_REGISTER_VISITORS.

   *     - contact: COMMENT_ANONYMOUS_MAY_CONTACT or

   *       COMMENT_ANONYMOUS_MAYNOT_CONTACT.

   *     - comments: COMMENT_NODE_OPEN, COMMENT_NODE_CLOSED, or

   *       COMMENT_NODE_HIDDEN.

   *   - User permissions:

   *     These are granted or revoked for the user, according to the

   *     'authenticated' flag above. Pass 0 or 1 as parameter values. See

   *     user_role_change_permissions().

   *     - access comments

   *     - post comments

   *     - skip comment approval

   *     - edit own comments

   */

  function setEnvironment(array $info) {

    static $current;

    // Apply defaults to initial environment.

    if (!isset($current)) {

      $current = array(

        'authenticated' => FALSE,

        'comment count' => FALSE,

        'form' => COMMENT_FORM_BELOW,

        'user_register' => USER_REGISTER_VISITORS,

        'contact' => COMMENT_ANONYMOUS_MAY_CONTACT,

        'comments' => COMMENT_NODE_OPEN,

        'access comments' => 0,

        'post comments' => 0,

        // Enabled by default, because it's irrelevant for this test.

        'skip comment approval' => 1,

        'edit own comments' => 0,

      );

    }

    // Complete new environment with current environment.

    $info = array_merge($current, $info);

    // Change environment conditions.

    if ($current['authenticated'] != $info['authenticated']) {

      if ($this->loggedInUser) {

        $this->drupalLogout();

      }

      else {

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

      }

    }

    if ($current['comment count'] != $info['comment count']) {

      if ($info['comment count']) {

        // Create a comment via CRUD API functionality, since

        // $this->postComment() relies on actual user permissions.

        $comment = (object) array(

          'cid' => NULL,

          'nid' => $this->node->nid,

          'node_type' => $this->node->type,

          'pid' => 0,

          'uid' => 0,

          'status' => COMMENT_PUBLISHED,

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

          'hostname' => ip_address(),

          'language' => LANGUAGE_NONE,

          'comment_body' => array(LANGUAGE_NONE => array($this->randomName())),

        );

        comment_save($comment);

        $this->comment = $comment;

        // comment_num_new() relies on node_last_viewed(), so ensure that no one

        // has seen the node of this comment.

        db_delete('history')->condition('nid', $this->node->nid)->execute();

      }

      else {

        $cids = db_query("SELECT cid FROM {comment}")->fetchCol();

        comment_delete_multiple($cids);

        unset($this->comment);

      }

    }

    // Change comment settings.

    variable_set('comment_form_location_' . $this->node->type, $info['form']);

    variable_set('comment_anonymous_' . $this->node->type, $info['contact']);

    if ($this->node->comment != $info['comments']) {

      $this->node->comment = $info['comments'];

      node_save($this->node);

    }

    // Change user settings.

    variable_set('user_register', $info['user_register']);

    // Change user permissions.

    $rid = ($this->loggedInUser ? DRUPAL_AUTHENTICATED_RID : DRUPAL_ANONYMOUS_RID);

    $perms = array_intersect_key($info, array('access comments' => 1, 'post comments' => 1, 'skip comment approval' => 1, 'edit own comments' => 1));

    user_role_change_permissions($rid, $perms);

    // Output verbose debugging information.

    // @see DrupalTestCase::error()

    $t_form = array(

      COMMENT_FORM_BELOW => 'below',

      COMMENT_FORM_SEPARATE_PAGE => 'separate page',

    );

    $t_contact = array(

      COMMENT_ANONYMOUS_MAY_CONTACT => 'optional',

      COMMENT_ANONYMOUS_MAYNOT_CONTACT => 'disabled',

      COMMENT_ANONYMOUS_MUST_CONTACT => 'required',

    );

    $t_comments = array(

      COMMENT_NODE_OPEN => 'open',

      COMMENT_NODE_CLOSED => 'closed',

      COMMENT_NODE_HIDDEN => 'hidden',

    );

    $verbose = $info;

    $verbose['form'] = $t_form[$info['form']];

    $verbose['contact'] = $t_contact[$info['contact']];

    $verbose['comments'] = $t_comments[$info['comments']];

    $message = t('Changed environment:<pre>@verbose</pre>', array(

      '@verbose' => var_export($verbose, TRUE),

    ));

    $this->assert('debug', $message, 'Debug');

    // Update current environment.

    $current = $info;

    return $info;

  }

  /**

   * Asserts that comment links appear according to the passed environment setup.

   *

   * @param $info

   *   An associative array describing the environment to pass to

   *   setEnvironment().

   */

  function assertCommentLinks(array $info) {

    $info = $this->setEnvironment($info);

    $nid = $this->node->nid;

    foreach (array('', "node/$nid") as $path) {

      $this->drupalGet($path);

      // User is allowed to view comments.

      if ($info['access comments']) {

        if ($path == '') {

          // In teaser view, a link containing the comment count is always

          // expected.

          if ($info['comment count']) {

            $this->assertLink(t('1 comment'));

            // For logged in users, a link containing the amount of new/unread

            // comments is expected.

            // See important note about comment_num_new() below.

            if ($this->loggedInUser && isset($this->comment) && !isset($this->comment->seen)) {

              $this->assertLink(t('1 new comment'));

              $this->comment->seen = TRUE;

            }

          }

        }

      }

      else {

        $this->assertNoLink(t('1 comment'));

        $this->assertNoLink(t('1 new comment'));

      }

      // comment_num_new() is based on node views, so comments are marked as

      // read when a node is viewed, regardless of whether we have access to

      // comments.

      if ($path == "node/$nid" && $this->loggedInUser && isset($this->comment)) {

        $this->comment->seen = TRUE;

      }

      // User is not allowed to post comments.

      if (!$info['post comments']) {

        $this->assertNoLink('Add new comment');

        // Anonymous users should see a note to log in or register in case

        // authenticated users are allowed to post comments.

        // @see theme_comment_post_forbidden()

        if (!$this->loggedInUser) {

          if (user_access('post comments', $this->web_user)) {

            // The note depends on whether users are actually able to register.

            if ($info['user_register']) {

              $this->assertText('Log in or register to post comments');

            }

            else {

              $this->assertText('Log in to post comments');

            }

          }

          else {

            $this->assertNoText('Log in or register to post comments');

            $this->assertNoText('Log in to post comments');

          }

        }

      }

      // User is allowed to post comments.

      else {

        $this->assertNoText('Log in or register to post comments');

        // "Add new comment" is always expected, except when there are no

        // comments or if the user cannot see them.

        if ($path == "node/$nid" && $info['form'] == COMMENT_FORM_BELOW && (!$info['comment count'] || !$info['access comments'])) {

          $this->assertNoLink('Add new comment');

        }

        else {

          $this->assertLink('Add new comment');

        }

        // Also verify that the comment form appears according to the configured

        // location.

        if ($path == "node/$nid") {

          $elements = $this->xpath('//form[@id=:id]', array(':id' => 'comment-form'));

          if ($info['form'] == COMMENT_FORM_BELOW) {

            $this->assertTrue(count($elements), 'Comment form found below.');

          }

          else {

            $this->assertFalse(count($elements), 'Comment form not found below.');

          }

        }

      }

    }

  }

}

/**

 * Test previewing comments.

 */

class CommentPreviewTest extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Comment preview',

      'description' => 'Test comment preview.',

      'group' => 'Comment',

    );

  }

  /**

   * Test comment preview.

   */

  function testCommentPreview() {

    $langcode = LANGUAGE_NONE;

    // As admin user, configure comment settings.

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

    $this->setCommentPreview(DRUPAL_OPTIONAL);

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(TRUE);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');

    $this->drupalLogout();

    // Login as web user and add a signature and a user picture.

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

    variable_set('user_signatures', 1);

    variable_set('user_pictures', 1);

    $test_signature = $this->randomName();

    $edit['signature[value]'] = '<a href="http://example.com/">' . $test_signature. '</a>';

    $edit['signature[format]'] = 'filtered_html';

    $image = current($this->drupalGetTestFiles('image'));

    $edit['files[picture_upload]'] = drupal_realpath($image->uri);

    $this->drupalPost('user/' . $this->web_user->uid . '/edit', $edit, t('Save'));

    // As the web user, fill in the comment form and preview the comment.

    $edit = array();

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

    $edit['comment_body[' . $langcode . '][0][value]'] = $this->randomName(16);

    $this->drupalPost('node/' . $this->node->nid, $edit, t('Preview'));

    // Check that the preview is displaying the title and body.

    $this->assertTitle(t('Preview comment | Drupal'), 'Page title is "Preview comment".');

    $this->assertText($edit['subject'], 'Subject displayed.');

    $this->assertText($edit['comment_body[' . $langcode . '][0][value]'], 'Comment displayed.');

    // Check that the title and body fields are displayed with the correct values.

    $this->assertFieldByName('subject', $edit['subject'], 'Subject field displayed.');

    $this->assertFieldByName('comment_body[' . $langcode . '][0][value]', $edit['comment_body[' . $langcode . '][0][value]'], 'Comment field displayed.');

    // Check that the signature is displaying with the correct text format.

    $this->assertLink($test_signature);

    // Check that the user picture is displayed.

    $this->assertFieldByXPath("//div[contains(@class, 'comment-preview')]//div[contains(@class, 'user-picture')]//img", NULL, 'User picture displayed.');

  }

  /**

   * Test comment edit, preview, and save.

   */

  function testCommentEditPreviewSave() {

    $langcode = LANGUAGE_NONE;

    $web_user = $this->drupalCreateUser(array('access comments', 'post comments', 'skip comment approval'));

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

    $this->setCommentPreview(DRUPAL_OPTIONAL);

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(TRUE);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');

    $edit = array();

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

    $edit['comment_body[' . $langcode . '][0][value]'] = $this->randomName(16);

    $edit['name'] = $web_user->name;

    $edit['date'] = '2008-03-02 17:23 +0300';

    $raw_date = strtotime($edit['date']);

    $expected_text_date = format_date($raw_date);

    $expected_form_date = format_date($raw_date, 'custom', 'Y-m-d H:i O');

    $comment = $this->postComment($this->node, $edit['subject'], $edit['comment_body[' . $langcode . '][0][value]'], TRUE);

    $this->drupalPost('comment/' . $comment->id . '/edit', $edit, t('Preview'));

    // Check that the preview is displaying the subject, comment, author and date correctly.

    $this->assertTitle(t('Preview comment | Drupal'), 'Page title is "Preview comment".');

    $this->assertText($edit['subject'], 'Subject displayed.');

    $this->assertText($edit['comment_body[' . $langcode . '][0][value]'], 'Comment displayed.');

    $this->assertText($edit['name'], 'Author displayed.');

    $this->assertText($expected_text_date, 'Date displayed.');

    // Check that the subject, comment, author and date fields are displayed with the correct values.

    $this->assertFieldByName('subject', $edit['subject'], 'Subject field displayed.');

    $this->assertFieldByName('comment_body[' . $langcode . '][0][value]', $edit['comment_body[' . $langcode . '][0][value]'], 'Comment field displayed.');

    $this->assertFieldByName('name', $edit['name'], 'Author field displayed.');

    $this->assertFieldByName('date', $edit['date'], 'Date field displayed.');

    // Check that saving a comment produces a success message.

    $this->drupalPost('comment/' . $comment->id . '/edit', $edit, t('Save'));

    $this->assertText(t('Your comment has been posted.'), 'Comment posted.');

    // Check that the comment fields are correct after loading the saved comment.

    $this->drupalGet('comment/' . $comment->id . '/edit');

    $this->assertFieldByName('subject', $edit['subject'], 'Subject field displayed.');

    $this->assertFieldByName('comment_body[' . $langcode . '][0][value]', $edit['comment_body[' . $langcode . '][0][value]'], 'Comment field displayed.');

    $this->assertFieldByName('name', $edit['name'], 'Author field displayed.');

    $this->assertFieldByName('date', $expected_form_date, 'Date field displayed.');

    // Submit the form using the displayed values.

    $displayed = array();

    $displayed['subject'] = (string) current($this->xpath("//input[@id='edit-subject']/@value"));

    $displayed['comment_body[' . $langcode . '][0][value]'] = (string) current($this->xpath("//textarea[@id='edit-comment-body-" . $langcode . "-0-value']"));

    $displayed['name'] = (string) current($this->xpath("//input[@id='edit-name']/@value"));

    $displayed['date'] = (string) current($this->xpath("//input[@id='edit-date']/@value"));

    $this->drupalPost('comment/' . $comment->id . '/edit', $displayed, t('Save'));

    // Check that the saved comment is still correct.

    $comment_loaded = comment_load($comment->id);

    $this->assertEqual($comment_loaded->subject, $edit['subject'], 'Subject loaded.');

    $this->assertEqual($comment_loaded->comment_body[$langcode][0]['value'], $edit['comment_body[' . $langcode . '][0][value]'], 'Comment body loaded.');

    $this->assertEqual($comment_loaded->name, $edit['name'], 'Name loaded.');

    $this->assertEqual($comment_loaded->created, $raw_date, 'Date loaded.');

  }

}

class CommentAnonymous extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Anonymous comments',

      'description' => 'Test anonymous comments.',

      'group' => 'Comment',

    );

  }

  function setUp() {

    parent::setUp();

    variable_set('user_register', USER_REGISTER_VISITORS);

  }

  /**

   * Test anonymous comment functionality.

   */

  function testAnonymous() {

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

    // Enabled anonymous user comments.

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => TRUE,

      'post comments' => TRUE,

      'skip comment approval' => TRUE,

    ));

    $this->setCommentAnonymous('0'); // Ensure that doesn't require contact info.

    $this->drupalLogout();

    // Post anonymous comment without contact info.

    $anonymous_comment1 = $this->postComment($this->node, $this->randomName(), $this->randomName());

    $this->assertTrue($this->commentExists($anonymous_comment1), 'Anonymous comment without contact info found.');

    // Allow contact info.

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

    $this->setCommentAnonymous('1');

    // Attempt to edit anonymous comment.

    $this->drupalGet('comment/' . $anonymous_comment1->id . '/edit');

    $edited_comment = $this->postComment(NULL, $this->randomName(), $this->randomName());

    $this->assertTrue($this->commentExists($edited_comment, FALSE), 'Modified reply found.');

    $this->drupalLogout();

    // Post anonymous comment with contact info (optional).

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $this->assertTrue($this->commentContactInfoAvailable(), 'Contact information available.');

    $anonymous_comment2 = $this->postComment($this->node, $this->randomName(), $this->randomName());

    $this->assertTrue($this->commentExists($anonymous_comment2), 'Anonymous comment with contact info (optional) found.');

    // Ensure anonymous users cannot post in the name of registered users.

    $langcode = LANGUAGE_NONE;

    $edit = array(

      'name' => $this->admin_user->name,

      'mail' => $this->randomName() . '@example.com',

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

      "comment_body[$langcode][0][value]" => $this->randomName(),

    );

    $this->drupalPost('comment/reply/' . $this->node->nid, $edit, t('Save'));

    $this->assertText(t('The name you used belongs to a registered user.'));

    // Require contact info.

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

    $this->setCommentAnonymous('2');

    $this->drupalLogout();

    // Try to post comment with contact info (required).

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $this->assertTrue($this->commentContactInfoAvailable(), 'Contact information available.');

    $anonymous_comment3 = $this->postComment($this->node, $this->randomName(), $this->randomName(), TRUE);

    // Name should have 'Anonymous' for value by default.

    $this->assertText(t('E-mail field is required.'), 'E-mail required.');

    $this->assertFalse($this->commentExists($anonymous_comment3), 'Anonymous comment with contact info (required) not found.');

    // Post comment with contact info (required).

    $author_name = $this->randomName();

    $author_mail = $this->randomName() . '@example.com';

    $anonymous_comment3 = $this->postComment($this->node, $this->randomName(), $this->randomName(), array('name' => $author_name, 'mail' => $author_mail));

    $this->assertTrue($this->commentExists($anonymous_comment3), 'Anonymous comment with contact info (required) found.');

    // Make sure the user data appears correctly when editing the comment.

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

    $this->drupalGet('comment/' . $anonymous_comment3->id . '/edit');

    $this->assertRaw($author_name, "The anonymous user's name is correct when editing the comment.");

    $this->assertRaw($author_mail, "The anonymous user's e-mail address is correct when editing the comment.");

    // Unpublish comment.

    $this->performCommentOperation($anonymous_comment3, 'unpublish');

    $this->drupalGet('admin/content/comment/approval');

    $this->assertRaw('comments[' . $anonymous_comment3->id . ']', 'Comment was unpublished.');

    // Publish comment.

    $this->performCommentOperation($anonymous_comment3, 'publish', TRUE);

    $this->drupalGet('admin/content/comment');

    $this->assertRaw('comments[' . $anonymous_comment3->id . ']', 'Comment was published.');

    // Delete comment.

    $this->performCommentOperation($anonymous_comment3, 'delete');

    $this->drupalGet('admin/content/comment');

    $this->assertNoRaw('comments[' . $anonymous_comment3->id . ']', 'Comment was deleted.');

    $this->drupalLogout();

    // Reset.

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => FALSE,

      'post comments' => FALSE,

      'skip comment approval' => FALSE,

    ));

    // Attempt to view comments while disallowed.

    // NOTE: if authenticated user has permission to post comments, then a

    // "Login or register to post comments" type link may be shown.

    $this->drupalGet('node/' . $this->node->nid);

    $this->assertNoPattern('@<h2[^>]*>Comments</h2>@', 'Comments were not displayed.');

    $this->assertNoLink('Add new comment', 'Link to add comment was found.');

    // Attempt to view node-comment form while disallowed.

    $this->drupalGet('comment/reply/' . $this->node->nid);

    $this->assertText('You are not authorized to post comments', 'Error attempting to post comment.');

    $this->assertNoFieldByName('subject', '', 'Subject field not found.');

    $this->assertNoFieldByName("comment_body[$langcode][0][value]", '', 'Comment field not found.');

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => TRUE,

      'post comments' => FALSE,

      'skip comment approval' => FALSE,

    ));

    $this->drupalGet('node/' . $this->node->nid);

    $this->assertPattern('@<h2[^>]*>Comments</h2>@', 'Comments were displayed.');

    $this->assertLink('Log in', 1, 'Link to log in was found.');

    $this->assertLink('register', 1, 'Link to register was found.');

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => FALSE,

      'post comments' => TRUE,

      'skip comment approval' => TRUE,

    ));

    $this->drupalGet('node/' . $this->node->nid);

    $this->assertNoPattern('@<h2[^>]*>Comments</h2>@', 'Comments were not displayed.');

    $this->assertFieldByName('subject', '', 'Subject field found.');

    $this->assertFieldByName("comment_body[$langcode][0][value]", '', 'Comment field found.');

    $this->drupalGet('comment/reply/' . $this->node->nid . '/' . $anonymous_comment3->id);

    $this->assertText('You are not authorized to view comments', 'Error attempting to post reply.');

    $this->assertNoText($author_name, 'Comment not displayed.');

  }

}

/**

 * Verify pagination of comments.

 */

class CommentPagerTest extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Comment paging settings',

      'description' => 'Test paging of comments and their settings.',

      'group' => 'Comment',

    );

  }

  /**

   * Confirm comment paging works correctly with flat and threaded comments.

   */

  function testCommentPaging() {

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

    // Set comment variables.

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(TRUE);

    $this->setCommentPreview(DRUPAL_DISABLED);

    // Create a node and three comments.

    $node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1));

    $comments = array();

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_FLAT, 'Comment paging changed.');

    // Set comments to one per page so that we are able to test paging without

    // needing to insert large numbers of comments.

    $this->setCommentsPerPage(1);

    // Check the first page of the node, and confirm the correct comments are

    // shown.

    $this->drupalGet('node/' . $node->nid);

    $this->assertRaw(t('next'), 'Paging links found.');

    $this->assertTrue($this->commentExists($comments[0]), 'Comment 1 appears on page 1.');

    $this->assertFalse($this->commentExists($comments[1]), 'Comment 2 does not appear on page 1.');

    $this->assertFalse($this->commentExists($comments[2]), 'Comment 3 does not appear on page 1.');

    // Check the second page.

    $this->drupalGet('node/' . $node->nid, array('query' => array('page' => 1)));

    $this->assertTrue($this->commentExists($comments[1]), 'Comment 2 appears on page 2.');

    $this->assertFalse($this->commentExists($comments[0]), 'Comment 1 does not appear on page 2.');

    $this->assertFalse($this->commentExists($comments[2]), 'Comment 3 does not appear on page 2.');

    // Check the third page.

    $this->drupalGet('node/' . $node->nid, array('query' => array('page' => 2)));

    $this->assertTrue($this->commentExists($comments[2]), 'Comment 3 appears on page 3.');

    $this->assertFalse($this->commentExists($comments[0]), 'Comment 1 does not appear on page 3.');

    $this->assertFalse($this->commentExists($comments[1]), 'Comment 2 does not appear on page 3.');

    // Post a reply to the oldest comment and test again.

    $replies = array();

    $oldest_comment = reset($comments);

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $oldest_comment->id);

    $reply = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    $this->setCommentsPerPage(2);

    // We are still in flat view - the replies should not be on the first page,

    // even though they are replies to the oldest comment.

    $this->drupalGet('node/' . $node->nid, array('query' => array('page' => 0)));

    $this->assertFalse($this->commentExists($reply, TRUE), 'In flat mode, reply does not appear on page 1.');

    // If we switch to threaded mode, the replies on the oldest comment

    // should be bumped to the first page and comment 6 should be bumped

    // to the second page.

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Switched to threaded mode.');

    $this->drupalGet('node/' . $node->nid, array('query' => array('page' => 0)));

    $this->assertTrue($this->commentExists($reply, TRUE), 'In threaded mode, reply appears on page 1.');

    $this->assertFalse($this->commentExists($comments[1]), 'In threaded mode, comment 2 has been bumped off of page 1.');

    // If (# replies > # comments per page) in threaded expanded view,

    // the overage should be bumped.

    $reply2 = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    $this->drupalGet('node/' . $node->nid, array('query' => array('page' => 0)));

    $this->assertFalse($this->commentExists($reply2, TRUE), 'In threaded mode where # replies > # comments per page, the newest reply does not appear on page 1.');

    $this->drupalLogout();

  }

  /**

   * Test comment ordering and threading.

   */

  function testCommentOrderingThreading() {

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

    // Set comment variables.

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(TRUE);

    $this->setCommentPreview(DRUPAL_DISABLED);

    // Display all the comments on the same page.

    $this->setCommentsPerPage(1000);

    // Create a node and three comments.

    $node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1));

    $comments = array();

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the second comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[1]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the first comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[0]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the last comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[2]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the second comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[3]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // At this point, the comment tree is:

    // - 0

    //   - 4

    // - 1

    //   - 3

    //     - 6

    // - 2

    //   - 5

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_FLAT, 'Comment paging changed.');

    $expected_order = array(

      0,

      1,

      2,

      3,

      4,

      5,

      6,

    );

    $this->drupalGet('node/' . $node->nid);

    $this->assertCommentOrder($comments, $expected_order);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Switched to threaded mode.');

    $expected_order = array(

      0,

      4,

      1,

      3,

      6,

      2,

      5,

    );

    $this->drupalGet('node/' . $node->nid);

    $this->assertCommentOrder($comments, $expected_order);

  }

  /**

   * Helper function: assert that the comments are displayed in the correct order.

   *

   * @param $comments

   *   And array of comments.

   * @param $expected_order

   *   An array of keys from $comments describing the expected order.

   */

  function assertCommentOrder(array $comments, array $expected_order) {

    $expected_cids = array();

    // First, rekey the expected order by cid.

    foreach ($expected_order as $key) {

      $expected_cids[] = $comments[$key]->id;

    }

    $comment_anchors = $this->xpath('//a[starts-with(@id,"comment-")]');

    $result_order = array();

    foreach ($comment_anchors as $anchor) {

      $result_order[] = substr($anchor['id'], 8);

    }

    return $this->assertIdentical($expected_cids, $result_order, format_string('Comment order: expected @expected, returned @returned.', array('@expected' => implode(',', $expected_cids), '@returned' => implode(',', $result_order))));

  }

  /**

   * Test comment_new_page_count().

   */

  function testCommentNewPageIndicator() {

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

    // Set comment variables.

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(TRUE);

    $this->setCommentPreview(DRUPAL_DISABLED);

    // Set comments to one per page so that we are able to test paging without

    // needing to insert large numbers of comments.

    $this->setCommentsPerPage(1);

    // Create a node and three comments.

    $node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1));

    $comments = array();

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    $comments[] = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the second comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[1]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the first comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[0]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // Post a reply to the last comment.

    $this->drupalGet('comment/reply/' . $node->nid . '/' . $comments[2]->id);

    $comments[] = $this->postComment(NULL, $this->randomName(), $this->randomName(), TRUE);

    // At this point, the comment tree is:

    // - 0

    //   - 4

    // - 1

    //   - 3

    // - 2

    //   - 5

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_FLAT, 'Comment paging changed.');

    $expected_pages = array(

      1 => 5, // Page of comment 5

      2 => 4, // Page of comment 4

      3 => 3, // Page of comment 3

      4 => 2, // Page of comment 2

      5 => 1, // Page of comment 1

      6 => 0, // Page of comment 0

    );

    $node = node_load($node->nid);

    foreach ($expected_pages as $new_replies => $expected_page) {

      $returned = comment_new_page_count($node->comment_count, $new_replies, $node);

      $returned_page = is_array($returned) ? $returned['page'] : 0;

      $this->assertIdentical($expected_page, $returned_page, format_string('Flat mode, @new replies: expected page @expected, returned page @returned.', array('@new' => $new_replies, '@expected' => $expected_page, '@returned' => $returned_page)));

    }

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Switched to threaded mode.');

    $expected_pages = array(

      1 => 5, // Page of comment 5

      2 => 1, // Page of comment 4

      3 => 1, // Page of comment 4

      4 => 1, // Page of comment 4

      5 => 1, // Page of comment 4

      6 => 0, // Page of comment 0

    );

    $node = node_load($node->nid);

    foreach ($expected_pages as $new_replies => $expected_page) {

      $returned = comment_new_page_count($node->comment_count, $new_replies, $node);

      $returned_page = is_array($returned) ? $returned['page'] : 0;

      $this->assertEqual($expected_page, $returned_page, format_string('Threaded mode, @new replies: expected page @expected, returned page @returned.', array('@new' => $new_replies, '@expected' => $expected_page, '@returned' => $returned_page)));

    }

  }

}

/**

 * Tests comments with node access.

 *

 * See http://drupal.org/node/886752 -- verify there is no PostgreSQL error when

 * viewing a node with threaded comments (a comment and a reply), if a node

 * access module is in use.

 */

class CommentNodeAccessTest extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Comment node access',

      'description' => 'Test comment viewing with node access.',

      'group' => 'Comment',

    );

  }

  function setUp() {

    parent::setUp('search', 'node_access_test');

    node_access_rebuild();

    // Create users and test node.

    $this->admin_user = $this->drupalCreateUser(array('administer content types', 'administer comments', 'administer blocks'));

    $this->web_user = $this->drupalCreateUser(array('access comments', 'post comments', 'create article content', 'edit own comments', 'node test view'));

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1, 'uid' => $this->web_user->uid));

  }

  /**

   * Test that threaded comments can be viewed.

   */

  function testThreadedCommentView() {

    $langcode = LANGUAGE_NONE;

    // Set comments to have subject required and preview disabled.

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

    $this->setCommentPreview(DRUPAL_DISABLED);

    $this->setCommentForm(TRUE);

    $this->setCommentSubject(TRUE);

    $this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');

    $this->drupalLogout();

    // Post comment.

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

    $comment_text = $this->randomName();

    $comment_subject = $this->randomName();

    $comment = $this->postComment($this->node, $comment_text, $comment_subject);

    $comment_loaded = comment_load($comment->id);

    $this->assertTrue($this->commentExists($comment), 'Comment found.');

    // Check comment display.

    $this->drupalGet('node/' . $this->node->nid . '/' . $comment->id);

    $this->assertText($comment_subject, 'Individual comment subject found.');

    $this->assertText($comment_text, 'Individual comment body found.');

    // Reply to comment, creating second comment.

    $this->drupalGet('comment/reply/' . $this->node->nid . '/' . $comment->id);

    $reply_text = $this->randomName();

    $reply_subject = $this->randomName();

    $reply = $this->postComment(NULL, $reply_text, $reply_subject, TRUE);

    $reply_loaded = comment_load($reply->id);

    $this->assertTrue($this->commentExists($reply, TRUE), 'Reply found.');

    // Go to the node page and verify comment and reply are visible.

    $this->drupalGet('node/' . $this->node->nid);

    $this->assertText($comment_text);

    $this->assertText($comment_subject);

    $this->assertText($reply_text);

    $this->assertText($reply_subject);

  }

}

class CommentApprovalTest extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Comment approval',

      'description' => 'Test comment approval functionality.',

      'group' => 'Comment',

    );

  }

  /**

   * Test comment approval functionality through admin/content/comment.

   */

  function testApprovalAdminInterface() {

    // Set anonymous comments to require approval.

    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(

      'access comments' => TRUE,

      'post comments' => TRUE,

      'skip comment approval' => FALSE,

    ));

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

    $this->setCommentAnonymous('0'); // Ensure that doesn't require contact info.

    // Test that the comments page loads correctly when there are no comments

    $this->drupalGet('admin/content/comment');

    $this->assertText(t('No comments available.'));