# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # 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 os from oslo.config import cfg from heat.api.aws import exception import heat.api.cloudwatch.watch as watches from heat.common import policy from heat.common import wsgi from heat.rpc import api as rpc_api from heat.rpc import client as rpc_client from heat.tests import common from heat.tests import utils class WatchControllerTest(common.HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def _dummy_GET_request(self, params=None): # Mangle the params dict into a query string params = params or {} qs = "&".join(["=".join([k, str(params[k])]) for k in params]) environ = {'REQUEST_METHOD': 'GET', 'QUERY_STRING': qs} req = wsgi.Request(environ) req.context = utils.dummy_context() return req # The tests def test_reformat_dimensions(self): dims = [{'StackId': u'21617058-781e-4262-97ab-5f9df371ee52', 'Foo': 'bar'}] self.assertEqual([{'Name': 'StackId', 'Value': u'21617058-781e-4262-97ab-5f9df371ee52'}, {'Name': 'Foo', 'Value': 'bar'}], self.controller._reformat_dimensions(dims) ) def test_enforce_default(self): self.m.ReplayAll() params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) self.controller.policy.policy_path = None response = self.controller._enforce(dummy_req, 'ListMetrics') self.assertIsNone(response) self.m.VerifyAll() def test_enforce_denied(self): self.m.ReplayAll() params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) dummy_req.context.roles = ['heat_stack_user'] self.controller.policy.policy_path = (self.policy_path + 'deny_stack_user.json') self.assertRaises(exception.HeatAccessDeniedError, self.controller._enforce, dummy_req, 'ListMetrics') self.m.VerifyAll() def test_enforce_ise(self): params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) dummy_req.context.roles = ['heat_stack_user'] self.m.StubOutWithMock(policy.Enforcer, 'enforce') policy.Enforcer.enforce(dummy_req.context, 'ListMetrics' ).AndRaise(AttributeError) self.m.ReplayAll() self.controller.policy.policy_path = (self.policy_path + 'deny_stack_user.json') self.assertRaises(exception.HeatInternalFailureError, self.controller._enforce, dummy_req, 'ListMetrics') self.m.VerifyAll() def test_delete(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DeleteAlarms'} dummy_req = self._dummy_GET_request(params) result = self.controller.delete_alarms(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_describe_alarm_history(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DescribeAlarmHistory'} dummy_req = self._dummy_GET_request(params) result = self.controller.describe_alarm_history(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_describe_all(self): watch_name = None # Get all watches # Format a dummy GET request to pass into the WSGI handler params = {'Action': 'DescribeAlarms'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'state_updated_time': u'2012-08-30T14:13:21Z', u'stack_id': u'21617058-781e-4262-97ab-5f9df371ee52', u'period': u'300', u'actions': [u'WebServerRestartPolicy'], u'topic': None, u'periods': u'1', u'statistic': u'SampleCount', u'threshold': u'2', u'unit': None, u'state_reason': None, u'dimensions': [], u'namespace': u'system/linux', u'state_value': u'NORMAL', u'ok_actions': None, u'description': u'Restart the WikiDatabase', u'actions_enabled': None, u'state_reason_data': None, u'insufficient_actions': None, u'metric_name': u'ServiceFailure', u'comparison': u'GreaterThanThreshold', u'name': u'HttpFailureAlarm', u'updated_time': u'2012-08-30T14:10:46Z'}] self.m.StubOutWithMock(rpc_client.EngineClient, 'call') rpc_client.EngineClient.call( dummy_req.context, ('show_watch', {'watch_name': watch_name}) ).AndReturn(engine_resp) self.m.ReplayAll() expected = {'DescribeAlarmsResponse': {'DescribeAlarmsResult': {'MetricAlarms': [ {'EvaluationPeriods': u'1', 'StateReasonData': None, 'AlarmArn': None, 'StateUpdatedTimestamp': u'2012-08-30T14:13:21Z', 'AlarmConfigurationUpdatedTimestamp': u'2012-08-30T14:10:46Z', 'AlarmActions': [u'WebServerRestartPolicy'], 'Threshold': u'2', 'AlarmDescription': u'Restart the WikiDatabase', 'Namespace': u'system/linux', 'Period': u'300', 'StateValue': u'NORMAL', 'ComparisonOperator': u'GreaterThanThreshold', 'AlarmName': u'HttpFailureAlarm', 'Unit': None, 'Statistic': u'SampleCount', 'StateReason': None, 'InsufficientDataActions': None, 'OKActions': None, 'MetricName': u'ServiceFailure', 'ActionsEnabled': None, 'Dimensions': [{'Name': 'StackId', 'Value': u'21617058-781e-4262-97ab-5f9df371ee52'}] }]}}} # Call the list controller function and compare the response self.assertEqual(expected, self.controller.describe_alarms(dummy_req)) def test_describe_alarms_for_metric(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DescribeAlarmsForMetric'} dummy_req = self._dummy_GET_request(params) result = self.controller.describe_alarms_for_metric(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_disable_alarm_actions(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DisableAlarmActions'} dummy_req = self._dummy_GET_request(params) result = self.controller.disable_alarm_actions(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_enable_alarm_actions(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'EnableAlarmActions'} dummy_req = self._dummy_GET_request(params) result = self.controller.enable_alarm_actions(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_get_metric_statistics(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'GetMetricStatistics'} dummy_req = self._dummy_GET_request(params) result = self.controller.get_metric_statistics(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_list_metrics_all(self): params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response # We dummy three different metrics and namespaces to test # filtering by parameter engine_resp = [{u'timestamp': u'2012-08-30T15:09:02Z', u'watch_name': u'HttpFailureAlarm', u'namespace': u'system/linux', u'metric_name': u'ServiceFailure', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:10:03Z', u'watch_name': u'HttpFailureAlarm2', u'namespace': u'system/linux2', u'metric_name': u'ServiceFailure2', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:16:03Z', u'watch_name': u'HttpFailureAlar3m', u'namespace': u'system/linux3', u'metric_name': u'ServiceFailure3', u'data': {u'Units': u'Counter', u'Value': 1}}] self.m.StubOutWithMock(rpc_client.EngineClient, 'call') # Current engine implementation means we filter in the API # and pass None/None for namespace/watch_name which returns # all metric data which we post-process in the API rpc_client.EngineClient.call( dummy_req.context, ('show_watch_metric', {'metric_namespace': None, 'metric_name': None}) ).AndReturn(engine_resp) self.m.ReplayAll() expected = {'ListMetricsResponse': {'ListMetricsResult': {'Metrics': [{'Namespace': u'system/linux', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:09:02Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure'}, {'Namespace': u'system/linux2', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm2'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:10:03Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure2'}, {'Namespace': u'system/linux3', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlar3m'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:16:03Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure3'}]}}} # First pass no query paramters filtering, should get all three self.assertEqual(expected, self.controller.list_metrics(dummy_req)) def test_list_metrics_filter_name(self): # Add a MetricName filter, so we should only get one of the three params = {'Action': 'ListMetrics', 'MetricName': 'ServiceFailure'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response # We dummy three different metrics and namespaces to test # filtering by parameter engine_resp = [{u'timestamp': u'2012-08-30T15:09:02Z', u'watch_name': u'HttpFailureAlarm', u'namespace': u'system/linux', u'metric_name': u'ServiceFailure', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:10:03Z', u'watch_name': u'HttpFailureAlarm2', u'namespace': u'system/linux2', u'metric_name': u'ServiceFailure2', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:16:03Z', u'watch_name': u'HttpFailureAlar3m', u'namespace': u'system/linux3', u'metric_name': u'ServiceFailure3', u'data': {u'Units': u'Counter', u'Value': 1}}] self.m.StubOutWithMock(rpc_client.EngineClient, 'call') # Current engine implementation means we filter in the API # and pass None/None for namespace/watch_name which returns # all metric data which we post-process in the API rpc_client.EngineClient.call( dummy_req.context, ('show_watch_metric', {'metric_namespace': None, 'metric_name': None}) ).AndReturn(engine_resp) self.m.ReplayAll() expected = {'ListMetricsResponse': {'ListMetricsResult': {'Metrics': [{'Namespace': u'system/linux', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:09:02Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure'}]}}} # First pass no query paramters filtering, should get all three self.assertEqual(expected, self.controller.list_metrics(dummy_req)) def test_list_metrics_filter_namespace(self): # Add a Namespace filter and change the engine response so # we should get two responses params = {'Action': 'ListMetrics', 'Namespace': 'atestnamespace/foo'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response # We dummy three different metrics and namespaces to test # filtering by parameter engine_resp = [{u'timestamp': u'2012-08-30T15:09:02Z', u'watch_name': u'HttpFailureAlarm', u'namespace': u'atestnamespace/foo', u'metric_name': u'ServiceFailure', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:10:03Z', u'watch_name': u'HttpFailureAlarm2', u'namespace': u'atestnamespace/foo', u'metric_name': u'ServiceFailure2', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:16:03Z', u'watch_name': u'HttpFailureAlar3m', u'namespace': u'system/linux3', u'metric_name': u'ServiceFailure3', u'data': {u'Units': u'Counter', u'Value': 1}}] self.m.StubOutWithMock(rpc_client.EngineClient, 'call') # Current engine implementation means we filter in the API # and pass None/None for namespace/watch_name which returns # all metric data which we post-process in the API rpc_client.EngineClient.call( dummy_req.context, ('show_watch_metric', {'metric_namespace': None, 'metric_name': None}) ).AndReturn(engine_resp) self.m.ReplayAll() expected = {'ListMetricsResponse': {'ListMetricsResult': {'Metrics': [{'Namespace': u'atestnamespace/foo', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:09:02Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure'}, {'Namespace': u'atestnamespace/foo', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm2'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:10:03Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure2'}]}}} self.assertEqual(expected, self.controller.list_metrics(dummy_req)) def test_put_metric_alarm(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'PutMetricAlarm'} dummy_req = self._dummy_GET_request(params) result = self.controller.put_metric_alarm(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_put_metric_data(self): params = {u'Namespace': u'system/linux', u'MetricData.member.1.Unit': u'Count', u'MetricData.member.1.Value': u'1', u'MetricData.member.1.MetricName': u'ServiceFailure', u'MetricData.member.1.Dimensions.member.1.Name': u'AlarmName', u'MetricData.member.1.Dimensions.member.1.Value': u'HttpFailureAlarm', u'Action': u'PutMetricData'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to verify the engine call parameters engine_resp = {} self.m.StubOutWithMock(rpc_client.EngineClient, 'call') rpc_client.EngineClient.call( dummy_req.context, ('create_watch_data', {'watch_name': u'HttpFailureAlarm', 'stats_data': { 'Namespace': u'system/linux', 'ServiceFailure': { 'Value': u'1', 'Unit': u'Count', 'Dimensions': []}}}) ).AndReturn(engine_resp) self.m.ReplayAll() expected = {'PutMetricDataResponse': {'PutMetricDataResult': {'ResponseMetadata': None}}} self.assertEqual(expected, self.controller.put_metric_data(dummy_req)) def test_set_alarm_state(self): state_map = {'OK': rpc_api.WATCH_STATE_OK, 'ALARM': rpc_api.WATCH_STATE_ALARM, 'INSUFFICIENT_DATA': rpc_api.WATCH_STATE_NODATA} for state in state_map.keys(): params = {u'StateValue': state, u'StateReason': u'', u'AlarmName': u'HttpFailureAlarm', u'Action': u'SetAlarmState'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to verify the engine call parameters # The real engine response is the same as show_watch but with # the state overridden, but since the API doesn't make use # of the response at present we pass nothing back from the stub engine_resp = {} self.m.StubOutWithMock(rpc_client.EngineClient, 'call') rpc_client.EngineClient.call( dummy_req.context, ('set_watch_state', {'state': state_map[state], 'watch_name': u'HttpFailureAlarm'}) ).AndReturn(engine_resp) self.m.ReplayAll() expected = {'SetAlarmStateResponse': {'SetAlarmStateResult': ''}} self.assertEqual(expected, self.controller.set_alarm_state(dummy_req)) self.m.UnsetStubs() self.m.VerifyAll() def test_set_alarm_state_badstate(self): params = {u'StateValue': "baaaaad", u'StateReason': u'', u'AlarmName': u'HttpFailureAlarm', u'Action': u'SetAlarmState'} dummy_req = self._dummy_GET_request(params) # should raise HeatInvalidParameterValueError result = self.controller.set_alarm_state(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def setUp(self): super(WatchControllerTest, self).setUp() self.path = os.path.dirname(os.path.realpath(__file__)) self.policy_path = self.path + "/policy/" opts = [ cfg.StrOpt('config_dir', default=self.policy_path), cfg.StrOpt('config_file', default='foo'), cfg.StrOpt('project', default='heat'), ] cfg.CONF.register_opts(opts) cfg.CONF.set_default('host', 'host') self.topic = rpc_api.ENGINE_TOPIC self.api_version = '1.0' # Create WSGI controller instance class DummyConfig(object): bind_port = 8003 cfgopts = DummyConfig() self.controller = watches.WatchController(options=cfgopts) self.controller.policy.enforcer.policy_path = (self.policy_path + 'deny_stack_user.json') self.addCleanup(self.m.VerifyAll)