Club Drupal

<?php

/**

 * @file

 * Tests for node.module.

 */

/**

 * Defines a base class for testing the Node module.

 */

class NodeWebTestCase extends DrupalWebTestCase {

  function setUp() {

    $modules = func_get_args();

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

      $modules = $modules[0];

    }

    $modules[] = 'node';

    parent::setUp($modules);

    // Create Basic page and Article node types.

    if ($this->profile != 'standard') {

      $this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));

      $this->drupalCreateContentType(array('type' => 'article', 'name' => 'Article'));

    }

  }

}

/**

 * Test the node_load_multiple() function.

 */

class NodeLoadMultipleTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Load multiple nodes',

      'description' => 'Test the loading of multiple nodes.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp();

    $web_user = $this->drupalCreateUser(array('create article content', 'create page content'));

    $this->drupalLogin($web_user);

  }

  /**

   * Create four nodes and ensure they're loaded correctly.

   */

  function testNodeMultipleLoad() {

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

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

    $node3 = $this->drupalCreateNode(array('type' => 'article', 'promote' => 0));

    $node4 = $this->drupalCreateNode(array('type' => 'page', 'promote' => 0));

    // Confirm that promoted nodes appear in the default node listing.

    $this->drupalGet('node');

    $this->assertText($node1->title, 'Node title appears on the default listing.');

    $this->assertText($node2->title, 'Node title appears on the default listing.');

    $this->assertNoText($node3->title, 'Node title does not appear in the default listing.');

    $this->assertNoText($node4->title, 'Node title does not appear in the default listing.');

    // Load nodes with only a condition. Nodes 3 and 4 will be loaded.

    $nodes = node_load_multiple(NULL, array('promote' => 0));

    $this->assertEqual($node3->title, $nodes[$node3->nid]->title, 'Node was loaded.');

    $this->assertEqual($node4->title, $nodes[$node4->nid]->title, 'Node was loaded.');

    $count = count($nodes);

    $this->assertTrue($count == 2, format_string('@count nodes loaded.', array('@count' => $count)));

    // Load nodes by nid. Nodes 1, 2 and 4 will be loaded.

    $nodes = node_load_multiple(array(1, 2, 4));

    $count = count($nodes);

    $this->assertTrue(count($nodes) == 3, format_string('@count nodes loaded', array('@count' => $count)));

    $this->assertTrue(isset($nodes[$node1->nid]), 'Node is correctly keyed in the array');

    $this->assertTrue(isset($nodes[$node2->nid]), 'Node is correctly keyed in the array');

    $this->assertTrue(isset($nodes[$node4->nid]), 'Node is correctly keyed in the array');

    foreach ($nodes as $node) {

      $this->assertTrue(is_object($node), 'Node is an object');

    }

    // Load nodes by nid, where type = article. Nodes 1, 2 and 3 will be loaded.

    $nodes = node_load_multiple(array(1, 2, 3, 4), array('type' => 'article'));

    $count = count($nodes);

    $this->assertTrue($count == 3, format_string('@count nodes loaded', array('@count' => $count)));

    $this->assertEqual($nodes[$node1->nid]->title, $node1->title, 'Node successfully loaded.');

    $this->assertEqual($nodes[$node2->nid]->title, $node2->title, 'Node successfully loaded.');

    $this->assertEqual($nodes[$node3->nid]->title, $node3->title, 'Node successfully loaded.');

    $this->assertFalse(isset($nodes[$node4->nid]));

    // Now that all nodes have been loaded into the static cache, ensure that

    // they are loaded correctly again when a condition is passed.

    $nodes = node_load_multiple(array(1, 2, 3, 4), array('type' => 'article'));

    $count = count($nodes);

    $this->assertTrue($count == 3, format_string('@count nodes loaded.', array('@count' => $count)));

    $this->assertEqual($nodes[$node1->nid]->title, $node1->title, 'Node successfully loaded');

    $this->assertEqual($nodes[$node2->nid]->title, $node2->title, 'Node successfully loaded');

    $this->assertEqual($nodes[$node3->nid]->title, $node3->title, 'Node successfully loaded');

    $this->assertFalse(isset($nodes[$node4->nid]), 'Node was not loaded');

    // Load nodes by nid, where type = article and promote = 0.

    $nodes = node_load_multiple(array(1, 2, 3, 4), array('type' => 'article', 'promote' => 0));

    $count = count($nodes);

    $this->assertTrue($count == 1, format_string('@count node loaded', array('@count' => $count)));

    $this->assertEqual($nodes[$node3->nid]->title, $node3->title, 'Node successfully loaded.');

  }

}

/**

 * Tests for the hooks invoked during node_load().

 */

class NodeLoadHooksTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node load hooks',

      'description' => 'Test the hooks invoked when a node is being loaded.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp('node_test');

  }

  /**

   * Test that hook_node_load() is invoked correctly.

   */

  function testHookNodeLoad() {

    // Create some sample articles and pages.

    $node1 = $this->drupalCreateNode(array('type' => 'article', 'status' => NODE_PUBLISHED));

    $node2 = $this->drupalCreateNode(array('type' => 'article', 'status' => NODE_PUBLISHED));

    $node3 = $this->drupalCreateNode(array('type' => 'article', 'status' => NODE_NOT_PUBLISHED));

    $node4 = $this->drupalCreateNode(array('type' => 'page', 'status' => NODE_NOT_PUBLISHED));

    // Check that when a set of nodes that only contains articles is loaded,

    // the properties added to the node by node_test_load_node() correctly

    // reflect the expected values.

    $nodes = node_load_multiple(array(), array('status' => NODE_PUBLISHED));

    $loaded_node = end($nodes);

    $this->assertEqual($loaded_node->node_test_loaded_nids, array($node1->nid, $node2->nid), 'hook_node_load() received the correct list of node IDs the first time it was called.');

    $this->assertEqual($loaded_node->node_test_loaded_types, array('article'), 'hook_node_load() received the correct list of node types the first time it was called.');

    // Now, as part of the same page request, load a set of nodes that contain

    // both articles and pages, and make sure the parameters passed to

    // node_test_node_load() are correctly updated.

    $nodes = node_load_multiple(array(), array('status' => NODE_NOT_PUBLISHED));

    $loaded_node = end($nodes);

    $this->assertEqual($loaded_node->node_test_loaded_nids, array($node3->nid, $node4->nid), 'hook_node_load() received the correct list of node IDs the second time it was called.');

    $this->assertEqual($loaded_node->node_test_loaded_types, array('article', 'page'), 'hook_node_load() received the correct list of node types the second time it was called.');

  }

}

/**

 * Tests the node revision functionality.

 */

class NodeRevisionsTestCase extends DrupalWebTestCase {

  /**

   * Nodes used by the test.

   *

   * @var array

   */

  protected $nodes;

  /**

   * The revision messages for node revisions created in the test.

   *

   * @var array

   */

  protected $logs;

