sms_valid.test in SMS Framework 7

Contains tests for the functions in sms.module and core sms framework.

File

modules/sms_valid/sms_valid.test

<?php

/**
 * @file
 * Contains tests for the functions in sms.module and core sms framework.
 */

/**
 * Provides unit tests for SMS Valid validation functions.
 */
class SmsValidWebTest extends DrupalWebTestCase {
  protected $adminUser;
  public static function getInfo() {
    return array(
      'name' => 'SMS Valid Web Test',
      'description' => 'Tests for the SMS Valid module.',
      'group' => 'SMS Framework',
    );
  }

  /**
   * {@inheritdoc}
   */
  public function setUp() {
    parent::setUp('sms', 'sms_valid');
    $this->adminUser = $this
      ->drupalCreateUser(array(
      'administer smsframework',
    ));
  }

  /**
   * Tests the sms_valid_validate() function.
   */
  public function testSmsValidValidate() {

    // Test that the default rulesets are added already.
    $this
      ->drupalLogin($this->adminUser);
    $this
      ->drupalGet('admin/smsframework/validation/rulesets');
    $this
      ->assertText('New Zealand', 'Default ruleset found in list view.');
    $test_numbers = array(
      '1234567890' => false,
      '123458767890' => false,
      '64219427-9238' => true,
      '6425=-,x2-4n292' => false,
      '6429;ajklf a/s,MFA' => true,
      '] W[OPQIRW' => false,
      '6429996789065' => true,
      '6428156789098765' => true,
    );

    // Test direct validation.
    $options = array(
      'test' => true,
    );
    foreach ($test_numbers as $number => $valid) {
      $result = sms_valid_validate($number, $options);
      $this
        ->assertEqual($valid, empty($result['errors']), 'Direct test: Number validation ok for ' . $number);
    }

    // Test through hook_sms_validate_number().
    foreach ($test_numbers as $number => $valid) {
      $errors = sms_validate_number($number, $options);
      $this
        ->assertEqual($valid, empty($errors), 'Hook test: Number validation ok for ' . $number);
    }
  }

  /**
   * Tests the creation, update and deletion of sms_valid rulesets.
   */
  public function testCrudSmsValidRulesets() {
    $this
      ->drupalLogin($this->adminUser);

    // Create a new ruleset.
    $edit = array(
      'prefix' => (string) rand(1, 999),
      'name' => $this
        ->randomName(15),
      'iso2' => 'AU',
      'out' => true,
      'in' => true,
      'rules' => "80+\n90-\n70\n65+\n",
    );
    $this
      ->drupalPost('admin/smsframework/validation/ruleset', $edit, t('Save Ruleset'));

    // Confirm that ruleset was correctly saved.
    $ruleset = sms_valid_get_ruleset($edit['prefix']);
    $original = array(
      'rules' => sms_valid_text_to_rules($edit['rules']),
      'dirs_enabled' => sms_dir($edit['out'], $edit['in']),
    ) + $edit;
    unset($original['in'], $original['out']);
    $this
      ->assertEqual($original, $ruleset, 'Ruleset ' . $edit['prefix'] . ' correctly saved.');

    // Update ruleset.
    $edit['in'] = false;
    $edit['out'] = false;
    $this
      ->drupalPost('admin/smsframework/validation/ruleset/' . $edit['prefix'], $edit, t('Save Ruleset'));
    $ruleset = sms_valid_get_ruleset($edit['prefix']);
    $this
      ->assertEqual('0', $ruleset['dirs_enabled'], 'Ruleset ' . $edit['prefix'] . ' updated');

    // Change direction settings from list page.
    $direction_change = array(
      $edit['prefix'] . '_in' => true,
      $edit['prefix'] . '_out' => true,
    );
    $this
      ->drupalPost('admin/smsframework/validation/rulesets', $direction_change, t('Save Changes'));
    $ruleset = sms_valid_get_ruleset($edit['prefix']);
    $this
      ->assertEqual($ruleset['dirs_enabled'], SMS_DIR_ALL, 'Directionality for ' . $edit['prefix'] . ' changed from list page');

    // Add another test ruleset and then check the ruleset load button.
    $edit1 = array(
      'prefix' => (string) rand(1, 999),
      'name' => $this
        ->randomName(15),
    ) + $edit;
    $this
      ->drupalPost('admin/smsframework/validation/ruleset', $edit1, t('Save Ruleset'));
    $this
      ->drupalPost('admin/smsframework/validation/ruleset', array(
      'select_prefix' => $edit1['prefix'],
    ), t('Refresh Editor (below)'));
    $this
      ->assertText($edit1['name'], 'Editor refresh button works.');

    // Delete ruleset.
    $delete = array(
      $edit['prefix'] . '_delete' => true,
    );
    $this
      ->drupalPost('admin/smsframework/validation/rulesets', $delete, t('Save Changes'));
    $this
      ->assertFalse(sms_valid_get_ruleset($edit['prefix']), 'Ruleset ' . $edit['prefix'] . ' deleted');
  }

