You are here

registration.test in Entity Registration 7

Same filename and directory in other branches
  1. 8.2 tests/registration.test
  2. 7.2 tests/registration.test

Tests for the Registration module

File

tests/registration.test
View source
<?php

/**
 * @file
 * Tests for the Registration module
 */
class RegistrationTestCase extends DrupalWebTestCase {
  function setUpEntity() {

    // Create registration bundle.
    $this->registration_type_name = $this
      ->randomName();
    $label = drupal_strtoupper($this->registration_type_name);
    $this->registration_type = entity_create('registration_type', array(
      'name' => $this->registration_type_name,
      'label' => $label,
    ));
    entity_save('registration_type', $this->registration_type);

    // Field.
    $field_name = 'test_registration_field';
    $this->field = field_create_field(array(
      'field_name' => $field_name,
      'type' => 'registration',
    ));

    // Create main entity.
    $this->host_entity_type = 'node';
    $this->host_entity = $this
      ->drupalCreateNode();
    list($this->host_entity_id, , $this->host_entity_bundle) = entity_extract_ids($this->host_entity_type, $this->host_entity);

    // Field instance.
    $this->field_instance = field_create_instance(array(
      'field_name' => $field_name,
      'entity_type' => $this->host_entity_type,
      'bundle' => $this->host_entity_bundle,
      'display' => array(
        'default' => array(
          'type' => 'registration_form',
        ),
      ),
    ));

    // Set registration type for entity.
    $this->host_entity->{$field_name}[LANGUAGE_NONE][0]['registration_type'] = $this->registration_type_name;
    entity_save($this->host_entity_type, $this->host_entity);
    $uri = entity_uri($this->host_entity_type, $this->host_entity);
    $this->host_entity_path = $uri['path'];
  }
  function entityLastId($entity_type) {
    $query = new EntityFieldQuery();
    $result = $query
      ->entityCondition('entity_type', $entity_type)
      ->entityOrderBy('entity_id', 'DESC')
      ->range(0, 1)
      ->execute();
    return key($result[$entity_type]);
  }
  function setHostEntitySettings(array $settings = array()) {

    // @todo: Remove ['settings']. Settings must be set in schema. registration_update_entity_settings() currently requires this.
    $settings['settings'] = serialize(isset($settings['settings']) ? $settings['settings'] : array());
    registration_update_entity_settings($this->host_entity_type, $this->host_entity_id, $settings);
  }

  /**
   * Create a Registration programmatically.
   *
   * @param array $values
   *   Additional properties to add to registration entity.
   */
  function createRegistration(array $values = array()) {
    $registration = entity_create('registration', array(
      'entity_type' => $this->host_entity_type,
      'entity_id' => $this->host_entity_id,
      'type' => $this->registration_type_name,
    ) + $values);
    entity_save('registration', $registration);
    return $registration;
  }

  /**
   * Loads a registration from the database, avoiding the cache.
   *
   * @param int $registration_id
   *   A registrations' unique identifier.
   */
  function loadRegistration($registration_id) {
    $this
      ->resetRegistration();
    return registration_load($registration_id);
  }

  /**
   * Reset session cache of registration entities.
   */
  function resetRegistration() {
    entity_get_controller('registration')
      ->resetCache();
  }

}

/**
 * Creates a registration type
 * Create node entity type
 * ensure registration type exists
 */
