function MonitoringApiTest::testAPI in Monitoring 7

Test the base class if info is set and passed correctly.

File

test/tests/monitoring.api.test, line 34

Contains \MonitoringApiTest.

Class

MonitoringApiTest

Tests for Monitoring API.

Code

function testAPI() {

  // == Test sensor info. == //
  // @todo - complete the sensor info tests in followup.
  $sensor_info_data = array(
    'label' => 'Test sensor info',
    'description' => 'To test correct sensor info hook implementation precedence.',
    'settings' => array(),
  );
  variable_set('monitoring_test_sensor_info', $sensor_info_data);
  $this->sensorManager
    ->resetCache();
  $sensor_info = $this->sensorManager
    ->getSensorInfoByName('test_sensor_info');
  $this
    ->assertEqual($sensor_info
    ->getLabel(), $sensor_info_data['label']);
  $this
    ->assertEqual($sensor_info
    ->getDescription(), $sensor_info_data['description']);

  // @todo - add tests for compulsory sensor info attributes.
  // Test all defaults.
  // Flag numeric should default to TRUE.
  $this
    ->assertEqual($sensor_info
    ->isNumeric(), TRUE);

  // @todo - add tests for default values of attributes.
  // @todo - override remaining attributes.
  $sensor_info_data['numeric'] = FALSE;

  // Define custom value label and NO value type. In this setup the sensor
  // defined value label must be used.
  $sensor_info_data['value_label'] = 'Test label';
  variable_set('monitoring_test_sensor_info', $sensor_info_data);
  $this->sensorManager
    ->resetCache();
  $sensor_info = $this->sensorManager
    ->getSensorInfoByName('test_sensor_info');

  // Test all custom defined.
  // Flag numeric must be false.
  $this
    ->assertEqual($sensor_info
    ->isNumeric(), FALSE);
  $this
    ->assertEqual($sensor_info
    ->getValueLabel(), $sensor_info_data['value_label']);

  // @todo - add tests for overridden values of attributes.
  // Test value label provided by the monitoring_value_types().
  // Set the value type to one defined by the monitoring_value_types().
  $sensor_info_data['value_type'] = 'time_interval';
  unset($sensor_info_data['value_label']);
  variable_set('monitoring_test_sensor_info', $sensor_info_data);
  $this->sensorManager
    ->resetCache();
  $sensor_info = $this->sensorManager
    ->getSensorInfoByName('test_sensor_info');
  $value_types = monitoring_value_types();
  $this
    ->assertEqual($sensor_info
    ->getValueLabel(), $value_types['time_interval']['label']);

  // == Test basic sensor infrastructure - value, status and message. == //
  $test_sensor_result_data = array(
    'sensor_value' => 3,
    'sensor_status' => SensorResultInterface::STATUS_OK,
    'sensor_message' => 'All OK',
    'execution_time' => 1,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = $this
    ->runSensor('test_sensor');
  $this
    ->assertTrue($result
    ->getExecutionTime() > 0);
  $this
    ->assertEqual($result
    ->getStatus(), $test_sensor_result_data['sensor_status']);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 3, ' . $test_sensor_result_data['sensor_message']);
  $this
    ->assertEqual($result
    ->getValue(), $test_sensor_result_data['sensor_value']);

  // == Test sensor result cache == //
  // Test cached result
  $result_cached = monitoring_sensor_run('test_sensor');
  $this
    ->assertTrue($result_cached
    ->isCached());
  $this
    ->assertEqual($result_cached
    ->getTimestamp(), REQUEST_TIME);
  $this
    ->assertEqual($result_cached
    ->getStatus(), $test_sensor_result_data['sensor_status']);
  $this
    ->assertEqual($result_cached
    ->getMessage(), 'Value 3, ' . $test_sensor_result_data['sensor_message']);
  $this
    ->assertEqual($result_cached
    ->getValue(), $test_sensor_result_data['sensor_value']);

  // Call a setter method to invalidate cache and reset values.
  $result_cached
    ->setValue(5);
  $this
    ->assertFalse($result_cached
    ->isCached());

  // == Non-existing sensor error handling == //
  // Trying to fetch information for a non-existing sensor or trying to
  // execute such a sensor must throw an exception.
  try {
    $this->sensorManager
      ->getSensorInfoByName('non_existing_sensor');
    $this
      ->fail('Expected exception for non-existing sensor not thrown.');
  } catch (NonExistingSensorException $e) {
    $this
      ->pass('Expected exception for non-existing sensor thrown.');
  }
  try {
    monitoring_sensor_run('non_existing_sensor');
    $this
      ->fail('Expected exception for non-existing sensor not thrown.');
  } catch (NonExistingSensorException $e) {
    $this
      ->pass('Expected exception for non-existing sensor thrown.');
  }

  // == Test disabled sensor. == //
  // Disable a sensor.
  $this->sensorManager
    ->disableSensor('test_sensor');

  // Running a disabled sensor must throw an exception.
  try {
    monitoring_sensor_run('test_sensor');
    $this
      ->fail('Expected exception for disabled sensor not thrown.');
  } catch (DisabledSensorException $e) {
    $this
      ->pass('Expected exception for disabled sensor thrown.');
  }

  // Enable the sensor again.
  $this->sensorManager
    ->enableSensor('test_sensor');
  $result = monitoring_sensor_run('test_sensor');
  $this
    ->assertTrue($result instanceof SensorResultInterface);

  // == Test settings. == //
  // == inner_interval gives error statuses.
  // Test for OK values.
  $test_sensor_result_data = array(
    'sensor_value' => 11,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_inner', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_OK);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 11');
  $test_sensor_result_data = array(
    'sensor_value' => 0,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_inner', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_OK);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 0');

  // Test for warning values.
  $test_sensor_result_data = array(
    'sensor_value' => 7,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_inner', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_WARNING);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 7, violating the interval @expected', array(
    '@expected' => '1 - 9',
  )));
  $test_sensor_result_data = array(
    'sensor_value' => 2,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_inner', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_WARNING);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 2, violating the interval @expected', array(
    '@expected' => '1 - 9',
  )));

  // Test for critical values.
  $test_sensor_result_data = array(
    'sensor_value' => 5,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_inner', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_CRITICAL);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 5, violating the interval @expected', array(
    '@expected' => '4 - 6',
  )));
  $test_sensor_result_data = array(
    'sensor_value' => 5,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_inner', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_CRITICAL);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 5, violating the interval @expected', array(
    '@expected' => '4 - 6',
  )));

  // == outer_intervals give error statuses.
  // Test for ok values.
  $test_sensor_result_data = array(
    'sensor_value' => 75,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_outer', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_OK);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 75');
  $test_sensor_result_data = array(
    'sensor_value' => 71,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_outer', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_OK);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 71');

  // Test for warning values.
  $test_sensor_result_data = array(
    'sensor_value' => 69,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_outer', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_WARNING);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 69, outside the allowed interval @expected', array(
    '@expected' => '70 - 80',
  )));
  $test_sensor_result_data = array(
    'sensor_value' => 65,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_outer', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_WARNING);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 65, outside the allowed interval @expected', array(
    '@expected' => '70 - 80',
  )));

  // Test for critical values.
  $test_sensor_result_data = array(
    'sensor_value' => 55,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_outer', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_CRITICAL);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 55, outside the allowed interval @expected', array(
    '@expected' => '60 - 90',
  )));
  $test_sensor_result_data = array(
    'sensor_value' => 130,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_outer', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_CRITICAL);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 130, outside the allowed interval @expected', array(
    '@expected' => '60 - 90',
  )));

  // == Exceeds interval gives error statuses.
  $test_sensor_result_data = array(
    'sensor_value' => 4,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_exceeds', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_OK);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 4');
  $test_sensor_result_data = array(
    'sensor_value' => 6,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_exceeds', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_WARNING);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 6, exceeds @expected', array(
    '@expected' => '5',
  )));
  $test_sensor_result_data = array(
    'sensor_value' => 14,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_exceeds', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_CRITICAL);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 14, exceeds @expected', array(
    '@expected' => '10',
  )));

  // == Falls interval gives error statuses.
  $test_sensor_result_data = array(
    'sensor_value' => 12,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_falls', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_OK);
  $this
    ->assertEqual($result
    ->getMessage(), 'Value 12');
  $test_sensor_result_data = array(
    'sensor_value' => 9,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_falls', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_WARNING);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 9, falls below @expected', array(
    '@expected' => '10',
  )));
  $test_sensor_result_data = array(
    'sensor_value' => 3,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = monitoring_sensor_run('test_sensor_falls', TRUE);
  $this
    ->assertEqual($result
    ->getStatus(), SensorResultInterface::STATUS_CRITICAL);
  $this
    ->assertEqual($result
    ->getMessage(), t('Value 3, falls below @expected', array(
    '@expected' => '5',
  )));

  // Test the case when sensor value is not set.
  $test_sensor_result_data = array(
    'sensor_value' => NULL,
    'sensor_status' => SensorResultInterface::STATUS_CRITICAL,
  );
  variable_set('test_sensor_result_data', $test_sensor_result_data);
  $result = $this
    ->runSensor('test_sensor');
  $this
    ->assertNull($result
    ->getValue());

  // Test variable-based overrides.
  global $conf;
  $conf['monitoring_sensor_info']['test_sensor'] = array(
    'label' => 'Overridden sensor',
    'settings' => array(
      'caching_time' => 1,
      'new setting' => 'example value',
    ),
  );
  monitoring_sensor_manager()
    ->resetCache();
  $info = $this->sensorManager
    ->getSensorInfoByName('test_sensor');
  $this
    ->assertEqual('Overridden sensor', $info
    ->getLabel());
  $this
    ->assertEqual(1, $info
    ->getSetting('caching_time'));
  $this
    ->assertEqual('example value', $info
    ->getSetting('new setting'));
}