function WorkbenchAccessTaxonomyTestCase::testWorkbenchAccessTaxonomy in Workbench Access 7

File

tests/workbench_access.test, line 196

Test file for Workbench Access.

Class

WorkbenchAccessTaxonomyTestCase

Code

function testWorkbenchAccessTaxonomy() {

  // Create some nodes and users.
  $this
    ->createWorkbenchAccessNodes();
  $this
    ->createWorkbenchAccessUsers();

  // Create the taxonomy test scheme.
  module_load_include('inc', 'workbench_access', 'workbench_access.admin');
  workbench_access_example_taxonomy();
  $count = db_query("SELECT COUNT(n.nid) FROM {node} n INNER JOIN {workbench_access_node} wan ON n.nid = wan.nid")
    ->fetchField();
  $this
    ->assertTrue($count == 10, t('Initial nodes assigned access data.'));

  // Check that the vocabulary is setup correctly.
  $this
    ->assertWorkbenchScheme('taxonomy');

  // Check that nodes have been assigned to the top-level item.
  $count = db_query("SELECT COUNT(n.nid) FROM {node} n INNER JOIN {workbench_access_node} wan ON n.nid = wan.nid WHERE wan.access_id = 'workbench_access' AND wan.access_scheme = 'taxonomy'")
    ->fetchField();
  $this
    ->assertTrue($count == 10, t('Initial nodes assigned to top-level hierarchy.'));

  // Test access settings of user 1.
  $account = user_load(1, TRUE);
  $this
    ->assertTrue(!empty($account->workbench_access['workbench_access']), t('User 1 assigned to top-level hierarchy.'));

  // Change the machine_name of the vocabulary and check that we track
  // the change. See https://drupal.org/node/1779502
  $vocabulary = taxonomy_vocabulary_machine_name_load('workbench_access');
  $vocabulary->machine_name = 'workbench_access_foo';
  taxonomy_vocabulary_save($vocabulary);

  // Check that the vocabulary is setup correctly.
  workbench_access_reset_tree();
  $active = workbench_access_get_active_tree();

  // Check that we reset properly.
  $this
    ->assertTrue(isset($active['tree']['workbench_access_foo']) && $active['active'][1]['access_type_id'] == 'workbench_access_foo', t('Updated vocabulary machine_name successfully.'));

  // Check that nodes have been assigned to the top-level item.
  $count = db_query("SELECT COUNT(n.nid) FROM {node} n INNER JOIN {workbench_access_node} wan ON n.nid = wan.nid WHERE wan.access_id = 'workbench_access_foo' AND wan.access_scheme = 'taxonomy'")
    ->fetchField();
  $this
    ->assertTrue($count == 10, t('Initial nodes re-assigned to top-level hierarchy.'));

  // Test access settings of user 1.
  $account = user_load(1, TRUE);
  $this
    ->assertTrue(!empty($account->workbench_access['workbench_access_foo']), t('User 1 re-assigned to top-level hierarchy.'));

  // Set things back.
  $vocabulary->machine_name = 'workbench_access';
  taxonomy_vocabulary_save($vocabulary);
  workbench_access_reset_tree();

  // Assign a user to a section and check permissions.
  // This is a multi-step check.
  // First, the user should not be able to do anything (Create, Update or Delete).
  $account = $this
    ->getWorkbenchAccessUser();
  $id = $account->testId;
  $this
    ->assertTrue(empty($account->workbench_access['workbench_access']), t('Test user not assigned to a section.'));
  $nids = db_query("SELECT nid FROM {node}")
    ->fetchAllAssoc('nid');
  $nodes = node_load_multiple(array_keys($nids));
  $assigned = TRUE;
  foreach ($nodes as $node) {
    if (!isset($node->workbench_access['workbench_access'])) {
      $assigned = FALSE;
    }
  }
  $this
    ->assertTrue(!empty($assigned), t('All nodes properly assigned.'));
  $this
    ->assertWorkbenchAccessCheck($nodes, $account, t('No sections'), FALSE);

  // Test that the role lookup function works correctly.
  $roles = workbench_access_get_roles('access workbench access by role');

  // The 'administrator' role always has permission.
  $this
    ->assertTrue(count($roles) == 2, t('One user role assigned.'));

  // Now, we assign the user to a section and check again.
  workbench_access_user_section_save($account->uid, 'workbench_access', $active['access_scheme']['access_scheme']);
  $account = user_load($account->uid, TRUE);
  $this
    ->assertTrue(!empty($account->workbench_access['workbench_access']), t('Test user assigned to top-level hierarchy.'));
  $this
    ->assertWorkbenchAccessCheck($nodes, $account, t('Assigned sections'), TRUE);

  // Remove the permission to 'access workbench access by role' and check again.
  user_role_revoke_permissions($this->editor_role, array(
    'access workbench access by role',
  ));
  $account = user_load($account->uid, TRUE);
  $this
    ->assertTrue(empty($account->workbench_access['workbench_access']), t('Permission revoked and test user not assigned to a section.'));
  $this
    ->assertWorkbenchAccessCheck($nodes, $account, t('Role disallowed'), FALSE);

  // Test that the role lookup function works correctly.
  drupal_static_reset('workbench_access_get_roles');
  $roles = workbench_access_get_roles('access workbench access by role');

  // The 'administrator' role always has permission. Ignore that.
  $this
    ->assertTrue(count($roles) == 1, t('No user roles assigned.'));

  // Now give them permissions again.
  user_role_grant_permissions($this->editor_role, array(
    'access workbench access by role',
  ));
  $account = user_load($account->uid, TRUE);
  $this
    ->assertTrue(!empty($account->workbench_access['workbench_access']), t('Permission reinstated and test user assigned to a section.'));
  $this
    ->assertWorkbenchAccessCheck($nodes, $account, t('Role allowed'), TRUE);

  // Test the autocomplete query for adding new editors.
  drupal_static_reset('workbench_access_get_roles');
  module_load_include('inc', 'workbench_access', 'workbench_access.pages');

  // Search for the existing user via autocomplete. Should return empty.
  $test = workbench_access_autocomplete('taxonomy', 'workbench_access', substr($account->name, 0), TRUE);
  $this
    ->assertTrue(empty($test), t('Autocomplete did not match assigned user.'));
  $test_account = $this
    ->getWorkbenchAccessUser($id);
  $test = workbench_access_autocomplete('taxonomy', 'workbench_access', substr($test_account->name, 0, 1), TRUE);
  $this
    ->assertTrue(!empty($test), t('Autocomplete matched unassigned user.'));

  // Now take away the core permissions to page content and test.
  $perms = array(
    'create page content',
    'edit any page content',
    'delete any page content',
  );
  user_role_revoke_permissions($this->editor_role, $perms);
  $account = user_load($account->uid, TRUE);
  $this
    ->assertWorkbenchAccessCheck($nodes, $account, t('Page access disallowed'), FALSE);

  // Now give back the core permissions.
  user_role_grant_permissions($this->editor_role, $perms);
  $account = user_load($account->uid, TRUE);
  $this
    ->assertWorkbenchAccessCheck($nodes, $account, t('Page access allowed'), TRUE);

  // Form testing in Drupal is horribly broken.
  // We can confirm that a form page is loaded, but cannot perform
  // any introspection on the $form array.
  $account->pass_raw = 'fubar';
  $this
    ->drupalLogin($account);

  // Set the form label.
  // Attempt to access edit page.
  $this
    ->drupalGet("node/{$node->nid}/edit");
  $this
    ->assertResponse(200);
  $this
    ->assertRaw('Section', t('Workbench Access field was found.'));

  // Note that the field is nested as
  // $form['workbench_access']['workbench_access'], which forces FormAPI to
  // add the --2 suffix to the id.
  $this
    ->assertRaw('<select id="edit-workbench-access--2" name="workbench_access" class="form-select required">', t('Form presents a select list with no multiple select.'));

  // Change some values and try again.
  variable_set('workbench_access_allow_multiple', 1);
  variable_set('workbench_access_label', 'TestWA');
  $this
    ->drupalGet("node/{$node->nid}/edit");
  $this
    ->assertRaw('TestWA', t('Workbench Access field was renamed.'));
  $this
    ->assertRaw('<select multiple="multiple" name="workbench_access[]" id="edit-workbench-access--2" class="form-select required">', t('Form presents a select list with multiple select.'));

  // Try some form introspection.
  $form = $this
    ->workbenchAccessNodeForm($account->uid, $node->type);
  $this
    ->assertTrue(isset($form['workbench_access']['workbench_access']['#options']), t('Form element returns properly.'));
  $this
    ->assertTrue(count($form['workbench_access']['workbench_access']['#options']) == 10, t('Form element returned ten options to user with all sections.'));

  // Delete global permission.
  workbench_access_user_section_delete($account->uid, 'workbench_access', 'taxonomy');

  // Add sub permission.
  $term = taxonomy_term_load(1);
  workbench_access_user_section_save($account->uid, $term->tid, 'taxonomy');
  $form = $this
    ->workbenchAccessNodeForm($account->uid, $node->type);
  $this
    ->assertTrue(count($form['workbench_access']['workbench_access']['#options']) == 3, t('Form element returned three options to user with limited options.'));

  // Check that access control by node type settings work.
  $this
    ->assertTrue(variable_get('workbench_access_node_type_' . $node->type, 1), t('Workbench Access enforced for %type content.', array(
    '%type' => $node->type,
  )));

  // Force a fail by removing this user's access rules. Else it will just
  // return NODE_ACCESS_IGNORE, which cannot be tested.
  $account->workbench_access = array(
    'foo',
  );
  $response = workbench_access_node_access($node, 'update', $account);
  $this
    ->assertTrue($response == NODE_ACCESS_DENY, t('Workbench Access rules enforced on test node.'));

  // Since the user is not in a section, this should DENY, unless the node
  // type is ignored.
  // Test for ignore.
  variable_set('workbench_access_node_type_' . $node->type, 0);
  $this
    ->assertFalse(variable_get('workbench_access_node_type_' . $node->type, 1), t('Workbench Access not enforced for %type content.', array(
    '%type' => $node->type,
  )));
  $response = workbench_access_node_access($node, 'update', $account);
  $this
    ->assertTrue($response == NODE_ACCESS_IGNORE, t('Workbench Access rules ignored on test node.'));

  // Test for deny.
  variable_set('workbench_access_node_type_' . $node->type, 1);
  $this
    ->assertTrue(variable_get('workbench_access_node_type_' . $node->type, 1), t('Workbench Access enforced for %type content.', array(
    '%type' => $node->type,
  )));
  $response = workbench_access_node_access($node, 'update', $account);
  $this
    ->assertTrue($response == NODE_ACCESS_DENY, t('Workbench Access rules enforced on test node.'));

  // If the node is not assigned, we should ignore.
  $temp = $node->workbench_access;
  $node->workbench_access = array();
  $response = workbench_access_node_access($node, 'update', $account);
  $this
    ->assertTrue($response == NODE_ACCESS_IGNORE, t('Workbench Access rules ignored for unassigned node.'));

  // Make sure the above was not a false positive.
  $node->workbench_access = $temp;
  $response = workbench_access_node_access($node, 'update', $account);
  $this
    ->assertTrue($response == NODE_ACCESS_DENY, t('Workbench Access rules enforced on test node.'));

  // Delete the user account.
  user_delete($account->uid);
  $records = db_query("SELECT 1 FROM {workbench_access_user} WHERE uid = :uid", array(
    ':uid' => $account->uid,
  ))
    ->fetchField();
  $this
    ->assertFalse($records, 'User section assignments removed.');

  // Test module hooks.
  // Ensure that our node type uses the form element.
  $GLOBALS['conf']['workbench_access_node_type_' . $node->type] = TRUE;
  $form = drupal_get_form($node->type . '_node_form', $node);
  $this
    ->assertTrue(!empty($form['workbench_access']['workbench_access']['#workbench_access_test']), t('hook_workbench_access_node_element_alter() fired correctly.'));
}