field_permission_example.test

<?php


/**
 * @file
 * Tests for Field Permission Example.
 *
 * @ingroup field_permission_example
 */

/**
 * A generic field testing class.
 *
 * Subclass this one to test your specific field type
 * and get some basic unit testing for free.
 *
 * Since Simpletest only looks through one class definition
 * to find test functions, we define generic tests as
 * 'code_testWhatever' or 'form_testWhatever'. Subclasses
 * can then implement shim test methods that just call the
 * generic tests.
 *
 * 'code_' and 'form_' prefixes denote the type of test:
 * using code only, or through Drupal page forms.
 *
 * @ingroup field_permission_example
 */
class GenericFieldTest extends DrupalWebTestCase {
    // Our tests will generate some random field instance
    // names. We store them here so many functions can act on them.
    protected $instanceNames;
    
    /**
     * {@inheritdoc}
     */
    public static function getInfo() {
        return array(
            'name' => 'Generic Field Test',
            'description' => 'Someone neglected to override GenericFieldTest::getInfo().',
            'group' => 'Examples',
        );
    }
    
    /**
     * Supply the field types we wish to test.
     *
     * Return an array of field types to instantiate and test.
     *
     * @return array
     *   The field types we wish to use.
     */
    protected function getFieldTypes() {
        return array(
            'these_are_not',
            'valid_field_types',
            'please_override',
        );
    }
    
    /**
     * The module to enable.
     *
     * @return string
     *   Module machine name.
     */
    protected function getModule() {
        return 'this-is-not-a-module-name-please-override';
    }
    
    /**
     * Simpletest's setUp().
     *
     * We want to be able to subclass this class, so we jump
     * through a few hoops in order to get the modules from args
     * and add our own.
     */
    public function setUp() {
        $this->instanceNames = array();
        $modules = func_get_args();
        if (isset($modules[0]) && is_array($modules[0])) {
            $modules = $modules[0];
        }
        $modules[] = 'node';
        $modules[] = 'field_ui';
        parent::setUp($modules);
    }
    
    /**
     * Verify that all required fields are specified in hook_field_info().
     *
     * The full list is label, description, settings, instance_settings,
     * default_widget, default_formatter, no_ui.
     *
     * Some are optional, and we won't check for those.
     *
     * In a sane world, this would be a unit test, rather than a
     * web test, but module_implements is unavailable to us
     * in unit tests.
     *
     * @see hook_field_info()
     */
    public function runTestGenericFieldInfo() {
        $field_types = $this->getFieldTypes();
        $module = $this->getModule();
        $info_keys = array(
            'label',
            'description',
            'default_widget',
            'default_formatter',
        );
        // We don't want to use field_info_field_types()
        // because there is a hook_field_info_alter().
        // We're testing the module here, not the rest of
        // the system. So invoke hook_field_info() ourselves.
        $modules = module_implements('field_info');
        $this->assertTrue(in_array($module, $modules), 'Module ' . $module . ' implements hook_field_info()');
        foreach ($field_types as $field_type) {
            $field_info = module_invoke($module, 'field_info');
            $this->assertTrue(isset($field_info[$field_type]), 'Module ' . $module . ' defines field type ' . $field_type);
            $field_info = $field_info[$field_type];
            foreach ($info_keys as $key) {
                $this->assertTrue(isset($field_info[$key]), $field_type . "'s " . $key . ' is set.');
            }
        }
    }
    
    /**
     * Add all testable fields as instances to a content type.
     *
     * As a side-effect: Store the names of the instances created
     * in $this->$instance_names.
     *
     * @param object $node_type
     *   A content type object. If none is provided, one will be generated.
     *
     * @return object
     *   The content type object that has the fields attached.
     */
    public function codeTestGenericAddAllFields($node_type = NULL) {
        $this->instanceNames = array();
        if (!$node_type) {
            $node_type = $this->drupalCreateContentType();
        }
        foreach ($this->getFieldTypes() as $field_type) {
            $instance_name = drupal_strtolower($this->randomName(32));
            $field = array(
                'field_name' => $instance_name,
                'type' => $field_type,
            );
            $field = field_create_field($field);
            $instance = array(
                'field_name' => $instance_name,
                'entity_type' => 'node',
                'bundle' => $node_type->name,
                'label' => drupal_strtolower($this->randomName(20)),
            );
            // Finally create the instance.
            $instance = field_create_instance($instance);
            // Reset the caches...
            _field_info_collate_fields(TRUE);
            // Grab this instance.
            $verify_instance = field_info_instance('node', $instance_name, $node_type->name);
            $this->assertTrue($verify_instance, 'Instance object exists.');
            $this->assertTrue($verify_instance != NULL, 'field_info_instance() says ' . $instance_name . ' (' . $node_type->name . ') was created.');
            $this->instanceNames[] = $instance_name;
        }
        return $node_type;
    }
    
