entity.test in Entity API 7
Entity CRUD API tests.
File
entity.testView source
<?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',
);
}
protected function setUp() {
parent::setUp('entity', 'entity_test');
}
/**
* Tests CRUD.
*/
public 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.
*/
public 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)
*/
public 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.
*/
public 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.
*/
public 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.
*/
public 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 entities.
*/
public 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.
*/
public 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',
),
);
}
protected 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.
*/
public 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',
);
}
public 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.
*/
public 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',
),
);
}
protected 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.
*/
public 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',
);
}
protected 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.
*/
public 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 & 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.
*/
public 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.
*/
public 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.
*/
public 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.
*/
public 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().
*/
public function testEntityQuery() {
// Create 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 author.');
// 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.
*/
public 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.
*/
protected 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);
}
}
protected 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.
*/
public 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',
);
}
protected 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',
);
}
protected 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.
*/
public 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 basic entity_access() functionality for taxonomy terms.
*/
class EntityMetadataTaxonomyAccessTestCase extends EntityWebTestCase {
public static function getInfo() {
return array(
'name' => 'Entity Metadata Taxonomy Access',
'description' => 'Test entity_access() for taxonomy terms',
'group' => 'Entity API',
);
}
/**
* Asserts entity_access() correctly grants or denies access.
*/
public function assertTaxonomyMetadataAccess($ops, $term, $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, 'taxonomy_term', $term, $account);
$this
->assertEqual($result, $access, $msg);
}
}
/**
* @inheritdoc
*/
protected function setUp() {
parent::setUp('entity', 'taxonomy');
// Clear permissions for authenticated users.
db_delete('role_permission')
->condition('rid', DRUPAL_AUTHENTICATED_RID)
->execute();
}
/**
* Runs basic tests for entity_access() function.
*/
public function testTaxonomyMetadataAccess() {
$vocab = $this
->createVocabulary();
$term = entity_property_values_create_entity('taxonomy_term', array(
'name' => $this
->randomName(),
'vocabulary' => $vocab,
))
->save()
->value();
// Clear permissions static cache to get new taxonomy permissions.
drupal_static_reset('checkPermissions');
// Check assignment of view permissions.
$user1 = $this
->drupalCreateUser(array(
'access content',
));
$this
->assertTaxonomyMetadataAccess(array(
'create' => FALSE,
'view' => TRUE,
'update' => FALSE,
'delete' => FALSE,
), $term, $user1);
// Check assignment of edit permissions.
$user2 = $this
->drupalCreateUser(array(
'edit terms in ' . $vocab->vid,
));
$this
->assertTaxonomyMetadataAccess(array(
'create' => FALSE,
'view' => FALSE,
'update' => TRUE,
'delete' => FALSE,
), $term, $user2);
// Check assignment of delete permissions.
$user3 = $this
->drupalCreateUser(array(
'delete terms in ' . $vocab->vid,
));
$this
->assertTaxonomyMetadataAccess(array(
'create' => FALSE,
'view' => FALSE,
'update' => FALSE,
'delete' => TRUE,
), $term, $user3);
// Check assignment of view, edit, delete permissions.
$user4 = $this
->drupalCreateUser(array(
'access content',
'edit terms in ' . $vocab->vid,
'delete terms in ' . $vocab->vid,
));
$this
->assertTaxonomyMetadataAccess(array(
'create' => FALSE,
'view' => TRUE,
'update' => TRUE,
'delete' => TRUE,
), $term, $user4);
// Check assignment of administration permissions.
$user5 = $this
->drupalCreateUser(array(
'administer taxonomy',
));
$this
->assertTaxonomyMetadataAccess(array(
'create' => TRUE,
'view' => TRUE,
'update' => TRUE,
'delete' => TRUE,
), $term, $user5);
}
}
/**
* 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',
);
}
protected function setUp() {
parent::setUp('entity_token');
}
/**
* Tests whether token support is basically working.
*/
public 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',
);
}
protected 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.
*/
public 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',
));
$node4 = $this
->drupalCreateNode(array(
'type' => 'book',
'book' => array(
'bid' => 0,
'plid' => -1,
),
));
// 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 a book node which is not contained in a hierarchy.
$wrapper = entity_metadata_wrapper('node', $node4);
$this
->assertEmptyArray($wrapper, 'book_ancestors');
}
/**
* Test properties of a comment.
*/
public 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.');
}
/**
* Test all properties of a node.
*/
public function testNodeProperties() {
$title = 'Book 1';
$node = $this
->drupalCreateNode(array(
'title' => $title,
'type' => 'page',
));
$wrapper = entity_metadata_wrapper('node', $node);
foreach ($wrapper as $key => $value) {
if ($key != 'book' && $key != 'book_ancestors' && $key != 'source' && $key != 'last_view') {
$this
->assertValue($wrapper, $key);
}
}
$this
->assertEmpty($wrapper, 'book');
$this
->assertEmptyArray($wrapper, 'book_ancestors');
$this
->assertEmpty($wrapper, 'source');
$this
->assertException($wrapper->source, 'title');
$this
->assertEmpty($wrapper, 'last_view');
// Test statistics module integration access.
$unpriviledged_user = $this
->drupalCreateUser(array(
'access content',
));
$this
->assertTrue($wrapper
->access('view', $unpriviledged_user), 'Unpriviledged user can view the node.');
$this
->assertFalse($wrapper
->access('edit', $unpriviledged_user), 'Unpriviledged user can not edit the node.');
$count_access_user = $this
->drupalCreateUser(array(
'view post access counter',
));
$admin_user = $this
->drupalCreateUser(array(
'access content',
'view post access counter',
'access statistics',
));
$this
->assertFalse($wrapper->views
->access('view', $unpriviledged_user), "Unpriviledged user cannot view the statistics counter property.");
$this
->assertTrue($wrapper->views
->access('view', $count_access_user), "Count access user can view the statistics counter property.");
$this
->assertTrue($wrapper->views
->access('view', $admin_user), "Admin user can view the statistics counter property.");
$admin_properties = array(
'day_views',
'last_view',
);
foreach ($admin_properties as $property_name) {
$this
->assertFalse($wrapper->{$property_name}
->access('view', $unpriviledged_user), "Unpriviledged user cannot view the {$property_name} property.");
$this
->assertFalse($wrapper->{$property_name}
->access('view', $count_access_user), "Count access user cannot view the {$property_name} property.");
$this
->assertTrue($wrapper->{$property_name}
->access('view', $admin_user), "Admin user can view the {$property_name} property.");
}
}
/**
* Tests properties provided by the taxonomy module.
*/
public function testTaxonomyProperties() {
$vocab = $this
->createVocabulary();
$term_parent = entity_property_values_create_entity('taxonomy_term', array(
'name' => $this
->randomName(),
'vocabulary' => $vocab,
))
->save()
->value();
$term_parent2 = entity_property_values_create_entity('taxonomy_term', array(
'name' => $this
->randomName(),
'vocabulary' => $vocab,
))
->save()
->value();
$term = entity_property_values_create_entity('taxonomy_term', array(
'name' => $this
->randomName(),
'vocabulary' => $vocab,
'description' => $this
->randomString(),
'weight' => mt_rand(0, 10),
'parent' => array(
$term_parent->tid,
),
))
->save()
->value();
$wrapper = entity_metadata_wrapper('taxonomy_term', $term);
foreach ($wrapper as $key => $value) {
$this
->assertValue($wrapper, $key);
}
// Test setting another parent using the full object.
$wrapper->parent[] = $term_parent2;
$this
->assertEqual($wrapper->parent[1]
->getIdentifier(), $term_parent2->tid, 'Term parent added.');
$parents = $wrapper->parent
->value();
$tids = $term_parent->tid . ':' . $term_parent2->tid;
$this
->assertEqual($parents[0]->tid . ':' . $parents[1]->tid, $tids, 'Parents returned.');
$this
->assertEqual(implode(':', $wrapper->parent
->value(array(
'identifier' => TRUE,
))), $tids, 'Parent ids returned.');
// Test vocabulary.
foreach ($wrapper->vocabulary as $key => $value) {
$this
->assertValue($wrapper->vocabulary, $key);
}
// Test field integration.
$tags[LANGUAGE_NONE][0]['tid'] = $term->tid;
$node = $this
->drupalCreateNode(array(
'title' => 'foo',
'type' => 'article',
'field_tags' => $tags,
));
$wrapper = entity_metadata_wrapper('node', $node);
$this
->assertEqual($wrapper->field_tags[0]->name
->value(), $term->name, 'Get an associated tag of a node with the wrapper.');
$wrapper->field_tags[1] = $term_parent;
$tags = $wrapper->field_tags
->value();
$this
->assertEqual($tags[1]->tid, $term_parent->tid, 'Associated a new tag with a node.');
$this
->assertEqual($tags[0]->tid, $term->tid, 'Previsous set association kept.');
// Test getting a list of identifiers.
$tags = $wrapper->field_tags
->value(array(
'identifier' => TRUE,
));
$this
->assertEqual($tags, array(
$term->tid,
$term_parent->tid,
), 'List of referenced term identifiers returned.');
// Test setting tags by using ids.
$wrapper->field_tags
->set(array(
2,
));
$this
->assertEqual($wrapper->field_tags[0]->tid
->value(), 2, 'Specified tags by a list of term ids.');
// Test unsetting all tags.
$wrapper->field_tags = NULL;
$this
->assertFalse($wrapper->field_tags
->value(), 'Unset all tags from a node.');
// Test setting entity references to NULL.
// Create a taxonomy term field for that purpose.
$field_name = drupal_strtolower($this
->randomName() . '_field_name');
$field = array(
'field_name' => $field_name,
'type' => 'taxonomy_term_reference',
'cardinality' => 1,
);
$field = field_create_field($field);
$field_id = $field['id'];
$field_instance = array(
'field_name' => $field_name,
'entity_type' => 'node',
'bundle' => 'article',
'label' => $this
->randomName() . '_label',
'description' => $this
->randomName() . '_description',
'weight' => mt_rand(0, 127),
'widget' => array(
'type' => 'options_select',
'label' => 'Test term field',
),
);
field_create_instance($field_instance);
$term_field[LANGUAGE_NONE][0]['tid'] = $term->tid;
$node = $this
->drupalCreateNode(array(
'title' => 'foo',
'type' => 'article',
$field_name => $term_field,
));
$wrapper = entity_metadata_wrapper('node', $node);
$wrapper->{$field_name}
->set(NULL);
$termref = $wrapper->{$field_name}
->value();
$this
->assertNull($termref, 'Unset of a term reference successful.');
}
/**
* Test all properties of a user.
*/
public function testUserProperties() {
$account = $this
->drupalCreateUser(array(
'access user profiles',
'change own username',
));
$account->login = REQUEST_TIME;
$account->access = REQUEST_TIME;
$wrapper = entity_metadata_wrapper('user', $account);
foreach ($wrapper as $key => $value) {
$this
->assertValue($wrapper, $key);
}
// Test property view access.
$unpriviledged_user = $this
->drupalCreateUser(array(
'access user profiles',
));
$admin_user = $this
->drupalCreateUser(array(
'administer users',
));
$this
->assertTrue($wrapper
->access('view', $unpriviledged_user), 'Unpriviledged account can view the user.');
$this
->assertFalse($wrapper
->access('edit', $unpriviledged_user), 'Unpriviledged account can not edit the user.');
$view_access = array(
'name',
'url',
'edit_url',
'created',
);
foreach ($view_access as $property_name) {
$this
->assertTrue($wrapper->{$property_name}
->access('view', $unpriviledged_user), "Unpriviledged user can view the {$property_name} property.");
}
$view_denied = array(
'mail',
'last_access',
'last_login',
'roles',
'status',
'theme',
);
foreach ($view_denied as $property_name) {
$this
->assertFalse($wrapper->{$property_name}
->access('view', $unpriviledged_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.");
}
// Test property edit access.
$edit_own_allowed = array(
'name',
'mail',
);
foreach ($edit_own_allowed as $property_name) {
$this
->assertTrue($wrapper->{$property_name}
->access('edit', $account), "Account owner can edit the {$property_name} property.");
}
$this
->assertTrue($wrapper->roles
->access('view', $account), "Account owner can view their own roles.");
$edit_denied = array(
'last_access',
'last_login',
'created',
'roles',
'status',
'theme',
);
foreach ($edit_denied as $property_name) {
$this
->assertFalse($wrapper->{$property_name}
->access('edit', $account), "Account owner cannot edit the {$property_name} property.");
$this
->assertTrue($wrapper->{$property_name}
->access('edit', $admin_user), "Admin user can edit the {$property_name} property.");
}
}
/**
* Test properties provided by system module.
*/
public function testSystemProperties() {
$wrapper = entity_metadata_site_wrapper();
foreach ($wrapper as $key => $value) {
$this
->assertValue($wrapper, $key);
}
// Test page request related properties.
foreach ($wrapper->current_page as $key => $value) {
$this
->assertValue($wrapper->current_page, $key);
}
// Test files.
$file = $this
->createFile();
$wrapper = entity_metadata_wrapper('file', $file);
foreach ($wrapper as $key => $value) {
$this
->assertValue($wrapper, $key);
}
}
/**
* Runs some generic tests on each entity.
*/
public function testCRUDfunctions() {
$info = entity_get_info();
foreach ($info as $entity_type => $entity_info) {
// Test using access callback.
entity_access('view', $entity_type);
entity_access('update', $entity_type);
entity_access('create', $entity_type);
entity_access('delete', $entity_type);
// Test creating the entity.
if (!isset($entity_info['creation callback'])) {
continue;
}
// Populate $values with all values that are setable. They will be set
// with an metadata wrapper, so we also test setting that way.
$values = array();
foreach (entity_metadata_wrapper($entity_type) as $name => $wrapper) {
$info = $wrapper
->info();
if (!empty($info['setter callback'])) {
$values[$name] = $this
->createValue($wrapper);
}
}
$entity = entity_property_values_create_entity($entity_type, $values)
->value();
$this
->assertTrue($entity, "Created {$entity_type} and set all setable values.");
// Save the new entity.
$return = entity_save($entity_type, $entity);
if ($return === FALSE) {
continue;
// No support for saving.
}
$id = entity_metadata_wrapper($entity_type, $entity)
->getIdentifier();
$this
->assertTrue($id, "{$entity_type} has been successfully saved.");
// And delete it.
$return = entity_delete($entity_type, $id);
if ($return === FALSE) {
continue;
// No support for deleting.
}
$return = entity_load_single($entity_type, $id);
$this
->assertFalse($return, "{$entity_type} has been successfully deleted.");
}
}
/**
* Test making use of a text fields.
*/
public function testTextFields() {
// Create a simple text field without text processing.
$field = array(
'field_name' => 'field_text',
'type' => 'text',
'cardinality' => 2,
);
field_create_field($field);
$instance = array(
'field_name' => 'field_text',
'entity_type' => 'node',
'label' => 'test',
'bundle' => 'article',
'widget' => array(
'type' => 'text_textfield',
'weight' => -1,
),
);
field_create_instance($instance);
$node = $this
->drupalCreateNode(array(
'type' => 'article',
));
$wrapper = entity_metadata_wrapper('node', $node);
$wrapper->field_text[0] = 'the text';
// Try saving the node and make sure the information is still there after
// loading the node again, thus the correct data structure has been written.
node_save($node);
$node = node_load($node->nid, NULL, TRUE);
$wrapper = entity_metadata_wrapper('node', $node);
$this
->assertEqual('the text', $wrapper->field_text[0]
->value(), 'Text has been specified.');
// Now activate text processing.
$instance['settings']['text_processing'] = 1;
field_update_instance($instance);
$node = $this
->drupalCreateNode(array(
'type' => 'article',
));
$wrapper = entity_metadata_wrapper('node', $node);
$wrapper->field_text[0]
->set(array(
'value' => "<b>The second body.</b>",
));
$this
->assertEqual("<p>The second body.</p>\n", $wrapper->field_text[0]->value
->value(), "Setting a processed text field value and reading it again.");
// Assert the summary property is correctly removed.
$this
->assertFalse(isset($wrapper->field_text[0]->summary), 'Processed text has no summary.');
// Create a text field with summary but without text processing.
$field = array(
'field_name' => 'field_text2',
'type' => 'text_with_summary',
'cardinality' => 1,
);
field_create_field($field);
$instance = array(
'field_name' => 'field_text2',
'entity_type' => 'node',
'label' => 'test',
'bundle' => 'article',
'settings' => array(
'text_processing' => 0,
),
'widget' => array(
'type' => 'text_textarea_with_summary',
'weight' => -1,
),
);
field_create_instance($instance);
$node = $this
->drupalCreateNode(array(
'type' => 'article',
));
$wrapper = entity_metadata_wrapper('node', $node);
$wrapper->field_text2->summary = 'the summary';
$wrapper->field_text2->value = 'the text';
// Try saving the node and make sure the information is still there after
// loading the node again, thus the correct data structure has been written.
node_save($node);
$node = node_load($node->nid, NULL, TRUE);
$wrapper = entity_metadata_wrapper('node', $node);
$this
->assertEqual('the text', $wrapper->field_text2->value
->value(), 'Text has been specified.');
$this
->assertEqual('the summary', $wrapper->field_text2->summary
->value(), 'Summary has been specified.');
}
/**
* Test making use of a file field.
*/
public function testFileFields() {
$file = $this
->createFile();
// Create a file field.
$field = array(
'field_name' => 'field_file',
'type' => 'file',
'cardinality' => 2,
'settings' => array(
'display_field' => TRUE,
),
);
field_create_field($field);
$instance = array(
'field_name' => 'field_file',
'entity_type' => 'node',
'label' => 'File',
'bundle' => 'article',
'settings' => array(
'description_field' => TRUE,
),
'required' => FALSE,
'widget' => array(
'type' => 'file_generic',
'weight' => -1,
),
);
field_create_instance($instance);
$node = $this
->drupalCreateNode(array(
'type' => 'article',
));
$wrapper = entity_metadata_wrapper('node', $node);
$wrapper->field_file[0] = array(
'fid' => $file->fid,
'display' => FALSE,
);
$this
->assertEqual($file->filename, $wrapper->field_file[0]->file->name
->value(), 'File has been specified.');
$wrapper->field_file[0]->description = 'foo';
$wrapper->field_file[0]->display = TRUE;
$this
->assertEqual($wrapper->field_file[0]->description
->value(), 'foo', 'File description has been correctly set.');
// Try saving the node and make sure the information is still there after
// loading the node again, thus the correct data structure has been written.
node_save($node);
$node = node_load($node->nid, NULL, TRUE);
$wrapper = entity_metadata_wrapper('node', $node);
$this
->assertEqual($wrapper->field_file[0]->description
->value(), 'foo', 'File description has been correctly set.');
$this
->assertEqual($wrapper->field_file[0]->display
->value(), TRUE, 'File display value has been correctly set.');
// Test adding a new file, the display-property has to be created
// automatically.
$wrapper->field_file[1]->file = $file;
node_save($node);
$node = node_load($node->nid, NULL, TRUE);
$this
->assertEqual($file->fid, $wrapper->field_file[1]->file
->getIdentifier(), 'New file has been added.');
// Test adding an invalid file-field item, i.e. without any file.
try {
$wrapper->field_file[] = array(
'description' => 'test',
);
$this
->fail('Exception not thrown.');
} catch (EntityMetadataWrapperException $e) {
$this
->pass('Not valid file-field item has thrown an exception.');
}
// Test remove all file-field items.
$wrapper->field_file = NULL;
$this
->assertFalse($wrapper->field_file
->value(), 'Removed multiple file-field items.');
}
/**
* Test making use of an image field.
*/
public function testImageFields() {
$file = $this
->createFile('image');
// Just use the image field on the article node.
$node = $this
->drupalCreateNode(array(
'type' => 'article',
));
$wrapper = entity_metadata_wrapper('node', $node);
$wrapper->field_image = array(
'fid' => $file->fid,
);
$this
->assertEqual($file->filename, $wrapper->field_image->file->name
->value(), 'File has been specified.');
$wrapper->field_image->alt = 'foo';
$this
->assertEqual($wrapper->field_image->alt
->value(), 'foo', 'Image alt attribute has been correctly set.');
// Try saving the node and make sure the information is still there after
// loading the node again, thus the correct data structure has been written.
node_save($node);
$node = node_load($node->nid, NULL, TRUE);
$wrapper = entity_metadata_wrapper('node', $node);
$this
->assertEqual($wrapper->field_image->alt
->value(), 'foo', 'File description has been correctly set.');
// Test adding a new image.
$wrapper->field_image->file = $file;
node_save($node);
$node = node_load($node->nid, NULL, TRUE);
$this
->assertEqual($file->fid, $wrapper->field_image->file
->getIdentifier(), 'New file has been added.');
// Test adding an invalid image-field item, i.e. without any file.
try {
$wrapper->field_image = array();
$this
->fail('Exception not thrown.');
} catch (EntityMetadataWrapperException $e) {
$this
->pass('Not valid image-field item has thrown an exception.');
}
}
/**
* Creates a value for the given property.
*/
protected function createValue($wrapper) {
if (!isset($this->node)) {
$this->node = $this
->drupalCreateNode(array(
'type' => 'page',
));
$this->user = $this
->drupalCreateUser();
$this->taxonomy_vocabulary = $this
->createVocabulary();
}
if ($options = $wrapper
->optionsList()) {
$options = entity_property_options_flatten($options);
return $wrapper instanceof EntityListWrapper ? array(
key($options),
) : key($options);
}
// For mail addresses properly pass an mail address.
$info = $wrapper
->info();
if ($info['name'] == 'mail') {
return 'webmaster@example.com';
}
switch ($wrapper
->type()) {
case 'decimal':
case 'integer':
case 'duration':
return 1;
case 'date':
return REQUEST_TIME;
case 'boolean':
return TRUE;
case 'token':
return drupal_strtolower($this
->randomName(8));
case 'text':
return $this
->randomName(32);
case 'text_formatted':
return array(
'value' => $this
->randomName(16),
);
case 'list<taxonomy_term>':
return array();
default:
return $this->{$wrapper
->type()};
}
}
}Classes
Name |
Description |
|---|---|
| EntityAPICommentNodeAccessTestCase | Tests comments with node access. |
| EntityAPIi18nItegrationTestCase | Test the i18n integration. |
| EntityAPIRulesIntegrationTestCase | Test the generated Rules integration. |
| EntityAPITestCase | Test basic API. |
| EntityMetadataIntegrationTestCase | Tests provided entity property info of the core modules. |
| EntityMetadataNodeAccessTestCase | Tests basic entity_access() functionality for nodes. |
| EntityMetadataNodeCreateAccessTestCase | Test user permissions for node creation. |
| EntityMetadataNodeRevisionAccessTestCase | Tests user permissions for node revisions. |
| EntityMetadataTaxonomyAccessTestCase | Tests basic entity_access() functionality for taxonomy terms. |
| EntityMetadataTestCase | Tests metadata wrappers. |
| EntityTokenTestCase | Tests provided entity property info of the core modules. |
| EntityWebTestCase | Common parent class containing common helpers. |