Club Drupal

<?php

/**

 * @file

 * Entity CRUD API tests.

 */

/**

 * Common parent class containing common helpers.

 */

abstract class EntityWebTestCase extends DrupalWebTestCase {

  /**

   * Creates a new vocabulary.

   */

  protected function createVocabulary() {

    $vocab = entity_create('taxonomy_vocabulary', array(

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

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

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

    ));

    entity_save('taxonomy_vocabulary', $vocab);

    return $vocab;

  }

  /**

   * Creates a random file of the given type.

   */

  protected function createFile($file_type = 'text') {

    // Create a managed file.

    $file = current($this->drupalGetTestFiles($file_type));

    // Set additional file properties and save it.

    $file->filemime = file_get_mimetype($file->filename);

    $file->uid = 1;

    $file->timestamp = REQUEST_TIME;

    $file->filesize = filesize($file->uri);

    $file->status = 0;

    file_save($file);

    return $file;

  }

}

/**

 * Test basic API.

 */

class EntityAPITestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity CRUD',

      'description' => 'Tests basic CRUD API functionality.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'entity_test');

  }

  /**

   * Tests CRUD.

   */

  function testCRUD() {

    module_enable(array('entity_feature'));

    $user1 = $this->drupalCreateUser();

    // Create test entities for the user1 and unrelated to a user.

    $entity = entity_create('entity_test', array('name' => 'test', 'uid' => $user1->uid));

    $entity->save();

    $entity = entity_create('entity_test', array('name' => 'test2', 'uid' => $user1->uid));

    $entity->save();

    $entity = entity_create('entity_test', array('name' => 'test', 'uid' => NULL));

    $entity->save();

    $entities = array_values(entity_test_load_multiple(FALSE, array('name' => 'test')));

    $this->assertEqual($entities[0]->name, 'test', 'Created and loaded entity.');

    $this->assertEqual($entities[1]->name, 'test', 'Created and loaded entity.');

    $results = entity_test_load_multiple(array($entity->pid));

    $loaded = array_pop($results);

    $this->assertEqual($loaded->pid, $entity->pid, 'Loaded the entity unrelated to a user.');

    $entities = array_values(entity_test_load_multiple(FALSE, array('name' => 'test2')));

    $entities[0]->delete();

    $entities = array_values(entity_test_load_multiple(FALSE, array('name' => 'test2')));

    $this->assertEqual($entities, array(), 'Entity successfully deleted.');

    $entity->save();

    $this->assertEqual($entity->pid, $loaded->pid, 'Entity successfully updated.');

    // Try deleting multiple test entities by deleting all.

    $pids = array_keys(entity_test_load_multiple(FALSE));

    entity_test_delete_multiple($pids);

  }

  /**

   * Tests CRUD for entities supporting revisions.

   */

  function testCRUDRevisisions() {

    module_enable(array('entity_feature'));

    // Add text field to entity.

    $field_info = array(

      'field_name' => 'field_text',

      'type' => 'text',

      'entity_types' => array('entity_test2'),

    );

    field_create_field($field_info);

    $instance = array(

      'label' => 'Text Field',

      'field_name' => 'field_text',

      'entity_type' => 'entity_test2',

      'bundle' => 'entity_test2',

      'settings' => array(),

      'required' => FALSE,

    );

    field_create_instance($instance);

    // Create a test entity.

    $entity_first_revision = entity_create('entity_test2', array('title' => 'first revision', 'name' => 'main', 'uid' => 1));

    $entity_first_revision->field_text[LANGUAGE_NONE][0]['value'] = 'first revision text';

    entity_save('entity_test2', $entity_first_revision);

    $entities = array_values(entity_load('entity_test2', FALSE));

    $this->assertEqual(count($entities), 1, 'Entity created.');

    $this->assertTrue($entities[0]->default_revision, 'Initial entity revision is marked as default revision.');

    // Saving the entity in revision mode should create a new revision.

    $entity_second_revision = clone $entity_first_revision;

    $entity_second_revision->title = 'second revision';

    $entity_second_revision->is_new_revision = TRUE;

    $entity_second_revision->default_revision = TRUE;

    $entity_second_revision->field_text[LANGUAGE_NONE][0]['value'] = 'second revision text';

    entity_save('entity_test2', $entity_second_revision);

    $this->assertNotEqual($entity_second_revision->revision_id, $entity_first_revision->revision_id, 'Saving an entity in new revision mode creates a revision.');

    $this->assertTrue($entity_second_revision->default_revision, 'New entity revision is marked as default revision.');

    // Check the saved entity.

    $entity = current(entity_load('entity_test2', array($entity_first_revision->pid), array(), TRUE));

    $this->assertNotEqual($entity->title, $entity_first_revision->title, 'Default revision was changed.');

    // Create third revision that is not default.

    $entity_third_revision = clone $entity_first_revision;

    $entity_third_revision->title = 'third revision';

    $entity_third_revision->is_new_revision = TRUE;

    $entity_third_revision->default_revision = FALSE;

    $entity_third_revision->field_text[LANGUAGE_NONE][0]['value'] = 'third revision text';

    entity_save('entity_test2', $entity_third_revision);

    $this->assertNotEqual($entity_second_revision->revision_id, $entity_third_revision->revision_id, 'Saving an entity in revision mode creates a revision.');

    $this->assertFalse($entity_third_revision->default_revision, 'Entity revision is not marked as default revision.');

    $entity = current(entity_load('entity_test2', array($entity_first_revision->pid), array(), TRUE));

    $this->assertEqual($entity->title, $entity_second_revision->title, 'Default revision was not changed.');

    $this->assertEqual($entity->field_text[LANGUAGE_NONE][0]['value'], $entity_second_revision->field_text[LANGUAGE_NONE][0]['value'], 'Default revision text field was not changed.');

    // Load not default revision.

    $revision = entity_revision_load('entity_test2', $entity_third_revision->revision_id);

    $this->assertEqual($revision->revision_id, $entity_third_revision->revision_id, 'Revision successfully loaded.');

    $this->assertFalse($revision->default_revision, 'Entity revision is not marked as default revision after loading.');

    // Save not default revision.

    $entity_third_revision->title = 'third revision updated';

    $entity_third_revision->field_text[LANGUAGE_NONE][0]['value'] = 'third revision text updated';

    entity_save('entity_test2', $entity_third_revision);

    // Ensure that not default revision has been changed.

    $entity = entity_revision_load('entity_test2', $entity_third_revision->revision_id);

    $this->assertEqual($entity->title, 'third revision updated', 'Not default revision was updated successfully.');

    $this->assertEqual($entity->field_text[LANGUAGE_NONE][0]['value'], 'third revision text updated', 'Not default revision field was updated successfully.');

    // Ensure that default revision has not been changed.

    $entity = current(entity_load('entity_test2', array($entity_first_revision->pid), array(), TRUE));

    $this->assertEqual($entity->title, $entity_second_revision->title, 'Default revision was not changed.');

    // Try to delete default revision.

    $result = entity_revision_delete('entity_test2', $entity_second_revision->revision_id);

    $this->assertFalse($result, 'Default revision cannot be deleted.');

    // Make sure default revision is still set after trying to delete it.

    $entity = current(entity_load('entity_test2', array($entity_first_revision->pid), array(), TRUE));

    $this->assertEqual($entity->revision_id, $entity_second_revision->revision_id, 'Second revision is still default.');

    // Delete first revision.

    $result = entity_revision_delete('entity_test2', $entity_first_revision->revision_id);

    $this->assertTrue($result, 'Not default revision deleted.');

    $entity = entity_revision_load('entity_test2', $entity_first_revision->revision_id);

    $this->assertFalse($entity, 'First revision deleted.');

    // Delete the entity and make sure third revision has been deleted as well.

    entity_delete('entity_test2', $entity_second_revision->pid);

    $entity_info = entity_get_info('entity_test2');

    $result = db_select($entity_info['revision table'])

      ->condition('revision_id', $entity_third_revision->revision_id)

      ->countQuery()

      ->execute()

      ->fetchField();

    $this->assertEqual($result, 0, 'Entity deleted with its all revisions.');

  }

  /**

   * Tests CRUD API functions: entity_(create|delete|save)

   */

  function testCRUDAPIfunctions() {

    module_enable(array('entity_feature'));

    $user1 = $this->drupalCreateUser();

    // Create test entities for the user1 and unrelated to a user.

    $entity = entity_create('entity_test', array('name' => 'test', 'uid' => $user1->uid));

    entity_save('entity_test', $entity);

    $entity = entity_create('entity_test', array('name' => 'test2', 'uid' => $user1->uid));

    entity_save('entity_test', $entity);

    $entity = entity_create('entity_test', array('name' => 'test', 'uid' => NULL));

    entity_save('entity_test', $entity);

    $entities = array_values(entity_test_load_multiple(FALSE, array('name' => 'test')));

    $this->assertEqual($entities[0]->name, 'test', 'Created and loaded entity.');

    $this->assertEqual($entities[1]->name, 'test', 'Created and loaded entity.');

    // Test getting the entity label, which is the used test-type's label.

    $label = entity_label('entity_test', $entities[0]);

    $this->assertEqual($label, 'label', 'Default label returned.');

    $results = entity_test_load_multiple(array($entity->pid));

    $loaded = array_pop($results);

    $this->assertEqual($loaded->pid, $entity->pid, 'Loaded the entity unrelated to a user.');

    $entities = array_values(entity_test_load_multiple(FALSE, array('name' => 'test2')));

    entity_delete('entity_test', $entities[0]->pid);

    $entities = array_values(entity_test_load_multiple(FALSE, array('name' => 'test2')));

    $this->assertEqual($entities, array(), 'Entity successfully deleted.');

    entity_save('entity_test', $entity);

    $this->assertEqual($entity->pid, $loaded->pid, 'Entity successfully updated.');

    // Try deleting multiple test entities by deleting all.

    $pids = array_keys(entity_test_load_multiple(FALSE));

    entity_delete_multiple('entity_test', $pids);

  }

  /**

   * Test loading entities defined in code.

   */

  function testExportables() {

    module_enable(array('entity_feature'));

    $types = entity_load_multiple_by_name('entity_test_type', array('test2', 'test'));

    $this->assertEqual(array_keys($types), array('test2', 'test'), 'Entities have been loaded in the order as specified.');

    $this->assertEqual($types['test']->label, 'label', 'Default type loaded.');

    $this->assertTrue($types['test']->status & ENTITY_IN_CODE && !($types['test']->status & ENTITY_CUSTOM), 'Default type status is correct.');

    // Test using a condition, which has to be applied on the defaults.

    $types = entity_load_multiple_by_name('entity_test_type', FALSE, array('label' => 'label'));

    $this->assertEqual($types['test']->label, 'label', 'Condition to default type applied.');

    $types['test']->label = 'modified';

    $types['test']->save();

    // Ensure loading the changed entity works.

    $types = entity_load_multiple_by_name('entity_test_type', FALSE, array('label' => 'modified'));

    $this->assertEqual($types['test']->label, 'modified', 'Modified type loaded.');

    // Clear the cache to simulate a new page load.

    entity_get_controller('entity_test_type')->resetCache();

    // Test loading using a condition again, now they default may not appear any

    // more as it's overridden by an entity with another label.

    $types = entity_load_multiple_by_name('entity_test_type', FALSE, array('label' => 'label'));

    $this->assertTrue(empty($types), 'Conditions are applied to the overridden entity only.');

    // But the overridden entity has to appear with another condition.

    $types = entity_load_multiple_by_name('entity_test_type', FALSE, array('label' => 'modified'));

    $this->assertEqual($types['test']->label, 'modified', 'Modified default type loaded by condition.');

    $types = entity_load_multiple_by_name('entity_test_type', array('test', 'test2'));

    $this->assertEqual($types['test']->label, 'modified', 'Modified default type loaded by id.');

    $this->assertTrue(entity_has_status('entity_test_type', $types['test'], ENTITY_OVERRIDDEN), 'Status of overridden type is correct.');

    // Test rebuilding the defaults and make sure overridden entities stay.

    entity_defaults_rebuild();

    $types = entity_load_multiple_by_name('entity_test_type', array('test', 'test2'));

    $this->assertEqual($types['test']->label, 'modified', 'Overridden entity is still overridden.');

    $this->assertTrue(entity_has_status('entity_test_type', $types['test'], ENTITY_OVERRIDDEN), 'Status of overridden type is correct.');

    // Test reverting.

    $types['test']->delete();

    $types = entity_load_multiple_by_name('entity_test_type', array('test', 'test2'));

    $this->assertEqual($types['test']->label, 'label', 'Entity has been reverted.');

    // Test loading an exportable by its numeric id.

    $result = entity_load_multiple_by_name('entity_test_type', array($types['test']->id));

    $this->assertTrue(isset($result['test']), 'Exportable entity loaded by the numeric id.');

    // Test exporting an entity to JSON.

    $serialized_string = $types['test']->export();

    $data = drupal_json_decode($serialized_string);

    $this->assertNotNull($data, 'Exported entity is valid JSON.');

    $import = entity_import('entity_test_type', $serialized_string);

    $this->assertTrue(get_class($import) == get_class($types['test']) && $types['test']->label == $import->label, 'Successfully exported entity to code.');

    $this->assertTrue(!isset($import->status), 'Exportable status has not been exported to code.');

    // Test disabling the module providing the defaults in code.

    $types = entity_load_multiple_by_name('entity_test_type', array('test', 'test2'));

    $types['test']->label = 'modified';

    $types['test']->save();

    module_disable(array('entity_feature'));

    // Make sure the overridden entity stays and the other one is deleted.

    entity_get_controller('entity_test_type')->resetCache();

    $test = entity_load_single('entity_test_type', 'test');

    $this->assertTrue(!empty($test) && $test->label == 'modified', 'Overidden entity is still available.');

    $this->assertTrue(!empty($test) && !entity_has_status('entity_test_type', $test, ENTITY_IN_CODE) && entity_has_status('entity_test_type', $test, ENTITY_CUSTOM), 'Overidden entity is now marked as custom.');

    $test2 = entity_load_single('entity_test_type', 'test2');

    $this->assertFalse($test2, 'Default entity has disappeared.');

  }

  /**

   * Make sure insert() and update() hooks for exportables are invoked.

   */

  function testExportableHooks() {

    $_SESSION['entity_hook_test'] = array();

    // Enabling the module should invoke the enabled hook for the other

    // entities provided in code.

    module_enable(array('entity_feature'));

    $insert = array('main', 'test', 'test2');

    $this->assertTrue($_SESSION['entity_hook_test']['entity_insert'] == $insert, 'Hook entity_insert has been invoked.');

    $this->assertTrue($_SESSION['entity_hook_test']['entity_test_type_insert'] == $insert, 'Hook entity_test_type_insert has been invoked.');

    // Load a default entity and make sure the rebuilt logic only ran once.

    entity_load_single('entity_test_type', 'test');

    $this->assertTrue(!isset($_SESSION['entity_hook_test']['entity_test_type_update']), '"Entity-test-type" defaults have been rebuilt only once.');

    // Add a new test entity in DB and make sure the hook is invoked too.

    $test3 = entity_create('entity_test_type', array(

      'name' => 'test3',

      'label' => 'label',

      'weight' => 0,

    ));

    $test3->save();

    $insert[] = 'test3';

    $this->assertTrue($_SESSION['entity_hook_test']['entity_insert'] == $insert, 'Hook entity_insert has been invoked.');

    $this->assertTrue($_SESSION['entity_hook_test']['entity_test_type_insert'] == $insert, 'Hook entity_test_type_insert has been invoked.');

    // Now override the 'test' entity and make sure it invokes the update hook.

    $result = entity_load_multiple_by_name('entity_test_type', array('test'));

    $result['test']->label = 'modified';

    $result['test']->save();

    $this->assertTrue($_SESSION['entity_hook_test']['entity_update'] == array('test'), 'Hook entity_update has been invoked.');

    $this->assertTrue($_SESSION['entity_hook_test']['entity_test_type_update'] == array('test'), 'Hook entity_test_type_update has been invoked.');

    // 'test' has to remain enabled, as it has been overridden.

    $delete = array('main', 'test2');

    module_disable(array('entity_feature'));

    $this->assertTrue($_SESSION['entity_hook_test']['entity_delete'] == $delete, 'Hook entity_deleted has been invoked.');

    $this->assertTrue($_SESSION['entity_hook_test']['entity_test_type_delete'] == $delete, 'Hook entity_test_type_deleted has been invoked.');

    // Now make sure 'test' is not overridden any more, but custom.

    $result = entity_load_multiple_by_name('entity_test_type', array('test'));

    $this->assertTrue(!$result['test']->hasStatus(ENTITY_OVERRIDDEN), 'Entity is not marked as overridden any more.');

    $this->assertTrue(entity_has_status('entity_test_type', $result['test'], ENTITY_CUSTOM), 'Entity is marked as custom.');

    // Test deleting the remaining entities from DB.

    entity_delete_multiple('entity_test_type', array('test', 'test3'));

    $delete[] = 'test';

    $delete[] = 'test3';

    $this->assertTrue($_SESSION['entity_hook_test']['entity_delete'] == $delete, 'Hook entity_deleted has been invoked.');

    $this->assertTrue($_SESSION['entity_hook_test']['entity_test_type_delete'] == $delete, 'Hook entity_test_type_deleted has been invoked.');

  }

  /**

   * Tests determining changes.

   */

  function testChanges() {

    module_enable(array('entity_feature'));

    $types = entity_load_multiple_by_name('entity_test_type');

    // Override the default entity, such it gets saved in the DB.

    $types['test']->label ='test_changes';

    $types['test']->save();

    // Now test an update without applying any changes.

    $types['test']->save();

    $this->assertEqual($types['test']->label, 'test_changes', 'No changes have been determined.');

    // Apply changes.

    $types['test']->label = 'updated';

    $types['test']->save();

    // The hook implementations entity_test_entity_test_type_presave() and

    // entity_test_entity_test_type_update() determine changes and change the

    // label.

    $this->assertEqual($types['test']->label, 'updated_presave_update', 'Changes have been determined.');

    // Test the static load cache to be cleared.

    $types = entity_load_multiple_by_name('entity_test_type');

    $this->assertEqual($types['test']->label, 'updated_presave', 'Static cache has been cleared.');

  }

  /**

   * Tests viewing entites.

   */

  function testRendering() {

    module_enable(array('entity_feature'));

    $user1 = $this->drupalCreateUser();

    // Create test entities for the user1 and unrelated to a user.

    $entity = entity_create('entity_test', array('name' => 'test', 'uid' => $user1->uid));

    $render = $entity->view();

    $output = drupal_render($render);

    // The entity class adds the user name to the output. Verify it is there.

    $this->assertTrue(strpos($output, format_username($user1)) !== FALSE, 'Entity has been rendered');

  }

  /**

   * Test uninstall of the entity_test module.

   */

  function testUninstall() {

    // Add a test type and add a field instance, uninstall, then re-install and

    // make sure the field instance can be re-created.

    $test_type = entity_create('entity_test_type', array(

      'name' => 'test',

      'label' => 'label',

      'weight' => 0,

    ));

    $test_type->save();

    $field = array(

      'field_name' => 'field_test_fullname',

      'type' => 'text',

      'cardinality' => 1,

      'translatable' => FALSE,

    );

    field_create_field($field);

    $instance = array(

      'entity_type' => 'entity_test',

      'field_name' => 'field_test_fullname',

      'bundle' => 'test',

      'label' => 'Full name',

      'description' => 'Specify your first and last name.',

      'widget' => array(

        'type' => 'text_textfield',

        'weight' => 0,

      ),

    );

    field_create_instance($instance);

    // Uninstallation has to remove all bundles, thus also field instances.

    module_disable(array('entity_test'));

    require_once DRUPAL_ROOT . '/includes/install.inc';

    drupal_uninstall_modules(array('entity_test'));

    // Make sure the instance has been deleted.

    $instance_read = field_read_instance('entity_test', 'field_test_fullname', 'test', array('include_inactive' => 1));

    $this->assertFalse((bool) $instance_read, 'Field instance has been deleted.');

    // Ensure re-creating the same instance now works.

    module_enable(array('entity_test'));

    $test_type = entity_create('entity_test_type', array(

      'name' => 'test',

      'label' => 'label',

      'weight' => 0,

    ));

    $test_type->save();

    field_create_field($field);

    field_create_instance($instance);

    $instance_read = field_info_instance('entity_test', 'field_test_fullname', 'test');

    $this->assertTrue((bool) $instance_read, 'Field instance has been re-created.');

  }

}