    /**
     * Remove all fields in $this->field_names.
     *
     * @param mixed $node_type
     *   A content type object. If none is specified,
     *   the test fails.
     */
    public function codeTestGenericRemoveAllFields($node_type = NULL) {
        if (!$node_type) {
            $this->fail('No node type.');
        }
        if (count($this->instanceNames) < 1) {
            $this->fail('There are no instances to remove.');
            return;
        }
        foreach ($this->instanceNames as $instance_name) {
            $instance = field_info_instance('node', $instance_name, $node_type->name);
            $this->assertTrue($instance, "Instance exists, now we'll delete it.");
            field_delete_field($instance_name);
            $instance = field_info_instance('node', $instance_name, $node_type->name);
            $this->assertFalse($instance, 'Instance was deleted.');
        }
        $this->instanceNames = array();
    }
    
    /**
     * Add and delete all field types through Form API.
     *
     * @access public
     */
    public function formTestGenericFieldNodeAddDeleteForm() {
        // Create and login user.
        $account = $this->drupalCreateUser(array(
            'administer content types',
            'administer fields',
        ));
        $this->drupalLogin($account);
        // Add a content type.
        $node_type = $this->drupalCreateContentType();
        // Add all our testable fields.
        $field_names = $this->formAddAllFields($node_type);
        // Now let's delete all the fields.
        foreach ($field_names as $field_name) {
            // This is the path for the 'delete' link on field admin page.
            $this->drupalGet('admin/structure/types/manage/' . $node_type->name . '/fields/field_' . $field_name . '/delete');
            // Click the 'delete' button.
            $this->drupalPost(NULL, array(), t('Delete'));
            $this->assertText(t('The field @field has been deleted from the @type content type.', array(
                '@field' => $field_name,
                '@type' => $node_type->name,
            )));
        }
    }
    
    /**
     * Add all fields using Form API.
     *
     * @param mixed $node_type
     *   A content type object. If none is specified,
     *   the test fails.
     */
    protected function formAddAllFields($node_type = NULL) {
        if (!$node_type) {
            $this->fail('No content type specified.');
        }
        // Get all our field types.
        $field_types = $this->getFieldTypes();
        // Keep a list of no_ui fields so we can tell the user.
        $unsafe_field_types = array();
        $field_names = array();
        $manage_path = 'admin/structure/types/manage/' . $node_type->name . '/fields';
        foreach ($field_types as $field_type) {
            // Get the field info.
            $field_info = field_info_field_types($field_type);
            // Exclude no_ui field types.
            if (isset($field_info['no_ui']) && $field_info['no_ui']) {
                $unsafe_field_types[] = $field_type;
            }
            else {
                // Generate a name for our field.
                // 26 is max length for field name.
                $field_name = drupal_strtolower($this->randomName(26));
                $field_names[$field_type] = $field_name;
                // Create the field through Form API.
                $this->formCreateField($manage_path, $field_type, $field_name, $field_info['default_widget'], 1);
            }
        }
        // Tell the user which fields we couldn't test.
        if (!empty($unsafe_field_types)) {
            debug('Unable to attach these no_ui fields: ' . implode(', ', $unsafe_field_types));
        }
        // Somehow clicking "save" isn't enough, and we have to
        // rebuild a few caches.
        node_types_rebuild();
        menu_rebuild();
        return $field_names;
    }
    