  public static function getInfo() {

    return array(

      'name' => 'Node revisions',

      'description' => 'Create a node with revisions and test viewing, saving, reverting, and deleting revisions.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp();

    // Create and login user.

    $web_user = $this->drupalCreateUser(array('view revisions', 'revert revisions', 'edit any page content',

                                               'delete revisions', 'delete any page content'));

    $this->drupalLogin($web_user);

    // Create initial node.

    $node = $this->drupalCreateNode();

    $settings = get_object_vars($node);

    $settings['revision'] = 1;

    $nodes = array();

    $logs = array();

    // Get original node.

    $nodes[] = $node;

    // Create three revisions.

    $revision_count = 3;

    for ($i = 0; $i < $revision_count; $i++) {

      $logs[] = $settings['log'] = $this->randomName(32);

      // Create revision with random title and body and update variables.

      $this->drupalCreateNode($settings);

      $node = node_load($node->nid); // Make sure we get revision information.

      $settings = get_object_vars($node);

      $nodes[] = $node;

    }

    $this->nodes = $nodes;

    $this->logs = $logs;

  }

  /**

   * Checks node revision related operations.

   */

  function testRevisions() {

    $nodes = $this->nodes;

    $logs = $this->logs;

    // Get last node for simple checks.

    $node = $nodes[3];

    // Confirm the correct revision text appears on "view revisions" page.

    $this->drupalGet("node/$node->nid/revisions/$node->vid/view");

    $this->assertText($node->body[LANGUAGE_NONE][0]['value'], 'Correct text displays for version.');

    // Confirm the correct log message appears on "revisions overview" page.

    $this->drupalGet("node/$node->nid/revisions");

    foreach ($logs as $log) {

      $this->assertText($log, 'Log message found.');

    }

    // Confirm that revisions revert properly.

    $this->drupalPost("node/$node->nid/revisions/{$nodes[1]->vid}/revert", array(), t('Revert'));

    $this->assertRaw(t('@type %title has been reverted back to the revision from %revision-date.',

                        array('@type' => 'Basic page', '%title' => $nodes[1]->title,

                              '%revision-date' => format_date($nodes[1]->revision_timestamp))), 'Revision reverted.');

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

    $this->assertTrue(($nodes[1]->body[LANGUAGE_NONE][0]['value'] == $reverted_node->body[LANGUAGE_NONE][0]['value']), 'Node reverted correctly.');

    // Confirm revisions delete properly.

    $this->drupalPost("node/$node->nid/revisions/{$nodes[1]->vid}/delete", array(), t('Delete'));

    $this->assertRaw(t('Revision from %revision-date of @type %title has been deleted.',

                        array('%revision-date' => format_date($nodes[1]->revision_timestamp),

                              '@type' => 'Basic page', '%title' => $nodes[1]->title)), 'Revision deleted.');

    $this->assertTrue(db_query('SELECT COUNT(vid) FROM {node_revision} WHERE nid = :nid and vid = :vid', array(':nid' => $node->nid, ':vid' => $nodes[1]->vid))->fetchField() == 0, 'Revision not found.');

  }

  /**

   * Checks that revisions are correctly saved without log messages.

   */

  function testNodeRevisionWithoutLogMessage() {

    // Create a node with an initial log message.

    $log = $this->randomName(10);

    $node = $this->drupalCreateNode(array('log' => $log));

    // Save over the same revision and explicitly provide an empty log message

    // (for example, to mimic the case of a node form submitted with no text in

    // the "log message" field), and check that the original log message is

    // preserved.

    $new_title = $this->randomName(10) . 'testNodeRevisionWithoutLogMessage1';

    $updated_node = (object) array(

      'nid' => $node->nid,

      'vid' => $node->vid,

      'uid' => $node->uid,

      'type' => $node->type,

      'title' => $new_title,

      'log' => '',

    );

    node_save($updated_node);

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

    $this->assertText($new_title, 'New node title appears on the page.');

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

    $this->assertEqual($node_revision->log, $log, 'After an existing node revision is re-saved without a log message, the original log message is preserved.');

    // Create another node with an initial log message.

    $node = $this->drupalCreateNode(array('log' => $log));

    // Save a new node revision without providing a log message, and check that

    // this revision has an empty log message.

    $new_title = $this->randomName(10) . 'testNodeRevisionWithoutLogMessage2';

    $updated_node = (object) array(

      'nid' => $node->nid,

      'vid' => $node->vid,

      'uid' => $node->uid,

      'type' => $node->type,

      'title' => $new_title,

      'revision' => 1,

    );

    node_save($updated_node);

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

    $this->assertText($new_title, 'New node title appears on the page.');

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

    $this->assertTrue(empty($node_revision->log), 'After a new node revision is saved with an empty log message, the log message for the node is empty.');

  }

}

/**

 * Tests the node edit functionality.

 */

class PageEditTestCase extends DrupalWebTestCase {

  /**

   * A user with permission to create and edit own page content.

   *

   * @var object

   */

  protected $web_user;

  /**

   * A user with permission to bypass node access and administer nodes.

   *

   * @var object

   */

  protected $admin_user;

  public static function getInfo() {

    return array(

      'name' => 'Node edit',

      'description' => 'Create a node and test node edit functionality.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp();

    $this->web_user = $this->drupalCreateUser(array('edit own page content', 'create page content'));

    $this->admin_user = $this->drupalCreateUser(array('bypass node access', 'administer nodes'));

  }

  /**

   * Checks node edit functionality.

   */

  function testPageEdit() {

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

    $langcode = LANGUAGE_NONE;

    $title_key = "title";

    $body_key = "body[$langcode][0][value]";

    // Create node to edit.

    $edit = array();

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

    $edit[$body_key] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Save'));

    // Check that the node exists in the database.

    $node = $this->drupalGetNodeByTitle($edit[$title_key]);

    $this->assertTrue($node, 'Node found in database.');

    // Check that "edit" link points to correct page.

    $this->clickLink(t('Edit'));

    $edit_url = url("node/$node->nid/edit", array('absolute' => TRUE));

    $actual_url = $this->getURL();

    $this->assertEqual($edit_url, $actual_url, 'On edit page.');

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

    $active = '<span class="element-invisible">' . t('(active tab)') . '</span>';

    $link_text = t('!local-task-title!active', array('!local-task-title' => t('Edit'), '!active' => $active));

    $this->assertText(strip_tags($link_text), 0, 'Edit tab found and marked active.');

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

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

    // Edit the content of the node.

    $edit = array();

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

    $edit[$body_key] = $this->randomName(16);

    // Stay on the current page, without reloading.

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

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

    $this->assertText($edit[$title_key], 'Title displayed.');

    $this->assertText($edit[$body_key], 'Body displayed.');

    // Login as a second administrator user.

    $second_web_user = $this->drupalCreateUser(array('administer nodes', 'edit any page content'));

    $this->drupalLogin($second_web_user);

    // Edit the same node, creating a new revision.

    $this->drupalGet("node/$node->nid/edit");

    $edit = array();

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

    $edit[$body_key] = $this->randomName(16);

    $edit['revision'] = TRUE;

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

    // Ensure that the node revision has been created.

    $revised_node = $this->drupalGetNodeByTitle($edit['title']);

    $this->assertNotIdentical($node->vid, $revised_node->vid, 'A new revision has been created.');

    // Ensure that the node author is preserved when it was not changed in the

    // edit form.

    $this->assertIdentical($node->uid, $revised_node->uid, 'The node author has been preserved.');

    // Ensure that the revision authors are different since the revisions were

    // made by different users.

    $first_node_version = node_load($node->nid, $node->vid);

    $second_node_version = node_load($node->nid, $revised_node->vid);

    $this->assertNotIdentical($first_node_version->revision_uid, $second_node_version->revision_uid, 'Each revision has a distinct user.');

  }

  /**

   * Tests changing a node's "authored by" field.

   */

  function testPageAuthoredBy() {

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

    // Create node to edit.

    $langcode = LANGUAGE_NONE;

    $body_key = "body[$langcode][0][value]";

    $edit = array();

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

    $edit[$body_key] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Save'));

    // Check that the node was authored by the currently logged in user.

    $node = $this->drupalGetNodeByTitle($edit['title']);

    $this->assertIdentical($node->uid, $this->admin_user->uid, 'Node authored by admin user.');

    // Try to change the 'authored by' field to an invalid user name.

    $edit = array(

      'name' => 'invalid-name',

    );

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

    $this->assertText('The username invalid-name does not exist.');

    // Change the authored by field to an empty string, which should assign

    // authorship to the anonymous user (uid 0).

    $edit['name'] = '';

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

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

    $this->assertIdentical($node->uid, '0', 'Node authored by anonymous user.');

    // Change the authored by field to another user's name (that is not

    // logged in).

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

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

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

    $this->assertIdentical($node->uid, $this->web_user->uid, 'Node authored by normal user.');

    // Check that normal users cannot change the authored by information.

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

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

    $this->assertNoFieldByName('name');

  }

}

/**

 * Tests the node entity preview functionality.

 */

class PagePreviewTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node preview',

