class RegistrationStandardTestCase in Entity Registration 8.2

Creates a registration type Create node entity type ensure registration type exists

Hierarchy

• class \RegistrationTestCase extends \DrupalWebTestCase
  • class \RegistrationStandardTestCase

File

tests/registration.test, line 124

Tests for the Registration module

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,
      'registrant_id' => $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() {
    $user = \Drupal::currentUser();
    $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.
    end($registrations)->registration_id
      ->delete();
    $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 own ' . $this->registration_type_name . ' registration',
    );
    $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 own ' . $this->registration_type_name . ' registration',
    );

    // 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 "create own registration" permission to test with.
    $permissions = array(
      'create own ' . $this->registration_type_name . ' registration',
    );
    $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_SELF,
    );
    $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);

    // 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, $user_register_self_permission->mail), t('User who did not register is not registered.'), 'Registration');
    $this
      ->assertTrue(registration_is_registered($registration_b, $user->mail), 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_OTHER,
      'registrant_mail' => $user_no_permission->mail,
    );
    $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->registrant_id, $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,
      'registrant_id' => $user_b->uid,
    ));
    $this->host_entity_id
      ->delete();
    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(
      'registrant_id' => $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->registrant_id == 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(
      'registrant_id' => $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->registrant_id == NULL, t('Deleting user, and reassigning registrations he is associated, to anonymous.'));
  }

}

Members

Name	Modifiers	Type	Description	Overrides
RegistrationStandardTestCase::getInfo	public static	function
RegistrationStandardTestCase::setUp		function
RegistrationStandardTestCase::testHostEntityBroadcastForm		function	Tests email broadcast functionality.
RegistrationStandardTestCase::testHostEntitySettings		function	Tests entity update helper.
RegistrationStandardTestCase::testHostEntitySettingsForm		function
RegistrationStandardTestCase::testHostRegistrationStatus		function	Check internal status modifiers.
RegistrationStandardTestCase::testRegistrationCreateAccess		function
RegistrationStandardTestCase::testRegistrationFieldCreate		function	Tests if registration fields were created successfully, and associated with an entity.
RegistrationStandardTestCase::testRegistrationForm	public	function	Tests for the registration add/edit form.
RegistrationStandardTestCase::testRegistrationHostDelete		function
RegistrationStandardTestCase::testRegistrationType		function	Tests if registration type is set.
RegistrationStandardTestCase::testUserCancel		function	Ensure registrations are processed when a user is cancelled.
RegistrationTestCase::createRegistration		function	Create a Registration programmatically.
RegistrationTestCase::entityLastId		function
RegistrationTestCase::loadRegistration		function	Loads a registration from the database, avoiding the cache.
RegistrationTestCase::resetRegistration		function	Reset session cache of registration entities.
RegistrationTestCase::setHostEntitySettings		function
RegistrationTestCase::setUpEntity		function