Functional tests for OpenStack Telemetry plugin

Tests are added for default OpenstackTelemetry plugin configuration

Change-Id: I99f7d672f238df467d3c1fdb19c2813b0412abc6

stacklight_tests/helpers/helpers.py

@@ -14,6 +14,7 @@
 
 import os
 import re
+import signal
 import tempfile
 import time
 import urllib2
@@ -682,3 +683,73 @@ class PluginHelper(object):
                                               disk_format='qcow2',
                                               data=fp)
         return image
+
+    @staticmethod
+    def verify(secs, func, step='', msg='', action='', duration=1000,
+               sleep_for=10, *args, **kwargs):
+        """Arguments:
+        :secs: timeout time;
+        :func: function to be verified;
+        :step: number of test step;
+        :msg: message that will be displayed if an exception occurs;
+        :action: action that is performed by the method.
+        """
+        logger.info("STEP:{0}, verify action: '{1}'".format(step, action))
+        now = time.time()
+        time_out = now + duration
+        try:
+            with timeout(secs, action):
+                while now < time_out:
+                    result = func(*args, **kwargs)
+                    if result or result is None:
+                        return result
+                    logger.info(
+                        "{} is failed. Will try again".
+                        format(action)
+                    )
+                    time.sleep(sleep_for)
+                    now = time.time()
+        except Exception as exc:
+            logger.exception(exc)
+            if type(exc) is AssertionError:
+                msg = str(exc)
+            raise AssertionError(
+                "Step {} failed: {} Please refer to OpenStack logs for more "
+                "details.".format(step, msg)
+            )
+        else:
+            return result
+
+
+def _raise_TimeOut(sig, stack):
+    raise TimeoutException()
+
+
+class timeout(object):
+    """Timeout context that will stop code running within context
+    if timeout is reached
+
+    >>with timeout(2):
+    ...     requests.get("http://msdn.com")
+    """
+
+    def __init__(self, timeout, action):
+        self.timeout = timeout
+        self.action = action
+
+    def __enter__(self):
+        signal.signal(signal.SIGALRM, _raise_TimeOut)
+        signal.alarm(self.timeout)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        signal.alarm(0)  # disable the alarm
+        if exc_type is not TimeoutException:
+            return False  # never swallow other exceptions
+        else:
+            logger.info("Timeout {timeout}s exceeded for {call}".format(
+                call=self.action,
+                timeout=self.timeout
+            ))
+            msg = ("Time limit exceeded while waiting for {call} to "
+                   "finish.").format(call=self.action)
+            raise AssertionError(msg)

stacklight_tests/openstack_telemetry/api.py

@@ -11,7 +11,9 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+import datetime
 
+import ceilometerclient.v2.client
 from fuelweb_test.helpers import checkers as fuelweb_checkers
 from fuelweb_test import logger
 
@@ -25,6 +27,35 @@ from stacklight_tests.openstack_telemetry import plugin_settings
 class OpenstackTelemeteryPluginApi(base_test.PluginApi):
     def __init__(self):
         super(OpenstackTelemeteryPluginApi, self).__init__()
+        self._ceilometer = None
+
+    @property
+    def ceilometer_client(self):
+        if self._ceilometer is None:
+            keystone_access = self.helpers.os_conn.keystone
+            endpoint = keystone_access.service_catalog.url_for(
+                service_type='metering',
+                service_name='ceilometer',
+                endpoint_type='internalURL'
+            )
+            if not endpoint:
+                raise self.helpers.NotFound(
+                    "Cannot find Ceilometer endpoint")
+            aodh_endpoint = keystone_access.service_catalog.url_for(
+                service_type='alarming',
+                service_name='aodh',
+                endpoint_type='internalURL'
+            )
+            if not aodh_endpoint:
+                raise self.helpers.NotFound(
+                    "Cannot find AODH (alarm) endpoint")
+
+            self._ceilometer = ceilometerclient.v2.Client(
+                aodh_endpoint=aodh_endpoint,
+                auth_url=keystone_access.auth_url,
+                endpoint=endpoint,
+                token=lambda: keystone_access.auth_token)
+        return self._ceilometer
 
     def get_plugin_settings(self):
         return plugin_settings
@@ -97,3 +128,80 @@ class OpenstackTelemeteryPluginApi(base_test.PluginApi):
     def check_uninstall_failure(self):
         return self.helpers.check_plugin_cannot_be_uninstalled(
             self.settings.name, self.settings.version)