      'description' => 'Test node preview functionality.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp();

    $web_user = $this->drupalCreateUser(array('edit own page content', 'create page content'));

    $this->drupalLogin($web_user);

  }

  /**

   * Checks the node preview functionality.

   */

  function testPagePreview() {

    $langcode = LANGUAGE_NONE;

    $title_key = "title";

    $body_key = "body[$langcode][0][value]";

    // Fill in node creation form and preview node.

    $edit = array();

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

    $edit[$body_key] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Preview'));

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

    $this->assertTitle(t('Preview | Drupal'), 'Basic page title is preview.');

    $this->assertText($edit[$title_key], 'Title displayed.');

    $this->assertText($edit[$body_key], 'Body displayed.');

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

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

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

  }

  /**

   * Checks the node preview functionality, when using revisions.

   */

  function testPagePreviewWithRevisions() {

    $langcode = LANGUAGE_NONE;

    $title_key = "title";

    $body_key = "body[$langcode][0][value]";

    // Force revision on "Basic page" content.

    variable_set('node_options_page', array('status', 'revision'));

    // Fill in node creation form and preview node.

    $edit = array();

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

    $edit[$body_key] = $this->randomName(16);

    $edit['log'] = $this->randomName(32);

    $this->drupalPost('node/add/page', $edit, t('Preview'));

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

    $this->assertTitle(t('Preview | Drupal'), 'Basic page title is preview.');

    $this->assertText($edit[$title_key], 'Title displayed.');

    $this->assertText($edit[$body_key], 'Body displayed.');

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

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

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

    // Check that the log field has the correct value.

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

  }

}

/**

 * Tests creating and saving a node.

 */

class NodeCreationTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node creation',

      'description' => 'Create a node and test saving it.',

      'group' => 'Node',

    );

  }

  function setUp() {

    // Enable dummy module that implements hook_node_insert for exceptions.

    parent::setUp('node_test_exception');

    $web_user = $this->drupalCreateUser(array('create page content', 'edit own page content'));

    $this->drupalLogin($web_user);

  }

  /**

   * Creates a "Basic page" node and verifies its consistency in the database.

   */

  function testNodeCreation() {

    // Create a node.

    $edit = array();

    $langcode = LANGUAGE_NONE;

    $edit["title"] = $this->randomName(8);

    $edit["body[$langcode][0][value]"] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Save'));

    // Check that the Basic page has been created.

    $this->assertRaw(t('!post %title has been created.', array('!post' => 'Basic page', '%title' => $edit["title"])), 'Basic page created.');

    // Check that the node exists in the database.

    $node = $this->drupalGetNodeByTitle($edit["title"]);

    $this->assertTrue($node, 'Node found in database.');

  }

  /**

   * Verifies that a transaction rolls back the failed creation.

   */

  function testFailedPageCreation() {

    // Create a node.

    $edit = array(

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

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

      'type'     => 'page',

      'language' => LANGUAGE_NONE,

      'title'    => 'testing_transaction_exception',

    );

    try {

      // An exception is generated by node_test_exception_node_insert() if the

      // title is 'testing_transaction_exception'.

      node_save((object) $edit);

      $this->fail(t('Expected exception has not been thrown.'));

    }

    catch (Exception $e) {

      $this->pass(t('Expected exception has been thrown.'));

    }

    if (Database::getConnection()->supportsTransactions()) {

      // Check that the node does not exist in the database.

      $node = $this->drupalGetNodeByTitle($edit['title']);

      $this->assertFalse($node, 'Transactions supported, and node not found in database.');

    }

    else {

      // Check that the node exists in the database.

      $node = $this->drupalGetNodeByTitle($edit['title']);

      $this->assertTrue($node, 'Transactions not supported, and node found in database.');

      // Check that the failed rollback was logged.

      $records = db_query("SELECT wid FROM {watchdog} WHERE message LIKE 'Explicit rollback failed%'")->fetchAll();

      $this->assertTrue(count($records) > 0, 'Transactions not supported, and rollback error logged to watchdog.');

    }

    // Check that the rollback error was logged.

    $records = db_query("SELECT wid FROM {watchdog} WHERE variables LIKE '%Test exception for rollback.%'")->fetchAll();

    $this->assertTrue(count($records) > 0, 'Rollback explanatory error logged to watchdog.');

  }

  /**

   * Create an unpublished node and confirm correct redirect behavior.

   */

  function testUnpublishedNodeCreation() {

    // Set "Basic page" content type to be unpublished by default.

    variable_set('node_options_page', array());

    // Set the front page to the default "node" page.

    variable_set('site_frontpage', 'node');

    // Create a node.

    $edit = array();

    $edit["title"] = $this->randomName(8);

    $edit["body[" . LANGUAGE_NONE . "][0][value]"] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Save'));

    // Check that the user was redirected to the home page.

    $this->assertText(t('Welcome to Drupal'), t('The user is redirected to the home page.'));

  }

}

/**

 * Tests the functionality of node entity edit permissions.

 */

class PageViewTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node edit permissions',

      'description' => 'Create a node and test edit permissions.',

      'group' => 'Node',

    );

  }

  /**

   * Tests an anonymous and unpermissioned user attempting to edit the node.

   */

  function testPageView() {

    // Create a node to view.

    $node = $this->drupalCreateNode();

    $this->assertTrue(node_load($node->nid), 'Node created.');

    // Try to edit with anonymous user.

    $html = $this->drupalGet("node/$node->nid/edit");

    $this->assertResponse(403);

    // Create a user without permission to edit node.

    $web_user = $this->drupalCreateUser(array('access content'));

    $this->drupalLogin($web_user);

    // Attempt to access edit page.

    $this->drupalGet("node/$node->nid/edit");

    $this->assertResponse(403);

    // Create user with permission to edit node.

    $web_user = $this->drupalCreateUser(array('bypass node access'));

    $this->drupalLogin($web_user);

    // Attempt to access edit page.

    $this->drupalGet("node/$node->nid/edit");

    $this->assertResponse(200);

  }

}

