<?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(array('taxonomy', 'node'));

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

    $this->drupalLogin($web_user);

    // Add a vocabulary so we can test different view modes.

    $vocabulary = (object) array(

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

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

      'machine_name' => drupal_strtolower($this->randomName()),

      'help' => '',

      'nodes' => array('page' => 'page'),

    );

    taxonomy_vocabulary_save($vocabulary);

    $this->vocabulary = $vocabulary;

    // Add a term to the vocabulary.

    $term = (object) array(

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

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

      // Use the first available text format.

      'format' => db_query_range('SELECT format FROM {filter_format}', 0, 1)->fetchField(),

      'vid' => $this->vocabulary->vid,

      'vocabulary_machine_name' => $vocabulary->machine_name,

    );

    taxonomy_term_save($term);

    $this->term = $term;

    // Set up a field and instance.

    $this->field_name = drupal_strtolower($this->randomName());

    $this->field = array(

      'field_name' => $this->field_name,

      'type' => 'taxonomy_term_reference',

      'settings' => array(

        'allowed_values' => array(

          array(

            'vocabulary' => $this->vocabulary->machine_name,

            'parent' => '0',

          ),

        ),

      )

    );

    field_create_field($this->field);

    $this->instance = array(

      'field_name' => $this->field_name,

      'entity_type' => 'node',

      'bundle' => 'page',

      'widget' => array(

        'type' => 'options_select',

      ),

      // Hide on full display but render on teaser.

      'display' => array(

        'default' => array(

          'type' => 'hidden',

        ),

        'teaser' => array(

          'type' => 'taxonomy_term_reference_link',

        ),

      ),

    );

    field_create_instance($this->instance);

  }

  /**

   * Checks the node preview functionality.

   */

  function testPagePreview() {