You are here

Home » API reference » Services 6.3

ServicesResourceNodeTests.test in Services 6.3

Same filename and directory in other branches
  1. 7.3 tests/functional/ServicesResourceNodeTests.test

File

tests/functional/ServicesResourceNodeTests.test
View source 
<?php

/**
 * @file
 * Call the endpoint tests when no authentication is being used.
 *
 */
require_once 'ServicesWebTestCase.php';

/**
 * Run test cases for the endpoint with no authentication turned on.
 *
 */
class ServicesResourceNodetests extends ServicesWebtestCase {

  // Class variables
  protected $privilegedUser = NULL;

  // Endpoint details.
  protected $endpoint = NULL;

  /**
   * Implementation of setUp().
   */
  public function setUp() {
    parent::setUp('taxonomy', 'autoload', 'ctools', 'services', 'rest_server', 'inputstream', 'upload', 'comment');

    // Set up endpoint.
    $this->endpoint = $this
      ->saveNewEndpoint();
  }

  /**
   * Implementation of getInfo().
   */
  public static function getInfo() {
    return array(
      'name' => t('Resource Node'),
      'description' => t('Test the resource Node methods and actions.'),
      'group' => t('Services'),
    );
  }

  /**
   * testing node_resource Index
   */
  public function testNewEndpointResourceNodeIndex() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'perform unlimited index queries',
    ));
    $this
      ->drupalLogin($this->privilegedUser);

    // Create a set of nodes. The node resource returns 20 returns at a time,
    // so we create two pages and a half worth.
    $nodes = array();
    $count = 50;
    for ($i = 0; $i < $count; $i++) {
      $node = $this
        ->drupalCreateNode();
      $nodes[$node->nid] = $node;
    }

    // Get the content.
    $page_count = ceil(count($nodes) / 20);
    $retrieved_nodes = array();
    for ($page = 0; $page < $page_count; $page++) {
      $responseArray = $this
        ->servicesGet($this->endpoint->path . '/node', array(
        'page' => $page,
        'fields' => 'nid,title',
      ));
      $this
        ->assertTrue(count($responseArray['body']) <= 20, t('Correct number of items returned'));

      // Store the returned node IDs.
      foreach ($responseArray['body'] as $node) {
        if (isset($retrieved_nodes[$node->nid])) {
          $this
            ->fail(t('Duplicate node @nid returned.', array(
            '@nid' => $node->nid,
          )));
        }
        $retrieved_nodes[$node->nid] = TRUE;
        $this
          ->assertTrue($nodes[$node->nid]->title == $node->title, t('Successfully received Node info'), 'NodeResource: Index');
      }
    }

    // We should have got all the nodes.
    $expected_nids = array_keys($nodes);
    sort($expected_nids);
    $retrieved_nids = array_keys($retrieved_nodes);
    sort($retrieved_nids);
    $this
      ->assertEqual($expected_nids, $retrieved_nids, t('Retrieved all nodes'));

    // The n+1 page should be empty.
    $responseArray = $this
      ->servicesGet($this->endpoint->path . '/node', array(
      'page' => $page_count + 1,
    ));
    $this
      ->assertEqual(count($responseArray['body']), 0, t('The n+1 page is empty'));

    // Adjust the pager size.
    $responseArray = $this
      ->servicesGet($this->endpoint->path . '/node', array(
      'fields' => 'nid,title',
      'pagesize' => 40,
    ));
    $this
      ->assertTrue(count($responseArray['body']) == 40, t('Correct number of items returned'));

    // Swap to user that can only use the default pager size.
    $this->lessPrivilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
    ));
    $this
      ->drupalLogin($this->lessPrivilegedUser);
    $responseArray = $this
      ->servicesGet($this->endpoint->path . '/node', array(
      'fields' => 'nid,title',
      'pagesize' => 40,
    ));
    $this
      ->assertTrue(count($responseArray['body']) == 20, t('Correct number of items returned'));
  }

  /**
   * testing node_resource Get
   */
  public function testNewEndpointResourceNodeGet() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = $this
      ->drupalCreateNode();
    $responseArray = $this
      ->servicesGet($this->endpoint->path . '/node/' . $node->nid);
    $this
      ->assertTrue($node->title == $responseArray['body']->title, t('Successfully received Node info'), 'NodeResource: Retrieve');

    //Verify node not found.
    unset($node);
    $responseArray = $this
      ->servicesGet($this->endpoint->path . '/node/99');
    $this
      ->assertTrue($responseArray['code'] == '404', t('Successfully was rejected to non existent node'), 'NodeResource: Retrieve');
  }

  /**
   * testing node_resource Create
   */
  public function testEndpointResourceNodeCreate() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = array(
      'title' => 'testing',
      'body' => 'bodytest',
      'type' => 'story',
      'name' => $this->privilegedUser->name,
    );
    $responseArray = $this
      ->servicesPost($this->endpoint->path . '/node', $node);
    $nodeResourceCreateReturn = $responseArray['body'];
    $this
      ->assertTrue(isset($nodeResourceCreateReturn['nid']), t('Node was successfully created'), 'NodeResource: Create');
    if (isset($nodeResourceCreateReturn['nid'])) {
      $newNode = node_load($nodeResourceCreateReturn['nid']);
      $this
        ->assertTrue($newNode->title = $node['title'], t('Title was the same'), 'NodeResource: Create');
      $this
        ->assertTrue($newNode->body = $node['body'], t('Body was the same'), 'NodeResource: Create');
    }
  }

  /**
   * Testing node_resource Create (Legacy).
   *
   * TODO: To be removed in future version.
   * @see http://drupal.org/node/1083242
   */
  public function testEndpointResourceNodeCreateLegacy() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = array(
      'title' => 'testing',
      'body' => 'bodytest',
      'type' => 'story',
      'name' => $this->privilegedUser->name,
    );
    $responseArray = $this
      ->servicesPost($this->endpoint->path . '/node', array(
      'node' => $node,
    ));
    $nodeResourceCreateReturn = $responseArray['body'];
    $this
      ->assertTrue(isset($nodeResourceCreateReturn['nid']), t('Node was successfully created'), 'NodeResource: Create (Legacy)');
    if (isset($nodeResourceCreateReturn['nid'])) {
      $newNode = node_load($nodeResourceCreateReturn['nid']);
      $this
        ->assertTrue($newNode->title = $node['title'], t('Title was the same'), 'NodeResource: Create (Legacy)');
      $this
        ->assertTrue($newNode->body = $node['body'], t('Body was the same'), 'NodeResource: Create (Legacy)');
    }
  }

  /**
   * testing node_resource Created make ure it fails with no perms
   */
  public function testEndpointResourceNodeCreateFail() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = array(
      'title' => 'testing',
      'body' => 'bodytest',
      'type' => 'story',
      'name' => $this->privilegedUser->name,
    );
    $responseArray = $this
      ->servicesPost($this->endpoint->path . '/node', $node);
    $this
      ->assertTrue($responseArray['code'] == 401, t('User with not sufficient permissions cannot create node'), 'NodeResource: Create');
  }

  /**
   * testing node_resource Validate missing Title
   */
  public function testEndpointResourceNodeCreateMissingTitle() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = array(
      'title' => '',
      'body' => 'bodytest',
      'name' => $this->privilegedUser->name,
      'type' => 'page',
    );
    $response_array = $this
      ->servicesPost($this->endpoint->path . '/node', $node);
    $this
      ->assertEqual($response_array['body'], t('Title field is required.'), t('Node was not created without title.'), 'NodeResource: Created');
  }

  /**
   * Create node with taxonomy terms added.
   */
  public function testEndpointResourceNodeCreateWithTaxonomyTerms() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
      'administer taxonomy',
    ));
    $this
      ->drupalLogin($this->privilegedUser);

    // Create vocabulary.
    $edit = array(
      'name' => $this
        ->randomName(),
      'multiple' => 1,
      'nodes[page]' => 1,
    );
    $this
      ->drupalPost('admin/content/taxonomy/add/vocabulary', $edit, t('Save'));

    // Create three terms.
    for ($i = 0; $i < 3; $i++) {
      $term = array(
        'name' => $this
          ->randomName(),
      );
      $this
        ->drupalPost('admin/content/taxonomy/1/add/term', $term, t('Save'));
    }
    $node = array(
      'nid' => NULL,
      'title' => $this
        ->randomString(),
      'body' => $this
        ->randomString(),
      'name' => $this->privilegedUser->name,
      'type' => 'page',
      'taxonomy' => array(
        1 => array(
          1 => 1,
          2 => 2,
        ),
      ),
    );
    $response = $this
      ->servicesPost($this->endpoint->path . '/node', $node);

    // Get number of attached taxonomy terms from this node. We do it manually
    // as we cannot get terms on node_load as as empty array is statically
    // cached in taxonomy_node_get_terms() and we cannot clear the cache.
    $terms_number = db_result(db_query('SELECT COUNT(*) result FROM {term_node} r INNER JOIN {node} n ON n.vid = r.vid WHERE n.nid = %d', $response['body']['nid']));
    $this
      ->assertTrue($terms_number == 2, t('Node with two terms was successfully created.'), 'NodeResource: Create');
  }

  /**
   * Test loadNodeComments method.
   */
  function testCommentLoadNodeComments() {
    $path = $this->endpoint->path;
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
    ));
    $this
      ->drupalLogin($this->privilegedUser);

    // Create node with commenting.
    $settings = array(
      'comment' => COMMENT_NODE_READ_WRITE,
    );
    $node = $this
      ->drupalCreateNode($settings);
    $nid = $node->nid;

    // Generate 15 comments for node.
    $comments = array();
    for ($i = 0; $i < 15; $i++) {
      $comment = array(
        'uid' => $this->privilegedUser->uid,
        'nid' => $nid,
        'subject' => $this
          ->randomString(),
        'comment' => $this
          ->randomString(),
      );
      $cid = comment_save($comment);
      $comments[] = _comment_load($cid);
    }
    $comments = array_reverse($comments);

    // Generate some comments for another node.
    $settings = array(
      'comment' => COMMENT_NODE_READ_WRITE,
    );
    $node2 = $this
      ->drupalCreateNode($settings);
    for ($i = 0; $i < 5; $i++) {
      $comment = array(
        'uid' => $this->privilegedUser->uid,
        'nid' => $node2->nid,
        'subject' => $this
          ->randomString(),
        'comment' => $this
          ->randomString(),
      );
      $cid = comment_save($comment);
    }

    // Load all comments of the first node.
    $response = $this
      ->servicesGet($path . '/node/' . $nid . '/comments');
    $this
      ->assertEqual($comments, $response['body'], t('Received all 15 comments.'), 'NodeResource: comments');

    // Load only 5 comments of the first node.
    $response = $this
      ->servicesGet($path . '/node/' . $nid . '/comments', array(
      'count' => 5,
    ));
    $this
      ->assertEqual(array_slice($comments, 0, 5), array_slice($response['body'], 0, 5), t('Received last 5 comments.'), 'NodeResource: comments');

    // Load only 5 comments of the first node starting from fifth comment.
    $response = $this
      ->servicesGet($path . '/node/' . $nid . '/comments', array(
      'count' => 5,
      'offset' => 5,
    ));
    $this
      ->assertEqual(array_slice($comments, 5, 5), array_merge(array(), $response['body']), t('Received 5 comments starting from fifth comment.'), 'NodeResource: comments');
  }

  /**
   * Test files relationship.
   */
  public function testNodeRelationshipFiles() {
    $this->privileged_user = $this
      ->drupalCreateUser(array(
      'get own binary files',
      'save file information',
      'administer services',
      'administer site configuration',
      'upload files',
    ));
    $this
      ->drupalLogin($this->privileged_user);
    $testfiles = $this
      ->drupalGetTestFiles('text');
    $testfile1 = $this
      ->uploadTestFile($testfiles);
    $testfile2 = $this
      ->uploadTestFile($testfiles);
    $testfile3 = $this
      ->uploadTestFile($testfiles);

    // Needed for upload module to create new records in {upload} table.
    // @see upload_save()
    $testfile1['new'] = TRUE;
    $testfile2['new'] = TRUE;
    $testfile3['new'] = TRUE;

    // First two files are listed. Third is not listed.
    $testfile1['list'] = 1;
    $testfile2['list'] = 1;
    $testfile3['list'] = 0;

    // Create node with three files.
    $settings = array(
      'files' => array(
        $testfile1['fid'] => (object) $testfile1,
        $testfile2['fid'] => (object) $testfile2,
        $testfile3['fid'] => (object) $testfile3,
      ),
    );
    $node = $this
      ->drupalCreateNode($settings);
    $result = $this
      ->servicesGet($this->endpoint->path . '/node/' . $node->nid . '/files');
    $this
      ->assertTrue(isset($result['body'][$testfile1['fid']]) && isset($result['body'][$testfile2['fid']]) && !isset($result['body'][$testfile3['fid']]), t('Attached files listed.'), 'FileResource: nodeFiles');
  }

  /**
   * Testing node_resource Update
   */
  public function testEndpointResourceNodeUpdate() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = $this
      ->drupalCreateNode();
    $node_update = array(
      'title' => 'testing',
      'body' => 'bodytest',
      'type' => 'page',
      'name' => $this->privilegedUser->name,
    );
    $responseArray = $this
      ->servicesPut($this->endpoint->path . '/node/' . $node->nid, $node_update);
    $nodeAfterUpdate = node_load($responseArray['body']['nid']);
    $this
      ->assertTrue(isset($nodeAfterUpdate->nid), t('Node was successfully updated'), 'NodeResource: Updated');
    if (isset($nodeAfterUpdate->nid)) {
      $this
        ->assertTrue($nodeAfterUpdate->title == $node_update['title'], t('Title was the same'), 'NodeResource: Update');
      $this
        ->assertTrue($nodeAfterUpdate->body == $node_update['body'], t('Body was the same'), 'NodeResource: Update');
    }

    // Try to update the node without node type.
    $node_update_no_type = $node_update;
    unset($node_update_no_type['type']);
    $node_update_no_type['title'] = $this
      ->randomName();
    $responseArray = $this
      ->servicesPut($this->endpoint->path . '/node/' . $node->nid, $node_update_no_type);
    $this
      ->assertNotEqual($responseArray['code'], 200, t('Can\'t update node without specifying node type'), 'NodeResource: Update');
  }

  /**
   * Testing node_resource Update (Legacy).
   *
   * TODO: To be removed in future version.
   * @see http://drupal.org/node/1083242
   */
  public function testEndpointResourceNodeUpdateLegacy() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = $this
      ->drupalCreateNode();
    $node_update = array(
      'title' => 'testing',
      'body' => 'bodytest',
      'type' => 'page',
      'name' => $this->privilegedUser->name,
    );
    $responseArray = $this
      ->servicesPut($this->endpoint->path . '/node/' . $node->nid, array(
      'node' => $node_update,
    ));
    $nodeAfterUpdate = node_load($responseArray['body']['nid']);
    $this
      ->assertTrue(isset($nodeAfterUpdate->nid), t('Node was successfully updated'), 'NodeResource: Updated (Legacy)');
    if (isset($nodeAfterUpdate->nid)) {
      $this
        ->assertTrue($nodeAfterUpdate->title == $node_update['title'], t('Title was the same'), 'NodeResource: Update (Legacy)');
      $this
        ->assertTrue($nodeAfterUpdate->body == $node_update['body'], t('Body was the same'), 'NodeResource: Update (Legacy)');
    }
  }

  /**
   * testing node_resource Update fail with no permissions
   */
  public function testEndpointResourceNodeUpdatePermFail() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'create story content',
      'edit own story content',
    ));
    $this
      ->drupalLogin($this->privilegedUser);

    // Create node from user no 1.
    $node = $this
      ->drupalCreateNode(array(
      'uid' => 1,
    ));

    // Try to update this node with different user not
    // having permission to edit any story content.
    $node_update = array(
      'title' => 'testing',
      'body' => 'bodytest',
      'type' => 'page',
    );
    $responseArray = $this
      ->servicesPut($this->endpoint->path . '/node/' . $node->nid, $node_update);
    $this
      ->assertTrue(strpos($responseArray['status'], 'Access denied for user'), t('Updating the node failed without needed permissions. This is good!'), 'NodeResource: Update');
  }

  /**
   * testing node_resource Update verify missing title
   */
  public function testEndpointResourceNodeUpdateMissingTitle() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = $this
      ->drupalCreateNode();
    $node_update = array(
      'title' => '',
      'body' => 'bodytest',
      'name' => $this->privilegedUser->name,
      'type' => 'page',
    );
    $responseArray = $this
      ->servicesPut($this->endpoint->path . '/node/' . $node->nid, $node_update);
    $this
      ->assertTrue(strpos($responseArray['status'], 'Title field is required.'), t('Node was not updated without title.'), 'NodeResource: Update');
  }

  /**
   * testing node_resource Delete
   */
  public function testEndpointResourceNodeDelete() {

    // Create and log in our privileged user.
    $this->privilegedUser = $this
      ->drupalCreateUser(array(
      'administer services',
      'administer nodes',
    ));
    $this
      ->drupalLogin($this->privilegedUser);
    $node = $this
      ->drupalCreateNode();
    $data = '';
    $responseArray = $this
      ->servicesDelete($this->endpoint->path . '/node/' . $node->nid, $data);
    $deleted_node = node_load($node->nid, NULL, TRUE);
    $this
      ->assertTrue(empty($deleted_node), t('Node was deleted.'), 'NodeResource: Deleted');
    $responseArray = $this
      ->servicesDelete($this->endpoint->path . '/node/' . $node->nid, $data);
    $this
      ->assertFalse($responseArray['code'] == 200, t('Node was deleted. It shoudlnt have been because it doesnt exist'), 'NodeResource: Deleted');
  }

  /**
   * Emulate uploaded file.
   *
   * Copy file from simpletest file samples and create record in files table.
   *
   * @return array
   *  File data.
   */
  public function uploadTestFile($file = NULL) {
    if (empty($file)) {
      $file = next($this->testfiles);
    }
    $testfile = array(
      'fid' => NULL,
      'uid' => $this->privileged_user->uid,
      'filename' => trim(basename($file->filename), '.'),
      'filepath' => $file->filename,
      'filemime' => file_get_mimetype($file->filename),
      'filesize' => filesize($file->filename),
      'status' => FILE_STATUS_PERMANENT,
      'timestamp' => time(),
    );
    $source = $testfile['filepath'];
    $destination = file_directory_path() . '/' . $testfile['filepath'];
    $dirname = dirname($destination);
    file_check_directory($dirname, FILE_CREATE_DIRECTORY);
    file_copy($source, $destination);
    drupal_write_record('files', $testfile);
    return $testfile;
  }

}

Classes

Namesort descending Description
ServicesResourceNodetests Run test cases for the endpoint with no authentication turned on.