You are here

Home » API reference » Open Atrium Core 7.2 » oa_access.test

class OpenAtriumAccessTestCase in Open Atrium Core 7.2

Functional tests for the Open Atrium Access module.

Hierarchy

Expanded class hierarchy of OpenAtriumAccessTestCase

File

modules/oa_access/tests/oa_access.test, line 308
Functional tests for the Open Atrium Access module.

View source 
class OpenAtriumAccessTestCase extends OpenAtriumAccessBaseTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Open Atrium Access',
      'description' => 'Test the Open Atrium Access API.',
      'group' => 'Open Atrium Access',
    );
  }
  public function setUp() {
    parent::setUp(array(
      'oa_access_test',
    ));
  }
  public function testGetPermissions() {
    $this
      ->assertEqual($this
      ->getPermissions('oa_access_test'), array(
      'access oa_access_test' => array(
        'title' => t('Access Open Atrium Access Test'),
        'description' => t('Gives you the ability to access Open Atrium Access Test'),
        'module' => 'oa_access_test',
        'type' => OA_ACCESS_DEFAULT_PERMISSION,
        'combine' => OA_ACCESS_COMBINE_UNION,
      ),
      'administer oa_access_test' => array(
        'title' => t('Administer Open Atrium Access Test'),
        'description' => t('Gives you the ability to administer Open Atrium Access Test'),
        'module' => 'oa_access_test',
        'type' => OA_ACCESS_DEFAULT_PERMISSION,
        'combine' => OA_ACCESS_COMBINE_UNION,
      ),
      'group permission for oa_access_test' => array(
        'title' => t('A Group-only permission for Open Atrium Access Test'),
        'description' => t('Used to test Group-only permissions'),
        'type' => OA_ACCESS_GROUP_PERMISSION,
        'module' => 'oa_access_test',
        'combine' => OA_ACCESS_COMBINE_UNION,
      ),
      'team permission for oa_access_test' => array(
        'title' => t('A Team-only permission for Open Atrium Access Test'),
        'description' => t('Used to test Team-only permissions'),
        'type' => OA_ACCESS_TEAM_PERMISSION,
        'module' => 'oa_access_test',
        'combine' => OA_ACCESS_COMBINE_UNION,
      ),
      'permission with all option for oa_access_test' => array(
        'title' => t('A permission with an "All" option'),
        'description' => t('Used to test the "All" option'),
        'type' => OA_ACCESS_DEFAULT_PERMISSION | OA_ACCESS_ALLOW_OPTION_ALL,
        'module' => 'oa_access_test',
        'combine' => OA_ACCESS_COMBINE_UNION,
      ),
      'access oa_access_test intersection' => array(
        'title' => t('Access Open Atrium Access Test (Intersection)'),
        'description' => t('Tests OA_ACCESS_COMBINE_INTERSECTION.'),
        'type' => OA_ACCESS_DEFAULT_PERMISSION | OA_ACCESS_ALLOW_OPTION_ALL,
        'combine' => OA_ACCESS_COMBINE_INTERSECTION,
        'module' => 'oa_access_test',
      ),
      'access oa_access_test team override' => array(
        'title' => t('Access Open Atrium Access Test (Team Override)'),
        'description' => t('Tests OA_ACCESS_COMBINE_TEAM_OVERRIDE.'),
        'type' => OA_ACCESS_DEFAULT_PERMISSION | OA_ACCESS_ALLOW_OPTION_ALL,
        'combine' => OA_ACCESS_COMBINE_TEAM_OVERRIDE,
        'module' => 'oa_access_test',
      ),
      'access oa_access_test group override' => array(
        'title' => t('Access Open Atrium Access Test (Group Override)'),
        'description' => t('Tests OA_ACCESS_COMBINE_GROUP_OVERRIDE.'),
        'type' => OA_ACCESS_DEFAULT_PERMISSION | OA_ACCESS_ALLOW_OPTION_ALL,
        'combine' => OA_ACCESS_COMBINE_GROUP_OVERRIDE,
        'module' => 'oa_access_test',
      ),
      'a permission for oa_access_test that is only conditionally available' => array(
        'title' => t('Some fickle permission'),
        'description' => t('A permission for oa_access_test that is only conditionally available'),
        'module' => 'oa_access_test',
        'type' => OA_ACCESS_DEFAULT_PERMISSION,
        'combine' => OA_ACCESS_COMBINE_UNION,
      ),
    ));
  }
  public function testUserGroups() {

    // Create an admin user and login.
    $account = $this
      ->oaCreateUser(array(
      'create oa_space content',
    ));
    $this
      ->drupalLogin($account);
    $group_a = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group A',
    ), array(
      'access content',
    ));
    $group_b = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group B',
    ), array(
      'access content',
    ));

    // Add the user from $group_a to $group_b as well.
    og_group('node', $group_b['group']->nid, array(
      'entity type' => 'user',
      'entity' => $group_a['user']->uid,
      'membership type' => OG_MEMBERSHIP_TYPE_DEFAULT,
    ));

    // Check the groups that the $group_a user belongs to.
    $this
      ->assertEqual(oa_access_user_groups($group_a['user']), array(
      $group_a['group']->nid => $group_a['group']->nid,
      $group_b['group']->nid => $group_b['group']->nid,
      // Magic 'All' Group.
      0 => 0,
    ));

    // Check the (much simpler) $group_b user.
    $this
      ->assertEqual(oa_access_user_groups($group_b['user']), array(
      $group_b['group']->nid => $group_b['group']->nid,
      // Magic 'All' Group.
      0 => 0,
    ));
  }
  public function testUserTeams() {

    // Create an admin user and login.
    $account = $this
      ->oaCreateUser(array(
      'create oa_space content',
    ));
    $this
      ->drupalLogin($account);

    // Create a Space that all our users are going to belong to.
    $space1 = $this
      ->oaCreateNode(array(
      'title' => 'Space A',
      'type' => 'oa_space',
      'uid' => $account->uid,
    ));
    $user_a = $this
      ->oaCreateUser(array(), $space1);

    // Now, create a Team in our Space.
    $team_a = $this
      ->oaCreateTeamWithUser(array(
      'title' => 'Team A',
    ), array(
      'access content',
    ), $space1);

    // Check the teams that the $team_a user belongs to.
    $this
      ->assertEqual(oa_access_user_teams($space1->nid, $team_a['user']), array(
      $team_a['team']->nid => $team_a['team']->nid,
      $space1->nid => $space1->nid,
    ));

    // Check the (much simpler) $user_a user.
    $this
      ->assertEqual(oa_access_user_teams($space1->nid, $user_a), array(
      // Magic 'All' Team.
      $space1->nid => $space1->nid,
    ));
  }
  public function testGetSetGroupPermissions() {
    $group_a = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group A',
    ), array(
      'access content',
    ));
    $group_b = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group B',
    ), array(
      'access content',
    ));
    $group_permissions = array(
      $group_a['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
          'administer oa_access_test',
        ),
      ),
      $group_b['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
    );

    // First, verify that there are no permissions set.
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), array(
      $group_a['group']->nid => array(),
      $group_b['group']->nid => array(),
    ));

    // Set the permissions in the database, then get them back out and make
    // sure they are the same.
    oa_access_set_group_permissions($group_permissions);
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), $group_permissions);

    // We'll update only one of the groups permissions, but get both and make
    // sure that we don't overwrite the wrong one.
    $group_permissions[$group_b['group']->nid]['oa_access_test'] = array(
      'administer oa_access_test',
    );
    $group_permissions_partial = $group_permissions;
    unset($group_permissions_partial[$group_a['group']->nid]);
    oa_access_set_group_permissions($group_permissions_partial);
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), $group_permissions);

    // Now, clear the static cache on 'oa_access_get_group_permissions' and
    // try it again - this will pull from the database.
    drupal_static_reset('oa_access_get_group_permissions');
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), $group_permissions);
  }
  public function testCombinedGroupPermissions() {
    $group_a = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group A',
    ), array(
      'access content',
    ));
    $group_b = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group B',
    ), array(
      'access content',
    ));
    $group_permissions = array(
      $group_a['group']->nid => array(
        'oa_access_test' => array(
          'administer oa_access_test',
        ),
      ),
      $group_b['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
    );
    oa_access_set_group_permissions($group_permissions);
    $group_permissions_combined = array(
      'administer oa_access_test' => TRUE,
      'access oa_access_test' => TRUE,
    );
    $this
      ->assertEqual(oa_access_get_group_permissions_combined(array_keys($group_permissions)), $group_permissions_combined);
  }
  public function testGroupAccess() {
    $group_a = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group A',
    ), array(
      'access content',
    ));
    $group_b = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group B',
    ), array(
      'access content',
    ));
    $not_in_group = $this
      ->oaCreateUser(array(
      'access content',
    ));
    $group_permissions = array(
      $group_a['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
          'administer oa_access_test',
        ),
      ),
      $group_b['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
    );
    oa_access_set_group_permissions($group_permissions);

    // Make sure that each user has the permissions that they should.
    $this
      ->assertFalse(oa_access(NULL, 'access oa_access_test', $not_in_group));
    $this
      ->assertFalse(oa_access(NULL, 'administer oa_access_test', $not_in_group));
    $this
      ->assertTrue(oa_access(NULL, 'access oa_access_test', $group_a['user']));
    $this
      ->assertTrue(oa_access(NULL, 'administer oa_access_test', $group_a['user']));
    $this
      ->assertTrue(oa_access(NULL, 'access oa_access_test', $group_b['user']));
    $this
      ->assertFalse(oa_access(NULL, 'administer oa_access_test', $group_b['user']));

    // Assert that setting the 'All' group permission will give it to everyone
    // including even the user who is not in any group.
    $this
      ->assertFalse(oa_access(NULL, 'permission with all option for oa_access_test', $not_in_group));
    $this
      ->assertFalse(oa_access(NULL, 'permission with all option for oa_access_test', $group_a['user']));
    $this
      ->assertFalse(oa_access(NULL, 'permission with all option for oa_access_test', $group_b['user']));
    oa_access_set_group_permissions(array(
      0 => array(
        'oa_access_test' => array(
          'permission with all option for oa_access_test',
        ),
      ),
    ));
    drupal_static_reset('oa_access');
    $this
      ->assertTrue(oa_access(NULL, 'permission with all option for oa_access_test', $not_in_group));
    $this
      ->assertTrue(oa_access(NULL, 'permission with all option for oa_access_test', $group_a['user']));
    $this
      ->assertTrue(oa_access(NULL, 'permission with all option for oa_access_test', $group_b['user']));
  }
  public function testTeamAccess() {

    // Create an admin user and login.
    $account = $this
      ->oaCreateUser(array(
      'create oa_space content',
    ));
    $this
      ->drupalLogin($account);

    // Create a Space that all our users are going to belong to.
    $space1 = $this
      ->oaCreateNode(array(
      'title' => 'Space A',
      'type' => 'oa_space',
      'uid' => $account->uid,
    ));
    $team_a = $this
      ->oaCreateTeamWithUser(array(
      'title' => 'Team A',
    ), array(
      'access content',
    ), $space1);
    $team_b = $this
      ->oaCreateTeamWithUser(array(
      'title' => 'Team B',
    ), array(
      'access content',
    ), $space1);
    $not_in_team = $this
      ->oaCreateUser(array(
      'access content',
    ), $space1);
    $not_in_group = $this
      ->oaCreateUser(array(
      'access content',
    ));
    $group_permissions = array(
      $team_a['team']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
          'administer oa_access_test',
        ),
      ),
      $team_b['team']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
    );
    oa_access_set_group_permissions($group_permissions);

    // Make sure that each user has the permissions that they should.
    $this
      ->assertFalse(oa_access($space1, 'access oa_access_test', $not_in_team));
    $this
      ->assertFalse(oa_access($space1, 'administer oa_access_test', $not_in_team));
    $this
      ->assertFalse(oa_access($space1, 'access oa_access_test', $not_in_group));
    $this
      ->assertFalse(oa_access($space1, 'administer oa_access_test', $not_in_group));
    $this
      ->assertTrue(oa_access($space1, 'access oa_access_test', $team_a['user']));
    $this
      ->assertTrue(oa_access($space1, 'administer oa_access_test', $team_a['user']));
    $this
      ->assertTrue(oa_access($space1, 'access oa_access_test', $team_b['user']));
    $this
      ->assertFalse(oa_access($space1, 'administer oa_access_test', $team_b['user']));

    // Now, create a new Space which our users don't belong to and verify that
    // they don't get any permissions there.
    $space2 = $this
      ->oaCreateNode(array(
      'title' => 'Space B',
      'type' => 'oa_space',
      'uid' => $account->uid,
    ));
    $this
      ->assertFalse(oa_access($space2, 'access oa_access_test', $team_a['user']));
    $this
      ->assertFalse(oa_access($space2, 'administer oa_access_test', $team_a['user']));
    $this
      ->assertFalse(oa_access($space2, 'access oa_access_test', $team_b['user']));
    $this
      ->assertFalse(oa_access($space2, 'administer oa_access_test', $team_b['user']));

    // And, just for good measure, make sure they don't have these permissions
    // when we aren't in any Space context.
    $this
      ->assertFalse(oa_access(NULL, 'access oa_access_test', $team_a['user']));
    $this
      ->assertFalse(oa_access(NULL, 'administer oa_access_test', $team_a['user']));
    $this
      ->assertFalse(oa_access(NULL, 'access oa_access_test', $team_b['user']));
    $this
      ->assertFalse(oa_access(NULL, 'administer oa_access_test', $team_b['user']));

    // Assert that setting the 'All' team permission will give it to everyone
    // including even the user who is not in any team (but not the user who
    // isn't in the group).
    $this
      ->assertFalse(oa_access($space1, 'permission with all option for oa_access_test', $not_in_team));
    $this
      ->assertFalse(oa_access($space1, 'permission with all option for oa_access_test', $not_in_group));
    $this
      ->assertFalse(oa_access($space1, 'permission with all option for oa_access_test', $team_a['user']));
    $this
      ->assertFalse(oa_access($space1, 'permission with all option for oa_access_test', $team_b['user']));
    oa_access_set_group_permissions(array(
      $space1->nid => array(
        'oa_access_test' => array(
          'permission with all option for oa_access_test',
        ),
      ),
    ));
    drupal_static_reset('oa_access');
    $this
      ->assertTrue(oa_access($space1, 'permission with all option for oa_access_test', $not_in_team));
    $this
      ->assertFalse(oa_access($space1, 'permission with all option for oa_access_test', $not_in_group));
    $this
      ->assertTrue(oa_access($space1, 'permission with all option for oa_access_test', $team_a['user']));
    $this
      ->assertTrue(oa_access($space1, 'permission with all option for oa_access_test', $team_b['user']));
  }
  public function testTeamOverride() {

    // Create an admin user and login.
    $account = $this
      ->oaCreateUser(array(
      'create oa_space content',
    ));
    $this
      ->drupalLogin($account);

    // Create a Space that all our users are going to belong to.
    $space1 = $this
      ->oaCreateNode(array(
      'title' => 'Space A',
      'type' => 'oa_space',
      'uid' => $account->uid,
    ));
    $team_a = $this
      ->oaCreateTeamWithUser(array(
      'title' => 'Team A',
    ), array(
      'access content',
    ), $space1);
    $not_in_team = $this
      ->oaCreateUser(array(
      'access content',
    ), $space1);
    $not_in_space = $this
      ->oaCreateUser(array(
      'access content',
    ));
    $group_permissions = array(
      // Say (via Groups permissions) that 'All site users' have access to this
      // permission.
      0 => array(
        'oa_access_test' => array(
          'access oa_access_test team override',
        ),
      ),
      $team_a['team']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test team override',
        ),
      ),
    );
    oa_access_set_group_permissions($group_permissions);

    // So, in this case, only members of $team_a should have this permission
    // even though 'All site users' have it, the Team permissions have further
    // reduced access.
    $this
      ->assertTrue(oa_access($space1, 'access oa_access_test team override', $team_a['user']));
    $this
      ->assertFalse(oa_access($space1, 'access oa_access_test team override', $not_in_team));
    $this
      ->assertFalse(oa_access($space1, 'access oa_access_test team override', $not_in_space));

    // However, if we are operating outside of a Space context, then all users
    // should get it, ie. there are no Teams to restrict access further.
    $this
      ->assertTrue(oa_access(NULL, 'access oa_access_test team override', $team_a['user']));
    $this
      ->assertTrue(oa_access(NULL, 'access oa_access_test team override', $not_in_team));
    $this
      ->assertTrue(oa_access(NULL, 'access oa_access_test team override', $not_in_space));
  }
  public function testGroupAdminPage() {

    // Create an admin user and login.
    $account = $this
      ->oaCreateUser(array(
      'administer oa_access permissions',
    ));
    $this
      ->drupalLogin($account);
    $group_a = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group A',
    ), array(
      'access content',
    ));
    $group_b = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group B',
    ), array(
      'access content',
    ));

    // Configure Group A with both permissions, but Group B only with one.
    $this
      ->drupalGet(OA_ACCESS_GROUP_ADMIN_PATH);
    $this
      ->assertText(t('Used to test Group-only permissions'));
    $this
      ->assertNoText(t('Used to test Team-only permissions'));
    $this
      ->assertText(t('All site users'));
    $this
      ->assertNoText(t('All Space members'));
    $this
      ->assertTrue($this
      ->hasSelectOption('permissions[oa_access_test][permission with all option for oa_access_test][groups][]', 0));
    $this
      ->assertFalse($this
      ->hasSelectOption('permissions[oa_access_test][access oa_access_test][groups][]', 0));
    $this
      ->oaPostPermissions(array(
      'oa_access_test' => array(
        'access oa_access_test' => array(
          $group_a['group']->nid,
          $group_b['group']->nid,
        ),
        'administer oa_access_test' => array(
          $group_a['group']->nid,
        ),
        'group permission for oa_access_test' => array(
          $group_a['group']->nid,
        ),
      ),
    ));

    // Get permissions via the API and make sure they match.
    $group_permissions = array(
      $group_a['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
          'administer oa_access_test',
          'group permission for oa_access_test',
        ),
      ),
      $group_b['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
    );
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), $group_permissions);
  }
  public function testTeamAdminPage() {

    // Create an admin user and login.
    $account = $this
      ->oaCreateUser(array(
      'administer oa_access permissions',
    ));
    $this
      ->drupalLogin($account);

    // Create a Space that all our users are going to belong to.
    $space1 = $this
      ->oaCreateNode(array(
      'title' => 'Space A',
      'type' => 'oa_space',
      'uid' => $account->uid,
    ));
    $team_a = $this
      ->oaCreateTeamWithUser(array(
      'title' => 'Team A',
    ), array(
      'access content',
    ), $space1);
    $team_b = $this
      ->oaCreateTeamWithUser(array(
      'title' => 'Team B',
    ), array(
      'access content',
    ), $space1);

    // Configure Team A with both permissions, but Team B only with one.
    $parts = explode('/', OA_ACCESS_TEAM_ADMIN_PATH);
    $parts[1] = 'node';
    $parts[2] = $space1->nid;
    $this
      ->drupalGet(implode('/', $parts));
    $this
      ->assertNoText(t('Used to test Group-only permissions'));
    $this
      ->assertText(t('Used to test Team-only permissions'));
    $this
      ->assertNoText(t('All site users'));
    $this
      ->assertText(t('All Space members'));
    $this
      ->assertTrue($this
      ->hasSelectOption('permissions[oa_access_test][permission with all option for oa_access_test][groups][]', $space1->nid));
    $this
      ->assertFalse($this
      ->hasSelectOption('permissions[oa_access_test][access oa_access_test][groups][]', $space1->nid));
    $this
      ->oaPostPermissions(array(
      'oa_access_test' => array(
        'access oa_access_test' => array(
          $team_a['team']->nid,
          $team_b['team']->nid,
        ),
        'administer oa_access_test' => array(
          $team_a['team']->nid,
        ),
        'team permission for oa_access_test' => array(
          $team_a['team']->nid,
        ),
      ),
    ));

    // Get permissions via the API and make sure they match.
    $group_permissions = array(
      $team_a['team']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
          'administer oa_access_test',
          'team permission for oa_access_test',
        ),
      ),
      $team_b['team']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
    );
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), $group_permissions);
  }
  public function testCleanupPermissions() {
    $group_a = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group A',
    ), array(
      'access content',
    ));
    $group_b = $this
      ->oaCreateGroupWithUser(array(
      'title' => 'Group B',
    ), array(
      'access content',
    ));

    // Add some groups with a permission available, that we're going to remove
    // and then cleanup.
    $group_permissions = array(
      $group_a['group']->nid => array(
        'oa_access_test' => array(
          'a permission for oa_access_test that is only conditionally available',
          'access oa_access_test',
        ),
      ),
      $group_b['group']->nid => array(
        'oa_access_test' => array(
          'a permission for oa_access_test that is only conditionally available',
        ),
      ),
    );
    oa_access_set_group_permissions($group_permissions);

    // Now, we remove the permission.
    variable_set('oa_access_test_remove_permission', TRUE);
    drupal_static_reset('oa_access_get_permissions');
    $valid_permissions = oa_access_get_permissions();
    $this
      ->assertFalse(isset($valid_permissions['a permission for oa_access_test that is only conditionally available']));

    // Before we do the clean-up, the removed permission will still be set for
    // $group_a and $group_b. Clear the static cache to make sure we're getting
    // the database version.
    drupal_static_reset('oa_access_get_group_permissions');
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), $group_permissions);

    // Perform the clean-up.
    oa_access_cleanup_permissions();

    // And now verify that the permissions have been removed.
    drupal_static_reset('oa_access_get_group_permissions');
    $this
      ->assertEqual(oa_access_get_group_permissions(array_keys($group_permissions)), array(
      $group_a['group']->nid => array(
        'oa_access_test' => array(
          'access oa_access_test',
        ),
      ),
      $group_b['group']->nid => array(),
    ));
  }

}

