1260 lines
52 KiB
Plaintext
1260 lines
52 KiB
Plaintext
<?php
|
|
// $Id$
|
|
|
|
class CommentHelperCase extends DrupalWebTestCase {
|
|
protected $admin_user;
|
|
protected $web_user;
|
|
protected $node;
|
|
|
|
function setUp() {
|
|
parent::setUp('comment', 'search');
|
|
// 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'));
|
|
$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', '', t('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'), t('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'), t('Preview button found.'));
|
|
$this->assertFieldByName('op', t('Save'), t('Save button found.'));
|
|
$this->drupalPost(NULL, $edit, t('Save'));
|
|
break;
|
|
|
|
case DRUPAL_DISABLED:
|
|
$this->assertNoFieldByName('op', t('Preview'), t('Preview button not found.'));
|
|
$this->assertFieldByName('op', t('Save'), t('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])), t('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.'), t('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, 'Comment preview ' . $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, 'Anonymous commenting set to 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, 'Number of comments per page set to ' . $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);
|
|
$this->assertTrue(TRUE, t($message)); // Display status 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(t('Deleted @count comments.', array('@count' => 1)), t('Operation "' . $operation . '" was performed on comment.'));
|
|
}
|
|
else {
|
|
$this->assertText(t('The update has been performed.'), t('Operation "' . $operation . '" was performed on comment.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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, t('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), t('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), t('Comment found.'));
|
|
|
|
// Check comment display.
|
|
$this->drupalGet('node/' . $this->node->nid . '/' . $comment->id);
|
|
$this->assertText($subject_text, t('Individual comment subject found.'));
|
|
$this->assertText($comment_text, t('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);
|
|
$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, t('Individual comment-reply subject found.'));
|
|
$this->assertText($comment_text, t('Individual comment-reply body found.'));
|
|
$reply = $this->postComment(NULL, $this->randomName(), '', TRUE);
|
|
$reply_loaded = comment_load($reply->id);
|
|
$this->assertTrue($this->commentExists($reply, TRUE), t('Reply found.'));
|
|
$this->assertEqual($comment->id, $reply_loaded->pid, t('Pid of a reply to a comment is set correctly.'));
|
|
$this->assertEqual(rtrim($comment_loaded->thread, '/') . '.00/', $reply_loaded->thread, t('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, t('Individual comment-reply subject found.'));
|
|
$this->assertText($comment_text, t('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), t('Second reply found.'));
|
|
$this->assertEqual(rtrim($comment_loaded->thread, '/') . '.01/', $reply_loaded->thread, t('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), t('Modified reply found.'));
|
|
|
|
// Correct link count
|
|
$this->drupalGet('node');
|
|
$this->assertRaw('4 comments', t('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), t('Page one exists. %s'));
|
|
$this->drupalGet('node/' . $this->node->nid, array('query' => array('page' => 1)));
|
|
$this->assertTrue($this->commentExists($reply, TRUE), t('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, t('Article node created.'));
|
|
$this->drupalGet('comment/reply/' . $this->node->nid);
|
|
$this->assertText('This discussion is closed', t('Posting to node with comments disabled'));
|
|
$this->assertNoField('edit-comment', t('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, t('Article node created.'));
|
|
$this->drupalGet('comment/reply/' . $this->node->nid);
|
|
$this->assertText('This discussion is closed', t('Posting to node with comments read-only'));
|
|
$this->assertNoField('edit-comment', t('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, t('Article node created.'));
|
|
$this->drupalGet('comment/reply/' . $this->node->nid);
|
|
$this->assertNoText('This discussion is closed', t('Posting to node with comments enabled'));
|
|
$this->assertField('edit-comment-body-' . $langcode . '-0-value', t('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), t('Comment not found.'));
|
|
$this->assertFalse($this->commentExists($reply, TRUE), t('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), t('Form comment found.'));
|
|
|
|
// Disable comment form on node page.
|
|
$this->drupalLogout();
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->setCommentForm(FALSE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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, t('Comment paging changed.'));
|
|
$this->drupalLogout();
|
|
|
|
// As web user, fill in node creation form and preview node.
|
|
$this->drupalLogin($this->web_user);
|
|
$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'), t('Page title is "Preview comment".'));
|
|
$this->assertText($edit['subject'], t('Subject displayed.'));
|
|
$this->assertText($edit['comment_body[' . $langcode . '][0][value]'], t('Comment displayed.'));
|
|
|
|
// Check that the title and body fields are displayed with the correct values.
|
|
$this->assertFieldByName('subject', $edit['subject'], t('Subject field displayed.'));
|
|
$this->assertFieldByName('comment_body[' . $langcode . '][0][value]', $edit['comment_body[' . $langcode . '][0][value]'], t('Comment field displayed.'));
|
|
}
|
|
|
|
/**
|
|
* Test comment edit and preview.
|
|
*/
|
|
function testCommentEditPreview() {
|
|
$langcode = LANGUAGE_NONE;
|
|
$web_user = $this->drupalCreateUser(array('access comments', 'post comments', 'post comments without approval'));
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->setCommentPreview(DRUPAL_OPTIONAL);
|
|
$this->setCommentForm(TRUE);
|
|
$this->setCommentSubject(TRUE);
|
|
$this->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, t('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';
|
|
$expected_date = format_date(strtotime($edit['date']));
|
|
$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'), t('Page title is "Preview comment".'));
|
|
$this->assertText($edit['subject'], t('Subject displayed.'));
|
|
$this->assertText($edit['comment_body[' . $langcode . '][0][value]'], t('Comment displayed.'));
|
|
$this->assertText($edit['name'], t('Author displayed.'));
|
|
$this->assertText($expected_date, t('Date displayed.'));
|
|
|
|
// Check that the title and body fields are displayed with the correct values.
|
|
$this->assertFieldByName('subject', $edit['subject'], t('Subject field displayed.'));
|
|
$this->assertFieldByName('comment_body[' . $langcode . '][0][value]', $edit['comment_body[' . $langcode . '][0][value]'], t('Comment field displayed.'));
|
|
$this->assertFieldByName('name', $edit['name'], t('Author field displayed.'));
|
|
$this->assertFieldByName('date', $edit['date'], t('Date field displayed.'));
|
|
}
|
|
|
|
}
|
|
|
|
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,
|
|
'post comments without 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), t('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), t('Modified reply found.'));
|
|
$this->drupalLogout();
|
|
|
|
// Post anonymous comment with contact info (optional).
|
|
$this->drupalGet('comment/reply/' . $this->node->nid);
|
|
$this->assertTrue($this->commentContactInfoAvailable(), t('Contact information available.'));
|
|
|
|
$anonymous_comment2 = $this->postComment($this->node, $this->randomName(), $this->randomName());
|
|
$this->assertTrue($this->commentExists($anonymous_comment2), t('Anonymous comment with contact info (optional) found.'));
|
|
|
|
// Ensure anonymous users cannot post in the name of registered users.
|
|
$edit = array(
|
|
'name' => $this->admin_user->name,
|
|
'mail' => $this->randomName() . '@example.com',
|
|
'subject' => $this->randomName(),
|
|
'comment_body[' . LANGUAGE_NONE . '][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(), t('Contact information available.'));
|
|
|
|
$anonymous_comment3 = $this->postComment($this->node, $this->randomName(), $this->randomName(), TRUE);
|
|
$this->assertText(t('E-mail field is required.'), t('E-mail required.')); // Name should have 'Anonymous' for value by default.
|
|
$this->assertFalse($this->commentExists($anonymous_comment3), t('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), t('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, t("The anonymous user's name is correct when editing the comment."));
|
|
$this->assertRaw($author_mail, t("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 . ']', t('Comment was unpublished.'));
|
|
|
|
// Publish comment.
|
|
$this->performCommentOperation($anonymous_comment3, 'publish', TRUE);
|
|
|
|
$this->drupalGet('admin/content/comment');
|
|
$this->assertRaw('comments[' . $anonymous_comment3->id . ']', t('Comment was published.'));
|
|
|
|
// Delete comment.
|
|
$this->performCommentOperation($anonymous_comment3, 'delete');
|
|
|
|
$this->drupalGet('admin/content/comment');
|
|
$this->assertNoRaw('comments[' . $anonymous_comment3->id . ']', t('Comment was deleted.'));
|
|
$this->drupalLogout();
|
|
|
|
// Reset.
|
|
user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(
|
|
'access comments' => FALSE,
|
|
'post comments' => FALSE,
|
|
'post comments without 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('/<div ([^>]*?)id="comments"([^>]*?)>/', t('Comments were not displayed.'));
|
|
$this->assertNoLink('Add new comment', t('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 view comments', t('Error attempting to post comment.'));
|
|
$this->assertNoFieldByName('subject', '', t('Subject field not found.'));
|
|
$this->assertNoFieldByName('comment[value]', '', t('Comment field not found.'));
|
|
|
|
user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(
|
|
'access comments' => TRUE,
|
|
'post comments' => FALSE,
|
|
'post comments without approval' => FALSE,
|
|
));
|
|
$this->drupalGet('node/' . $this->node->nid);
|
|
$this->assertPattern('/<div ([^>]*?)id="comments"([^>]*?)>/', t('Comments were displayed.'));
|
|
$this->assertLink('Log in', 1, t('Link to log in was found.'));
|
|
$this->assertLink('register', 1, t('Link to register was found.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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, t('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'), t('Paging links found.'));
|
|
$this->assertTrue($this->commentExists($comments[0]), t('Comment 1 appears on page 1.'));
|
|
$this->assertFalse($this->commentExists($comments[1]), t('Comment 2 does not appear on page 1.'));
|
|
$this->assertFalse($this->commentExists($comments[2]), t('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]), t('Comment 2 appears on page 2.'));
|
|
$this->assertFalse($this->commentExists($comments[0]), t('Comment 1 does not appear on page 2.'));
|
|
$this->assertFalse($this->commentExists($comments[2]), t('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]), t('Comment 3 appears on page 3.'));
|
|
$this->assertFalse($this->commentExists($comments[0]), t('Comment 1 does not appear on page 3.'));
|
|
$this->assertFalse($this->commentExists($comments[1]), t('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), t('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, t('Switched to threaded mode.'));
|
|
$this->drupalGet('node/' . $node->nid, array('query' => array('page' => 0)));
|
|
$this->assertTrue($this->commentExists($reply, TRUE), t('In threaded mode, reply appears on page 1.'));
|
|
$this->assertFalse($this->commentExists($comments[1]), t('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), t('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, t('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, t('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, t('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, t('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, t('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, t('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, t('Threaded mode, @new replies: expected page @expected, returned page @returned.', array('@new' => $new_replies, '@expected' => $expected_page, '@returned' => $returned_page)));
|
|
}
|
|
}
|
|
}
|
|
|
|
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,
|
|
'post comments without 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.'));
|
|
|
|
$this->drupalLogout();
|
|
|
|
// Post anonymous comment without contact info.
|
|
$subject = $this->randomName();
|
|
$body = $this->randomName();
|
|
$this->postComment($this->node, $body, $subject, TRUE); // Set $contact to true so that it won't check for id and message.
|
|
$this->assertText(t('Your comment has been queued for review by site administrators and will be published after approval.'), t('Comment requires approval.'));
|
|
|
|
// Get unapproved comment id.
|
|
$this->drupalLogin($this->admin_user);
|
|
$anonymous_comment4 = $this->getUnapprovedComment($subject);
|
|
$anonymous_comment4 = (object) array('id' => $anonymous_comment4, 'subject' => $subject, 'comment' => $body);
|
|
$this->drupalLogout();
|
|
|
|
$this->assertFalse($this->commentExists($anonymous_comment4), t('Anonymous comment was not published.'));
|
|
|
|
// Approve comment.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->performCommentOperation($anonymous_comment4, 'publish', TRUE);
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet('node/' . $this->node->nid);
|
|
$this->assertTrue($this->commentExists($anonymous_comment4), t('Anonymous comment visible.'));
|
|
|
|
// Post 2 anonymous comments without contact info.
|
|
$comments[] = $this->postComment($this->node, $this->randomName(), $this->randomName(), TRUE);
|
|
$comments[] = $this->postComment($this->node, $this->randomName(), $this->randomName(), TRUE);
|
|
|
|
// Publish multiple comments in one operation.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalGet('admin/content/comment/approval');
|
|
$this->assertText(t('Unapproved comments (@count)', array('@count' => 2)), t('Two unapproved comments waiting for approval.'));
|
|
$edit = array(
|
|
"comments[{$comments[0]->id}]" => 1,
|
|
"comments[{$comments[1]->id}]" => 1,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Update'));
|
|
$this->assertText(t('Unapproved comments (@count)', array('@count' => 0)), t('All comments were approved.'));
|
|
|
|
// Delete multiple comments in one operation.
|
|
$edit = array(
|
|
'operation' => 'delete',
|
|
"comments[{$comments[0]->id}]" => 1,
|
|
"comments[{$comments[1]->id}]" => 1,
|
|
"comments[{$anonymous_comment4->id}]" => 1,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Update'));
|
|
$this->assertText(t('Are you sure you want to delete these comments and all their children?'), t('Confirmation required.'));
|
|
$this->drupalPost(NULL, $edit, t('Delete comments'));
|
|
$this->assertText(t('No comments available.'), t('All comments were deleted.'));
|
|
}
|
|
|
|
/**
|
|
* Test comment approval functionality through node interface.
|
|
*/
|
|
function testApprovalNodeInterface() {
|
|
// Set anonymous comments to require approval.
|
|
user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(
|
|
'access comments' => TRUE,
|
|
'post comments' => TRUE,
|
|
'post comments without approval' => FALSE,
|
|
));
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->setCommentAnonymous('0'); // Ensure that doesn't require contact info.
|
|
$this->drupalLogout();
|
|
|
|
// Post anonymous comment without contact info.
|
|
$subject = $this->randomName();
|
|
$body = $this->randomName();
|
|
$this->postComment($this->node, $body, $subject, TRUE); // Set $contact to true so that it won't check for id and message.
|
|
$this->assertText(t('Your comment has been queued for review by site administrators and will be published after approval.'), t('Comment requires approval.'));
|
|
|
|
// Get unapproved comment id.
|
|
$this->drupalLogin($this->admin_user);
|
|
$anonymous_comment4 = $this->getUnapprovedComment($subject);
|
|
$anonymous_comment4 = (object) array('id' => $anonymous_comment4, 'subject' => $subject, 'comment' => $body);
|
|
$this->drupalLogout();
|
|
|
|
$this->assertFalse($this->commentExists($anonymous_comment4), t('Anonymous comment was not published.'));
|
|
|
|
// Approve comment.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalGet('comment/1/approve');
|
|
$this->assertResponse(403, t('Forged comment approval was denied.'));
|
|
$this->drupalGet('comment/1/approve', array('query' => array('token' => 'forged')));
|
|
$this->assertResponse(403, t('Forged comment approval was denied.'));
|
|
$this->drupalGet('node/' . $this->node->nid);
|
|
$this->clickLink(t('approve'));
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet('node/' . $this->node->nid);
|
|
$this->assertTrue($this->commentExists($anonymous_comment4), t('Anonymous comment visible.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for the comment module blocks.
|
|
*/
|
|
class CommentBlockFunctionalTest extends CommentHelperCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Comment blocks',
|
|
'description' => 'Test comment block functionality.',
|
|
'group' => 'Comment',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test the recent comments block.
|
|
*/
|
|
function testRecentCommentBlock() {
|
|
$this->drupalLogin($this->admin_user);
|
|
|
|
// Set the block to a region to confirm block is available.
|
|
$edit = array(
|
|
'blocks[comment_recent][region]' => 'sidebar_first',
|
|
);
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
$this->assertText(t('The block settings have been updated.'), t('Block saved to first sidebar region.'));
|
|
|
|
// Set block title and variables.
|
|
$block = array(
|
|
'title' => $this->randomName(),
|
|
'comment_block_count' => 2,
|
|
);
|
|
$this->drupalPost('admin/structure/block/manage/comment/recent/configure', $block, t('Save block'));
|
|
$this->assertText(t('The block configuration has been saved.'), t('Block saved.'));
|
|
|
|
// Add some test comments, one without a subject.
|
|
$comment1 = $this->postComment($this->node, $this->randomName(), $this->randomName());
|
|
$comment2 = $this->postComment($this->node, $this->randomName(), $this->randomName());
|
|
$comment3 = $this->postComment($this->node, $this->randomName());
|
|
|
|
// Test that a user without the 'access comments' permission cannot see the
|
|
// block.
|
|
$this->drupalLogout();
|
|
user_role_revoke_permissions(DRUPAL_ANONYMOUS_RID, array('access comments'));
|
|
$this->drupalGet('');
|
|
$this->assertNoText($block['title'], t('Block was not found.'));
|
|
user_role_grant_permissions(DRUPAL_ANONYMOUS_RID, array('access comments'));
|
|
|
|
// Test that a user with the 'access comments' permission can see the
|
|
// block.
|
|
$this->drupalLogin($this->web_user);
|
|
$this->drupalGet('');
|
|
$this->assertText($block['title'], t('Block was found.'));
|
|
|
|
// Test the only the 2 latest comments are shown and in the proper order.
|
|
$this->assertNoText($comment1->subject, t('Comment not found in block.'));
|
|
$this->assertText($comment2->subject, t('Comment found in block.'));
|
|
$this->assertText($comment3->comment, t('Comment found in block.'));
|
|
$this->assertTrue(strpos($this->drupalGetContent(), $comment3->comment) < strpos($this->drupalGetContent(), $comment2->subject), t('Comments were ordered correctly in block.'));
|
|
|
|
// Set the number of recent comments to show to 10.
|
|
$this->drupalLogout();
|
|
$this->drupalLogin($this->admin_user);
|
|
$block = array(
|
|
'comment_block_count' => 10,
|
|
);
|
|
$this->drupalPost('admin/structure/block/manage/comment/recent/configure', $block, t('Save block'));
|
|
$this->assertText(t('The block configuration has been saved.'), t('Block saved.'));
|
|
|
|
// Post an additional comment.
|
|
$comment4 = $this->postComment($this->node, $this->randomName(), $this->randomName());
|
|
|
|
// Test that all four comments are shown.
|
|
$this->assertText($comment1->subject, t('Comment found in block.'));
|
|
$this->assertText($comment2->subject, t('Comment found in block.'));
|
|
$this->assertText($comment3->comment, t('Comment found in block.'));
|
|
$this->assertText($comment4->subject, t('Comment found in block.'));
|
|
|
|
// Test that links to comments work when comments are across pages.
|
|
$this->setCommentsPerPage(1);
|
|
$this->drupalGet('');
|
|
$this->clickLink($comment1->subject);
|
|
$this->assertText($comment1->subject, t('Comment link goes to correct page.'));
|
|
$this->drupalGet('');
|
|
$this->clickLink($comment2->subject);
|
|
$this->assertText($comment2->subject, t('Comment link goes to correct page.'));
|
|
$this->clickLink($comment4->subject);
|
|
$this->assertText($comment4->subject, t('Comment link goes to correct page.'));
|
|
// Check that when viewing a comment page from a link to the comment, that
|
|
// rel="canonical" is added to the head of the document.
|
|
$this->assertRaw('<link rel="canonical"', t('Canonical URL was found in the HTML head'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unit tests for comment module integration with RSS feeds.
|
|
*/
|
|
class CommentRSSUnitTest extends CommentHelperCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Comment RSS',
|
|
'description' => 'Test comments as part of an RSS feed.',
|
|
'group' => 'Comment',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test comments as part of an RSS feed.
|
|
*/
|
|
function testCommentRSS() {
|
|
// Find comment in RSS feed.
|
|
$this->drupalLogin($this->web_user);
|
|
$comment = $this->postComment($this->node, $this->randomName(), $this->randomName());
|
|
$this->drupalGet('rss.xml');
|
|
$raw = '<comments>' . url('node/' . $this->node->nid, array('fragment' => 'comments', 'absolute' => TRUE)) . '</comments>';
|
|
$this->assertRaw($raw, t('Comments as part of RSS feed.'));
|
|
|
|
// Hide comments from RSS feed and check presence.
|
|
$this->node->comment = COMMENT_NODE_HIDDEN;
|
|
node_save($this->node);
|
|
$this->drupalGet('rss.xml');
|
|
$this->assertNoRaw($raw, t('Hidden comments is not a part of RSS feed.'));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Test to make sure comment content is rebuilt.
|
|
*/
|
|
class CommentContentRebuild extends CommentHelperCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Comment Rebuild',
|
|
'description' => 'Test to make sure the comment content is rebuilt.',
|
|
'group' => 'Comment',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test to ensure that the comment's content array is rebuilt for every
|
|
* call to comment_view().
|
|
*/
|
|
function testCommentRebuild() {
|
|
// Update the comment settings so preview isn't required.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->setCommentSubject(TRUE);
|
|
$this->setCommentPreview(DRUPAL_OPTIONAL);
|
|
$this->drupalLogout();
|
|
|
|
// Log in as the web user and add the comment.
|
|
$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), t('Comment found.'));
|
|
|
|
// Add the property to the content array and then see if it still exists on build.
|
|
$comment_loaded->content['test_property'] = array('#value' => $this->randomString());
|
|
$built_content = comment_view($comment_loaded, $this->node);
|
|
|
|
// This means that the content was rebuilt as the added test property no longer exists.
|
|
$this->assertFalse(isset($built_content['test_property']), t('Comment content was emptied before being built.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test comment token replacement in strings.
|
|
*/
|
|
class CommentTokenReplaceTestCase extends CommentHelperCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Comment token replacement',
|
|
'description' => 'Generates text using placeholders for dummy content to check comment token replacement.',
|
|
'group' => 'Comment',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Creates a comment, then tests the tokens generated from it.
|
|
*/
|
|
function testCommentTokenReplacement() {
|
|
global $language;
|
|
$url_options = array(
|
|
'absolute' => TRUE,
|
|
'language' => $language,
|
|
);
|
|
|
|
$this->drupalLogin($this->admin_user);
|
|
|
|
// Set comment variables.
|
|
$this->setCommentSubject(TRUE);
|
|
|
|
// Create a node and a comment.
|
|
$node = $this->drupalCreateNode(array('type' => 'article'));
|
|
$parent_comment = $this->postComment($node, $this->randomName(), $this->randomName(), TRUE);
|
|
|
|
// Post a reply to the comment.
|
|
$this->drupalGet('comment/reply/' . $node->nid . '/' . $parent_comment->id);
|
|
$child_comment = $this->postComment(NULL, $this->randomName(), $this->randomName());
|
|
$comment = comment_load($child_comment->id);
|
|
$comment->homepage = 'http://example.org/';
|
|
|
|
// Add HTML to ensure that sanitation of some fields tested directly.
|
|
$comment->subject = '<blink>Blinking Comment</blink>';
|
|
$instance = field_info_instance('comment', 'body', 'comment_body');
|
|
|
|
// Generate and test sanitized tokens.
|
|
$tests = array();
|
|
$tests['[comment:cid]'] = $comment->cid;
|
|
$tests['[comment:hostname]'] = check_plain($comment->hostname);
|
|
$tests['[comment:name]'] = filter_xss($comment->name);
|
|
$tests['[comment:mail]'] = check_plain($this->admin_user->mail);
|
|
$tests['[comment:homepage]'] = check_url($comment->homepage);
|
|
$tests['[comment:title]'] = filter_xss($comment->subject);
|
|
$tests['[comment:body]'] = _text_sanitize($instance, LANGUAGE_NONE, $comment->comment_body[LANGUAGE_NONE][0], 'value');
|
|
$tests['[comment:url]'] = url('comment/' . $comment->cid, $url_options + array('fragment' => 'comment-' . $comment->cid));
|
|
$tests['[comment:edit-url]'] = url('comment/' . $comment->cid . '/edit', $url_options);
|
|
$tests['[comment:created:since]'] = format_interval(REQUEST_TIME - $comment->created, 2, $language->language);
|
|
$tests['[comment:changed:since]'] = format_interval(REQUEST_TIME - $comment->changed, 2, $language->language);
|
|
$tests['[comment:parent:cid]'] = $comment->pid;
|
|
$tests['[comment:parent:title]'] = check_plain($parent_comment->subject);
|
|
$tests['[comment:node:nid]'] = $comment->nid;
|
|
$tests['[comment:node:title]'] = check_plain($node->title);
|
|
$tests['[comment:author:uid]'] = $comment->uid;
|
|
$tests['[comment:author:name]'] = check_plain($this->admin_user->name);
|
|
|
|
// Test to make sure that we generated something for each token.
|
|
$this->assertFalse(in_array(0, array_map('strlen', $tests)), t('No empty tokens generated.'));
|
|
|
|
foreach ($tests as $input => $expected) {
|
|
$output = token_replace($input, array('comment' => $comment), array('language' => $language));
|
|
$this->assertFalse(strcmp($output, $expected), t('Sanitized comment token %token replaced.', array('%token' => $input)));
|
|
}
|
|
|
|
// Generate and test unsanitized tokens.
|
|
$tests['[comment:hostname]'] = $comment->hostname;
|
|
$tests['[comment:name]'] = $comment->name;
|
|
$tests['[comment:mail]'] = $this->admin_user->mail;
|
|
$tests['[comment:homepage]'] = $comment->homepage;
|
|
$tests['[comment:title]'] = $comment->subject;
|
|
$tests['[comment:body]'] = $comment->comment_body[LANGUAGE_NONE][0]['value'];
|
|
$tests['[comment:parent:title]'] = $parent_comment->subject;
|
|
$tests['[comment:node:title]'] = $node->title;
|
|
$tests['[comment:author:name]'] = $this->admin_user->name;
|
|
|
|
foreach ($tests as $input => $expected) {
|
|
$output = token_replace($input, array('comment' => $comment), array('language' => $language, 'sanitize' => FALSE));
|
|
$this->assertFalse(strcmp($output, $expected), t('Unsanitized comment token %token replaced.', array('%token' => $input)));
|
|
}
|
|
|
|
// Load node so comment_count gets computed.
|
|
$node = node_load($node->nid);
|
|
|
|
// Generate comment tokens for the node (it has 2 comments, both new).
|
|
$tests = array();
|
|
$tests['[node:comment-count]'] = 2;
|
|
$tests['[node:comment-count-new]'] = 2;
|
|
|
|
foreach ($tests as $input => $expected) {
|
|
$output = token_replace($input, array('node' => $node), array('language' => $language));
|
|
$this->assertFalse(strcmp($output, $expected), t('Node comment token %token replaced.', array('%token' => $input)));
|
|
}
|
|
}
|
|
}
|