    /**
     * Create a field using the content type management form.
     *
     * @param mixed $manage_path
     *   Path to our content type management form.
     * @param mixed $field_type
     *   The type of field we're adding.
     * @param mixed $field_name
     *   The name of the field instance we want.
     * @param mixed $widget_type
     *   Which widget would we like?
     * @param mixed $cardinality
     *   Cardinality for this field instance.
     */
    protected function formCreateField($manage_path, $field_type, $field_name, $widget_type, $cardinality) {
        // $manage_path is the field edit form for our content type.
        $this->drupalGet($manage_path);
        $edit = array(
            'fields[_add_new_field][label]' => $field_name,
            'fields[_add_new_field][field_name]' => $field_name,
            'fields[_add_new_field][type]' => $field_type,
            'fields[_add_new_field][widget_type]' => $widget_type,
        );
        $this->drupalPost(NULL, $edit, t('Save'));
        // Assume there are no settings for this,
        // so just press the button.
        $this->drupalPost(NULL, array(), t('Save field settings'));
        $edit = array(
            'field[cardinality]' => (string) $cardinality,
        );
        $this->drupalPost(NULL, $edit, t('Save settings'));
        debug(t('Saved settings for field !field_name with widget !widget_type and cardinality !cardinality', array(
            '!field_name' => $field_name,
            '!widget_type' => $widget_type,
            '!cardinality' => $cardinality,
        )));
        $this->assertText(t('Saved @name configuration.', array(
            '@name' => $field_name,
        )));
    }
    
    /**
     * Create a node with some field content.
     *
     * @return object
     *   Node object for the created node.
     */
    public function createFieldContentForUser($account = NULL, $content = 'testable_content', $node_type = NULL, $instance_name = '', $column = NULL) {
        if (!$column) {
            $this->fail('No column name given.');
            return NULL;
        }
        if (!$account) {
            $account = $this->drupalCreateUser(array(
                'bypass node access',
                'administer content types',
            ));
        }
        $this->drupalLogin($account);
        if (!$node_type) {
            $node_type = $this->codeTestGenericAddAllFields();
        }
        if (!$instance_name) {
            $instance_name = reset($this->instanceNames);
        }
        $field = array();
        $field[LANGUAGE_NONE][0][$column] = $content;
        $settings = array(
            'type' => $node_type->name,
            $instance_name => $field,
        );
        $node = $this->drupalCreateNode($settings);
        $this->assertTrue($node, 'Node of type ' . $node->type . ' allegedly created.');
        $node = node_load($node->nid);
        debug('Loaded node id: ' . $node->nid);
        $this->assertTrue($node->{$instance_name}, 'Field actually created.');
        $field = $node->{$instance_name};
        $this->assertTrue($field[LANGUAGE_NONE][0][$column] == $content, 'Content was stored properly on the field.');
        return $node;
    }

}
class FieldTestPermissionsExample extends GenericFieldTest {
    
    /**
     * {@inheritdoc}
     */
    public function setUp() {
        parent::setUp(array(
            'field_permission_example',
        ));
    }
    