  /**
   * Tests the application of the sms_valid settings form and settings.
   */
  public function testSmsValidSettingsForm() {

    // Create two rulesets for test.
    $ruleset = $this
      ->randomRuleset();
    $ruleset['prefix'] = '991';
    $ruleset['rules'] = sms_valid_text_to_rules("23- # Explicit deny 23");
    sms_valid_save_ruleset($ruleset);
    $ruleset = $this
      ->randomRuleset();
    $ruleset['prefix'] = '234';
    $ruleset['rules'] = sms_valid_text_to_rules("56+ # Explicit allow 56");
    sms_valid_save_ruleset($ruleset);

    // Update settings.
    $edit = array(
      'mode' => 1,
      'global_ruleset' => '64',
      'local_number_prefix' => '0',
      'local_number_ruleset' => '234',
      'last_resort_enabled' => true,
      'last_resort_ruleset' => '991',
    );
    $this
      ->drupalLogin($this->adminUser);
    $this
      ->drupalPost('admin/smsframework/validation', $edit, t('Save settings'));

    // Confirm settings were updated correctly.
    $this
      ->assertTrue(variable_get('sms_valid_use_rulesets'), 'Use rulesets correctly set.');
    $this
      ->assertFalse(variable_get('sms_valid_use_global_ruleset'), 'Use rulesets correctly set.');
    $this
      ->assertEqual('64', variable_get('sms_valid_global_ruleset'), 'Global ruleset correctly set.');
    $this
      ->assertEqual('0', variable_get('sms_valid_local_number_prefix', -1), 'Local number prefix correctly set.');
    $this
      ->assertEqual('234', variable_get('sms_valid_local_number_ruleset'), 'Local number ruleset correctly set.');
    $this
      ->assertTrue(variable_get('sms_valid_last_resort_enabled'), 'Last resort option correctly set.');
    $this
      ->assertEqual('991', variable_get('sms_valid_last_resort_ruleset'), 'Last resort ruleset correctly set.');

    // Use specific ruleset.
    $result = sms_valid_validate('2345678901234', array(
      'prefix' => '991',
    ));
    $this
      ->assertFalse($result['pass'], 'Specific ruleset caused fail.');
    $result = sms_valid_validate('2345678901234', array(
      'prefix' => '234',
    ));
    $this
      ->assertTrue($result['pass'], 'Specific ruleset caused pass.');

    // Use global ruleset.
    variable_set('sms_valid_use_global_ruleset', true);
    variable_set('sms_valid_global_ruleset', '234');
    $result = sms_valid_validate('2345678901234');
    $this
      ->assertFalse($result['pass'], 'Global ruleset "234" applied to valid number');
    $result = sms_valid_validate('9915678901234');
    $this
      ->assertFalse($result['pass'], 'Global ruleset "234" applied to invalid number');

    // Local number validation.
    $ruleset = $this
      ->randomRuleset();
    $ruleset['prefix'] = '419';
    $ruleset['rules'] = sms_valid_text_to_rules("80- # Explicit deny 80\n90+ # Explicit allow 90");
    sms_valid_save_ruleset($ruleset);
    variable_set('sms_valid_local_number_prefix', '0');
    variable_set('sms_valid_local_number_ruleset', '419');
    variable_set('sms_valid_use_global_ruleset', false);
    $result = sms_valid_validate('08078901234');
    $this
      ->assertFalse($result['pass'], 'Local number validation failed as expected for 08078901234');
    $result = sms_valid_validate('09078901234');
    $this
      ->assertTrue($result['pass'], 'Local number validation passed as expected for 09078901234');

    // Last resort ruleset.
    $ruleset = sms_valid_get_ruleset('991');
    $ruleset['rules'] = sms_valid_text_to_rules("2- # Explicit deny (2...)\n1+ # Explicit allow (1...)");
    sms_valid_save_ruleset($ruleset);
    variable_set('sms_valid_use_global_ruleset', false);
    variable_set('sms_valid_last_resort_enabled', true);
    variable_set('sms_valid_last_resort_ruleset', '991');
    $result = sms_valid_validate('2189751234');
    $this
      ->assertFalse($result['pass'], 'Fallback rule validation failed as expected for 2189751234');
    $result = sms_valid_validate('1189751234');
    $this
      ->assertTrue($result['pass'], 'Fallback rule validation passed as expected for 1189751234');
  }

