Replaced mox with mock in test_watch

Change-Id: Ic7d4d152c529b29fa1e07cf865181f623d6744b8
Implements: blueprint mox-to-mock-conversion

1 files changed, 430 insertions, 397 deletions

diff --git a/heat/tests/test_watch.py b/heat/tests/test_watch.py
index a1f0cc5c0..93ca07358 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()
-
-        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()
-
-        # Then use WatchRule.load() to retrieve each by name
-        # and check that the object properties match the data above
+        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()
+
+        rules.append(watchrule.WatchRule(context=self.ctx,
+                                         watch_name='AnotherWatch',
+                                         rule=rule,
+                                         watch_data=[],
+                                         stack_id=self.stack_id,
+                                         state='NORMAL'))
+        rules[1].store()
+
+        # 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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('NODATA', self.wr.state)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('NORMAL', self.wr.state)
-        self.assertEqual(now, self.wr.last_evaluated)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('ALARM', self.wr.state)
-        self.assertEqual(now, self.wr.last_evaluated)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        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)
-
-        self.wr.state_set(self.wr.SUSPENDED)
-
-        actions = self.wr.evaluate()
-        self.assertEqual(self.wr.SUSPENDED, self.wr.state)
+        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)
+
+        # 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)
-
-        self.wr.state_set(self.wr.CEILOMETER_CONTROLLED)
-
-        actions = self.wr.evaluate()
-        self.assertEqual(self.wr.CEILOMETER_CONTROLLED, self.wr.state)
+        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)
+
+        # 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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('NORMAL', self.wr.state)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # 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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('ALARM', self.wr.state)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # 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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('ALARM', self.wr.state)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # 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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('NODATA', self.wr.state)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # 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)
-
-        actions = self.wr.evaluate()
-        self.assertEqual('ALARM', self.wr.state)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[data],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # 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')
-
-        self.wr = watchrule.WatchRule(context=self.ctx,
-                                      watch_name='create_data_test',
-                                      stack_id=self.stack_id, rule=rule)
-        self.wr.store()
-
-        self.patchobject(cc.AuthPlugin, 'redirect_to_aodh_endpoint',
-                         side_effect=exceptions.EndpointNotFound)
-        self.m.StubOutWithMock(self.wr.context.clients.client('ceilometer').
-                               samples, 'create', True)
-
-        # fake samples.create callback
-        def fake_create(counter_type, counter_name, counter_volume,
-                        counter_unit, resource_metadata, resource_id):
-            pass
-
-        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")
+
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name='create_data_test',
+                                 stack_id=self.stack_id,
+                                 rule=rule)
+        wr.store()
+
+        mock_ceilometer_client = mock.MagicMock()
+
+        self.ctx._clients = mock.MagicMock()
+        self.ctx._clients.client.return_value = mock_ceilometer_client
+
+        # Test
+        wr._to_ceilometer(testdata)
+
+        # 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)
-
-        actions = self.wr.set_watch_state(watchrule.WatchRule.NODATA)
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # 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)
-
-        self.assertRaises(ValueError, self.wr.set_watch_state, None)
-
-        self.assertRaises(ValueError, self.wr.set_watch_state, "BADSTATE")
+        wr = watchrule.WatchRule(context=self.ctx,
+                                 watch_name="testwatch",
+                                 rule=rule,
+                                 watch_data=[],
+                                 stack_id=self.stack_id,
+                                 last_evaluated=last)
+
+        # Test
+        self.assertRaises(ValueError, wr.set_watch_state, None)
+        self.assertRaises(ValueError, wr.set_watch_state, "BADSTATE")