/**

 * Test the generated Rules integration.

 */

class EntityAPIRulesIntegrationTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity CRUD Rules integration',

      'description' => 'Tests the Rules integration provided by the Entity CRUD API.',

      'group' => 'Entity API',

      'dependencies' => array('rules'),

    );

  }

  function setUp() {

    parent::setUp('entity', 'entity_test', 'rules');

    // Make sure the logger is enabled so the debug log is saved.

    variable_set('rules_debug_log', 1);

  }

  /**

   * Test the events.

   */

  function testEvents() {

    $rule = rules_reaction_rule();

    $rule->event('entity_test_presave');

    $rule->event('entity_test_insert');

    $rule->event('entity_test_update');

    $rule->event('entity_test_delete');

    $rule->action('drupal_message', array('message' => 'hello!'));

    $rule->save();

    rules_clear_cache(TRUE);

    // Let the events occur.

    $user1 = $this->drupalCreateUser();

    RulesLog::logger()->clear();

    $entity = entity_create('entity_test', array('name' => 'test', 'uid' => $user1->uid));

    $entity->save();

    $entity->name = 'update';

    $entity->save();

    $entity->delete();

    // Now there should have been 5 events, 2 times presave and once insert,

    // update and delete.

    $count = substr_count(RulesLog::logger()->render(), '0 ms Reacting on event');

    $this->assertTrue($count == 5, 'Events have been properly invoked.');

    RulesLog::logger()->checkLog();

  }

}