  /**
   * Tests the internal sms_valid functions.
   */
  public function testSmsValidFunctions() {

    // Clear all rulesets.
    $count = count(sms_valid_get_all_rulesets());
    $ruleset1 = $this
      ->randomRuleset();
    $ruleset1['iso2'] = 'AU';
    $ruleset1['rules'] = sms_valid_text_to_rules("80- # Test 1\n90+ # Test 2");
    sms_valid_save_ruleset($ruleset1);
    $ruleset2 = $this
      ->randomRuleset();
    $ruleset2['iso2'] = 'AU';
    $ruleset2['rules'] = sms_valid_text_to_rules("81- # Test 1\n91+ # Test 2");
    sms_valid_save_ruleset($ruleset2);
    $new_rulesets = sms_valid_get_all_rulesets();
    $this
      ->assertEqual(2, count($new_rulesets) - $count, 'All new rulesets found.');
    $this
      ->assertEqual($ruleset2, (array) $new_rulesets[$ruleset2['prefix']], 'sms_valid_get_all_rulesets() functional.');
    $this
      ->assertEqual(sms_valid_get_ruleset($ruleset1['prefix']), $ruleset1, 'sms_valid_get_ruleset() functional.');
    $rules = sms_valid_rules_to_text($ruleset2['rules']);
    $this
      ->assertEqual($rules, "81-    # Test 1\n91+    # Test 2", 'Rules converted to text.');
    $rules = sms_valid_text_to_rules($rules);
    $this
      ->assertEqual($rules, $ruleset2['rules'], 'Rules converted from text.');
    $this
      ->assertEqual($ruleset2, sms_valid_get_ruleset_for_number($ruleset2['prefix'] . '98765432'), 'Found right ruleset for ' . $ruleset2['prefix'] . '98765432');

    // @todo This test may fail at random times.
    $this
      ->assertFalse(sms_valid_get_ruleset_for_number('876298765432'), 'No ruleset for 876298765432');

    // php array comparison needs sorting.
    $expected = array(
      $ruleset1['prefix'],
      $ruleset2['prefix'],
    );
    $actual = sms_valid_get_prefixes_for_iso2('AU');
    sort($expected);
    sort($actual);
    $this
      ->assertEqual($expected, $actual, 'sms_valid_get_prefixes_for_iso2() functional.');

    // Set status.
    sms_valid_ruleset_set_status($ruleset1['prefix'], SMS_DIR_ALL);
    $ruleset = sms_valid_get_ruleset($ruleset1['prefix']);
    $this
      ->assertEqual(SMS_DIR_ALL, $ruleset['dirs_enabled'], 'sms_valid_ruleset_set_status() functional.');

    // Local number check.
    variable_set('sms_valid_local_number_prefix', '0');
    $this
      ->assertTrue(sms_valid_is_local_number('08032149857'), 'Local number check passes.');
    $this
      ->assertFalse(sms_valid_is_local_number('8032149857'), 'Local number check passes.');
  }

  /**
   * Creates a random ruleset.
   */
  protected function randomRuleset() {
    $ruleset = array(
      'prefix' => (string) rand(1, 999),
      'name' => $this
        ->randomName(),
      'dirs_enabled' => 4,
      'iso2' => strtoupper($this
        ->randomName(1) . $this
        ->randomName(1)),
    );

    // Populate random rules.
    for ($i = 0; $i < rand(0, 10); $i++) {
      $ruleset['rules'][rand(1, 99)] = array(
        'allow' => rand(1, 10) > 5,
        'comment' => $this
          ->randomString(),
      );
    }
    return $ruleset;
  }

}

Classes

Name	Description
SmsValidWebTest	Provides unit tests for SMS Valid validation functions.