heat engine : make WatchRule initial state NODATA

Initial state should be NODATA not NORMAL, as we've not
done any metric evaluation until the first evaluation
period has elapsed

fixes bug 1102446

Change-Id: Ic41df29c00a5df2f3d161bc1b1d054d816c5afa5
Signed-off-by: Steven Hardy <shardy@redhat.com>

diff --git a/heat/engine/watchrule.py b/heat/engine/watchrule.py
index 6450bb8bf6ed79969411dad0877175e538208866..a613898fc3aa89638c888a37d3fcda5456c06338 100644 (file)
--- a/heat/engine/watchrule.py
+++ b/heat/engine/watchrule.py
@@ -44,7 +44,7 @@ class WatchRule(object):
     updated_at = timestamp.Timestamp(db_api.watch_rule_get, 'updated_at')
 
     def __init__(self, context, watch_name, rule, stack_id=None,
-                 state=NORMAL, wid=None, watch_data=[],
+                 state=NODATA, wid=None, watch_data=[],
                  last_evaluated=timeutils.utcnow()):
         self.context = context
         self.now = timeutils.utcnow()

diff --git a/heat/tests/test_watch.py b/heat/tests/test_watch.py
index 12b961596993c401247e679b4028d778a8ff3fec..2baf4d662f09225a48d6d6f5e3413db712a23f82 100644 (file)
--- a/heat/tests/test_watch.py
+++ b/heat/tests/test_watch.py
@@ -328,7 +328,7 @@ class WatchRuleTest(unittest.TestCase):
         dbwr = db_api.watch_rule_get_by_name(self.ctx, 'storetest')
         self.assertNotEqual(dbwr, None)
         self.assertEqual(dbwr.name, 'storetest')
-        self.assertEqual(dbwr.state, watchrule.WatchRule.NORMAL)
+        self.assertEqual(dbwr.state, watchrule.WatchRule.NODATA)
         self.assertEqual(dbwr.rule, rule)
 
         # Cleanup
@@ -347,9 +347,23 @@ class WatchRuleTest(unittest.TestCase):
         timeutils.utcnow().MultipleTimes().AndReturn(now)
         self.m.ReplayAll()
 
-        # Data breaches threshold, but it's not time to evaluate
+        # It's not time to evaluate, so should stay NODATA
         last = now - datetime.timedelta(seconds=299)
-        data = WatchData(35, now - datetime.timedelta(seconds=150))
+        data = WatchData(25, now - datetime.timedelta(seconds=150))
+        watcher = watchrule.WatchRule(context=self.ctx,
+                                      watch_name="testwatch",
+                                      rule=rule,
+                                      watch_data=[data],
+                                      stack_id=self.stack_id,
+                                      last_evaluated=last)
+
+        actions = watcher.evaluate()
+        self.assertEqual(watcher.state, 'NODATA')
+        self.assertEqual(actions, [])
+
+        # now - last == Period, so should set NORMAL
+        last = now - datetime.timedelta(seconds=300)
+        data = WatchData(25, now - datetime.timedelta(seconds=150))
         watcher = watchrule.WatchRule(context=self.ctx,
                                       watch_name="testwatch",
                                       rule=rule,
@@ -359,9 +373,10 @@ class WatchRuleTest(unittest.TestCase):
 
         actions = watcher.evaluate()
         self.assertEqual(watcher.state, 'NORMAL')
+        self.assertEqual(watcher.last_evaluated, now)
         self.assertEqual(actions, [])
 
-        # now - last == Period, so should set ALARM
+        # Now data breaches Threshold, so should set ALARM
         last = now - datetime.timedelta(seconds=300)
         data = WatchData(35, now - datetime.timedelta(seconds=150))
         watcher = watchrule.WatchRule(context=self.ctx,
@@ -374,7 +389,6 @@ class WatchRuleTest(unittest.TestCase):
         actions = watcher.evaluate()
         self.assertEqual(watcher.state, 'ALARM')
         self.assertEqual(watcher.last_evaluated, now)
-        # No AlarmActions defined in the rule, so expect []
         self.assertEqual(actions, [])
 
     def test_rule_actions_alarm_normal(self):
@@ -476,18 +490,17 @@ class WatchRuleTest(unittest.TestCase):
         now = timeutils.utcnow()
         self._action_set_stubs(now)
 
-        # Set data so rule evaluates to ALARM state
+        # On creation the rule evaluates to NODATA state
         last = now - datetime.timedelta(seconds=300)
-        data = WatchData(35, now - datetime.timedelta(seconds=150))
         watcher = watchrule.WatchRule(context=self.ctx,
                                       watch_name="testwatch",
                                       rule=rule,
-                                      watch_data=[data],
+                                      watch_data=[],
                                       stack_id=self.stack_id,
                                       last_evaluated=last)
 
         actions = watcher.evaluate()
-        self.assertEqual(watcher.state, 'ALARM')
+        self.assertEqual(watcher.state, 'NODATA')
         self.assertEqual(actions, [])
 
         # Move time forward and add data below threshold so we transition from