RestfulCreateEntityTestCase.test in RESTful 7

Contains RestfulCreateEntityTestCase

File

tests/RestfulCreateEntityTestCase.test

<?php

/**
 * @file
 * Contains RestfulCreateEntityTestCase
 */
class RestfulCreateEntityTestCase extends RestfulCurlBaseTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Create entity',
      'description' => 'Test the creation of an entity.',
      'group' => 'RESTful',
    );
  }

  /**
   * @var string
   *
   * Holds the path to a random generated image for upload purposes.
   */
  private $imagePath;

  /**
   * @var \stdClass
   *
   * Holds the created account.
   */
  protected $account;
  function setUp() {
    parent::setUp('restful_test', 'entityreference');

    // Add common fields, vocabulary and terms.
    restful_test_add_fields();
    $images = $this
      ->drupalGetTestFiles('image');
    $image = reset($images);
    $this->imagePath = drupal_realpath($image->uri);
    $this->account = $this
      ->drupalCreateUser();
  }

  /**
   * Test creating an entity (POST method).
   */
  function testCreateEntity() {

    // Create test entities to be referenced.
    $ids = array();
    foreach (array(
      1,
      2,
    ) as $id) {
      $entity = entity_create('entity_test', array(
        'name' => 'main',
      ));
      $entity
        ->save();
      $ids[] = $entity->pid;
    }
    $images = array();
    foreach ($this
      ->drupalGetTestFiles('image') as $file) {
      $file = file_save($file);
      $images[] = $file->fid;
    }
    $handler = restful_get_restful_handler('main', 1, 1);
    $query = new EntityFieldQuery();
    $result = $query
      ->entityCondition('entity_type', 'taxonomy_term')
      ->entityCondition('bundle', 'test_vocab')
      ->execute();
    $tids = array_keys($result['taxonomy_term']);
    $text1 = $this
      ->randomName();
    $text2 = $this
      ->randomName();
    $request = array(
      'text_single' => $text1,
      'text_multiple' => array(
        $text1,
        $text2,
      ),
      'text_single_processing' => $text1,
      'text_multiple_processing' => array(
        $text1,
        $text2,
      ),
      'entity_reference_single' => $ids[0],
      'entity_reference_multiple' => $ids,
      'term_single' => $tids[0],
      'term_multiple' => array(
        $tids[0],
        $tids[1],
      ),
      'file_single' => $images[0],
      'file_multiple' => array(
        $images[0],
        $images[1],
      ),
      'image_single' => $images[0],
      'image_multiple' => array(
        $images[0],
        $images[1],
      ),
    );
    $response = $handler
      ->post('', $request);
    $result = $response[0];
    $text_single = trim(strip_tags($result['text_single']));
    $text_multiple = array(
      trim(strip_tags($result['text_multiple'][0])),
      trim(strip_tags($result['text_multiple'][1])),
    );
    $expected_result = $request;

    // Strip some elements, and the text, for easier assertion.
    $striped_result = $result;
    unset($striped_result['id']);
    unset($striped_result['label']);
    unset($striped_result['self']);
    unset($striped_result['entity_reference_single_resource']);
    unset($striped_result['entity_reference_multiple_resource']);
    $striped_result['text_single'] = $text_single;
    $striped_result['text_multiple'] = $text_multiple;
    $striped_result['text_single_processing'] = $text_single;
    $striped_result['text_multiple_processing'] = $text_multiple;
    ksort($striped_result);
    ksort($expected_result);
    $this
      ->assertEqual($expected_result, $striped_result, 'Entity was created with correct values.');
    $this
      ->assertEqual($result['entity_reference_single_resource']['id'], $ids[0], ' Entity reference single resource was created correctly');
    $this
      ->assertEqual($result['entity_reference_multiple_resource'][0]['id'], $ids[0], ' Entity reference multiple resource was created correctly');

    // Create an entity with empty request.
    try {
      $handler
        ->post();
      $this
        ->fail('User can create an entity with empty request.');
    } catch (\RestfulBadRequestException $e) {
      $this
        ->pass('User cannot create an entity with empty request.');
    } catch (\Exception $e) {
      $this
        ->fail('Wrong exception thrown when creating an entity with empty request.');
    }

    // Create an entity with invalid property name.
    $request['invalid'] = 'wrong';
    try {
      $handler
        ->post('', $request);
      $this
        ->fail('User can create an entity with invalid property name.');
    } catch (\RestfulBadRequestException $e) {
      $this
        ->pass('User cannot create an entity with invalid property name.');
    } catch (\Exception $e) {
      $this
        ->fail('Wrong exception thrown when creating an entity with invalid property name.');
    }

    // Create entity with comma separated multiple entity reference.
    $request = array(
      'entity_reference_multiple' => implode(',', $ids),
    );
    $response = $handler
      ->post('', $request);
    $result = $response[0];
    $this
      ->assertEqual($result['entity_reference_multiple'], $ids, 'Created entity with comma separated multiple entity reference.');

    // Create entity with comma separated multiple taxonomy term reference.
    $ids = array(
      $tids[0],
      $tids[1],
    );
    $request = array(
      'term_multiple' => implode(',', $ids),
    );
    $response = $handler
      ->post('', $request);
    $result = $response[0];
    $this
      ->assertEqual($result['term_multiple'], $ids, 'Created entity with comma separated multiple taxonomy term reference.');

    // Create entity with comma separated multiple file reference.
    $ids = array(
      $images[0],
      $images[1],
    );
    $request = array(
      'file_multiple' => implode(',', $ids),
    );
    $response = $handler
      ->post('', $request);
    $result = $response[0];
    $this
      ->assertEqual($result['file_multiple'], $ids, 'Created entity with comma separated multiple file reference.');

    // Create entity with comma separated multiple image reference.
    $ids = array(
      $images[0],
      $images[1],
    );
    $request = array(
      'image_multiple' => implode(',', $ids),
    );
    $response = $handler
      ->post('', $request);
    $result = $response[0];
    $this
      ->assertEqual($result['image_multiple'], $ids, 'Created entity with comma separated multiple image reference.');
  }

  /**
   * Test access for file upload.
   */
  public function testFileUploadAccess() {
    variable_set('restful_file_upload', TRUE);
    variable_set('restful_file_upload_allow_anonymous_user', TRUE);

    // Test access for anonymous user (allowed).
    $return = $this
      ->uploadFile();
    $this
      ->assertEqual($return['code'], 200, 'File upload is allowed to anonymous users.');
    variable_set('restful_file_upload_allow_anonymous_user', FALSE);

    // Now that we have a successfully uploaded file, make sure it's the same
    // file that was uploaded.
    $original = hash_file('md5', $this->imagePath);
    $return_array = drupal_json_decode($return['body']);
    $file = file_load($return_array['data'][0]['id']);
    $uploaded = hash_file('md5', file_create_url($file->uri));
    $this
      ->assertEqual($original, $uploaded, 'Original and uploaded file are identical.');

    // Test access for anonymous user (denied).
    $return = $this
      ->uploadFile();
    $this
      ->assertEqual($return['code'], 403, 'File upload is denied to anonymous users.');
    $this
      ->drupalLogin($this->account);

    // Test access for authenticated users (allowed).
    $return = $this
      ->uploadFile();
    $this
      ->assertEqual($return['code'], 200, 'File upload is allowed to authenticated users.');

    // Test access for authenticated users (denied).
    variable_set('restful_file_upload', FALSE);
    $return = $this
      ->uploadFile();
    $this
      ->assertEqual($return['code'], 403, 'File upload is denied to authenticated users.');
  }

  /**
   * Uploads a file issuing a POST HTTP request.
   */
  protected function uploadFile() {
    $value = '@' . $this->imagePath;

    // PHP 5.5 introduced a CurlFile object that deprecates the old @filename
    // syntax. See: https://wiki.php.net/rfc/curl-file-upload
    if (function_exists('curl_file_create')) {
      $value = curl_file_create($this->imagePath);
    }
    return $this
      ->httpRequest('api/file-upload', \RestfulInterface::POST, array(
      'filename' => $value,
    ), array(
      'Content-Type' => 'multipart/form-data',
    ), TRUE);
  }

}

Classes

Name	Description
RestfulCreateEntityTestCase	@file Contains RestfulCreateEntityTestCase