/**

 * Tests comments with node access.

 */

class EntityAPICommentNodeAccessTestCase extends CommentHelperCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity API comment node access',

      'description' => 'Test viewing comments on nodes with node access.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    DrupalWebTestCase::setUp('comment', 'entity', 'node_access_test');

    node_access_rebuild();

    // Create test node and user with simple node access permission. The

    // 'node test view' permission is implemented and granted by the

    // node_access_test module.

    $this->accessUser = $this->drupalCreateUser(array('access comments', 'post comments', 'edit own comments', 'node test view'));

    $this->noAccessUser = $this->drupalCreateUser(array('administer comments'));

    $this->node = $this->drupalCreateNode(array('type' => 'article', 'uid' => $this->accessUser->uid));

  }

  /**

   * Tests comment access when node access is enabled.

   */

  function testCommentNodeAccess() {

    // Post comment.

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

    $comment_text = $this->randomName();

    $comment = $this->postComment($this->node, $comment_text);

    $comment_loaded = comment_load($comment->id);

    $this->assertTrue($this->commentExists($comment), 'Comment found.');

    $this->drupalLogout();

    // Check access to node and associated comment for access user.

    $this->assertTrue(entity_access('view', 'node', $this->node, $this->accessUser), 'Access to view node was granted for access user');

    $this->assertTrue(entity_access('view', 'comment', $comment_loaded, $this->accessUser), 'Access to view comment was granted for access user');

    $this->assertTrue(entity_access('update', 'comment', $comment_loaded, $this->accessUser), 'Access to update comment was granted for access user');

    $this->assertFalse(entity_access('delete', 'comment', $comment_loaded, $this->accessUser), 'Access to delete comment was denied for access user');

    // Check access to node and associated comment for no access user.

    $this->assertFalse(entity_access('view', 'node', $this->node, $this->noAccessUser), 'Access to view node was denied for no access user');

    $this->assertFalse(entity_access('view', 'comment', $comment_loaded, $this->noAccessUser), 'Access to view comment was denied for no access user');

    $this->assertFalse(entity_access('update', 'comment', $comment_loaded, $this->noAccessUser), 'Access to update comment was denied for no access user');

    $this->assertFalse(entity_access('delete', 'comment', $comment_loaded, $this->noAccessUser), 'Access to delete comment was denied for no access user');

  }

}