+
+    def check_ceilometer_sample_functionality(self):
+        fail_msg = 'Failed to get sample list.'
+        msg = 'getting samples list'
+        self.helpers.verify(60, self.ceilometer_client.new_samples.list, 1,
+                            fail_msg, msg, limit=10)
+
+        fail_msg = 'Failed to get statistic of metric.'
+        msg = 'getting statistic of metric'
+        an_hour_ago = (datetime.datetime.now() -
+                       datetime.timedelta(hours=1)).isoformat()
+        query = [{'field': 'timestamp', 'op': 'gt', 'value': an_hour_ago}]
+
+        self.helpers.verify(600, self.ceilometer_client.statistics.list, 2,
+                            fail_msg, msg, meter_name='image', q=query)
+
+    def check_ceilometer_alarm_functionality(self):
+        fail_msg = 'Failed to create alarm.'
+        msg = 'creating alarm'
+        alarm = self.helpers.verify(60, self.create_alarm, 1, fail_msg, msg,
+                                    meter_name='image',
+                                    threshold=0.9,
+                                    name='ceilometer-fake-alarm',
+                                    period=600,
+                                    statistic='avg',
+                                    comparison_operator='lt')
+
+        fail_msg = 'Failed to get alarm.'
+        msg = 'getting alarm'
+        self.helpers.verify(60, self.ceilometer_client.alarms.get, 2,
+                            fail_msg, msg, alarm_id=alarm.alarm_id)
+
+        fail_msg = 'Failed while waiting for alarm state to become "ok".'
+        msg = 'waiting for alarm state to become "ok"'
+        self.helpers.verify(1000, self.check_alarm_state, 3,
+                            fail_msg, msg, alarm_id=alarm.alarm_id, state='ok')
+
+        fail_msg = 'Failed to update alarm.'
+        msg = 'updating alarm'
+        self.helpers.verify(60, self.ceilometer_client.alarms.update, 4,
+                            fail_msg, msg, alarm_id=alarm.alarm_id,
+                            threshold=1.1)
+
+        fail_msg = 'Failed while waiting for alarm state to become "alarm".'
+        msg = 'waiting for alarm state to become "alarm"'
+        self.helpers.verify(1000, self.check_alarm_state, 5,
+                            fail_msg, msg, alarm_id=alarm.alarm_id,
+                            state='alarm')
+
+        fail_msg = 'Failed to get alarm history.'
+        msg = 'getting alarm history'
+        self.helpers.verify(60, self.ceilometer_client.alarms.get_history, 6,
+                            fail_msg, msg, alarm_id=alarm.alarm_id)
+
+        fail_msg = 'Failed to delete alarm.'
+        msg = 'deleting alarm'
+        self.helpers.verify(60, self.ceilometer_client.alarms.delete, 7,
+                            fail_msg, msg, alarm_id=alarm.alarm_id)
+
+    def create_alarm(self, **kwargs):
+        for alarm in self.ceilometer_client.alarms.list():
+            if alarm.name == kwargs['name']:
+                self.ceilometer_client.alarms.delete(alarm.alarm_id)
+        return self.ceilometer_client.alarms.create(**kwargs)
+
+    def check_alarm_state(self, alarm_id, state=None):
+        try:
+            alarm_state = self.ceilometer_client.alarms.get_state(
+                alarm_id)
+        except Exception:
+            alarm_state = None
+        if state:
+            if alarm_state == state:
+                return True
+        elif alarm_state == 'alarm' or 'ok':
+            return True
+        return False

stacklight_tests/toolchain/test_openstack_telemetry.py

@@ -61,3 +61,26 @@ class TestOpenstackTelemetry(api.ToolchainApi):
         self.check_plugins_online()
         self.helpers.run_ostf()
         self.env.make_snapshot("deploy_openstack_telemetry", is_make=True)
+
+
+@test(groups=["openstack_telemetry"])
+class TestOpenstackTelemetryFunctional(api.ToolchainApi):
+    """Class for functional testing the Openstack Telemetry Plugin."""
+
+    @test(depends_on_groups=['deploy_openstack_telemetry'],
+          groups=["openstack_telemetry_default_functional", "functional"])
+    def openstack_telemetry_default_functional(self):
+        """Deploy an environment with Openstack-Telemetry plugin with
+        Elasticsearch and InfluxDB backends and check default functionality
+
+            1. Revert deploy_openstack_telemetry with Openstack-Telemetry,
+            Elasticsearch-Kibana and InfluxDB-Grafana plugins installed
+            2. Check Ceilometer Sample API
+            3. Check Ceilometer Alarm API
+
+        Duration 90m
+        """
+        self.check_run("openstack_telemetry_default_functional")
+        self.env.revert_snapshot("deploy_openstack_telemetry")
+        self.OPENSTACK_TELEMETRY.check_ceilometer_sample_functionality()
+        self.OPENSTACK_TELEMETRY.check_ceilometer_alarm_functionality()