/**

 * Tests the summary length functionality.

 */

class SummaryLengthTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Summary length',

      'description' => 'Test summary length.',

      'group' => 'Node',

    );

  }

  /**

   * Tests the node summary length functionality.

   */

  function testSummaryLength() {

    // Create a node to view.

    $settings = array(

      'body' => array(LANGUAGE_NONE => array(array('value' => 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam vitae arcu at leo cursus laoreet. Curabitur dui tortor, adipiscing malesuada tempor in, bibendum ac diam. Cras non tellus a libero pellentesque condimentum. What is a Drupalism? Suspendisse ac lacus libero. Ut non est vel nisl faucibus interdum nec sed leo. Pellentesque sem risus, vulputate eu semper eget, auctor in libero. Ut fermentum est vitae metus convallis scelerisque. Phasellus pellentesque rhoncus tellus, eu dignissim purus posuere id. Quisque eu fringilla ligula. Morbi ullamcorper, lorem et mattis egestas, tortor neque pretium velit, eget eleifend odio turpis eu purus. Donec vitae metus quis leo pretium tincidunt a pulvinar sem. Morbi adipiscing laoreet mauris vel placerat. Nullam elementum, nisl sit amet scelerisque malesuada, dolor nunc hendrerit quam, eu ultrices erat est in orci. Curabitur feugiat egestas nisl sed accumsan.'))),

      'promote' => 1,

    );

    $node = $this->drupalCreateNode($settings);

    $this->assertTrue(node_load($node->nid), 'Node created.');

    // Create user with permission to view the node.

    $web_user = $this->drupalCreateUser(array('access content', 'administer content types'));

    $this->drupalLogin($web_user);

    // Attempt to access the front page.

    $this->drupalGet("node");

    // The node teaser when it has 600 characters in length

    $expected = 'What is a Drupalism?';

    $this->assertRaw($expected, 'Check that the summary is 600 characters in length', 'Node');

    // Change the teaser length for "Basic page" content type.

    $instance = field_info_instance('node', 'body', $node->type);

    $instance['display']['teaser']['settings']['trim_length'] = 200;

    field_update_instance($instance);

    // Attempt to access the front page again and check if the summary is now only 200 characters in length.

    $this->drupalGet("node");

    $this->assertNoRaw($expected, 'Check that the summary is not longer than 200 characters', 'Node');

  }

}

/**

 * Tests XSS functionality with a node entity.

 */

class NodeTitleXSSTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node title XSS filtering',

      'description' => 'Create a node with dangerous tags in its title and test that they are escaped.',

      'group' => 'Node',

    );

  }

  /**

   * Tests XSS functionality with a node entity.

   */

  function testNodeTitleXSS() {

    // Prepare a user to do the stuff.

    $web_user = $this->drupalCreateUser(array('create page content', 'edit any page content'));

    $this->drupalLogin($web_user);

    $xss = '<script>alert("xss")</script>';

    $title = $xss . $this->randomName();

    $edit = array("title" => $title);

    $this->drupalPost('node/add/page', $edit, t('Preview'));

    $this->assertNoRaw($xss, 'Harmful tags are escaped when previewing a node.');

    $settings = array('title' => $title);

    $node = $this->drupalCreateNode($settings);

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

    // assertTitle() decodes HTML-entities inside the <title> element.

    $this->assertTitle($edit["title"] . ' | Drupal', 'Title is diplayed when viewing a node.');

    $this->assertNoRaw($xss, 'Harmful tags are escaped when viewing a node.');

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

    $this->assertNoRaw($xss, 'Harmful tags are escaped when editing a node.');

  }

}

/**

 * Tests the availability of the syndicate block.

 */

class NodeBlockTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Block availability',

      'description' => 'Check if the syndicate block is available.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp();

    // Create and login user

    $admin_user = $this->drupalCreateUser(array('administer blocks'));

    $this->drupalLogin($admin_user);

  }

  /**

   * Tests that the "Syndicate" block is shown when enabled.

   */

  function testSyndicateBlock() {

    // Set block title to confirm that the interface is available.

    $this->drupalPost('admin/structure/block/manage/node/syndicate/configure', array('title' => $this->randomName(8)), t('Save block'));

    $this->assertText(t('The block configuration has been saved.'), 'Block configuration set.');

    // Set the block to a region to confirm block is available.

    $edit = array();

    $edit['blocks[node_syndicate][region]'] = 'footer';

    $this->drupalPost('admin/structure/block', $edit, t('Save blocks'));

    $this->assertText(t('The block settings have been updated.'), 'Block successfully move to footer region.');

  }

}

/**

 * Checks that the post information displays when enabled for a content type.

 */

class NodePostSettingsTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node post information display',

      'description' => 'Check that the post information (submitted by Username on date) text displays appropriately.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp();

    $web_user = $this->drupalCreateUser(array('create page content', 'administer content types', 'access user profiles'));

    $this->drupalLogin($web_user);

  }

  /**

   * Confirms "Basic page" content type and post information is on a new node.

   */

  function testPagePostInfo() {

    // Set "Basic page" content type to display post information.

    $edit = array();

    $edit['node_submitted'] = TRUE;

    $this->drupalPost('admin/structure/types/manage/page', $edit, t('Save content type'));

    // Create a node.

    $edit = array();

    $langcode = LANGUAGE_NONE;

    $edit["title"] = $this->randomName(8);

    $edit["body[$langcode][0][value]"] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Save'));

    // Check that the post information is displayed.

    $node = $this->drupalGetNodeByTitle($edit["title"]);

    $elements = $this->xpath('//div[contains(@class,:class)]', array(':class' => 'submitted'));

    $this->assertEqual(count($elements), 1, 'Post information is displayed.');

  }

  /**

   * Confirms absence of post information on a new node.

   */

  function testPageNotPostInfo() {

    // Set "Basic page" content type to display post information.

    $edit = array();

    $edit['node_submitted'] = FALSE;

    $this->drupalPost('admin/structure/types/manage/page', $edit, t('Save content type'));

    // Create a node.

    $edit = array();

    $langcode = LANGUAGE_NONE;

    $edit["title"] = $this->randomName(8);

    $edit["body[$langcode][0][value]"] = $this->randomName(16);

    $this->drupalPost('node/add/page', $edit, t('Save'));

    // Check that the post information is displayed.

    $node = $this->drupalGetNodeByTitle($edit["title"]);

    $this->assertNoRaw('<span class="submitted">', 'Post information is not displayed.');

  }

}

/**

 * Ensures that data added to nodes by other modules appears in RSS feeds.

 *

 * Create a node, enable the node_test module to ensure that extra data is

 * added to the node->content array, then verify that the data appears on the

 * sitewide RSS feed at rss.xml.

 */

class NodeRSSContentTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node RSS Content',

      'description' => 'Ensure that data added to nodes by other modules appears in RSS feeds.',

      'group' => 'Node',

    );

  }

  function setUp() {

    // Enable dummy module that implements hook_node_view.

    parent::setUp('node_test');

    // Use bypass node access permission here, because the test class uses

    // hook_grants_alter() to deny access to everyone on node_access

    // queries.

    $user = $this->drupalCreateUser(array('bypass node access', 'access content', 'create article content'));

    $this->drupalLogin($user);

  }

  /**

   * Ensures that a new node includes the custom data when added to an RSS feed.

   */

  function testNodeRSSContent() {

    // Create a node.

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

    $this->drupalGet('rss.xml');

    // Check that content added in 'rss' view mode appear in RSS feed.

    $rss_only_content = t('Extra data that should appear only in the RSS feed for node !nid.', array('!nid' => $node->nid));

    $this->assertText($rss_only_content, 'Node content designated for RSS appear in RSS feed.');

    // Check that content added in view modes other than 'rss' doesn't

    // appear in RSS feed.

    $non_rss_content = t('Extra data that should appear everywhere except the RSS feed for node !nid.', array('!nid' => $node->nid));

    $this->assertNoText($non_rss_content, 'Node content not designed for RSS doesn\'t appear in RSS feed.');

    // Check that extra RSS elements and namespaces are added to RSS feed.

    $test_element = array(

      'key' => 'testElement',

      'value' => t('Value of testElement RSS element for node !nid.', array('!nid' => $node->nid)),

    );

    $test_ns = 'xmlns:drupaltest="http://example.com/test-namespace"';

    $this->assertRaw(format_xml_elements(array($test_element)), 'Extra RSS elements appear in RSS feed.');

    $this->assertRaw($test_ns, 'Extra namespaces appear in RSS feed.');

    // Check that content added in 'rss' view mode doesn't appear when

    // viewing node.

    $this->drupalGet("node/$node->nid");

    $this->assertNoText($rss_only_content, 'Node content designed for RSS doesn\'t appear when viewing node.');

    // Check that the node feed page does not try to interpret additional path

    // components as arguments for node_feed() and returns default content.

    $this->drupalGet('rss.xml/' . $this->randomName() . '/' . $this->randomName());

    $this->assertText($rss_only_content, 'Ignore page arguments when delivering rss.xml.');

  }

}

/**

 * Tests basic node_access functionality.

 *

 * Note that hook_node_access_records() is covered in another test class.

 *

 * @todo Cover hook_node_access in a separate test class.

 */

class NodeAccessTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node access',

      'description' => 'Test node_access function',

      'group' => 'Node',

    );

  }

  /**

   * Asserts node_access() correctly grants or denies access.

   */

  function assertNodeAccess($ops, $node, $account) {

    foreach ($ops as $op => $result) {

      $msg = format_string("node_access returns @result with operation '@op'.", array('@result' => $result ? 'true' : 'false', '@op' => $op));

      $this->assertEqual($result, node_access($op, $node, $account), $msg);

    }

  }

  function setUp() {

    parent::setUp();

    // Clear permissions for authenticated users.

    db_delete('role_permission')

      ->condition('rid', DRUPAL_AUTHENTICATED_RID)

      ->execute();

  }

  /**

   * Runs basic tests for node_access function.

   */

  function testNodeAccess() {

    // Ensures user without 'access content' permission can do nothing.

    $web_user1 = $this->drupalCreateUser(array('create page content', 'edit any page content', 'delete any page content'));

    $node1 = $this->drupalCreateNode(array('type' => 'page'));

    $this->assertNodeAccess(array('create' => FALSE), 'page', $web_user1);

    $this->assertNodeAccess(array('view' => FALSE, 'update' => FALSE, 'delete' => FALSE), $node1, $web_user1);

    // Ensures user with 'bypass node access' permission can do everything.

    $web_user2 = $this->drupalCreateUser(array('bypass node access'));

    $node2 = $this->drupalCreateNode(array('type' => 'page'));

    $this->assertNodeAccess(array('create' => TRUE), 'page', $web_user2);

    $this->assertNodeAccess(array('view' => TRUE, 'update' => TRUE, 'delete' => TRUE), $node2, $web_user2);

    // User cannot 'view own unpublished content'.

    $web_user3 = $this->drupalCreateUser(array('access content'));

    $node3 = $this->drupalCreateNode(array('status' => 0, 'uid' => $web_user3->uid));

    $this->assertNodeAccess(array('view' => FALSE), $node3, $web_user3);

    // User cannot create content without permission.

    $this->assertNodeAccess(array('create' => FALSE), 'page', $web_user3);

    // User can 'view own unpublished content', but another user cannot.

    $web_user4 = $this->drupalCreateUser(array('access content', 'view own unpublished content'));

    $web_user5 = $this->drupalCreateUser(array('access content', 'view own unpublished content'));

    $node4 = $this->drupalCreateNode(array('status' => 0, 'uid' => $web_user4->uid));

    $this->assertNodeAccess(array('view' => TRUE, 'update' => FALSE), $node4, $web_user4);

    $this->assertNodeAccess(array('view' => FALSE), $node4, $web_user5);

    // Tests the default access provided for a published node.

    $node5 = $this->drupalCreateNode();

    $this->assertNodeAccess(array('view' => TRUE, 'update' => FALSE, 'delete' => FALSE), $node5, $web_user3);

  }

}

/**

 * Tests hook_node_access_records() functionality.

 */

class NodeAccessRecordsTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node access records',

      'description' => 'Test hook_node_access_records when acquiring grants.',

      'group' => 'Node',

    );

  }

  function setUp() {

    // Enable dummy module that implements hook_node_grants(),

    // hook_node_access_records(), hook_node_grants_alter() and

    // hook_node_access_records_alter().

    parent::setUp('node_test');

  }

  /**

   * Creates a node and tests the creation of node access rules.

   */

  function testNodeAccessRecords() {

    // Create an article node.

    $node1 = $this->drupalCreateNode(array('type' => 'article'));

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

    // Check to see if grants added by node_test_node_access_records made it in.

    $records = db_query('SELECT realm, gid FROM {node_access} WHERE nid = :nid', array(':nid' => $node1->nid))->fetchAll();

    $this->assertEqual(count($records), 1, 'Returned the correct number of rows.');

    $this->assertEqual($records[0]->realm, 'test_article_realm', 'Grant with article_realm acquired for node without alteration.');

    $this->assertEqual($records[0]->gid, 1, 'Grant with gid = 1 acquired for node without alteration.');

    // Create an unpromoted "Basic page" node.

    $node2 = $this->drupalCreateNode(array('type' => 'page', 'promote' => 0));

    $this->assertTrue(node_load($node2->nid), 'Unpromoted basic page node created.');

    // Check to see if grants added by node_test_node_access_records made it in.

    $records = db_query('SELECT realm, gid FROM {node_access} WHERE nid = :nid', array(':nid' => $node2->nid))->fetchAll();

    $this->assertEqual(count($records), 1, 'Returned the correct number of rows.');

    $this->assertEqual($records[0]->realm, 'test_page_realm', 'Grant with page_realm acquired for node without alteration.');

    $this->assertEqual($records[0]->gid, 1, 'Grant with gid = 1 acquired for node without alteration.');

    // Create an unpromoted, unpublished "Basic page" node.

    $node3 = $this->drupalCreateNode(array('type' => 'page', 'promote' => 0, 'status' => 0));

    $this->assertTrue(node_load($node3->nid), 'Unpromoted, unpublished basic page node created.');

    // Check to see if grants added by node_test_node_access_records made it in.

    $records = db_query('SELECT realm, gid FROM {node_access} WHERE nid = :nid', array(':nid' => $node3->nid))->fetchAll();

    $this->assertEqual(count($records), 1, 'Returned the correct number of rows.');

    $this->assertEqual($records[0]->realm, 'test_page_realm', 'Grant with page_realm acquired for node without alteration.');

    $this->assertEqual($records[0]->gid, 1, 'Grant with gid = 1 acquired for node without alteration.');

    // Create a promoted "Basic page" node.

    $node4 = $this->drupalCreateNode(array('type' => 'page', 'promote' => 1));

    $this->assertTrue(node_load($node4->nid), 'Promoted basic page node created.');

    // Check to see if grant added by node_test_node_access_records was altered

    // by node_test_node_access_records_alter.

    $records = db_query('SELECT realm, gid FROM {node_access} WHERE nid = :nid', array(':nid' => $node4->nid))->fetchAll();

    $this->assertEqual(count($records), 1, 'Returned the correct number of rows.');

    $this->assertEqual($records[0]->realm, 'test_alter_realm', 'Altered grant with alter_realm acquired for node.');

    $this->assertEqual($records[0]->gid, 2, 'Altered grant with gid = 2 acquired for node.');

    // Check to see if we can alter grants with hook_node_grants_alter().

    $operations = array('view', 'update', 'delete');

    // Create a user that is allowed to access content.

    $web_user = $this->drupalCreateUser(array('access content'));

    foreach ($operations as $op) {

      $grants = node_test_node_grants($op, $web_user);

      $altered_grants = $grants;

      drupal_alter('node_grants', $altered_grants, $web_user, $op);

      $this->assertNotEqual($grants, $altered_grants, format_string('Altered the %op grant for a user.', array('%op' => $op)));

    }

    // Check that core does not grant access to an unpublished node when an

    // empty $grants array is returned.

    $node6 = $this->drupalCreateNode(array('status' => 0, 'disable_node_access' => TRUE));

    $records = db_query('SELECT realm, gid FROM {node_access} WHERE nid = :nid', array(':nid' => $node6->nid))->fetchAll();

    $this->assertEqual(count($records), 0, 'Returned no records for unpublished node.');

  }

}

/**

 * Tests for Node Access with a non-node base table.

 */

class NodeAccessBaseTableTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node Access on any table',

      'description' => 'Checks behavior of the node access subsystem if the base table is not node.',

      'group' => 'Node',

    );

  }

  public function setUp() {

    parent::setUp('node_access_test');

    node_access_rebuild();

    variable_set('node_access_test_private', TRUE);

  }

  /**

   * Tests the "private" node access functionality.

   *

   * - Create 2 users with "access content" and "create article" permissions.

   * - Each user creates one private and one not private article.

   * - Test that each user can view the other user's non-private article.

   * - Test that each user cannot view the other user's private article.

   * - Test that each user finds only appropriate (non-private + own private)

   *   in taxonomy listing.

   * - Create another user with 'view any private content'.

   * - Test that user 4 can view all content created above.

   * - Test that user 4 can view all content on taxonomy listing.

   */

  function testNodeAccessBasic() {

    $num_simple_users = 2;

    $simple_users = array();

    // nodes keyed by uid and nid: $nodes[$uid][$nid] = $is_private;

    $this->nodesByUser = array();

    $titles = array(); // Titles keyed by nid

    $private_nodes = array(); // Array of nids marked private.

    for ($i = 0; $i < $num_simple_users; $i++) {

      $simple_users[$i] = $this->drupalCreateUser(array('access content', 'create article content'));

    }

    foreach ($simple_users as $this->webUser) {

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

      foreach (array(0 => 'Public', 1 => 'Private') as $is_private => $type) {

        $edit = array(

          'title' => t('@private_public Article created by @user', array('@private_public' => $type, '@user' => $this->webUser->name)),

        );

        if ($is_private) {

          $edit['private'] = TRUE;

          $edit['body[und][0][value]'] = 'private node';

          $edit['field_tags[und]'] = 'private';

        }

        else {

          $edit['body[und][0][value]'] = 'public node';

          $edit['field_tags[und]'] = 'public';

        }

        $this->drupalPost('node/add/article', $edit, t('Save'));

        $nid = db_query('SELECT nid FROM {node} WHERE title = :title', array(':title' => $edit['title']))->fetchField();

        $private_status = db_query('SELECT private FROM {node_access_test} where nid = :nid', array(':nid' => $nid))->fetchField();

        $this->assertTrue($is_private == $private_status, 'The private status of the node was properly set in the node_access_test table.');

        if ($is_private) {

          $private_nodes[] = $nid;

        }

        $titles[$nid] = $edit['title'];

        $this->nodesByUser[$this->webUser->uid][$nid] = $is_private;

      }

    }

    $this->publicTid = db_query('SELECT tid FROM {taxonomy_term_data} WHERE name = :name', array(':name' => 'public'))->fetchField();

    $this->privateTid = db_query('SELECT tid FROM {taxonomy_term_data} WHERE name = :name', array(':name' => 'private'))->fetchField();

    $this->assertTrue($this->publicTid, 'Public tid was found');

    $this->assertTrue($this->privateTid, 'Private tid was found');

    foreach ($simple_users as $this->webUser) {

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

      // Check own nodes to see that all are readable.

      foreach ($this->nodesByUser as $uid => $data) {

        foreach ($data as $nid => $is_private) {

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

          if ($is_private) {

            $should_be_visible = $uid == $this->webUser->uid;

          }

          else {

            $should_be_visible = TRUE;

          }

          $this->assertResponse($should_be_visible ? 200 : 403, strtr('A %private node by user %uid is %visible for user %current_uid.', array(

            '%private' => $is_private ? 'private' : 'public',

            '%uid' => $uid,

            '%visible' => $should_be_visible ? 'visible' : 'not visible',

            '%current_uid' => $this->webUser->uid,

          )));

        }

      }

      // Check to see that the correct nodes are shown on taxonomy/private

      // and taxonomy/public.

      $this->assertTaxonomyPage(FALSE);

    }

    // Now test that a user with 'access any private content' can view content.

    $access_user = $this->drupalCreateUser(array('access content', 'create article content', 'node test view', 'search content'));

    $this->drupalLogin($access_user);

    foreach ($this->nodesByUser as $uid => $private_status) {

      foreach ($private_status as $nid => $is_private) {

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

        $this->assertResponse(200);

      }

    }

    // This user should be able to see all of the nodes on the relevant

    // taxonomy pages.

    $this->assertTaxonomyPage(TRUE);

  }

  /**

   * Checks taxonomy/term listings to ensure only accessible nodes are listed.

   *

   * @param $is_admin

   *   A boolean indicating whether the current user is an administrator. If

   *   TRUE, all nodes should be listed. If FALSE, only public nodes and the

   *   user's own private nodes should be listed.

   */

  protected function assertTaxonomyPage($is_admin) {

    foreach (array($this->publicTid, $this->privateTid) as $tid_is_private => $tid) {

      $this->drupalGet("taxonomy/term/$tid");

      $this->nids_visible = array();

      foreach ($this->xpath("//a[text()='Read more']") as $link) {

        $this->assertTrue(preg_match('|node/(\d+)$|', (string) $link['href'], $matches), 'Read more points to a node');

        $this->nids_visible[$matches[1]] = TRUE;

      }

      foreach ($this->nodesByUser as $uid => $data) {

        foreach ($data as $nid => $is_private) {

          // Private nodes should be visible on the private term page,

          // public nodes should be visible on the public term page.

          $should_be_visible = $tid_is_private == $is_private;

          // Non-administrators can only see their own nodes on the private

          // term page.

          if (!$is_admin && $tid_is_private) {

            $should_be_visible = $should_be_visible && $uid == $this->webUser->uid;

          }

          $this->assertIdentical(isset($this->nids_visible[$nid]), $should_be_visible, strtr('A %private node by user %uid is %visible for user %current_uid on the %tid_is_private page.', array(

            '%private' => $is_private ? 'private' : 'public',

            '%uid' => $uid,

            '%visible' => isset($this->nids_visible[$nid]) ? 'visible' : 'not visible',

            '%current_uid' => $this->webUser->uid,

            '%tid_is_private' => $tid_is_private ? 'private' : 'public',

          )));

        }

      }

    }

  }

}