/**

 * Test the i18n integration.

 */

class EntityAPIi18nItegrationTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity CRUD i18n integration',

      'description' => 'Tests the i18n integration provided by the Entity CRUD API.',

      'group' => 'Entity API',

      'dependencies' => array('i18n_string'),

    );

  }

  function setUp() {

    parent::setUp('entity_test_i18n');

    $this->admin_user = $this->drupalCreateUser(array('bypass node access', 'administer nodes', 'administer languages', 'administer content types', 'administer blocks', 'access administration pages'));

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

    $this->addLanguage('de');

  }

  /**

   * Copied from i18n module (class Drupali18nTestCase).

   *

   * We cannot extend from Drupali18nTestCase as else the test-bot would die.

   */

  public function addLanguage($language_code) {

    // Check to make sure that language has not already been installed.

    $this->drupalGet('admin/config/regional/language');

    if (strpos($this->drupalGetContent(), 'enabled[' . $language_code . ']') === FALSE) {

      // Doesn't have language installed so add it.

      $edit = array();

      $edit['langcode'] = $language_code;

      $this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));

      // Make sure we are not using a stale list.

      drupal_static_reset('language_list');

      $languages = language_list('language');

      $this->assertTrue(array_key_exists($language_code, $languages), t('Language was installed successfully.'));

      if (array_key_exists($language_code, $languages)) {

        $this->assertRaw(t('The language %language has been created and can now be used. More information is available on the <a href="@locale-help">help screen</a>.', array('%language' => $languages[$language_code]->name, '@locale-help' => url('admin/help/locale'))), t('Language has been created.'));

      }

    }

    elseif ($this->xpath('//input[@type="checkbox" and @name=:name and @checked="checked"]', array(':name' => 'enabled[' . $language_code . ']'))) {

      // It's installed and enabled. No need to do anything.

      $this->assertTrue(true, 'Language [' . $language_code . '] already installed and enabled.');

    }

    else {

      // It's installed but not enabled. Enable it.

      $this->assertTrue(true, 'Language [' . $language_code . '] already installed.');

      $this->drupalPost(NULL, array('enabled[' . $language_code . ']' => TRUE), t('Save configuration'));

      $this->assertRaw(t('Configuration saved.'), t('Language successfully enabled.'));

    }

  }

  /**

   * Tests the provided default controller.

   */

  function testDefaultController() {

    // Create test entities for the user1 and unrelated to a user.

    $entity = entity_create('entity_test_type', array(

      'name' => 'test',

      'uid' => $GLOBALS['user']->uid,

      'label' => 'label-en',

    ));

    $entity->save();

    // Add a translation.

    i18n_string_textgroup('entity_test')->update_translation("entity_test_type:{$entity->name}:label", 'de', 'label-de');

    $default = entity_i18n_string("entity_test:entity_test_type:{$entity->name}:label", 'label-en');

    $translation = entity_i18n_string("entity_test:entity_test_type:{$entity->name}:label", 'label-en', 'de');

    $this->assertEqual($translation, 'label-de', 'Label has been translated.');

    $this->assertEqual($default, 'label-en', 'Default label retrieved.');

    // Test the helper method.

    $translation = $entity->getTranslation('label', 'de');

    $default = $entity->getTranslation('label');

    $this->assertEqual($translation, 'label-de', 'Label has been translated via the helper method.');

    $this->assertEqual($default, 'label-en', 'Default label retrieved via the helper method.');

    // Test updating and make sure the translation stays.

    $entity->name = 'test2';

    $entity->save();

    $translation = $entity->getTranslation('label', 'de');

    $this->assertEqual($translation, 'label-de', 'Translation survives a name change.');

    // Test using the wrapper to retrieve a translation.

    $wrapper = entity_metadata_wrapper('entity_test_type', $entity);

    $translation = $wrapper->language('de')->label->value();

    $this->assertEqual($translation, 'label-de', 'Translation retrieved via the wrapper.');

    // Test deleting.

    $entity->delete();

    $translation = entity_i18n_string("entity_test:entity_test_type:{$entity->name}:label", 'label-en', 'de');

    $this->assertEqual($translation, 'label-en', 'Translation has been deleted.');

  }

}

/**

 * Tests metadata wrappers.

 */

class EntityMetadataTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Metadata Wrapper',

      'description' => 'Makes sure metadata wrapper are working right.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'entity_test', 'locale');

    // Create a field having 4 values for testing multiple value support.

    $this->field_name = drupal_strtolower($this->randomName() . '_field_name');

    $this->field = array('field_name' => $this->field_name, 'type' => 'text', 'cardinality' => 4);

    $this->field = field_create_field($this->field);

    $this->field_id = $this->field['id'];

    $this->instance = array(

      'field_name' => $this->field_name,

      'entity_type' => 'node',

      'bundle' => 'page',

      'label' => $this->randomName() . '_label',

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

      'weight' => mt_rand(0, 127),

      'settings' => array(

        'text_processing' => FALSE,

      ),

      'widget' => array(

        'type' => 'text_textfield',

        'label' => 'Test Field',

        'settings' => array(

          'size' => 64,

        )

      )

    );

    field_create_instance($this->instance);

    // Make the body field and the node type 'page' translatable.

    $field = field_info_field('body');

    $field['translatable'] = TRUE;

    field_update_field($field);

    variable_set('language_content_type_page', 1);

  }

  /**

   * Creates a user and a node, then tests getting the properties.

   */

  function testEntityMetadataWrapper() {

    $account = $this->drupalCreateUser();

    // For testing sanitizing give the user a malicious user name

    $account = user_save($account, array('name' => '<b>BadName</b>'));

    $title = '<b>Is it bold?<b>';

    $body[LANGUAGE_NONE][0] = array('value' => '<b>The body & nothing.</b>', 'summary' => '<b>The body.</b>');

    $node = $this->drupalCreateNode(array('uid' => $account->uid, 'name' => $account->name, 'body' => $body, 'title' => $title, 'summary' => '', 'type' => 'page'));

    // First test without sanitizing.

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertEqual('<b>Is it bold?<b>', $wrapper->title->value(), 'Getting a field value.');

    $this->assertEqual($node->title, $wrapper->title->raw(), 'Getting a raw property value.');

    // Test chaining.

    $this->assertEqual($account->mail, $wrapper->author->mail->value(), 'Testing chained usage.');

    $this->assertEqual($account->name, $wrapper->author->name->value(), 'Testing chained usage with callback and sanitizing.');

    // Test sanitized output.

    $options = array('sanitize' => TRUE);

    $this->assertEqual(check_plain('<b>Is it bold?<b>'), $wrapper->title->value($options), 'Getting sanitized field.');

    $this->assertEqual(filter_xss($node->name), $wrapper->author->name->value($options), 'Getting sanitized property with getter callback.');

    // Test getting an not existing property.

    try {

      echo $wrapper->dummy;

      $this->fail('Getting an not existing property.');

    }

    catch (EntityMetadataWrapperException $e) {

      $this->pass('Getting an not existing property.');

    }

    // Test setting.

    $wrapper->author = 0;

    $this->assertEqual(0, $wrapper->author->uid->value(), 'Setting a property.');

    try {

      $wrapper->url = 'dummy';

      $this->fail('Setting an unsupported property.');

    }

    catch (EntityMetadataWrapperException $e) {

      $this->pass('Setting an unsupported property.');

    }

    // Test value validation.

    $this->assertFalse($wrapper->author->name->validate(array(3)), 'Validation correctly checks for valid data types.');

    try {

      $wrapper->author->mail = 'foo';

      $this->fail('An invalid mail address has been set.');

    }

    catch (EntityMetadataWrapperException $e) {

      $this->pass('Setting an invalid mail address throws exception.');

    }

    // Test unsetting a required property.

    try {

      $wrapper->author = NULL;

      $this->fail('The required node author has been unset.');

    }

    catch (EntityMetadataWrapperException $e) {

      $this->pass('Unsetting the required node author throws an exception.');

    }

    // Test setting a referenced entity by id.

    $wrapper->author->set($GLOBALS['user']->uid);

    $this->assertEqual($wrapper->author->getIdentifier(), $GLOBALS['user']->uid, 'Get the identifier of a referenced entity.');

    $this->assertEqual($wrapper->author->uid->value(), $GLOBALS['user']->uid, 'Successfully set referenced entity using the identifier.');

    // Set by object.

    $wrapper->author->set($GLOBALS['user']);

    $this->assertEqual($wrapper->author->uid->value(), $GLOBALS['user']->uid, 'Successfully set referenced entity using the entity.');

    // Test getting by the field API processed values like the node body.

    $body_value = $wrapper->body->value;

    $this->assertEqual("<p>The body &amp; nothing.</p>\n", $body_value->value(), "Getting processed value.");

    $this->assertEqual("The body & nothing.\n", $body_value->value(array('decode' => TRUE)), "Decoded value.");

    $this->assertEqual("<b>The body & nothing.</b>", $body_value->raw(), "Raw body returned.");

    // Test getting the summary.

    $this->assertEqual("<p>The body.</p>\n", $wrapper->body->summary->value(), "Getting body summary.");

    $wrapper->body->set(array('value' => "<b>The second body.</b>"));

    $this->assertEqual("<p>The second body.</p>\n", $wrapper->body->value->value(), "Setting a processed field value and reading it again.");

    $this->assertEqual($node->body[LANGUAGE_NONE][0]['value'], "<b>The second body.</b>", 'Update appears in the wrapped entity.');

    $this->assert(isset($node->body[LANGUAGE_NONE][0]['safe_value']), 'Formatted text has been processed.');

    // Test translating the body on an English node.

    locale_add_language('de');

    $body['en'][0] = array('value' => '<b>English body.</b>', 'summary' => '<b>The body.</b>');

    $node = $this->drupalCreateNode(array('body' => $body, 'language' => 'en', 'type' => 'page'));

    $wrapper = entity_metadata_wrapper('node', $node);

    $wrapper->language('de');

    $languages = language_list();

    $this->assertEqual($wrapper->getPropertyLanguage(), $languages['de'], 'Wrapper language has been set to German');

    $this->assertEqual($wrapper->body->value->value(), "<p>English body.</p>\n", 'Language fallback on default language.');

    // Set a German text using the wrapper.

    $wrapper->body->set(array('value' => "<b>Der zweite Text.</b>"));

    $this->assertEqual($wrapper->body->value->value(), "<p>Der zweite Text.</p>\n", 'German body set and retrieved.');

    $wrapper->language(LANGUAGE_NONE);

    $this->assertEqual($wrapper->body->value->value(), "<p>English body.</p>\n", 'Default language text is still there.');

    // Test iterator.

    $type_info = entity_get_property_info('node');

    $this->assertFalse(array_diff_key($type_info['properties'], iterator_to_array($wrapper->getIterator())), 'Iterator is working.');

    foreach ($wrapper as $property) {

      $this->assertTrue($property instanceof EntityMetadataWrapper, 'Iterate over wrapper properties.');

    }

    // Test setting a new node.

    $node->title = 'foo';

    $wrapper->set($node);

    $this->assertEqual($wrapper->title->value(), 'foo', 'Changed the wrapped node.');

    // Test getting options lists.

    $this->assertEqual($wrapper->type->optionsList(), node_type_get_names(), 'Options list returned.');

    // Test making use of a generic 'entity' reference property the

    // 'entity_test' module provides. The property defaults to the node author.

    $this->assertEqual($wrapper->reference->uid->value(), $wrapper->author->getIdentifier(), 'Used generic entity reference property.');

    // Test updating a property of the generic entity reference.

    $wrapper->reference->name->set('foo');

    $this->assertEqual($wrapper->reference->name->value(), 'foo', 'Updated property of generic entity reference');

    // For testing, just point the reference to the node itself now.

    $wrapper->reference->set($wrapper);

    $this->assertEqual($wrapper->reference->nid->value(), $wrapper->getIdentifier(), 'Correctly updated the generic entity referenced property.');

    // Test saving and deleting.

    $wrapper->save();

    $wrapper->delete();

    $return = node_load($wrapper->getIdentifier());

    $this->assertFalse($return, "Node has been successfully deleted.");

    // Ensure changing the bundle changes available wrapper properties.

    $wrapper->type->set('article');

    $this->assertTrue(isset($wrapper->field_tags), 'Changing bundle changes available wrapper properties.');

    // Test labels.

    $user = $this->drupalCreateUser();

    user_save($user, array('roles' => array()));

    $wrapper->author = $user->uid;

    $this->assertEqual($wrapper->label(), $node->title, 'Entity label returned.');

    $this->assertEqual($wrapper->author->roles[0]->label(), t('authenticated user'), 'Label from options list returned');

    $this->assertEqual($wrapper->author->roles->label(), t('authenticated user'), 'Label for a list from options list returned');

  }

  /**

   * Test supporting multi-valued fields.

   */

  function testListMetadataWrappers() {

    $property = $this->field_name;

    $values = array();

    $values[LANGUAGE_NONE][0] = array('value' => '<b>2009-09-05</b>');

    $values[LANGUAGE_NONE][1] = array('value' => '2009-09-05');

    $values[LANGUAGE_NONE][2] = array('value' => '2009-08-05');

    $node = $this->drupalCreateNode(array('type' => 'page', $property => $values));

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertEqual('<b>2009-09-05</b>', $wrapper->{$property}[0]->value(), 'Getting array entry.');

    $this->assertEqual('2009-09-05', $wrapper->{$property}->get(1)->value(), 'Getting array entry.');

    $this->assertEqual(3, count($wrapper->{$property}->value()), 'Getting the whole array.');

    // Test sanitizing

    $this->assertEqual(check_plain('<b>2009-09-05</b>'), $wrapper->{$property}[0]->value(array('sanitize' => TRUE)), 'Getting array entry.');

    // Test iterator

    $this->assertEqual(array_keys(iterator_to_array($wrapper->$property->getIterator())), array_keys($wrapper->$property->value()), 'Iterator is working.');

    foreach ($wrapper->$property as $p) {

      $this->assertTrue($p instanceof EntityMetadataWrapper, 'Iterate over list wrapper properties.');

    }

    // Make sure changing the array changes the actual entity property.

    $wrapper->{$property}[0] = '2009-10-05';

    unset($wrapper->{$property}[1], $wrapper->{$property}[2]);

    $this->assertEqual($wrapper->{$property}->value(), array('2009-10-05'), 'Setting multiple property values.');

    // Test setting an arbitrary list item.

    $list = array(0 => REQUEST_TIME);

    $wrapper = entity_metadata_wrapper('list<date>', $list);

    $wrapper[1] = strtotime('2009-09-05');

    $this->assertEqual($wrapper->value(), array(REQUEST_TIME, strtotime('2009-09-05')), 'Setting a list item.');

    $this->assertEqual($wrapper->count(), 2, 'List count is correct.');

    // Test using a list wrapper without data.

    $wrapper = entity_metadata_wrapper('list<date>');

    $info = array();

    foreach ($wrapper as $item) {

      $info[] = $item->info();

    }

    $this->assertTrue($info[0]['type'] == 'date', 'Iterated over empty list wrapper.');

    // Test using a list of entities with a list of term objects.

    $list = array();

    $list[] = entity_property_values_create_entity('taxonomy_term', array(

      'name' => 'term 1',

      'vocabulary' => 1,

    ))->save()->value();

    $list[] = entity_property_values_create_entity('taxonomy_term', array(

      'name' => 'term 2',

      'vocabulary' => 1,

    ))->save()->value();

    $wrapper = entity_metadata_wrapper('list<taxonomy_term>', $list);

    $this->assertTrue($wrapper[0]->name->value() == 'term 1', 'Used a list of entities.');

    // Test getting a list of identifiers.

    $ids = $wrapper->value(array('identifier' => TRUE));

    $this->assertTrue(!is_object($ids[0]), 'Get a list of entity ids.');

    $wrapper = entity_metadata_wrapper('list<taxonomy_term>', $ids);

    $this->assertTrue($wrapper[0]->name->value() == 'term 1', 'Created a list of entities with ids.');

    // Test with a list of generic entities. The list is expected to be a list

    // of entity wrappers, otherwise the entity type is unknown.

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

    $list = array();

    $list[] = entity_metadata_wrapper('node', $node);

    $wrapper = entity_metadata_wrapper('list<entity>', $list);

    $this->assertEqual($wrapper[0]->title->value(), 'node 1', 'Wrapped node was found in generic list of entities.');

  }

  /**

   * Tests using the wrapper without any data.

   */

  function testWithoutData() {

    $wrapper = entity_metadata_wrapper('node', NULL, array('bundle' => 'page'));

    $this->assertTrue(isset($wrapper->title), 'Bundle properties have been added.');

    $info = $wrapper->author->mail->info();

    $this->assertTrue(!empty($info) && is_array($info) && isset($info['label']), 'Property info returned.');

  }

  /**

   * Test using access() method.

   */

  function testAccess() {

    // Test without data.

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

    $this->assertTrue(entity_access('view', 'node', NULL, $account), 'Access without data checked.');

    // Test with actual data.

    $values[LANGUAGE_NONE][0] = array('value' => '<b>2009-09-05</b>');

    $values[LANGUAGE_NONE][1] = array('value' => '2009-09-05');

    $node = $this->drupalCreateNode(array('type' => 'page', $this->field_name => $values));

    $this->assertTrue(entity_access('delete', 'node', $node, $account), 'Access with data checked.');

    // Test per property access without data.

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

    $wrapper = entity_metadata_wrapper('node', NULL, array('bundle' => 'page'));

    $this->assertTrue($wrapper->access('edit', $account), 'Access to node granted.');

    $this->assertFalse($wrapper->status->access('edit', $account), 'Access for admin property denied.');

    $this->assertTrue($wrapper->status->access('edit', $account2), 'Access for admin property allowed for the admin.');

    // Test per property access with data.

    $wrapper = entity_metadata_wrapper('node', $node, array('bundle' => 'page'));

    $this->assertFalse($wrapper->status->access('edit', $account), 'Access for admin property denied.');

    $this->assertTrue($wrapper->status->access('edit', $account2), 'Access for admin property allowed for the admin.');

    // Test field level access.

    $this->assertTrue($wrapper->{$this->field_name}->access('view'), 'Field access granted.');

    // Create node owned by anonymous and test access() method on each of its

    // properties.

    $node = $this->drupalCreateNode(array('type' => 'page', 'uid' => 0));

    $wrapper = entity_metadata_wrapper('node', $node->nid);

    foreach ($wrapper as $name => $property) {

      $property->access('view');

    }

    // Property access of entity references takes entity access into account.

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

    $wrapper = entity_metadata_wrapper('node', $node);

    $unprivileged_user = $this->drupalCreateUser();

    $privileged_user = $this->drupalCreateUser(array('access user profiles'));

    $this->assertTrue($wrapper->author->access('view', $privileged_user));

    $this->assertFalse($wrapper->author->access('view', $unprivileged_user));

    // Ensure the same works with multiple entity references by testing the

    // $node->field_tags example.

    $privileged_user = $this->drupalCreateUser(array('administer taxonomy'));

    // Terms are view-able with access content, so make sure to remove this

    // permission first.

    user_role_revoke_permissions(DRUPAL_ANONYMOUS_RID, array('access content'));

    $unprivileged_user = drupal_anonymous_user();

    $this->assertTrue($wrapper->field_tags->access('view', $privileged_user), 'Privileged user has access.');

    $this->assertTrue($wrapper->field_tags->access('view', $unprivileged_user), 'Unprivileged user has access.');

    $this->assertTrue($wrapper->field_tags[0]->access('view', $privileged_user), 'Privileged user has access.');

    $this->assertFalse($wrapper->field_tags[0]->access('view', $unprivileged_user), 'Unprivileged user has no access.');

  }

  /**

   * Tests using a data structure with passed in metadata.

   */

  function testDataStructureWrapper() {

    $log_entry = array(

      'type'        => 'entity',

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

      'variables'   => array(),

      'severity'    => WATCHDOG_NOTICE,

      'link'        => '',

      'user'        => $GLOBALS['user'],

    );

    $info['property info'] = array(

      'type' => array('type' => 'text', 'label' => 'The category to which this message belongs.'),

      'message' => array('type' => 'text', 'label' => 'The log message.'),

      'user' => array('type' => 'user', 'label' => 'The user causing the log entry.'),

    );

    $wrapper = entity_metadata_wrapper('log_entry', $log_entry, $info);

    $this->assertEqual($wrapper->user->name->value(), $GLOBALS['user']->name, 'Wrapped custom entity.');

  }

  /**

   * Tests using entity_property_query().

   */

  function testEntityQuery() {

    // Creat a test node.

    $title = '<b>Is it bold?<b>';

    $values[LANGUAGE_NONE][0] = array('value' => 'foo');

    $node = $this->drupalCreateNode(array($this->field_name => $values, 'title' => $title, 'uid' => $GLOBALS['user']->uid));

    $results = entity_property_query('node', 'title', $title);

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a given title.');

    $results = entity_property_query('node', $this->field_name, 'foo');

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a given field value.');

    $results = entity_property_query('node', $this->field_name, array('foo', 'bar'));

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a list of possible values.');

    $results = entity_property_query('node', 'author', $GLOBALS['user']);

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a given auhtor.');

    // Create another test node and try querying for tags.

    $tag = entity_property_values_create_entity('taxonomy_term', array(

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

          'vocabulary' => 1,

    ))->save();

    $field_tag_value[LANGUAGE_NONE][0]['tid'] = $tag->getIdentifier();

    $node = $this->drupalCreateNode(array('type' => 'article', 'field_tags' => $field_tag_value));

    // Try query-ing with a single value.

    $results = entity_property_query('node', 'field_tags', $tag->getIdentifier());

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a given term id.');

    $results = entity_property_query('node', 'field_tags', $tag->value());

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a given term object.');

    // Try query-ing with a list of possible values.

    $results = entity_property_query('node', 'field_tags', array($tag->getIdentifier()));

    $this->assertEqual($results, array($node->nid), 'Queried nodes with a list of term ids.');

  }

  /**

   * Tests serializing data wrappers, in particular for EntityDrupalWrapper.

   */

  function testWrapperSerialization() {

    $node = $this->drupalCreateNode();

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertTrue($wrapper->value() == $node, 'Data correctly wrapped.');

    // Test serializing and make sure only the node id is stored.

    $this->assertTrue(strpos(serialize($wrapper), $node->title) === FALSE, 'Node has been correctly serialized.');

    $this->assertEqual(unserialize(serialize($wrapper))->title->value(), $node->title, 'Serializing works right.');

    $wrapper2 = unserialize(serialize($wrapper));

    // Test serializing the unloaded wrapper.

    $this->assertEqual(unserialize(serialize($wrapper2))->title->value(), $node->title, 'Serializing works right.');

    // Test loading a not more existing node.

    $s = serialize($wrapper2);

    node_delete($node->nid);

    $this->assertFalse(node_load($node->nid), 'Node deleted.');

    $value = unserialize($s)->value();

    $this->assertNull($value, 'Tried to load not existing node.');

  }

}