    /**
     * {@inheritdoc}
     */
    public static function getInfo() {
        return array(
            'name' => 'Field Permission Example',
            'description' => 'Various tests on the functionality of the Fieldnote field.',
            'group' => 'Examples',
        );
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getFieldTypes() {
        return array(
            'field_permission_example_fieldnote',
        );
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getModule() {
        return 'field_permission_example';
    }
    
    /**
     * Override createFieldContentForUser().
     *
     * We override so we can make sure $column is set to 'notes'.
     */
    public function createFieldContentForUser($account = NULL, $content = 'fieldnote_testable_content', $node_type = NULL, $instance_name = '', $column = 'notes') {
        return parent::createFieldContentForUser($account, $content, $node_type, $instance_name, $column);
    }
    
    /**
     * Test of hook_field_info() and other implementation requirements.
     *
     * @see GenericFieldTest::runTestGenericFieldInfo()
     */
    public function testFieldnoteInfo() {
        $this->runTestGenericFieldInfo();
    }
    
    /**
     * Add and remove the field through Form API.
     */
    public function testAddRemoveFieldnoteForm() {
        $this->formTestGenericFieldNodeAddDeleteForm();
    }
    
    /**
     * Add and remove the field through code.
     */
    public function testAddRemoveFieldnoteCode() {
        $node_type = $this->codeTestGenericAddAllFields();
        $this->codeTestGenericRemoveAllFields($node_type);
    }
    
    /**
     * Test view permissions.
     */
    public function testFieldnoteViewPerms() {
        // We create two sets of content so we can get a few
        // test cases out of the way.
        $view_own_content = $this->randomName(23);
        $view_any_content = $this->randomName(23);
        $view_own_node = $this->createFieldContentForUser(NULL, $view_own_content);
        // Get the type of the node so we can create another one.
        $node_type = node_type_load($view_own_node->type);
        $view_any_node = $this->createFieldContentForUser(NULL, $view_any_content, $node_type);
        // There should be a node now, with some lovely content, but it's the wrong
        // user for the view-own test.
        $view_own_account = $this->drupalCreateUser(array(
            'view own fieldnote',
        ));
        debug("Created user with 'view own fieldnote' permission.");
        // Now change the user id for the test node.
        $view_own_node = node_load($view_own_node->nid);
        $view_own_node->uid = $view_own_account->uid;
        node_save($view_own_node);
        $view_own_node = node_load($view_own_node->nid);
        $this->assertTrue($view_own_node->uid == $view_own_account->uid, 'New user assigned to node.');
        // Now we want to look at the page with the field and
        // check that we can see it.
        $this->drupalLogin($view_own_account);
        $this->drupalGet('node/' . $view_own_node->nid);
        // Check that the field content is present.
        $output_strings = $this->xpath("//div[contains(@class,'stickynote')]/text()");
        $this->assertEqual((string) reset($output_strings), $view_own_content);
        debug("'view own fieldnote' can view own field.");
        // This account shouldn't be able to see the field on the
        // 'view any' node.
        $this->drupalGet('node/' . $view_any_node->nid);
        // Check that the field content is not present.
        $output_strings = $this->xpath("//div[contains(@class,'stickynote')]/text()");
        $this->assertNotEqual((string) reset($output_strings), $view_any_content);
        debug("'view own fieldnote' cannot view other field.");
        // Now, to test for 'view any fieldnote' we create another user
        // with that permission, and try to look at the same node.
        $view_any_account = $this->drupalCreateUser(array(
            'view any fieldnote',
        ));
        debug("Created user with 'view any fieldnote' permission.");
        $this->drupalLogin($view_any_account);
        // This account should be able to see the field on the
        // 'view any' node.
        $this->drupalGet('node/' . $view_any_node->nid);
        // Check that the field content is present.
        $output_strings = $this->xpath("//div[contains(@class,'stickynote')]/text()");
        $this->assertEqual((string) reset($output_strings), $view_any_content);
        debug("'view any fieldnote' can view other field.");
    }
    
    /**
     * Test edit permissions.
     *
     * Note that this is mostly identical to testFieldnoteViewPerms() and could
     * probably be refactored.
     */
    public function testFieldnoteEditPerms() {
        // We create two sets of content so we can get a few
        // test cases out of the way.
        $edit_own_content = $this->randomName(23);
        $edit_any_content = $this->randomName(23);
        $edit_own_node = $this->createFieldContentForUser(NULL, $edit_own_content);
        // Get the type of the node so we can create another one.
        $node_type = node_type_load($edit_own_node->type);
        $edit_any_node = $this->createFieldContentForUser(NULL, $edit_any_content, $node_type);
        $edit_own_account = $this->drupalCreateUser(array(
            'edit own ' . $node_type->name . ' content',
            'edit own fieldnote',
        ));
        debug("Created user with 'edit own fieldnote' permission.");
        // Now change the user id for the test node.
        $edit_own_node = node_load($edit_own_node->nid);
        $edit_own_node->uid = $edit_own_account->uid;
        node_save($edit_own_node);
        $edit_own_node = node_load($edit_own_node->nid);
        $this->assertTrue($edit_own_node->uid == $edit_own_account->uid, 'New edit test user assigned to node.');
        // Now we want to look at the page with the field and
        // check that we can see it.
        $this->drupalLogin($edit_own_account);
        $this->drupalGet('node/' . $edit_own_node->nid . '/edit');
        $this->assertText($edit_own_content, "'edit own fieldnote' can edit own fieldnote.");
        // This account shouldn't be able to edit the field on the
        // 'edit any' node.
        $this->drupalGet('node/' . $edit_any_node->nid . '/edit');
        $this->assertNoText($edit_any_content, "'edit own fieldnote' can not edit any fieldnote.");
        // Now, to test for 'edit any fieldnote' we create another user
        // with that permission, and try to edit at the same node.
        // We have to add the ability to edit any node content, as well
        // or Drupal will deny us access to the page.
        $edit_any_account = $this->drupalCreateUser(array(
            'edit any ' . $node_type->name . ' content',
            'edit any fieldnote',
        ));
        debug("Created user with 'edit any fieldnote' permission.");
        $this->drupalLogin($edit_any_account);
        // This account should be able to see the field on the
        // 'edit any' node.
        $this->drupalGet('node/' . $edit_any_node->nid . '/edit');
        $this->assertText($edit_any_content, "'edit any fieldnote' can edit any fieldnote.");
    }

}