diff --git a/heat/tests/test_watch.py b/heat/tests/test_watch.py index a1f0cc5c02..93ca07358a 100644 --- a/heat/tests/test_watch.py +++ b/heat/tests/test_watch.py @@ -14,9 +14,7 @@ import datetime -from ceilometerclient import client as cc -from keystoneclient import exceptions -import mox +import mock from oslo_utils import timeutils from heat.common import exception @@ -42,47 +40,42 @@ class DummyAction(object): class WatchRuleTest(common.HeatTestCase): stack_id = None - def setUpDatabase(self): + def setUp(self): + super(WatchRuleTest, self).setUp() + + self.username = 'watchrule_test_user' + self.ctx = utils.dummy_context() + self.ctx.auth_token = 'abcd1234' + + self._setup_database() + + def _setup_database(self): if self.stack_id is not None: return # Create a dummy stack in the DB as WatchRule instances # must be associated with a stack - ctx = utils.dummy_context() - ctx.auth_token = 'abcd1234' empty_tmpl = {'HeatTemplateFormatVersion': '2012-12-12'} tmpl = template.Template(empty_tmpl) stack_name = 'dummystack' - dummy_stack = stack.Stack(ctx, stack_name, tmpl) + dummy_stack = stack.Stack(self.ctx, stack_name, tmpl) dummy_stack.state_set(dummy_stack.CREATE, dummy_stack.COMPLETE, 'Testing') dummy_stack.store() self.stack_id = dummy_stack.id - def setUp(self): - super(WatchRuleTest, self).setUp() - self.setUpDatabase() - self.username = 'watchrule_test_user' - - self.ctx = utils.dummy_context() - self.ctx.auth_token = 'abcd1234' - - self.m.ReplayAll() - - def _action_set_stubs(self, now, action_expected=True): - # Setup stubs for the action tests + def _setup_action_mocks(self, mock_get_resource, now, + action_expected=True): + """Setup stubs for the action tests.""" timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) if action_expected: dummy_action = DummyAction() - self.m.StubOutWithMock(stack.Stack, 'resource_by_refid') - stack.Stack.resource_by_refid( - mox.IgnoreArg()).MultipleTimes().AndReturn(dummy_action) - - self.m.ReplayAll() + mock_get_resource.return_value = dummy_action def test_minimum(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -93,29 +86,31 @@ class WatchRuleTest(common.HeatTestCase): now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(77, now - datetime.timedelta(seconds=100))] - data.append(WatchData(53, now - datetime.timedelta(seconds=150))) - # all > 50 -> NORMAL - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - new_state = self.wr.get_alarm_state() + # Test 1 - Values greater than 0 are normal + data.append(WatchData(53, now - datetime.timedelta(seconds=150))) + wr = watchrule.WatchRule(self.ctx, + 'testwatch', + rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + new_state = wr.get_alarm_state() self.assertEqual('NORMAL', new_state) + # Test 2 data.append(WatchData(25, now - datetime.timedelta(seconds=250))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - new_state = self.wr.get_alarm_state() + wr = watchrule.WatchRule(self.ctx, + 'testwatch', + rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + new_state = wr.get_alarm_state() self.assertEqual('ALARM', new_state) def test_maximum(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -126,32 +121,33 @@ class WatchRuleTest(common.HeatTestCase): now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(7, now - datetime.timedelta(seconds=100))] - data.append(WatchData(23, now - datetime.timedelta(seconds=150))) - # all < 30 -> NORMAL - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + # Test 1 - values less than 30 are normal + data.append(WatchData(23, now - datetime.timedelta(seconds=150))) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('NORMAL', new_state) + # Test 2 data.append(WatchData(35, now - datetime.timedelta(seconds=150))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('ALARM', new_state) def test_samplecount(self): - + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -162,45 +158,46 @@ class WatchRuleTest(common.HeatTestCase): now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(1, now - datetime.timedelta(seconds=100))] - data.append(WatchData(1, now - datetime.timedelta(seconds=150))) - # only 2 samples -> NORMAL - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + # Test 1 - 2 samples is normal + data.append(WatchData(1, now - datetime.timedelta(seconds=150))) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('NORMAL', new_state) - # only 3 samples -> ALARM + # Test 2 - 3 samples is an alarm data.append(WatchData(1, now - datetime.timedelta(seconds=200))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('ALARM', new_state) - # only 3 samples (one old) -> NORMAL + # Test 3 - 3 samples (one old) is normal data.pop(0) data.append(WatchData(1, now - datetime.timedelta(seconds=400))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('NORMAL', new_state) def test_sum(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -211,32 +208,33 @@ class WatchRuleTest(common.HeatTestCase): now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(17, now - datetime.timedelta(seconds=100))] - data.append(WatchData(23, now - datetime.timedelta(seconds=150))) - # all < 40 -> NORMAL - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + # Test 1 - values less than 40 are normal + data.append(WatchData(23, now - datetime.timedelta(seconds=150))) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('NORMAL', new_state) - # sum > 100 -> ALARM + # Test 2 - sum greater than 100 is an alarm data.append(WatchData(85, now - datetime.timedelta(seconds=150))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('ALARM', new_state) - def test_ave(self): + def test_average(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -247,30 +245,33 @@ class WatchRuleTest(common.HeatTestCase): now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(117, now - datetime.timedelta(seconds=100))] - data.append(WatchData(23, now - datetime.timedelta(seconds=150))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + # Test 1 + data.append(WatchData(23, now - datetime.timedelta(seconds=150))) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('NORMAL', new_state) + # Test 2 data.append(WatchData(195, now - datetime.timedelta(seconds=250))) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=data, - stack_id=self.stack_id, - last_evaluated=last) - self.wr.now = now - new_state = self.wr.get_alarm_state() + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=data, + stack_id=self.stack_id, + last_evaluated=last) + wr.now = now + new_state = wr.get_alarm_state() self.assertEqual('ALARM', new_state) def test_load(self): + # Setup # Insert two dummy watch rules into the DB rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], @@ -281,25 +282,24 @@ class WatchRuleTest(common.HeatTestCase): u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} - self.wr = [] - self.wr.append(watchrule.WatchRule(context=self.ctx, - watch_name='HttpFailureAlarm', - rule=rule, - watch_data=[], - stack_id=self.stack_id, - state='NORMAL')) - self.wr[0].store() + rules = [] + rules.append(watchrule.WatchRule(context=self.ctx, + watch_name='HttpFailureAlarm', + rule=rule, + watch_data=[], + stack_id=self.stack_id, + state='NORMAL')) + rules[0].store() - self.wr.append(watchrule.WatchRule(context=self.ctx, - watch_name='AnotherWatch', - rule=rule, - watch_data=[], - stack_id=self.stack_id, - state='NORMAL')) - self.wr[1].store() + rules.append(watchrule.WatchRule(context=self.ctx, + watch_name='AnotherWatch', + rule=rule, + watch_data=[], + stack_id=self.stack_id, + state='NORMAL')) + rules[1].store() - # Then use WatchRule.load() to retrieve each by name - # and check that the object properties match the data above + # Test for wn in ('HttpFailureAlarm', 'AnotherWatch'): wr = watchrule.WatchRule.load(self.ctx, wn) self.assertIsInstance(wr, watchrule.WatchRule) @@ -310,6 +310,7 @@ class WatchRuleTest(common.HeatTestCase): wr.timeperiod) def test_store(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', @@ -319,10 +320,13 @@ class WatchRuleTest(common.HeatTestCase): u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} - self.wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest', - stack_id=self.stack_id, rule=rule) - self.wr.store() + # Test + wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest', + stack_id=self.stack_id, rule=rule) + wr.store() + + # Verify dbwr = watch_rule.WatchRule.get_by_name(self.ctx, 'storetest') self.assertIsNotNone(dbwr) self.assertEqual('storetest', dbwr.name) @@ -330,6 +334,7 @@ class WatchRuleTest(common.HeatTestCase): self.assertEqual(rule, dbwr.rule) def test_evaluate(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -341,51 +346,52 @@ class WatchRuleTest(common.HeatTestCase): timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) - # It's not time to evaluate, so should stay NODATA + # Test 1 - It's not time to evaluate, so should stay NODATA last = now - datetime.timedelta(seconds=299) data = WatchData(25, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('NODATA', self.wr.state) + actions = wr.evaluate() + self.assertEqual('NODATA', wr.state) self.assertEqual([], actions) - # now - last == Period, so should set NORMAL + # Test 2 - now - last == Period, so should set NORMAL last = now - datetime.timedelta(seconds=300) data = WatchData(25, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('NORMAL', self.wr.state) - self.assertEqual(now, self.wr.last_evaluated) + actions = wr.evaluate() + self.assertEqual('NORMAL', wr.state) + self.assertEqual(now, wr.last_evaluated) self.assertEqual([], actions) - # Now data breaches Threshold, so should set ALARM + # Test 3 - Now data breaches Threshold, so should set ALARM last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('ALARM', self.wr.state) - self.assertEqual(now, self.wr.last_evaluated) + actions = wr.evaluate() + self.assertEqual('ALARM', wr.state) + self.assertEqual(now, wr.last_evaluated) self.assertEqual([], actions) def test_evaluate_suspend(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -397,23 +403,23 @@ class WatchRuleTest(common.HeatTestCase): timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) - # Now data breaches Threshold, but we're suspended last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) + wr.state_set(wr.SUSPENDED) - self.wr.state_set(self.wr.SUSPENDED) - - actions = self.wr.evaluate() - self.assertEqual(self.wr.SUSPENDED, self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual(wr.SUSPENDED, wr.state) self.assertEqual([], actions) def test_evaluate_ceilometer_controlled(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', @@ -425,23 +431,24 @@ class WatchRuleTest(common.HeatTestCase): timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) - # Now data breaches Threshold, but we're suspended last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) + wr.state_set(wr.CEILOMETER_CONTROLLED) - self.wr.state_set(self.wr.CEILOMETER_CONTROLLED) - - actions = self.wr.evaluate() - self.assertEqual(self.wr.CEILOMETER_CONTROLLED, self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual(wr.CEILOMETER_CONTROLLED, wr.state) self.assertEqual([], actions) - def test_rule_actions_alarm_normal(self): + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_rule_actions_alarm_normal(self, mock_get_resource): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], @@ -451,24 +458,28 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} now = timeutils.utcnow() - self._action_set_stubs(now, action_expected=False) + self._setup_action_mocks(mock_get_resource, now, + action_expected=False) # Set data so rule evaluates to NORMAL state last = now - datetime.timedelta(seconds=300) data = WatchData(25, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('NORMAL', self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual('NORMAL', wr.state) self.assertEqual([], actions) - self.m.VerifyAll() + self.assertEqual(0, mock_get_resource.call_count) - def test_rule_actions_alarm_alarm(self): + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_rule_actions_alarm_alarm(self, mock_get_resource): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], @@ -478,31 +489,34 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} now = timeutils.utcnow() - self._action_set_stubs(now) + self._setup_action_mocks(mock_get_resource, now) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('ALARM', self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual('ALARM', wr.state) self.assertEqual(['DummyAction'], actions) # re-set last_evaluated so the rule will be evaluated again. last = now - datetime.timedelta(seconds=300) - self.wr.last_evaluated = last - actions = self.wr.evaluate() - self.assertEqual('ALARM', self.wr.state) + wr.last_evaluated = last + actions = wr.evaluate() + self.assertEqual('ALARM', wr.state) self.assertEqual(['DummyAction'], actions) - self.m.VerifyAll() + self.assertTrue(mock_get_resource.call_count > 0) - def test_rule_actions_alarm_two_actions(self): + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_rule_actions_alarm_two_actions(self, mock_get_resource): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction', 'AnotherDummyAction'], @@ -512,24 +526,27 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} now = timeutils.utcnow() - self._action_set_stubs(now) + self._setup_action_mocks(mock_get_resource, now) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('ALARM', self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual('ALARM', wr.state) self.assertEqual(['DummyAction', 'DummyAction'], actions) - self.m.VerifyAll() + self.assertTrue(mock_get_resource.call_count > 0) - def test_rule_actions_ok_alarm(self): + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_rule_actions_ok_alarm(self, mock_get_resource): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'OKActions': ['DummyAction'], @@ -539,37 +556,38 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} now = timeutils.utcnow() - self._action_set_stubs(now, action_expected=False) + self._setup_action_mocks(mock_get_resource, now, action_expected=False) # On creation the rule evaluates to NODATA state last = now - datetime.timedelta(seconds=300) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('NODATA', self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual('NODATA', wr.state) self.assertEqual([], actions) # Move time forward and add data below threshold so we transition from # ALARM -> NORMAL, so evaluate() should output a 'DummyAction' now = now + datetime.timedelta(seconds=300) - self.m.VerifyAll() - self.m.UnsetStubs() - self._action_set_stubs(now) + self._setup_action_mocks(mock_get_resource, now) data = WatchData(25, now - datetime.timedelta(seconds=150)) - self.wr.watch_data = [data] + wr.watch_data = [data] - actions = self.wr.evaluate() - self.assertEqual('NORMAL', self.wr.state) + actions = wr.evaluate() + self.assertEqual('NORMAL', wr.state) self.assertEqual(['DummyAction'], actions) - self.m.VerifyAll() + self.assertTrue(mock_get_resource.call_count > 0) - def test_rule_actions_nodata(self): + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_rule_actions_nodata(self, mock_get_resource): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'InsufficientDataActions': ['DummyAction'], @@ -579,36 +597,37 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} now = timeutils.utcnow() - self._action_set_stubs(now, action_expected=False) + self._setup_action_mocks(mock_get_resource, now, action_expected=False) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[data], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[data], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.evaluate() - self.assertEqual('ALARM', self.wr.state) + # Test + actions = wr.evaluate() + self.assertEqual('ALARM', wr.state) self.assertEqual([], actions) # Move time forward and don't add data so we transition from # ALARM -> NODATA, so evaluate() should output a 'DummyAction' now = now + datetime.timedelta(seconds=300) - self.m.VerifyAll() - self.m.UnsetStubs() - self._action_set_stubs(now) + self._setup_action_mocks(mock_get_resource, now) - actions = self.wr.evaluate() - self.assertEqual('NODATA', self.wr.state) + actions = wr.evaluate() + self.assertEqual('NODATA', wr.state) self.assertEqual(['DummyAction'], actions) - self.m.VerifyAll() - - def test_to_ceilometer(self): + self.assertTrue(mock_get_resource.call_count > 0) + @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint') + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_to_ceilometer(self, mock_get_resource, mock_redirect): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -617,45 +636,36 @@ class WatchRuleTest(common.HeatTestCase): u'Threshold': u'2', u'MetricName': u'CreateDataMetric'} testdata = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1"}} - sample = dict() - sample['counter_type'] = 'gauge' - for k, d in iter(testdata.items()): - if k == 'Namespace': - continue - sample['counter_name'] = k - sample['counter_volume'] = d['Value'] - sample['counter_unit'] = d['Unit'] - dims = d.get('Dimensions', {}) - if isinstance(dims, list): - dims = dims[0] - sample['resource_metadata'] = dims - sample['resource_id'] = dims.get('InstanceId') + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) + wr.store() - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) - self.wr.store() + mock_ceilometer_client = mock.MagicMock() - self.patchobject(cc.AuthPlugin, 'redirect_to_aodh_endpoint', - side_effect=exceptions.EndpointNotFound) - self.m.StubOutWithMock(self.wr.context.clients.client('ceilometer'). - samples, 'create', True) + self.ctx._clients = mock.MagicMock() + self.ctx._clients.client.return_value = mock_ceilometer_client - # fake samples.create callback - def fake_create(counter_type, counter_name, counter_volume, - counter_unit, resource_metadata, resource_id): - pass + # Test + wr._to_ceilometer(testdata) - self.wr.context.clients.client('ceilometer').samples.\ - create(**sample).MultipleTimes().WithSideEffects(fake_create) - self.m.ReplayAll() - try: - self.wr._to_ceilometer(testdata) - except mox.UnexpectedMethodCallError: - raise KeyError("Error input parameter") + # Verify + self.assertEqual(1, mock_ceilometer_client.samples.create.call_count) + create_kw_args = mock_ceilometer_client.samples.create.call_args[1] + expected = { + 'counter_type': 'gauge', + 'counter_name': 'CreateDataMetric', + 'counter_volume': '1', + 'counter_unit': 'Counter', + 'resource_metadata': {}, + 'resource_id': None, + } + self.assertEqual(expected, create_kw_args) def test_create_watch_data(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -663,17 +673,20 @@ class WatchRuleTest(common.HeatTestCase): u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) - self.wr.store() + wr.store() + # Test data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": []}} - self.wr.create_watch_data(data) + wr.create_watch_data(data) + # Verify obj_wr = watch_rule.WatchRule.get_by_name(self.ctx, 'create_data_test') obj_wds = [wd for wd in obj_wr.watch_data] self.assertEqual(data, obj_wds[0].data) @@ -686,6 +699,7 @@ class WatchRuleTest(common.HeatTestCase): # watch_rule.id, so leave it as a single-datapoint test for now. def test_create_watch_data_suspended(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -693,23 +707,27 @@ class WatchRuleTest(common.HeatTestCase): u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule, - state=watchrule.WatchRule.SUSPENDED) + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule, + state=watchrule.WatchRule.SUSPENDED) - self.wr.store() + wr.store() + # Test data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": []}} - self.wr.create_watch_data(data) + wr.create_watch_data(data) + # Verify obj_wr = watch_rule.WatchRule.get_by_name(self.ctx, 'create_data_test') obj_wds = [wd for wd in obj_wr.watch_data] self.assertEqual([], obj_wds) def test_create_watch_data_match(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -719,18 +737,21 @@ class WatchRuleTest(common.HeatTestCase): u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) - self.wr.store() + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) + wr.store() + # Test data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [{u'AutoScalingGroupName': u'group_x'}]}} - self.assertTrue(watchrule.rule_can_use_sample(self.wr, data)) + self.assertTrue(watchrule.rule_can_use_sample(wr, data)) def test_create_watch_data_match_2(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -740,11 +761,13 @@ class WatchRuleTest(common.HeatTestCase): u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) - self.wr.store() + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) + wr.store() + # Test data = {u'not_interesting': {"Unit": "Counter", "Value": "1", "Dimensions": [ @@ -755,9 +778,10 @@ class WatchRuleTest(common.HeatTestCase): "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}} - self.assertTrue(watchrule.rule_can_use_sample(self.wr, data)) + self.assertTrue(watchrule.rule_can_use_sample(wr, data)) def test_create_watch_data_match_3(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -767,24 +791,22 @@ class WatchRuleTest(common.HeatTestCase): u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) - self.wr.store() + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) + wr.store() + # Test data = {u'CreateDataMetric': {"Unit": "Counter", - "Value": "1", - "Dimensions": [ - {u'AutoScalingGroupName': - u'not_this'}]}, - u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}} - self.assertTrue(watchrule.rule_can_use_sample(self.wr, data)) + self.assertTrue(watchrule.rule_can_use_sample(wr, data)) def test_create_watch_data_not_match_metric(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -794,11 +816,13 @@ class WatchRuleTest(common.HeatTestCase): u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) - self.wr.store() + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) + wr.store() + # Test data = {u'not_this': {"Unit": "Counter", "Value": "1", "Dimensions": [ @@ -809,9 +833,10 @@ class WatchRuleTest(common.HeatTestCase): "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}} - self.assertFalse(watchrule.rule_can_use_sample(self.wr, data)) + self.assertFalse(watchrule.rule_can_use_sample(wr, data)) def test_create_watch_data_not_match_dimensions(self): + # Setup rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', @@ -821,24 +846,22 @@ class WatchRuleTest(common.HeatTestCase): u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name='create_data_test', - stack_id=self.stack_id, rule=rule) - self.wr.store() + wr = watchrule.WatchRule(context=self.ctx, + watch_name='create_data_test', + stack_id=self.stack_id, + rule=rule) + wr.store() + # Test data = {u'CreateDataMetric': {"Unit": "Counter", - "Value": "1", - "Dimensions": [ - {u'AutoScalingGroupName': - u'not_this'}]}, - u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'wrong_key': u'group_x'}]}} - self.assertFalse(watchrule.rule_can_use_sample(self.wr, data)) + self.assertFalse(watchrule.rule_can_use_sample(wr, data)) def test_destroy(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], @@ -848,25 +871,29 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} last = timeutils.utcnow() - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch_destroy", - rule=rule, - watch_data=[], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name='testwatch_destroy', + rule=rule, + watch_data=[], + stack_id=self.stack_id, + last_evaluated=last) - self.wr.store() + wr.store() + # Sanity Check check = watchrule.WatchRule.load(context=self.ctx, - watch_name="testwatch_destroy") + watch_name='testwatch_destroy') self.assertIsInstance(check, watchrule.WatchRule) - self.wr.destroy() + # Test + wr.destroy() self.assertRaises(exception.WatchRuleNotFound, - watchrule.WatchRule.load, context=self.ctx, - watch_name="testwatch_destroy") + watchrule.WatchRule.load, + context=self.ctx, + watch_name='testwatch_destroy') def test_state_set(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], @@ -883,14 +910,18 @@ class WatchRuleTest(common.HeatTestCase): stack_id=self.stack_id, last_evaluated=last) + # Test watcher.state_set(watcher.SUSPENDED) - self.assertEqual(watcher.SUSPENDED, watcher.state) + # Verify + self.assertEqual(watcher.SUSPENDED, watcher.state) check = watchrule.WatchRule.load(context=self.ctx, - watch_name="testwatch_set_state") + watch_name='testwatch_set_state') self.assertEqual(watchrule.WatchRule.SUSPENDED, check.state) - def test_set_watch_state(self): + @mock.patch('heat.engine.stack.Stack.resource_by_refid') + def test_set_watch_state(self, mock_get_resource): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], @@ -900,28 +931,30 @@ class WatchRuleTest(common.HeatTestCase): 'Threshold': '30'} now = timeutils.utcnow() - self._action_set_stubs(now) + self._setup_action_mocks(mock_get_resource, now) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=200) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[], + stack_id=self.stack_id, + last_evaluated=last) - actions = self.wr.set_watch_state(watchrule.WatchRule.NODATA) + # Test + actions = wr.set_watch_state(watchrule.WatchRule.NODATA) self.assertEqual([], actions) - actions = self.wr.set_watch_state(watchrule.WatchRule.NORMAL) + actions = wr.set_watch_state(watchrule.WatchRule.NORMAL) self.assertEqual([], actions) - actions = self.wr.set_watch_state(watchrule.WatchRule.ALARM) + actions = wr.set_watch_state(watchrule.WatchRule.ALARM) self.assertEqual(['DummyAction'], actions) - self.m.VerifyAll() + self.assertTrue(mock_get_resource.call_count > 0) def test_set_watch_state_invalid(self): + # Setup rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], @@ -933,13 +966,13 @@ class WatchRuleTest(common.HeatTestCase): now = timeutils.utcnow() last = now - datetime.timedelta(seconds=200) - self.wr = watchrule.WatchRule(context=self.ctx, - watch_name="testwatch", - rule=rule, - watch_data=[], - stack_id=self.stack_id, - last_evaluated=last) + wr = watchrule.WatchRule(context=self.ctx, + watch_name="testwatch", + rule=rule, + watch_data=[], + stack_id=self.stack_id, + last_evaluated=last) - self.assertRaises(ValueError, self.wr.set_watch_state, None) - - self.assertRaises(ValueError, self.wr.set_watch_state, "BADSTATE") + # Test + self.assertRaises(ValueError, wr.set_watch_state, None) + self.assertRaises(ValueError, wr.set_watch_state, "BADSTATE")