/**

 * Tests basic entity_access() functionality for nodes.

 *

 * This code is a modified version of NodeAccessTestCase.

 *

 * @see NodeAccessTestCase

 */

class EntityMetadataNodeAccessTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity Metadata Node Access',

      'description' => 'Test entity_access() for nodes',

      'group' => 'Entity API',

    );

  }

  /**

   * Asserts node_access() correctly grants or denies access.

   */

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

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

      $msg = t("entity_access() returns @result with operation '@op'.", array('@result' => $result ? 'TRUE' : 'FALSE', '@op' => $op));

      $access = entity_access($op, 'node', $node, $account);

      $this->assertEqual($result, $access, $msg);

    }

  }

  function setUp() {

    parent::setUp('entity', 'node');

    // Clear permissions for authenticated users.

    db_delete('role_permission')

      ->condition('rid', DRUPAL_AUTHENTICATED_RID)

      ->execute();

  }

  /**

   * Runs basic tests for entity_access() function.

   */

  function testNodeMetadataAccess() {

    // Author user.

    $node_author_account = $this->drupalCreateUser(array());

    // Make a node object.

    $settings = array(

      'uid' => $node_author_account->uid,

      'type' => 'page',

      'title' => 'Node ' . $this->randomName(32),

    );

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

    // 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'));

    $this->assertNodeMetadataAccess(array('create' => FALSE, 'view' => FALSE, 'update' => FALSE, 'delete' => FALSE), $node, $web_user1);

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

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

    $this->assertNodeMetadataAccess(array('create' => TRUE, 'view' => TRUE, 'update' => TRUE, 'delete' => TRUE), $node, $web_user2);

    // User cannot 'view own unpublished content'.

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

    // Create an unpublished node.

    $settings = array('type' => 'page', 'status' => 0, 'uid' => $web_user3->uid);

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

    $this->assertNodeMetadataAccess(array('view' => FALSE), $node_unpublished, $web_user3);

    // User cannot create content without permission.

    $this->assertNodeMetadataAccess(array('create' => FALSE), $node, $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->assertNodeMetadataAccess(array('view' => TRUE, 'update' => FALSE), $node4, $web_user4);

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

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

    $node5 = $this->drupalCreateNode();

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

  }

}