class RegistrationStandardTestCase extends RegistrationTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Registration module',
      'description' => 'Test Registration module.',
      'group' => 'Registration',
    );
  }
  function setUp() {
    parent::setUp(array(
      'registration',
    ));
    $this
      ->setUpEntity();
  }

  /**
   * Tests if registration fields were created successfully, and associated with an entity.
   */
  function testRegistrationFieldCreate() {
    $field_name =& $this->field['field_name'];
    $entity =& $this->host_entity;

    // Field created.
    $this
      ->assertTrue(isset($this->field['id']), t('Registration field created'), 'Registration');

    // Instance created.
    $read_instance = field_read_instance($this->host_entity_type, $field_name, $entity->type);
    $this
      ->assertNotIdentical(FALSE, $read_instance, t('Create registration instance'), 'Registration');

    // Get Instance.
    $registration_instances = registration_get_registration_instances(array(
      'entity_type' => $this->host_entity_type,
      'bundle' => $entity->type,
    ));
    $this
      ->assertTrue(count($registration_instances) == 1, t('Read registration field instances'), 'Registration');
    $this
      ->assertTrue($registration_instances[0]['field_name'] == $field_name, t('Validate registration field instance data.'), 'Registration');
  }

  /**
   * Tests if registration type is set.
   */
  function testRegistrationType() {

    // Save.
    $this
      ->assertTrue(is_numeric($this->registration_type->id), t('registration bundle has ID'), 'Registration');

    // Load.
    $registration_type_load = entity_load_single('registration_type', $this->registration_type->id);
    $this
      ->assertNotIdentical(FALSE, $registration_type_load, t('registration bundle loaded'), 'Registration');
    $this
      ->assertEqual($this->registration_type->id, $registration_type_load->id, t('registration bundle matches previously saved bundle.'), 'Registration');

    // Get all types.
    $types = registration_get_types();
    $this
      ->assertTrue(isset($types[$this->registration_type_name]), t('Load all registration types'), 'Registration');

    // Ensure value on field saves.
    $this
      ->resetRegistration();
    $entity2 = entity_load_single($this->host_entity_type, $this->host_entity_id);
    $this
      ->assertEqual(registration_get_entity_registration_type($this->host_entity_type, $entity2), $this->registration_type_name, t('Saved registration type in registration field.'), 'Registration');

    // Ensure permissions exist for registration type.
    $this
      ->checkPermissions(array(
      'administer ' . $this->registration_type_name . ' registration',
    ), TRUE);
  }

  /**
   * Tests entity update helper.
   */
  function testHostEntitySettings() {
    $settings = array(
      'status' => 1,
      'settings' => array(
        'random_string' => $this
          ->randomName(),
      ),
    );
    $this
      ->setHostEntitySettings($settings);
    $db_settings = registration_entity_settings($this->host_entity_type, $this->host_entity_id);
    $this
      ->assertTrue($settings['settings']['random_string'] === $db_settings['settings']['random_string'], t('Saving host entity registration settings'), 'Registration');

    // Tests static caching.
    $settings = array(
      'status' => 0,
      'settings' => array(
        'random_string' => $this
          ->randomName(),
      ),
    );
    $this
      ->setHostEntitySettings($settings);
    $db_settings = registration_entity_settings($this->host_entity_type, $this->host_entity_id, TRUE);
    $this
      ->assertTrue($settings['settings']['random_string'] === $db_settings['settings']['random_string'], t('Saving host entity registration settings.'), 'Registration');
  }
  function testHostEntitySettingsForm() {
    $permissions = array(
      'administer ' . $this->registration_type_name . ' registration',
    );
    $this
      ->checkPermissions($permissions, TRUE);
    $user = $this
      ->drupalCreateUser($permissions);
    $this
      ->drupalLogin($user);

    // Display form.
    $this
      ->drupalGet($this->host_entity_path . '/registrations/settings');
    $this
      ->assertResponse(200, t('User can access host entity registration settings page.'), 'Registration');
    $this
      ->assertFieldByName('status');

    // Submit form.
    $test_date1 = '2011-06-04 09:42:33';
    $test_date2 = '2012-06-30 12:34:56';
    $edit = array(
      'status' => TRUE,
      'scheduling[open]' => $test_date1,
      'scheduling[close]' => $test_date2,
    );
    $this
      ->drupalPost($this->host_entity_path . '/registrations/settings', $edit, t('Save Settings'));
    $this
      ->assertText(t('Registration settings have been saved.'), t('Host entity registration settings form saved.'), 'Registration');

    // Verify settings saved to database.
    $settings = registration_entity_settings($this->host_entity_type, $this->host_entity_id);
    $this
      ->assertTrue($settings['status'], t('Host entity settings: status saved.'), 'Registration');
    $this
      ->assertTrue($settings['open'] == $test_date1, t('Host entity settings: open date saved.'), 'Registration');
    $this
      ->assertTrue($settings['close'] == $test_date2, t('Host entity settings: close date saved.'), 'Registration');
  }

  /**
   * Tests email broadcast functionality.
   *
   * Generates registrations for a host entity, and confirms that emails
   * were sent out to all registrants.
   */
  function testHostEntityBroadcastForm() {
    $permissions = array(
      'administer ' . $this->registration_type_name . ' registration',
    );
    $this
      ->checkPermissions($permissions, TRUE);
    $user = $this
      ->drupalCreateUser($permissions);
    $this
      ->drupalLogin($user);

    // Create registration, Drupal user.
    $user_a = $this
      ->drupalCreateUser($permissions);
    $this
      ->createRegistration(array(
      'author_uid' => $user->uid,
      'user_uid' => $user_a->uid,
    ));

    // Create registration, anonymous user.
    $anonymous_mail = $this
      ->randomName() . '@example.com';
    $this
      ->createRegistration(array(
      'author_uid' => $user->uid,
      'anon_mail' => $anonymous_mail,
    ));

    // Display form.
    $this
      ->drupalGet($this->host_entity_path . '/registrations/broadcast');
    $this
      ->assertResponse(200, t('User can access host entity broadcast settings page.'), 'Registration');
    $this
      ->assertFieldByName('subject');
    $this
      ->assertFieldByName('message');

    // Submit form.
    $edit = array(
      'subject' => $this
        ->randomName(16),
      'message' => $this
        ->randomString(),
    );
    $this
      ->drupalPost($this->host_entity_path . '/registrations/broadcast', $edit, t('Send'));
    $this
      ->assertText(t('Registration broadcast sent to @count registrants.', array(
      '@count' => 2,
    )), t('Host entity broadcast form submitted.'), 'Registration');

    // Verify emails were sent.
    $mails = $this
      ->drupalGetMails();
    $address_sent = array();
    foreach ($mails as $mail) {
      $address_sent[] = $mail['to'];
    }
    $this
      ->assertTrue(in_array($user_a->mail, $address_sent), t('Registration email broadcast to authenticated account.'), 'Registration');
    $this
      ->assertTrue(in_array($anonymous_mail, $address_sent), t('Registration email broadcast to anonymous person.'), 'Registration');
  }

  /**
   * Check internal status modifiers.
   *
   * Capacity, opening, and closing dates.
   */
  function testHostRegistrationStatus() {
    global $user;
    $permissions = array(
      'create ' . $this->registration_type_name . ' registration',
    );
    $this
      ->checkPermissions($permissions, TRUE);
    $basic_user = $this
      ->drupalCreateUser($permissions);
    $permissions = array(
      'administer ' . $this->registration_type_name . ' registration',
    );
    $this
      ->checkPermissions($permissions, TRUE);
    $admin_user = $this
      ->drupalCreateUser($permissions);

    // Start with the basic user.
    $user = $basic_user;
    $this
      ->assertFalse(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Default host entity status is closed.'), 'Registration');
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
      'capacity' => 10,
    ));
    $this
      ->assertTrue(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity main status is opened.'), 'Registration');

    // Fill capacity.
    $registrations = array();
    for ($i = 0; $i < 5; $i++) {
      $registrations[$i] = $this
        ->createRegistration(array(
        'count' => 2,
      ));
    }
    $this
      ->assertFalse(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is closed, filled with registrations.'), 'Registration');

    // Unfill capacity by one registration.
    entity_delete('registration', end($registrations)->registration_id);
    $this
      ->assertTrue(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Deleted a registration, capacity now not at maximum.'), 'Registration');

    // Test dates.
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
      'open' => date('Y-m-d H:i:s', time() + 3600),
      'close' => NULL,
    ));
    $this
      ->assertFalse(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is closed, open time has not passed.'), 'Registration');
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
      'open' => date('Y-m-d H:i:s', time() - 3600),
      'close' => date('Y-m-d H:i:s', time() + 3600),
    ));
    $this
      ->assertTrue(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is open, in between open and closing times.'), 'Registration');
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
      'open' => NULL,
      'close' => date('Y-m-d H:i:s', time() - 3600),
    ));
    $this
      ->assertFalse(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is closed, closing time has passed.'), 'Registration');
  }
  function testRegistrationCreateAccess() {

    // With permissions.
    $permissions = array(
      'create ' . $this->registration_type_name . ' registration',
      'create ' . $this->registration_type_name . ' registration other users',
      'create ' . $this->registration_type_name . ' registration other anonymous',
    );
    $this
      ->checkPermissions($permissions, TRUE);

    // Reset permission cache
    $user = $this
      ->drupalCreateUser($permissions);
    $this
      ->drupalLogin($user);
    $this
      ->drupalGet($this->host_entity_path . '/register');
    $this
      ->assertResponse(403, t('Close default host entity status (database).'), 'Registration');
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
    ));
    $this
      ->drupalGet($this->host_entity_path . '/register');
    $this
      ->assertResponse(200, t('Open default host entity status (database).'), 'Registration');
    $this
      ->assertRaw(t('Save Registration'), t('User with create permissions access register tab.'), 'Registration');
    $this
      ->assertFieldByName('who_is_registering');
  }

  /**
   * Tests for the registration add/edit form.
   */
  public function testRegistrationForm() {

    // Setup environment - create all users we'll need for tests.
    $permissions = array(
      'create ' . $this->registration_type_name . ' registration',
      'view own ' . $this->registration_type_name . ' registration',
      'update own ' . $this->registration_type_name . ' registration',
      'delete own ' . $this->registration_type_name . ' registration',
      'create ' . $this->registration_type_name . ' registration self',
      'create ' . $this->registration_type_name . ' registration other users',
      'create ' . $this->registration_type_name . ' registration other anonymous',
    );

    // Ensure permission set is valid before using them.
    $this
      ->checkPermissions($permissions, TRUE);

    // Create user with many permissions.
    $user = $this
      ->drupalCreateUser($permissions);

    // Create user with view permission only.
    $permissions = array(
      'view ' . $this->registration_type_name . ' registration',
    );
    $this
      ->checkPermissions($permissions, TRUE);
    $user_view_permission = $this
      ->drupalCreateUser($permissions);

    // Create a user with only "registration self" permission to test with.
    $permissions = array(
      'create ' . $this->registration_type_name . ' registration self',
    );
    $this
      ->checkPermissions($permissions, TRUE);
    $user_register_self_permission = $this
      ->drupalCreateUser($permissions);

    // Create a user with no registration permissions to test with.
    $user_no_permission = $this
      ->drupalCreateUser();

    // #######################################################################.
    // Login as user with many permissions - create registration.
    // #######################################################################.
    $this
      ->drupalLogin($user);

    // Configure registration settings on host entity.
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
      'capacity' => 2,
      'settings' => array(
        'maximum_spaces' => 1,
      ),
    ));

    // Submit a Registration form as the user with
    // many registration permissions.
    $this
      ->drupalGet($this->host_entity_path . '/register');
    $this
      ->assertResponse(200, t('Register page loaded.'), 'Registration');
    $registration_form = array(
      'who_is_registering' => REGISTRATION_REGISTRANT_TYPE_ME,
    );
    $this
      ->drupalPost($this->host_entity_path . '/register', $registration_form, t('Save Registration'));
    $this
      ->assertText(t('Registration for'), t('Registration saved.'), 'Registration');

    // Load registration that was just created and it's ID to be used again.
    $registration_a_id = $this
      ->entityLastId('registration');
    $registration_a = entity_load_single('registration', $registration_a_id);

    // Check registration we just created does not allow user without
    // "register self" permission the option to register themself.
    $access_people = registration_access_people($registration_a, $user_no_permission);
    $this
      ->assertTrue(count($access_people) == 0, t('Check user with no registration permissions is not allowed to register.'));

    // Check user with permission to register only themself, can only register
    // themself.
    $access_people = registration_access_people($registration_a, $user_register_self_permission);
    $this
      ->assertTrue(isset($access_people[REGISTRATION_REGISTRANT_TYPE_ME]) && count($access_people) == 1, t('Check user that is allowed to register only self, can register only self.'));

    // Ensure registration reports having space available.
    // Capacity is set to 2 and only 1 user has registered.
    $this
      ->assertTrue(registration_has_room($this->host_entity_type, $this->host_entity_id), t('Space available'), 'Registration');

    // #######################################################################.
    // Login as user with only view permission.
    // #######################################################################.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($user_view_permission);

    // Ensure user with view permission can the registration we just created.
    $this
      ->drupalGet('registration/' . $registration_a_id);
    $this
      ->assertResponse(200, t('User with permission can view registration'), 'Registration');

    // #######################################################################.
    // Login as user with no permissions.
    // #######################################################################.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($user_no_permission);

    // User with no permission - try to create, view, edit, delete registration.
    // Expect failure for all attempted operations.
    $this
      ->drupalGet($this->host_entity_path . '/register');
    $this
      ->assertResponse(403, t('User without permission cannot create registration.'), 'Registration');
    $this
      ->drupalGet('registration/' . $registration_a_id);
    $this
      ->assertResponse(403, t('User without permission cannot view registration.'), 'Registration');
    $this
      ->drupalGet('registration/' . $registration_a_id . '/edit');
    $this
      ->assertResponse(403, t('User without permission cannot edit registration.'), 'Registration');
    $this
      ->drupalGet('registration/' . $registration_a_id . '/delete');
    $this
      ->assertResponse(403, t('User without permission cannot delete registration.'), 'Registration');

    // #######################################################################.
    // Test registered users - not necessary to be logged in as a particular
    // user for this section of assertions.
    // #######################################################################.
    // Create a duplicate copy of the registration and unset the ID because
    // registration_is_registered will exclude the passed registration.
    $registration_b = $registration_a;
    unset($registration_b->registration_id);
    $this
      ->assertFalse(registration_is_registered($registration_b, NULL, $user_register_self_permission->uid), t('User who did not register is not registered.'), 'Registration');
    $this
      ->assertTrue(registration_is_registered($registration_b, NULL, $user->uid), t('User who registered is registered.'), 'Registration');

    // #######################################################################.
    // Login as user with many permissions - edit, then delete registration.
    // #######################################################################.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($user);

    // Edit a registration.
    $this
      ->drupalGet('registration/' . $registration_a_id . '/edit');
    $this
      ->assertResponse(200, t('User can access registration edit page.'), 'Registration');
    $edit = array(
      'who_is_registering' => REGISTRATION_REGISTRANT_TYPE_USER,
      'user' => $user_no_permission->name,
    );
    $this
      ->drupalPost('registration/' . $registration_a_id . '/edit', $edit, t('Save Registration'));
    $this
      ->assertText(t('Registration for'), t('Registration form saved.'), 'Registration');
    $this
      ->resetRegistration();
    $registration_a = entity_load_single('registration', $registration_a_id);
    $this
      ->drupalGet('registration/' . $registration_a_id);
    $this
      ->assertEqual($registration_a->user_uid, $user_no_permission->uid, t('Changed user on registration edit form.'), 'Registration');

    // Delete a registration.
    $this
      ->drupalGet('registration/' . $registration_a_id . '/delete');
    $this
      ->assertResponse(200, 'User can access registration delete confirmation page.', 'Registration');
    $this
      ->drupalPost('registration/' . $registration_a_id . '/delete', array(), t('Delete'));
    $this
      ->resetRegistration();
    $this
      ->assertFalse(entity_load_single('registration', $registration_a_id), t('Deleted registration via form'), 'Registration');
  }
  function testRegistrationHostDelete() {
    $user_a = $this
      ->drupalCreateUser();
    $this
      ->drupalLogin($user_a);

    // Delete the host entity.
    $user_b = $this
      ->drupalCreateUser();
    $registration_a = $this
      ->createRegistration(array(
      'author_uid' => $user_a->uid,
      'user_uid' => $user_b->uid,
    ));
    entity_delete($this->host_entity_type, $this->host_entity_id);
    entity_get_controller($this->host_entity_type)
      ->resetCache();
    $this
      ->resetRegistration();
    $this
      ->assertFalse(entity_load_single($this->host_entity_type, $this->host_entity_id), t('Delete host entity.'), 'Registration');
    $this
      ->assertFalse(entity_load_single('registration', $registration_a->registration_id), t('Delete registration when host entity is deleted.'), 'Registration');
  }

  /**
   * Ensure registrations are processed when a user is cancelled.
   *
   * Tests authorship, and people association, of registrations.
   */
  function testUserCancel() {
    $admin = $this
      ->drupalCreateUser(array(
      'administer users',
    ));
    $this
      ->drupalLogin($admin);

    // Blocking a user.
    $user = $this
      ->drupalCreateUser();
    $registration = $this
      ->createRegistration(array(
      'author_uid' => $user->uid,
    ));
    $edit = array(
      'user_cancel_method' => 'user_cancel_block',
    );
    $this
      ->drupalPost('user/' . $user->uid . '/cancel', $edit, t('Cancel account'));
    $registration_reload = $this
      ->loadRegistration($registration->registration_id);
    $this
      ->assertTrue($registration_reload instanceof Registration, t('Blocking a user does not modify his registrations.'));

    // Reassign a users content.
    $user = $this
      ->drupalCreateUser();
    $registration_author = $this
      ->createRegistration(array(
      'author_uid' => $user->uid,
    ));
    $registration_people = $this
      ->createRegistration(array(
      'user_uid' => $user->uid,
    ));
    $edit = array(
      'user_cancel_method' => 'user_cancel_reassign',
    );
    $this
      ->drupalPost('user/' . $user->uid . '/cancel', $edit, t('Cancel account'));
    $registration_author_db = $this
      ->loadRegistration($registration_author->registration_id);
    $this
      ->assertTrue($registration_author_db->author_uid == 0, t('Cancelling user, and reassigning registrations he is author, to anonymous.'));
    $registration_people_db = $this
      ->loadRegistration($registration_people->registration_id);
    $this
      ->assertTrue($registration_people_db->user_uid == NULL, t('Cancelling user, and reassigning registrations he is associated, to anonymous.'));

    // Delete a users content.
    $user = $this
      ->drupalCreateUser();
    $registration_author = $this
      ->createRegistration(array(
      'author_uid' => $user->uid,
    ));
    $registration_people = $this
      ->createRegistration(array(
      'user_uid' => $user->uid,
    ));
    $edit = array(
      'user_cancel_method' => 'user_cancel_delete',
    );
    $this
      ->drupalPost('user/' . $user->uid . '/cancel', $edit, t('Cancel account'));
    $registration_author_db = $this
      ->loadRegistration($registration_author->registration_id);
    $this
      ->assertFalse($registration_author_db, t('Deleting user, deletes registrations he authored.'));
    $registration_people_db = $this
      ->loadRegistration($registration_people->registration_id);
    $this
      ->assertTrue($registration_people_db->user_uid == NULL, t('Deleting user, and reassigning registrations he is associated, to anonymous.'));
  }

}
class RegistrationAPITestCase extends RegistrationTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Registration API',
      'description' => 'Test hooks provided by Registration.',
      'group' => 'Registration',
    );
  }
  function setUp() {
    parent::setUp(array(
      'registration_test_api',
    ));
    $this
      ->setUpEntity();
  }

  /**
   * Test hook_registration_access().
   */
  function testHookAccess() {
    $account = $this
      ->drupalCreateUser();
    $crud = array(
      'create',
      'view',
      'update',
      'delete',
    );
    $registration_values = array(
      'user_uid' => $account->uid,
    );

    // Test hook.
    $registration = $this
      ->createRegistration($registration_values);
    $random = $this
      ->randomString();
    $registration->hook_registration_access = $random;
    $this
      ->assertEqual($random, module_invoke('registration_test_api', 'registration_access', 'view', $registration, $account), t('Manually invoke hook_registration_access()'), 'Registration');

    // Default access (none).
    foreach ($crud as $op) {
      $registration = $this
        ->createRegistration();
      $this
        ->assertFalse(entity_access($op, 'registration', $registration, $account), t('User cannot @op registration.', array(
        '@op' => $op,
      )), 'Registration');
    }

    // Force allow access.
    foreach ($crud as $op) {
      $registration = $this
        ->createRegistration($registration_values);
      $registration->hook_registration_access = TRUE;
      $this
        ->assertTrue(entity_access($op, 'registration', $registration, $account), t('User can @op registration.', array(
        '@op' => $op,
      )), 'Registration');
    }
  }

  /**
   * Test hook_registration_status().
   */
  function testHookStatus() {

    // Testing host status, no hook.
    $this
      ->setHostEntitySettings(array(
      'status' => 1,
    ));
    $this
      ->assertTrue(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is open.'), 'Registration');

    // Host main status is opened, hook closes.
    variable_set('registration_test_api_registration_status_alter', FALSE);
    $this
      ->assertFalse(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is open, hook overrides'), 'Registration');

    // Hook should still be invoked if main status is closed.
    $this
      ->setHostEntitySettings(array(
      'status' => 0,
    ));
    variable_set('registration_test_api_registration_status_alter', TRUE);
    $this
      ->assertTrue(registration_status($this->host_entity_type, $this->host_entity_id, TRUE), t('Host entity status is closed, hook overrides.'), 'Registration');
  }

}

Classes

Namesort descending Description
RegistrationAPITestCase
RegistrationStandardTestCase Creates a registration type Create node entity type ensure registration type exists
RegistrationTestCase @file Tests for the Registration module