Members

Namesort descending Modifiers Type Description Overrides
OpenAtriumAccessBaseTestCase::$profile protected property
OpenAtriumAccessBaseTestCase::getGroupPermissions protected function Gets all the permissions that a list of groups have.
OpenAtriumAccessBaseTestCase::getPermissions protected function Get all permissions defined by implementing modules.
OpenAtriumAccessBaseTestCase::hasSelectOption function Check if a select has a certain option.
OpenAtriumAccessBaseTestCase::oaCreateGroupWithUser protected function Creates an Open Atrium Group with a new user in an optional Space.
OpenAtriumAccessBaseTestCase::oaCreateNode protected function Creates a node with an optional Space or Section.
OpenAtriumAccessBaseTestCase::oaCreateTeamWithUser protected function Creates an Open Atrium Team with a new user in a Space.
OpenAtriumAccessBaseTestCase::oaCreateUser protected function Create a user with an optional Space.
OpenAtriumAccessBaseTestCase::oaPostPermissions protected function Post to a Group/Team permisisons page with a set of values.
OpenAtriumAccessTestCase::getInfo public static function
OpenAtriumAccessTestCase::setUp public function Overrides OpenAtriumAccessBaseTestCase::setUp
OpenAtriumAccessTestCase::testCleanupPermissions public function
OpenAtriumAccessTestCase::testCombinedGroupPermissions public function
OpenAtriumAccessTestCase::testGetPermissions public function
OpenAtriumAccessTestCase::testGetSetGroupPermissions public function
OpenAtriumAccessTestCase::testGroupAccess public function
OpenAtriumAccessTestCase::testGroupAdminPage public function
OpenAtriumAccessTestCase::testTeamAccess public function
OpenAtriumAccessTestCase::testTeamAdminPage public function
OpenAtriumAccessTestCase::testTeamOverride public function
OpenAtriumAccessTestCase::testUserGroups public function
OpenAtriumAccessTestCase::testUserTeams public function