/**

 * Test user permissions for node creation.

 */

class EntityMetadataNodeCreateAccessTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity Metadata Node Create Access',

      'description' => 'Test entity_access() for nodes',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'node');

  }

  /**

   * Addresses the special case of 'create' access for nodes.

   */

  public function testNodeMetadataCreateAccess() {

    // Create some users. One with super-powers, one with create perms,

    // and one with no perms, and a different one to author the node.

    $admin_account = $this->drupalCreateUser(array(

      'bypass node access',

    ));

    $creator_account = $this->drupalCreateUser(array(

      'create page content',

    ));

    $auth_only_account = $this->drupalCreateUser(array());

    $node_author_account = $this->drupalCreateUser(array());

    // Make a node object with Entity API (contrib)

    $settings = array(

      'uid' => $node_author_account->uid,

      'type' => 'page',

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

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

    );

    $node = entity_create('node', $settings);

    // Test the populated wrapper.

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertTrue($wrapper->entityAccess('create', $admin_account), 'Create access allowed for ADMIN, for populated wrapper.');

    $this->assertTrue($wrapper->entityAccess('create', $creator_account), 'Create access allowed for CREATOR, for populated wrapper.');

    $this->assertFalse($wrapper->entityAccess('create', $auth_only_account), 'Create access denied for USER, for populated wrapper.');

    // Test entity_acces().

    $this->assertTrue(entity_access('create', 'node', $node, $admin_account), 'Create access allowed for ADMIN, for entity_access().');

    $this->assertTrue(entity_access('create', 'node', $node, $creator_account), 'Create access allowed for CREATOR, for entity_access().');

    $this->assertFalse(entity_access('create', 'node', $node, $auth_only_account), 'Create access denied for USER, for entity_access().');

  }

}

/**

 * Tests user permissions for node revisions.

 *

 * Based almost entirely on NodeRevisionPermissionsTestCase.

 */

class EntityMetadataNodeRevisionAccessTestCase extends DrupalWebTestCase {

  protected $node_revisions = array();

  protected $accounts = array();

  // Map revision permission names to node revision access ops.

  protected $map = array(

    'view' => 'view revisions',

    'update' => 'revert revisions',

    'delete' => 'delete revisions',

  );

  public static function getInfo() {

    return array(

      'name' => 'Entity Metadata Node Revision Access',

      'description' => 'Tests user permissions for node revision operations.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'node');

    // Create a node with several revisions.

    $node = $this->drupalCreateNode();

    $this->node_revisions[] = $node;

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

      // Create a revision for the same nid and settings with a random log.

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

      $revision->revision = 1;

      $revision->log = $this->randomName(32);

      node_save($revision);

      $this->node_revisions[] = node_load($revision->nid);

    }

    // Create three users, one with each revision permission.

    foreach ($this->map as $op => $permission) {

      // Create the user.

      $account = $this->drupalCreateUser(

        array(

          'access content',

          'edit any page content',

          'delete any page content',

          $permission,

        )

      );

      $account->op = $op;

      $this->accounts[] = $account;

    }

    // Create an admin account (returns TRUE for all revision permissions).

    $admin_account = $this->drupalCreateUser(array('access content', 'administer nodes'));

    $admin_account->is_admin = TRUE;

    $this->accounts['admin'] = $admin_account;

    // Create a normal account (returns FALSE for all revision permissions).

    $normal_account = $this->drupalCreateUser();

    $normal_account->op = FALSE;

    $this->accounts[] = $normal_account;

  }

  /**

   * Tests the entity_access() function for revisions.

   */

  function testNodeRevisionAccess() {

    // $node_revisions[1] won't be the latest revision.

    $revision = $this->node_revisions[1];

    $parameters = array(

      'op' => array_keys($this->map),

      'account' => $this->accounts,

    );

    $permutations = $this->generatePermutations($parameters);

    $entity_type = 'node';

    foreach ($permutations as $case) {

      if (!empty($case['account']->is_admin) || $case['op'] == $case['account']->op) {

        $access = entity_access($case['op'], $entity_type, $revision, $case['account']);

        $this->assertTrue($access, "{$this->map[$case['op']]} granted on $entity_type.");

      }

      else {

        $access = entity_access($case['op'], $entity_type, $revision, $case['account']);

        $this->assertFalse($access, "{$this->map[$case['op']]} NOT granted on $entity_type.");

      }

    }

  }

}

/**

 * Tests provided entity property info of the core modules.

 */

class EntityTokenTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Entity tokens',

      'description' => 'Tests provided tokens for entity properties.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity_token');

  }

  /**

   * Tests whether token support is basically working.

   */

  function testTokenSupport() {

    // Test basic tokens.

    $node = $this->drupalCreateNode(array('sticky' => TRUE, 'promote' => FALSE));

    $text = "Sticky: [node:sticky] Promote: [node:promote] User: [site:current-user:name]";

    $true = t('true');

    $false = t('false');

    $user_name = $GLOBALS['user']->name;

    $target = "Sticky: $true Promote: $false User: $user_name";

    $replace = token_replace($text, array('node' => $node));

    $this->assertEqual($replace, $target, 'Provided tokens basically work.');

    // Test multiple-value tokens using the tags field of articles.

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

      $tags[$i] = entity_property_values_create_entity('taxonomy_term', array(

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

        'vocabulary' => 1,

      ))->save();

      $field_value[LANGUAGE_NONE][$i]['tid'] = $tags[$i]->getIdentifier();

      $labels[$i] = $tags[$i]->label();

    }

    $node = $this->drupalCreateNode(array('title' => 'foo', 'type' => 'article', 'field_tags' => $field_value));

    $text = "Tags: [node:field-tags] First: [node:field-tags:0] 2nd name: [node:field-tags:1:name] 1st vocab [node:field-tags:0:vocabulary]";

    $tag_labels = implode(', ', $labels);

    $target = "Tags: $tag_labels First: $labels[0] 2nd name: $labels[1] 1st vocab {$tags[0]->vocabulary->label()}";

    $replace = token_replace($text, array('node' => $node));

    $this->assertEqual($replace, $target, 'Multiple-value token replacements have been replaced.');

    // Make sure not existing values are not handled.

    $replace = token_replace("[node:field-tags:43]", array('node' => $node));

    $this->assertEqual($replace, "[node:field-tags:43]", 'Not existing values are not replaced.');

    // Test data-structure tokens like [site:current-page:url].

    $replace = token_replace("[site:current-page:url]", array());

    $this->assertEqual($replace, $GLOBALS['base_root'] . request_uri(), 'Token replacements of data structure properties replaced.');

    // Test chaining of data-structure tokens using an image-field.

    $file = $this->createFile('image');

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

    $wrapper = entity_metadata_wrapper('node', $node);

    $wrapper->field_image = array('fid' => $file->fid);

    $replace = token_replace("[node:field-image:file:name]", array('node' => $node));

    $this->assertEqual($replace, $wrapper->field_image->file->name->value(), 'Token replacements of an image field have been replaced.');

  }

}