/**

 * Tests node save related functionality, including import-save.

 */

class NodeSaveTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node save',

      'description' => 'Test node_save() for saving content.',

      'group' => 'Node',

    );

  }

  function setUp() {

    parent::setUp('node_test');

    // Create a user that is allowed to post; we'll use this to test the submission.

    $web_user = $this->drupalCreateUser(array('create article content'));

    $this->drupalLogin($web_user);

    $this->web_user = $web_user;

  }

  /**

   * Checks whether custom node IDs are saved properly during an import operation.

   *

   * Workflow:

   *  - first create a piece of content

   *  - save the content

   *  - check if node exists

   */

  function testImport() {

    // Node ID must be a number that is not in the database.

    $max_nid = db_query('SELECT MAX(nid) FROM {node}')->fetchField();

    $test_nid = $max_nid + mt_rand(1000, 1000000);

    $title = $this->randomName(8);

    $node = array(

      'title' => $title,

      'body' => array(LANGUAGE_NONE => array(array('value' => $this->randomName(32)))),

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

      'type' => 'article',

      'nid' => $test_nid,

      'is_new' => TRUE,

    );

    $node = node_submit((object) $node);

    // Verify that node_submit did not overwrite the user ID.

    $this->assertEqual($node->uid, $this->web_user->uid, 'Function node_submit() preserves user ID');

    node_save($node);

    // Test the import.

    $node_by_nid = node_load($test_nid);

    $this->assertTrue($node_by_nid, 'Node load by node ID.');

    $node_by_title = $this->drupalGetNodeByTitle($title);

    $this->assertTrue($node_by_title, 'Node load by node title.');

  }

  /**

   * Verifies accuracy of the "created" and "changed" timestamp functionality.

   */

  function testTimestamps() {

    // Use the default timestamps.

    $edit = array(

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

      'type' => 'article',

      'title' => $this->randomName(8),

    );

    node_save((object) $edit);

    $node = $this->drupalGetNodeByTitle($edit['title']);

    $this->assertEqual($node->created, REQUEST_TIME, 'Creating a node sets default "created" timestamp.');

    $this->assertEqual($node->changed, REQUEST_TIME, 'Creating a node sets default "changed" timestamp.');

    // Store the timestamps.

    $created = $node->created;

    $changed = $node->changed;

    node_save($node);

    $node = $this->drupalGetNodeByTitle($edit['title'], TRUE);

    $this->assertEqual($node->created, $created, 'Updating a node preserves "created" timestamp.');

    // Programmatically set the timestamps using hook_node_presave.

    $node->title = 'testing_node_presave';

    node_save($node);

    $node = $this->drupalGetNodeByTitle('testing_node_presave', TRUE);

    $this->assertEqual($node->created, 280299600, 'Saving a node uses "created" timestamp set in presave hook.');

    $this->assertEqual($node->changed, 979534800, 'Saving a node uses "changed" timestamp set in presave hook.');

    // Programmatically set the timestamps on the node.

    $edit = array(

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

      'type' => 'article',

      'title' => $this->randomName(8),

      'created' => 280299600, // Sun, 19 Nov 1978 05:00:00 GMT

      'changed' => 979534800, // Drupal 1.0 release.

    );

    node_save((object) $edit);

    $node = $this->drupalGetNodeByTitle($edit['title']);

    $this->assertEqual($node->created, 280299600, 'Creating a node uses user-set "created" timestamp.');

    $this->assertNotEqual($node->changed, 979534800, 'Creating a node doesn\'t use user-set "changed" timestamp.');

    // Update the timestamps.

    $node->created = 979534800;

    $node->changed = 280299600;

    node_save($node);

    $node = $this->drupalGetNodeByTitle($edit['title'], TRUE);

    $this->assertEqual($node->created, 979534800, 'Updating a node uses user-set "created" timestamp.');

    $this->assertNotEqual($node->changed, 280299600, 'Updating a node doesn\'t use user-set "changed" timestamp.');

  }

  /**

   * Tests determing changes in hook_node_presave() and verifies the static node

   * load cache is cleared upon save.

   */

  function testDeterminingChanges() {

    // Initial creation.

    $node = (object) array(

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

      'type' => 'article',

      'title' => 'test_changes',

    );

    node_save($node);

    // Update the node without applying changes.

    node_save($node);

    $this->assertEqual($node->title, 'test_changes', 'No changes have been determined.');

    // Apply changes.

    $node->title = 'updated';

    node_save($node);

    // The hook implementations node_test_node_presave() and

    // node_test_node_update() determine changes and change the title.

    $this->assertEqual($node->title, 'updated_presave_update', 'Changes have been determined.');

    // Test the static node load cache to be cleared.

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

    $this->assertEqual($node->title, 'updated_presave', 'Static cache has been cleared.');

  }

  /**

   * Tests saving a node on node insert.

   *

   * This test ensures that a node has been fully saved when hook_node_insert()

   * is invoked, so that the node can be saved again in a hook implementation

   * without errors.

   *

   * @see node_test_node_insert()

   */

  function testNodeSaveOnInsert() {

    // node_test_node_insert() triggers a save on insert if the title equals

    // 'new'.

    $node = $this->drupalCreateNode(array('title' => 'new'));

    $this->assertEqual($node->title, 'Node ' . $node->nid, 'Node saved on node insert.');

  }

}

/**

 * Tests related to node types.

 */

class NodeTypeTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node types',

      'description' => 'Ensures that node type functions work correctly.',

      'group' => 'Node',

    );

  }

  /**

   * Ensures that node type functions (node_type_get_*) work correctly.

   *

   * Load available node types and validate the returned data.

   */

  function testNodeTypeGetFunctions() {

    $node_types = node_type_get_types();

    $node_names = node_type_get_names();

    $this->assertTrue(isset($node_types['article']), 'Node type article is available.');

    $this->assertTrue(isset($node_types['page']), 'Node type basic page is available.');

    $this->assertEqual($node_types['article']->name, $node_names['article'], 'Correct node type base has been returned.');

    $this->assertEqual($node_types['article'], node_type_get_type('article'), 'Correct node type has been returned.');

    $this->assertEqual($node_types['article']->name, node_type_get_name('article'), 'Correct node type name has been returned.');

    $this->assertEqual($node_types['page']->base, node_type_get_base('page'), 'Correct node type base has been returned.');

  }

  /**

   * Tests creating a content type programmatically and via a form.

   */

  function testNodeTypeCreation() {

    // Create a content type programmaticaly.

    $type = $this->drupalCreateContentType();

    $type_exists = db_query('SELECT 1 FROM {node_type} WHERE type = :type', array(':type' => $type->type))->fetchField();

    $this->assertTrue($type_exists, 'The new content type has been created in the database.');

    // Login a test user.

    $web_user = $this->drupalCreateUser(array('create ' . $type->name . ' content'));

    $this->drupalLogin($web_user);

    $this->drupalGet('node/add/' . str_replace('_', '-', $type->name));

    $this->assertResponse(200, 'The new content type can be accessed at node/add.');

    // Create a content type via the user interface.

    $web_user = $this->drupalCreateUser(array('bypass node access', 'administer content types'));

    $this->drupalLogin($web_user);

    $edit = array(

      'name' => 'foo',

      'title_label' => 'title for foo',

      'type' => 'foo',

    );

    $this->drupalPost('admin/structure/types/add', $edit, t('Save content type'));

    $type_exists = db_query('SELECT 1 FROM {node_type} WHERE type = :type', array(':type' => 'foo'))->fetchField();

    $this->assertTrue($type_exists, 'The new content type has been created in the database.');

  }

  /**

   * Tests editing a node type using the UI.

   */

  function testNodeTypeEditing() {

    $web_user = $this->drupalCreateUser(array('bypass node access', 'administer content types'));

    $this->drupalLogin($web_user);

    $instance = field_info_instance('node', 'body', 'page');

    $this->assertEqual($instance['label'], 'Body', 'Body field was found.');

    // Verify that title and body fields are displayed.

    $this->drupalGet('node/add/page');

    $this->assertRaw('Title', 'Title field was found.');

    $this->assertRaw('Body', 'Body field was found.');

    // Rename the title field.

    $edit = array(

      'title_label' => 'Foo',

    );

    $this->drupalPost('admin/structure/types/manage/page', $edit, t('Save content type'));

    // Refresh the field information for the rest of the test.

    field_info_cache_clear();

    $this->drupalGet('node/add/page');

    $this->assertRaw('Foo', 'New title label was displayed.');

    $this->assertNoRaw('Title', 'Old title label was not displayed.');

    // Change the name, machine name and description.

    $edit = array(

      'name' => 'Bar',

      'type' => 'bar',

      'description' => 'Lorem ipsum.',

    );

    $this->drupalPost('admin/structure/types/manage/page', $edit, t('Save content type'));

    field_info_cache_clear();

    $this->drupalGet('node/add');

    $this->assertRaw('Bar', 'New name was displayed.');

    $this->assertRaw('Lorem ipsum', 'New description was displayed.');

    $this->clickLink('Bar');

    $this->assertEqual(url('node/add/bar', array('absolute' => TRUE)), $this->getUrl(), 'New machine name was used in URL.');

    $this->assertRaw('Foo', 'Title field was found.');

    $this->assertRaw('Body', 'Body field was found.');

    // Remove the body field.

    $this->drupalPost('admin/structure/types/manage/bar/fields/body/delete', NULL, t('Delete'));

    // Resave the settings for this type.

    $this->drupalPost('admin/structure/types/manage/bar', array(), t('Save content type'));

    // Check that the body field doesn't exist.

    $this->drupalGet('node/add/bar');

    $this->assertNoRaw('Body', 'Body field was not found.');

  }

  /**

   * Tests that node_types_rebuild() correctly handles the 'disabled' flag.

   */

  function testNodeTypeStatus() {

    // Enable all core node modules, and all types should be active.

    module_enable(array('blog', 'book', 'poll'), FALSE);

    node_types_rebuild();

    $types = node_type_get_types();

    foreach (array('blog', 'book', 'poll', 'article', 'page') as $type) {

      $this->assertTrue(isset($types[$type]), format_string('%type is found in node types.', array('%type' => $type)));

      $this->assertTrue(isset($types[$type]->disabled) && empty($types[$type]->disabled), format_string('%type type is enabled.', array('%type' => $type)));

    }

    // Disable poll module and the respective type should be marked as disabled.

    module_disable(array('poll'), FALSE);

    node_types_rebuild();

    $types = node_type_get_types();

    $this->assertTrue(!empty($types['poll']->disabled), "Poll module's node type disabled.");

    $this->assertTrue(isset($types['blog']) && empty($types['blog']->disabled), "Blog module's node type still active.");

    // Disable blog module and the respective type should be marked as disabled.

    module_disable(array('blog'), FALSE);

    node_types_rebuild();

    $types = node_type_get_types();

    $this->assertTrue(!empty($types['blog']->disabled), "Blog module's node type disabled.");

    $this->assertTrue(!empty($types['poll']->disabled), "Poll module's node type still disabled.");

    // Disable book module and the respective type should still be active, since

    // it is not provided by hook_node_info().

    module_disable(array('book'), FALSE);

    node_types_rebuild();

    $types = node_type_get_types();

    $this->assertTrue(isset($types['book']) && empty($types['book']->disabled), "Book module's node type still active.");

    $this->assertTrue(!empty($types['blog']->disabled), "Blog module's node type still disabled.");

    $this->assertTrue(!empty($types['poll']->disabled), "Poll module's node type still disabled.");

    $this->assertTrue(isset($types['article']) && empty($types['article']->disabled), "Article node type still active.");

    $this->assertTrue(isset($types['page']) && empty($types['page']->disabled), "Basic page node type still active.");

    // Re-enable the modules and verify that the types are active again.

    module_enable(array('blog', 'book', 'poll'), FALSE);

    node_types_rebuild();

    $types = node_type_get_types();

    foreach (array('blog', 'book', 'poll', 'article', 'page') as $type) {

      $this->assertTrue(isset($types[$type]), format_string('%type is found in node types.', array('%type' => $type)));

      $this->assertTrue(isset($types[$type]->disabled) && empty($types[$type]->disabled), format_string('%type type is enabled.', array('%type' => $type)));

    }

  }

}

/**

 * Test node type customizations persistence.

 */

class NodeTypePersistenceTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Node type persist',

      'description' => 'Ensures that node type customization survives module enabling and disabling.',

      'group' => 'Node',

    );

  }

  /**

   * Tests that node type customizations persist through disable and uninstall.

   */

  function testNodeTypeCustomizationPersistence() {

    $web_user = $this->drupalCreateUser(array('bypass node access', 'administer content types', 'administer modules'));

    $this->drupalLogin($web_user);

    $poll_key = 'modules[Core][poll][enable]';

    $poll_enable = array($poll_key => "1");

    $poll_disable = array($poll_key => FALSE);

    // Enable poll and verify that the node type is in the DB and is not

    // disabled.

    $this->drupalPost('admin/modules', $poll_enable, t('Save configuration'));

    $disabled = db_query('SELECT disabled FROM {node_type} WHERE type = :type', array(':type' => 'poll'))->fetchField();

    $this->assertNotIdentical($disabled, FALSE, 'Poll node type found in the database');