732 lines
24 KiB
Plaintext
732 lines
24 KiB
Plaintext
<?php
|
|
|
|
/**
|
|
* @file
|
|
* Unit tests for Publish Content module.
|
|
*/
|
|
|
|
/**
|
|
* We test to ensure we are not messing up with the default Drupal
|
|
* access for view node i.e. a owner of a node can view it even if unpublished.
|
|
*/
|
|
abstract class PublishContentWebTestBase extends DrupalWebTestCase {
|
|
|
|
/**
|
|
* Perform a GET operation on a node.
|
|
*
|
|
* This will check the response to access some operation via
|
|
* the URL of a node. In the case of 'publish' or 'unpublish'
|
|
* it will first visit the view of a node so that the relevant
|
|
* tabs can be generated.
|
|
*
|
|
* @param int $nid
|
|
* The node nid
|
|
* @param string $op
|
|
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
|
* @param int $expected_response
|
|
* The expexted response code. If the user should not be able to
|
|
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
|
* 200.
|
|
* @param string $msg
|
|
* (optional) An assertion log message.
|
|
*/
|
|
public abstract function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '');
|
|
|
|
/**
|
|
* Allow content type to be used with publish content.
|
|
*/
|
|
public function enablePublishContentForContentType($types) {
|
|
if (!is_array($types)) {
|
|
$types = array($types);
|
|
}
|
|
|
|
foreach ($types as $type) {
|
|
variable_set('publishcontent_' . $type, TRUE);
|
|
}
|
|
|
|
// Rebuild SimpleTests permissions cache.
|
|
$this->checkPermissions(array(), TRUE);
|
|
}
|
|
|
|
/**
|
|
* Assert the status of a given node.
|
|
*
|
|
* @param int $nid
|
|
* The node nid to check
|
|
* @param int $status
|
|
* Either 1 for published or 0 for unpublished
|
|
*/
|
|
public function assertNodeStatus($nid, $status, $msg = '') {
|
|
$node = node_load($nid, NULL, TRUE);
|
|
$msg = !empty($msg) ? $msg : t('Node status is @actual, expecting @expected', array('@actual' => $node->status, '@expected' => $status));
|
|
$this->assertEqual($node->status, $status, $msg);
|
|
}
|
|
|
|
/**
|
|
* Set the status of a node.
|
|
*
|
|
* @param node|int $node
|
|
* A loaded node object or node nid
|
|
* @param int $status
|
|
* The status to set, 1 for published, 0 for unpublished.
|
|
*/
|
|
public function setNodeStatus($node, $status, $msg = '') {
|
|
$node = is_object($node) ? $node : node_load($node);
|
|
if ($node->status != $status) {
|
|
$node->status = $status;
|
|
node_save($node);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check the current user session forbids publish of a given node.
|
|
*
|
|
* @param node $node
|
|
* The node object to test against.
|
|
*/
|
|
public function assertCurrentUserCannotPublish($node) {
|
|
$status = $node->status;
|
|
$username = $this->loggedInUser->name;
|
|
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
|
$this->assertNodeOperationAccess($node->nid, 'publish', 403, $username . ' cannot publish the published node');
|
|
$this->assertNodeStatus($node->nid, 1, 'node should be still published');
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the published node');
|
|
$this->setNodeStatus($node, 0);
|
|
$this->assertNodeOperationAccess($node->nid, 'publish', 403, $username . ' cannot publish the unpublished node');
|
|
$this->assertNodeStatus($node->nid, 0, 'node should be still unpublished');
|
|
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
|
}
|
|
|
|
/**
|
|
* Check the current user session cannot unpublish a given node.
|
|
*
|
|
* @param node $node
|
|
* The node object to test against.
|
|
*/
|
|
public function assertCurrentUserCannotUnpublish($node) {
|
|
$status = $node->status;
|
|
$username = $this->loggedInUser->name;
|
|
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
|
$this->assertNodeOperationAccess($node->nid, 'unpublish', 403, $username . ' cannot unpublish the published node');
|
|
$this->assertNodeStatus($node->nid, 1, 'node should be still published');
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the published node');
|
|
$this->setNodeStatus($node, 0);
|
|
$this->assertNodeOperationAccess($node->nid, 'unpublish', 403, $username . ' cannot unpublish an unpublished node');
|
|
$this->assertNodeStatus($node->nid, 0, 'node should be still unpublished');
|
|
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
|
}
|
|
|
|
/**
|
|
* Check the current user session can publish a given node.
|
|
*
|
|
* @param node $node
|
|
* The node object to test against.
|
|
*/
|
|
public function assertCurrentUserCanPublish($node) {
|
|
$status = $node->status;
|
|
$username = $this->loggedInUser->name;
|
|
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
|
$this->assertNodeOperationAccess($node->nid, 'publish', 403, $username . ' cannot access the publish callback for a node which is already published.');
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the published node');
|
|
$this->setNodeStatus($node, 0);
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view unpublished node');
|
|
$this->assertNodeOperationAccess($node->nid, 'publish', 200, $username . ' can access publish callback on an unpublished node');
|
|
$this->assertNodeStatus($node->nid, 1, 'node should now be published');
|
|
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
|
}
|
|
|
|
/**
|
|
* Check the current user session can unpublish a node.
|
|
*
|
|
* @param node $node
|
|
* The node to test against.
|
|
*/
|
|
public function assertCurrentUserCanUnpublish($node) {
|
|
$status = $node->status;
|
|
$username = $this->loggedInUser->name;
|
|
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
|
$this->assertNodeOperationAccess($node->nid, 'unpublish', 200, $username . ' can access unpublish callback on a published node');
|
|
$this->assertNodeStatus($node->nid, 0, 'Node should now be unpublished');
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the unpublished node.');
|
|
$this->assertNodeOperationAccess($node->nid, 'unpublish', 403, $username . ' cannot access the unpublish callback of an unpublished node');
|
|
$this->assertNodeStatus($node->nid, 0, 'Node should still be unpublished');
|
|
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
|
}
|
|
|
|
/**
|
|
* Assert the current user can publish a node from the listing test page.
|
|
*/
|
|
public function assertCanPublishFromLinksPage($node) {
|
|
$status = $node->status;
|
|
$this->setNodeStatus($node, 0, 'Start test with an unpublished node');
|
|
$this->drupalGet('publishcontent-links');
|
|
$this->assertResponse(200);
|
|
$this->assertLink('publish-' . $node->nid);
|
|
$this->assertNoLink('unpublish-' . $node->nid);
|
|
$this->clickLink('publish-' . $node->nid);
|
|
$this->assertResponse(200);
|
|
$this->assertNodeStatus($node->nid, 1);
|
|
$this->setNodeStatus($node, $status, 'Reset status');
|
|
}
|
|
|
|
/**
|
|
* Assert the current user cannot publish a node from the listing test page.
|
|
*/
|
|
public function assertCannotPublishFromLinksPage($node) {
|
|
$status = $node->status;
|
|
$this->setNodeStatus($node, 0, 'Start test with an unpublished node');
|
|
$this->drupalGet('publishcontent-links');
|
|
$this->assertResponse(200);
|
|
$this->assertNoLink('publish-' . $node->nid);
|
|
$this->assertNoLink('unpublish-' . $node->nid);
|
|
$this->setNodeStatus($node, $status, 'Reset status');
|
|
}
|
|
|
|
/**
|
|
* Assert the current user can unpublish a node from the listing test page.
|
|
*/
|
|
public function assertCanUnpublishFromLinksPage($node) {
|
|
$status = $node->status;
|
|
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
|
$this->drupalGet('publishcontent-links');
|
|
$this->assertResponse(200);
|
|
$this->assertLink('unpublish-' . $node->nid);
|
|
$this->assertNoLink('publish-' . $node->nid);
|
|
$this->clickLink('unpublish-' . $node->nid);
|
|
$this->assertResponse(200);
|
|
$this->assertNodeStatus($node->nid, 0);
|
|
$this->setNodeStatus($node, $status, 'Reset status');
|
|
}
|
|
|
|
/**
|
|
* Assert the current user cannot unpublish a node from the listing test page.
|
|
*/
|
|
public function assertCannotUnpublishFromLinksPage($node) {
|
|
$status = $node->status;
|
|
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
|
$this->drupalGet('publishcontent-links');
|
|
$this->assertResponse(200);
|
|
$this->assertNoLink('publish-' . $node->nid);
|
|
$this->assertNoLink('unpublish-' . $node->nid);
|
|
$this->setNodeStatus($node, $status, 'Reset status');
|
|
}
|
|
|
|
/**
|
|
* Check no publish permission by node owner.
|
|
*/
|
|
public function testNoPublishPermissionByOwner() {
|
|
$web_user = $this->drupalCreateUser(array('access content'));
|
|
$this->drupalLogin($web_user);
|
|
|
|
$node = $this->drupalCreateNode(
|
|
array(
|
|
'type' => 'page',
|
|
'uid' => $web_user->uid,
|
|
'status' => 1,
|
|
)
|
|
);
|
|
|
|
$this->assertCurrentUserCannotPublish($node);
|
|
$this->assertCurrentUserCannotUnpublish($node);
|
|
|
|
$this->setNodeStatus($node, 0);
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 403, 'Node is not accessible by its owner when unpublished.');
|
|
}
|
|
|
|
/**
|
|
* Check publishcontent module does not interfere with the normal Drupal.
|
|
*/
|
|
public function testNoPermissionAndNotOwner() {
|
|
$node = $this->drupalCreateNode(
|
|
array(
|
|
'type' => 'page',
|
|
'uid' => 0,
|
|
'status' => 1,
|
|
)
|
|
);
|
|
|
|
$this->drupalLogin($this->drupalCreateUser(array('access content')));
|
|
|
|
$this->assertCurrentUserCannotPublish($node);
|
|
$this->assertCurrentUserCannotUnpublish($node);
|
|
|
|
$this->setNodeStatus($node, 0);
|
|
$this->assertNodeOperationAccess($node->nid, 'view', 403, 'Node is not viewable by non owner when unpublished by a user without publish or unpublish permissions');
|
|
}
|
|
|
|
/**
|
|
* Test the combination of publish but not unpublish permissions.
|
|
*/
|
|
public function testPublishNotUnpublish() {
|
|
$type = 'page';
|
|
$this->enablePublishContentForContentType($type);
|
|
|
|
$web_user = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'publish editable ' . $type . ' content',
|
|
'view own unpublished content',
|
|
'edit own ' . $type . ' content',
|
|
));
|
|
|
|
$this->drupalLogin($web_user);
|
|
|
|
$node = $this->drupalCreateNode(
|
|
array(
|
|
'type' => $type,
|
|
'uid' => $web_user->uid,
|
|
'status' => 0,
|
|
)
|
|
);
|
|
|
|
$this->drupalGet('node/' . $node->nid . '/edit');
|
|
$this->assertResponse(200);
|
|
|
|
$this->assertCurrentUserCanPublish($node);
|
|
$this->assertCurrentUserCannotUnpublish($node);
|
|
}
|
|
|
|
/**
|
|
* Test the combination of unpublish but not publish.
|
|
*/
|
|
public function testNotPublishUnpublish() {
|
|
$type = 'page';
|
|
$this->enablePublishContentForContentType($type);
|
|
|
|
$web_user = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'unpublish any ' . $type . ' content',
|
|
'view own unpublished content',
|
|
'edit own ' . $type . ' content',
|
|
));
|
|
$this->drupalLogin($web_user);
|
|
|
|
$node = $this->drupalCreateNode(
|
|
array(
|
|
'type' => $type,
|
|
'uid' => $web_user->uid,
|
|
'status' => 1,
|
|
)
|
|
);
|
|
|
|
$this->assertCurrentUserCannotPublish($node);
|
|
$this->assertCurrentUserCanUnpublish($node);
|
|
}
|
|
|
|
/**
|
|
* Test the combination of both publish and unpublish.
|
|
*/
|
|
public function testPublishUnpublish() {
|
|
$type = 'page';
|
|
$this->enablePublishContentForContentType($type);
|
|
|
|
$web_user_1 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'view own unpublished content',
|
|
'edit any ' . $type . ' content',
|
|
'publish any content',
|
|
));
|
|
|
|
$node1 = $this->drupalCreateNode(
|
|
array(
|
|
'type' => $type,
|
|
'uid' => $web_user_1->uid,
|
|
'status' => 1,
|
|
)
|
|
);
|
|
|
|
$this->drupalLogin($web_user_1);
|
|
$this->assertCurrentUserCanPublish($node1);
|
|
$this->assertCurrentUserCannotUnpublish($node1);
|
|
|
|
$web_user_2 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'view own unpublished content',
|
|
'edit any ' . $type . ' content',
|
|
'unpublish any content',
|
|
));
|
|
|
|
$node2 = $this->drupalCreateNode(
|
|
array(
|
|
'type' => $type,
|
|
'uid' => $web_user_2->uid,
|
|
'status' => 1,
|
|
)
|
|
);
|
|
|
|
$this->drupalLogin($web_user_2);
|
|
$this->assertCurrentUserCannotPublish($node2);
|
|
$this->assertCurrentUserCanUnpublish($node2);
|
|
|
|
$web_user_3 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'view own unpublished content',
|
|
'edit any ' . $type . ' content',
|
|
'publish any content',
|
|
'unpublish any content',
|
|
));
|
|
|
|
$node3 = $this->drupalCreateNode(
|
|
array(
|
|
'type' => $type,
|
|
'uid' => $web_user_3->uid,
|
|
'status' => 1,
|
|
)
|
|
);
|
|
|
|
$this->drupalLogin($web_user_3);
|
|
$this->assertCurrentUserCanPublish($node3);
|
|
$this->assertCurrentUserCanUnpublish($node3);
|
|
}
|
|
|
|
/**
|
|
* Test basic publish ability using the publishcontent_test module.
|
|
*/
|
|
public function testBasicPublishCallback() {
|
|
$type = 'page';
|
|
$this->enablePublishContentForContentType(array($type, 'article'));
|
|
|
|
$web_user_1 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'publish any content',
|
|
));
|
|
|
|
$web_user_2 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'unpublish any content',
|
|
));
|
|
|
|
$web_user_3 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'publish any content',
|
|
'unpublish any content',
|
|
));
|
|
|
|
$web_user_4 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'publish any ' . $type . ' content',
|
|
));
|
|
|
|
$web_user_5 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'unpublish any ' . $type . ' content',
|
|
));
|
|
|
|
$web_user_6 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'publish any ' . $type . ' content',
|
|
'unpublish any ' . $type . ' content',
|
|
));
|
|
|
|
$web_user_7 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'publish any article content',
|
|
'unpublish any article content',
|
|
));
|
|
|
|
$node = $this->drupalCreateNode(
|
|
array(
|
|
'type' => $type,
|
|
'uid' => 1,
|
|
'status' => 0,
|
|
)
|
|
);
|
|
|
|
$this->drupalLogin($web_user_1);
|
|
$this->assertCanPublishFromLinksPage($node, 'Someone with publish any content can publish page node');
|
|
$this->assertCannotUnpublishFromLinksPage($node, 'Someone with publish any content cannot unpublish page node');
|
|
|
|
$this->drupalLogin($web_user_2);
|
|
$this->assertCannotPublishFromLinksPage($node, 'Someone with unpublish any content cannot publish page node');
|
|
$this->assertCanUnpublishFromLinksPage($node, 'Someone with unpublish any content can unpublish page node');
|
|
|
|
$this->drupalLogin($web_user_3);
|
|
$this->assertCanPublishFromLinksPage($node, 'Someone with publish and unpublish any content can publish page node');
|
|
$this->assertCanUnpublishFromLinksPage($node, 'Someone with publish and unpublish any content can unpublish page node');
|
|
|
|
$this->drupalLogin($web_user_4);
|
|
$this->assertCanPublishFromLinksPage($node, 'Someone with publish any page nodes can publish a page node');
|
|
$this->assertCannotUnpublishFromLinksPage($node, 'Someone with publish any page nodes cannot unpublish page node');
|
|
|
|
$this->drupalLogin($web_user_5);
|
|
$this->assertCannotPublishFromLinksPage($node, 'Someone with unpublish any page node cannot publish a page node');
|
|
$this->assertCanUnpublishFromLinksPage($node, 'Someone with unpublish any page node can unpublish a page node');
|
|
|
|
$this->drupalLogin($web_user_6);
|
|
$this->assertCanPublishFromLinksPage($node, 'Someone with publish and unpublish any page node can publish a page node');
|
|
$this->assertCanUnpublishFromLinksPage($node, 'Someone with publish and unpublish any page node can unpublish a page node');
|
|
|
|
$this->drupalLogin($web_user_7);
|
|
$this->assertCannotPublishFromLinksPage($node, 'Someone with publish any article content cannot publish page content');
|
|
$this->assertCannotUnpublishFromLinksPage($node, 'Someone with unpublish any article content cannot unpublish page content');
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Test permissions with the tab method.
|
|
*/
|
|
class PublishContentTabTests extends PublishContentWebTestBase {
|
|
|
|
/**
|
|
* Drupal SimpleTest method: return metadata about the test.
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => t('Publish Content: Tab Tests'),
|
|
'description' => t('Executes test suite for Publish Content module with the tab method.'),
|
|
'group' => t('Publish Content'),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test setup instructions.
|
|
*/
|
|
public function setUp() {
|
|
parent::setUp('publishcontent', 'publishcontent_test');
|
|
variable_set('publishcontent_method', PUBLISHCONTENT_METHOD_TABS);
|
|
}
|
|
|
|
/**
|
|
* Perform a GET operation on a node.
|
|
*
|
|
* This will check the response to access some operation via
|
|
* the URL of a node. In the case of 'publish' or 'unpublish'
|
|
* it will first visit the view of a node so that the relevant
|
|
* tabs can be generated.
|
|
*
|
|
* @param int $nid
|
|
* The node nid
|
|
* @param string $op
|
|
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
|
* @param int $expected_response
|
|
* The expexted response code. If the user should not be able to
|
|
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
|
* 200.
|
|
* @param string $msg
|
|
* (optional) An assertion log message.
|
|
*/
|
|
public function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '') {
|
|
if (in_array($op, array('publish', 'unpublish'))) {
|
|
$tab_link_text = ucfirst($op);
|
|
|
|
// Visit the edit page first to generate the tab.
|
|
$this->drupalGet("node/{$nid}");
|
|
$view_response = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
|
|
if ($view_response != 200) {
|
|
$msg .= t('Could not view the node. Response code: @response', array('@response' => $view_response));
|
|
$this->assert($expected_response == $view_response, $msg);
|
|
return;
|
|
}
|
|
|
|
// Check the tab exists.
|
|
$links = $this->xpath('//a[normalize-space(text())=:label]', array(':label' => $tab_link_text));
|
|
if (!isset($links[0])) {
|
|
// No tab.
|
|
$msg .= t('Could not find a tab called @tab', array('@tab' => $tab_link_text));
|
|
$this->assert($expected_response != 200, $msg);
|
|
return;
|
|
}
|
|
|
|
// Now visit the tab.
|
|
$this->clickLink($tab_link_text);
|
|
|
|
$node = node_load($nid);
|
|
|
|
if ($op == 'publish') {
|
|
$this->assertText(_publishcontent_get_message($node->nid, $node->title, TRUE),
|
|
'Publish content message is visible.');
|
|
}
|
|
else {
|
|
$this->assertText(_publishcontent_get_message($node->nid, $node->title, FALSE),
|
|
'Unpublish message is visible.');
|
|
}
|
|
}
|
|
else {
|
|
$url = $op == 'view' ? "node/{$nid}" : "node/$nid/$op";
|
|
$this->drupalGet($url);
|
|
}
|
|
|
|
$this->assertResponse($expected_response, $msg);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Test permissions with the button method.
|
|
*/
|
|
class PublishContentButtonTests extends PublishContentWebTestBase {
|
|
|
|
/**
|
|
* Drupal SimpleTest method: return metadata about the test.
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => t('Publish Content: Button Tests'),
|
|
'description' => t('Executes test suite for Publish Content module with the button method.'),
|
|
'group' => t('Publish Content'),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test setup instructions.
|
|
*/
|
|
public function setUp() {
|
|
parent::setUp('publishcontent', 'publishcontent_test');
|
|
variable_set('publishcontent_method', PUBLISHCONTENT_METHOD_BUTTON);
|
|
}
|
|
|
|
/**
|
|
* Perform a GET operation on a node.
|
|
*
|
|
* This will check the response to access some operation via
|
|
* the URL of a node. In the case of 'publish' or 'unpublish'
|
|
* it will first visit the view of a node so that the relevant
|
|
* tabs can be generated.
|
|
*
|
|
* @param int $nid
|
|
* The node nid
|
|
* @param string $op
|
|
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
|
* @param int $expected_response
|
|
* The expexted response code. If the user should not be able to
|
|
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
|
* 200.
|
|
* @param string $msg
|
|
* (optional) An assertion log message.
|
|
*/
|
|
public function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '') {
|
|
if (in_array($op, array('publish', 'unpublish'))) {
|
|
$button_text = t(ucfirst($op));
|
|
|
|
// Visit the edit page first to generate the tab.
|
|
$this->drupalGet("node/{$nid}/edit");
|
|
$view_response = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
|
|
if ($view_response != 200) {
|
|
$msg .= t('Could not view the node. Response code: @response', array('@response' => $view_response));
|
|
$this->assert($expected_response == $view_response, $msg);
|
|
return;
|
|
}
|
|
|
|
// Find the button.
|
|
$buttons = $this->xpath('//input[@value=:label]', array(':label' => $button_text));
|
|
if (!isset($buttons[0])) {
|
|
// No button.
|
|
$msg .= t('Could not find a button called @button', array('@button' => $button_text));
|
|
$this->assert($expected_response != 200, $msg);
|
|
return;
|
|
}
|
|
|
|
// Submit the form.
|
|
$this->drupalPost("node/{$nid}/edit", array(), $button_text);
|
|
}
|
|
else {
|
|
$url = $op == 'view' ? "node/{$nid}" : "node/$nid/$op";
|
|
$this->drupalGet($url);
|
|
}
|
|
|
|
$this->assertResponse($expected_response, $msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test permissions with the tab method.
|
|
*/
|
|
class PublishContentCheckboxTests extends PublishContentWebTestBase {
|
|
|
|
/**
|
|
* Drupal SimpleTest method: return metadata about the test.
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => t('Publish Content: Checkbox Tests'),
|
|
'description' => t('Executes test suite for Publish Content module with the checkbox method.'),
|
|
'group' => t('Publish Content'),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test setup instructions.
|
|
*/
|
|
public function setUp() {
|
|
parent::setUp('publishcontent', 'publishcontent_test');
|
|
variable_set('publishcontent_method', PUBLISHCONTENT_METHOD_NONE);
|
|
}
|
|
|
|
/**
|
|
* Perform a GET operation on a node.
|
|
*
|
|
* This will check the response to access some operation via
|
|
* the URL of a node. In the case of 'publish' or 'unpublish'
|
|
* it will first visit the view of a node so that the relevant
|
|
* tabs can be generated.
|
|
*
|
|
* @param int $nid
|
|
* The node nid
|
|
* @param string $op
|
|
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
|
* @param int $expected_response
|
|
* The expexted response code. If the user should not be able to
|
|
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
|
* 200.
|
|
* @param string $msg
|
|
* (optional) An assertion log message.
|
|
*/
|
|
public function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '') {
|
|
if (in_array($op, array('publish', 'unpublish'))) {
|
|
|
|
// Visit the edit page first to check for the published checkbox.
|
|
$this->drupalGet("node/{$nid}/edit");
|
|
$view_response = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
|
|
if ($view_response != 200) {
|
|
$msg .= t('Could not edit the node. Response code: @response', array('@response' => $view_response));
|
|
$this->assert($expected_response == $view_response, $msg);
|
|
return;
|
|
}
|
|
|
|
// Check the checkbox exists.
|
|
$elements = $this->xpath('//input[@id=:id]', array(':id' => 'edit-status'));
|
|
if (!isset($elements[0])) {
|
|
// No checkboxes.
|
|
$msg .= t('Published status checkbox is not accessible.');
|
|
$this->assert($expected_response != 200, $msg);
|
|
return;
|
|
}
|
|
|
|
// At this point the response code for checkboxes is irrelevant, if
|
|
// they can access the edit page and see the checkbox, they can edit it.
|
|
$expected_response = 200;
|
|
|
|
// Tick or untick the published checkbox and submit the form.
|
|
$edit_status = ($op == 'publish');
|
|
$this->drupalPost("node/{$nid}/edit", array('status' => $edit_status), t('Save'));
|
|
}
|
|
else {
|
|
$url = $op == 'view' ? "node/{$nid}" : "node/$nid/$op";
|
|
$this->drupalGet($url);
|
|
}
|
|
|
|
$this->assertResponse($expected_response, $msg);
|
|
}
|
|
|
|
/**
|
|
* Test access to the node add page is working.
|
|
*/
|
|
public function testAccessNodeAdd() {
|
|
$type = 'page';
|
|
$this->enablePublishContentForContentType($type);
|
|
|
|
$web_user_1 = $this->drupalCreateUser(array(
|
|
'access content',
|
|
'view own unpublished content',
|
|
'create ' . $type . ' content',
|
|
'publish editable content',
|
|
'unpublish editable content',
|
|
));
|
|
|
|
$this->drupalLogin($web_user_1);
|
|
$this->drupalGet('node/add/' . $type);
|
|
$this->assertResponse(200);
|
|
$this->assertFieldChecked('edit-status', t('Ensure the publish checkbox is available.'));
|
|
}
|
|
}
|