/**

 * Tests provided entity property info of the core modules.

 */

class EntityMetadataIntegrationTestCase extends EntityWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Property info core integration',

      'description' => 'Tests using metadata wrapper for drupal core.',

      'group' => 'Entity API',

    );

  }

  function setUp() {

    parent::setUp('entity', 'book', 'statistics', 'locale');

  }

  protected function assertException($wrapper, $name, $text = NULL) {

    $this->assertTrue(isset($wrapper->$name), 'Property wrapper ' . check_plain($name) . ' exists.');

    $text = isset($text) ? $text : 'Getting the not existing property ' . $name . ' throws exception.';

    try {

      $wrapper->$name->value();

      $this->fail($text);

    }

    catch (EntityMetadataWrapperException $e) {

      $this->pass($text);

    }

  }

  protected function assertEmpty($wrapper, $name) {

    $this->assertTrue(isset($wrapper->$name), 'Property ' . check_plain($name) . ' exists.');

    $this->assertTrue($wrapper->$name->value() === NULL, 'Property ' . check_plain($name) . ' is empty.');

  }

  protected function assertEmptyArray($wrapper, $name) {

    $this->assertTrue(isset($wrapper->$name), 'Property ' . check_plain($name) . ' exists.');

    $this->assertTrue($wrapper->$name->value() === array(), 'Property ' . check_plain($name) . ' is an empty array.');

  }

  protected function assertValue($wrapper, $key) {

    $this->assertTrue($wrapper->$key->value() !== NULL, check_plain($key) . ' property returned.');

    $info = $wrapper->$key->info();

    if (!empty($info['raw getter callback'])) {

      // Also test getting the raw value

      $this->assertTrue($wrapper->$key->raw() !== NULL, check_plain($key) . ' raw value returned.');

    }

  }

  /**

   * Test book module integration.

   */

  function testBookModule() {

    $title = 'Book 1';

    $node = $this->drupalCreateNode(array('title' => $title, 'type' => 'book', 'book' => array('bid' => 'new')));

    $book = array('bid' => $node->nid, 'plid' => $node->book['mlid']);

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

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

    // Test whether the properties work.

    $wrapper = entity_metadata_wrapper('node', $node2);

    $this->assertEqual($title, $wrapper->book->title->value(), "Book title returned.");

    $this->assertEqual(array($node->nid), $wrapper->book_ancestors->value(array('identifier' => TRUE)), "Book ancestors returned.");

    $this->assertEqual($node->nid, $wrapper->book->nid->value(), "Book id returned.");

    // Try using book properties for no book nodes.

    $wrapper = entity_metadata_wrapper('node', $node3);

    $this->assertEmpty($wrapper, 'book');

    $this->assertEmptyArray($wrapper, 'book_ancestors');

  }

  /**

   * Test properties of a comment.

   */

  function testComments() {

    $title = 'Node 1';

    $node = $this->drupalCreateNode(array('title' => $title, 'type' => 'page'));

    $author = $this->drupalCreateUser(array('access comments', 'post comments', 'edit own comments'));

    $comment = (object)array(

      'subject' => 'topic',

      'nid' => $node->nid,

      'uid' => $author->uid,

      'cid' => FALSE,

      'pid' => 0,

      'homepage' => '',

      'language' => LANGUAGE_NONE,

      'hostname' => ip_address(),

    );

    $comment->comment_body[LANGUAGE_NONE][0] = array('value' => 'text', 'format' => 0);

    comment_save($comment);

    $wrapper = entity_metadata_wrapper('comment', $comment);

    foreach ($wrapper as $key => $value) {

      if ($key != 'parent') {

        $this->assertValue($wrapper, $key);

      }

    }

    $this->assertEmpty($wrapper, 'parent');

    // Test comment entity access.

    $admin_user = $this->drupalCreateUser(array('access comments', 'administer comments', 'access user profiles'));

    // Also grant access to view user accounts to test the comment author

    // property.

    $unprivileged_user = $this->drupalCreateUser(array('access comments', 'access user profiles'));

    // Published comments can be viewed and edited by the author.

    $this->assertTrue($wrapper->access('view', $author), 'Comment author is allowed to view the published comment.');

    $this->assertTrue($wrapper->access('edit', $author), 'Comment author is allowed to edit the published comment.');

    // We cannot use $wrapper->access('delete') here because it only understands

    // view and edit.

    $this->assertFalse(entity_access('delete', 'comment', $comment, $author), 'Comment author is not allowed to delete the published comment.');

    // Administrators can do anything with published comments.

    $this->assertTrue($wrapper->access('view', $admin_user), 'Comment administrator is allowed to view the published comment.');

    $this->assertTrue($wrapper->access('edit', $admin_user), 'Comment administrator is allowed to edit the published comment.');

    $this->assertTrue(entity_access('delete', 'comment', $comment, $admin_user), 'Comment administrator is allowed to delete the published comment.');

    // Unpriviledged users can only view the published comment.

    $this->assertTrue($wrapper->access('view', $unprivileged_user), 'Unprivileged user is allowed to view the published comment.');

    $this->assertFalse($wrapper->access('edit', $unprivileged_user), 'Unprivileged user is not allowed to edit the published comment.');

    $this->assertFalse(entity_access('delete', 'comment', $comment, $unprivileged_user), 'Unprivileged user is not allowed to delete the published comment.');

    // Test property view access.

    $view_access = array('name', 'homepage', 'subject', 'created', 'author', 'node', 'parent', 'url', 'edit_url');

    foreach ($view_access as $property_name) {

      $this->assertTrue($wrapper->{$property_name}->access('view', $unprivileged_user), "Unpriviledged user can view the $property_name property.");

    }

    $view_denied = array('hostname', 'mail', 'status');

    foreach ($view_denied as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('view', $unprivileged_user), "Unpriviledged user can not view the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('view', $admin_user), "Admin user can view the $property_name property.");

    }

    // The author is allowed to edit the comment subject if they have the

    // 'edit own comments' permission.

    $this->assertTrue($wrapper->subject->access('edit', $author), "Author can edit the subject property.");

    $this->assertFalse($wrapper->subject->access('edit', $unprivileged_user), "Unpriviledged user cannot edit the subject property.");

    $this->assertTrue($wrapper->subject->access('edit', $admin_user), "Admin user can edit the subject property.");

    $edit_denied = array('hostname', 'mail', 'status', 'name', 'homepage', 'created', 'parent', 'node', 'author');

    foreach ($edit_denied as $property_name) {

      $this->assertFalse($wrapper->{$property_name}->access('edit', $author), "Author cannot edit the $property_name property.");

      $this->assertTrue($wrapper->{$property_name}->access('edit', $admin_user), "Admin user can edit the $property_name property.");

    }

    // Test access to unpublished comments.

    $comment->status = COMMENT_NOT_PUBLISHED;

    comment_save($comment);

    // Unpublished comments cannot be accessed by the author.

    $this->assertFalse($wrapper->access('view', $author), 'Comment author is not allowed to view the unpublished comment.');

    $this->assertFalse($wrapper->access('edit', $author), 'Comment author is not allowed to edit the unpublished comment.');

    $this->assertFalse(entity_access('delete', 'comment', $comment, $author), 'Comment author is not allowed to delete the unpublished comment.');

    // Administrators can do anything with unpublished comments.

    $this->assertTrue($wrapper->access('view', $admin_user), 'Comment administrator is allowed to view the unpublished comment.');

    $this->assertTrue($wrapper->access('edit', $admin_user), 'Comment administrator is allowed to edit the unpublished comment.');

    $this->assertTrue(entity_access('delete', 'comment', $comment, $admin_user), 'Comment administrator is allowed to delete the unpublished comment.');

    // Unpriviledged users cannot access unpublished comments.

    $this->assertFalse($wrapper->access('view', $unprivileged_user), 'Unprivileged user is not allowed to view the unpublished comment.');

    $this->assertFalse($wrapper->access('edit', $unprivileged_user), 'Unprivileged user is not allowed to edit the unpublished comment.');

    $this->assertFalse(entity_access('delete', 'comment', $comment, $unprivileged_user), 'Unprivileged user is not allowed to delete the unpublished comment.');

  }