class FieldTestPermissionsExample

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.");
    }

}