$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 help screen.', 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' => 'BadName'));
$title = 'Is it bold?';
$body[LANGUAGE_NONE][0] = array('value' => 'The body & nothing.', 'summary' => 'The body.');
$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('Is it bold?', $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('Is it bold?'), $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("The body & nothing.
\n", $body_value->value(), "Getting processed value.");
$this->assertEqual("The body & nothing.\n", $body_value->value(array('decode' => TRUE)), "Decoded value.");
$this->assertEqual("The body & nothing.", $body_value->raw(), "Raw body returned.");
// Test getting the summary.
$this->assertEqual("The body.
\n", $wrapper->body->summary->value(), "Getting body summary.");
$wrapper->body->set(array('value' => "The second body."));
$this->assertEqual("The second body.
\n", $wrapper->body->value->value(), "Setting a processed field value and reading it again.");
$this->assertEqual($node->body[LANGUAGE_NONE][0]['value'], "The second body.", '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' => 'English body.', 'summary' => 'The body.');
$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(), "English body.
\n", 'Language fallback on default language.');
// Set a German text using the wrapper.
$wrapper->body->set(array('value' => "Der zweite Text."));
$this->assertEqual($wrapper->body->value->value(), "Der zweite Text.
\n", 'German body set and retrieved.');
$wrapper->language(LANGUAGE_NONE);
$this->assertEqual($wrapper->body->value->value(), "English body.
\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' => '2009-09-05');
$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('2009-09-05', $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('2009-09-05'), $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', $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');
$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', $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', $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', $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' => '2009-09-05');
$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 = 'Is it bold?';
$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 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.
*/
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
*/
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.
*/
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',
);
}
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'));
$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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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' => "The second body."));
$this->assertEqual("The second body.
\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.
*/
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.
*/
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':
return array();
default:
return $this->{$wrapper->type()};
}
}
}