← Back to branch summary

~ubuntu-branches/ubuntu/trusty/heat/trusty-security

« back to all changes in this revision

Viewing changes to heat/tests/test_watch.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Yolanda Robla, Chuck Short
  • Date: 2013-07-22 16:22:29 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130722162229-zzvfu40id94ii0hc
Tags: 2013.2~b2-0ubuntu1
[ Yolanda Robla ]
* debian/tests: added autopkg tests

[ Chuck Short ]
* New upstream release
* debian/control:
  - Add python-pbr to build-depends.
  - Add python-d2to to build-depends.
  - Dropped python-argparse.
  - Add python-six to build-depends.
  - Dropped python-sendfile.
  - Dropped python-nose.
  - Added testrepository.
  - Added python-testtools.
* debian/rules: Run testrepository instead of nosetets.
* debian/patches/removes-lxml-version-limitation-from-pip-requires.patch: Dropped
  no longer needed.
* debian/patches/fix-package-version-detection-when-building-doc.patch: Dropped
  no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_watch.py
15
15
 
16
16
import datetime
17
17
import mox
18
 
from nose.plugins.attrib import attr
19
 
import unittest
20
18
from heat.common import context
21
 
import heat.db as db_api
 
19
import heat.db.api as db_api
22
20
 
 
21
from heat.common import exception
23
22
from heat.openstack.common import timeutils
24
23
from heat.engine import watchrule
25
24
from heat.engine import parser
 
25
from heat.tests.common import HeatTestCase
 
26
from heat.tests import utils
26
27
 
27
28
 
28
29
class WatchData:
36
37
    alarm = "DummyAction"
37
38
 
38
39
 
39
 
@attr(tag=['unit', 'watchrule'])
40
 
@attr(speed='fast')
41
 
class WatchRuleTest(unittest.TestCase):
 
40
class WatchRuleTest(HeatTestCase):
 
41
    stack_id = None
42
42
 
43
43
    @classmethod
44
 
    def setUpClass(cls):
 
44
    def setUpDatabase(cls):
 
45
        if cls.stack_id is not None:
 
46
            return
45
47
        # Create a dummy stack in the DB as WatchRule instances
46
48
        # must be associated with a stack
 
49
        utils.setup_dummy_db()
47
50
        ctx = context.get_admin_context()
48
51
        ctx.username = 'dummyuser'
49
52
        ctx.tenant_id = '123456'
50
53
        empty_tmpl = {"template": {}}
51
54
        tmpl = parser.Template(empty_tmpl)
52
55
        stack_name = 'dummystack'
53
 
        params = parser.Parameters(stack_name, tmpl, {'foo': 'bar'})
54
 
        dummy_stack = parser.Stack(ctx, stack_name, tmpl, params)
55
 
        dummy_stack.state_set(dummy_stack.CREATE_COMPLETE, 'Testing')
 
56
        dummy_stack = parser.Stack(ctx, stack_name, tmpl)
 
57
        dummy_stack.state_set(dummy_stack.CREATE, dummy_stack.COMPLETE,
 
58
                              'Testing')
56
59
        dummy_stack.store()
57
60
 
58
61
        cls.stack_id = dummy_stack.id
59
62
 
60
63
    def setUp(self):
 
64
        super(WatchRuleTest, self).setUp()
 
65
        self.setUpDatabase()
61
66
        self.username = 'watchrule_test_user'
62
67
 
63
 
        self.m = mox.Mox()
64
 
 
65
68
        self.ctx = context.get_admin_context()
66
69
        self.ctx.username = self.username
67
70
        self.ctx.tenant_id = u'123456'
68
71
 
69
72
        self.m.ReplayAll()
70
73
 
71
 
    def tearDown(self):
72
 
        self.m.UnsetStubs()
73
 
 
74
74
    def _action_set_stubs(self, now, action_expected=True):
75
75
        # Setup stubs for the action tests
76
76
        self.m.StubOutWithMock(timeutils, 'utcnow')
98
98
        data.append(WatchData(53, now - datetime.timedelta(seconds=150)))
99
99
 
100
100
        # all > 50 -> NORMAL
101
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
101
        self.wr = watchrule.WatchRule(context=self.ctx,
102
102
                                      watch_name="testwatch",
103
103
                                      rule=rule,
104
104
                                      watch_data=data,
105
105
                                      stack_id=self.stack_id,
106
106
                                      last_evaluated=last)
107
 
        new_state = watcher.get_alarm_state()
 
107
        new_state = self.wr.get_alarm_state()
108
108
        self.assertEqual(new_state, 'NORMAL')
109
109
 
110
110
        data.append(WatchData(25, now - datetime.timedelta(seconds=250)))
111
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
111
        self.wr = watchrule.WatchRule(context=self.ctx,
112
112
                                      watch_name="testwatch",
113
113
                                      rule=rule,
114
114
                                      watch_data=data,
115
115
                                      stack_id=self.stack_id,
116
116
                                      last_evaluated=last)
117
 
        new_state = watcher.get_alarm_state()
 
117
        new_state = self.wr.get_alarm_state()
118
118
        self.assertEqual(new_state, 'ALARM')
119
119
 
120
120
    def test_maximum(self):
131
131
        data.append(WatchData(23, now - datetime.timedelta(seconds=150)))
132
132
 
133
133
        # all < 30 -> NORMAL
134
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
134
        self.wr = watchrule.WatchRule(context=self.ctx,
135
135
                                      watch_name="testwatch",
136
136
                                      rule=rule,
137
137
                                      watch_data=data,
138
138
                                      stack_id=self.stack_id,
139
139
                                      last_evaluated=last)
140
 
        watcher.now = now
141
 
        new_state = watcher.get_alarm_state()
 
140
        self.wr.now = now
 
141
        new_state = self.wr.get_alarm_state()
142
142
        self.assertEqual(new_state, 'NORMAL')
143
143
 
144
144
        data.append(WatchData(35, now - datetime.timedelta(seconds=150)))
145
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
145
        self.wr = watchrule.WatchRule(context=self.ctx,
146
146
                                      watch_name="testwatch",
147
147
                                      rule=rule,
148
148
                                      watch_data=data,
149
149
                                      stack_id=self.stack_id,
150
150
                                      last_evaluated=last)
151
 
        watcher.now = now
152
 
        new_state = watcher.get_alarm_state()
 
151
        self.wr.now = now
 
152
        new_state = self.wr.get_alarm_state()
153
153
        self.assertEqual(new_state, 'ALARM')
154
154
 
155
155
    def test_samplecount(self):
167
167
        data.append(WatchData(1, now - datetime.timedelta(seconds=150)))
168
168
 
169
169
        # only 2 samples -> NORMAL
170
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
170
        self.wr = watchrule.WatchRule(context=self.ctx,
171
171
                                      watch_name="testwatch",
172
172
                                      rule=rule,
173
173
                                      watch_data=data,
174
174
                                      stack_id=self.stack_id,
175
175
                                      last_evaluated=last)
176
 
        watcher.now = now
177
 
        new_state = watcher.get_alarm_state()
 
176
        self.wr.now = now
 
177
        new_state = self.wr.get_alarm_state()
178
178
        self.assertEqual(new_state, 'NORMAL')
179
179
 
180
180
        # only 3 samples -> ALARM
181
181
        data.append(WatchData(1, now - datetime.timedelta(seconds=200)))
182
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
182
        self.wr = watchrule.WatchRule(context=self.ctx,
183
183
                                      watch_name="testwatch",
184
184
                                      rule=rule,
185
185
                                      watch_data=data,
186
186
                                      stack_id=self.stack_id,
187
187
                                      last_evaluated=last)
188
 
        watcher.now = now
189
 
        new_state = watcher.get_alarm_state()
 
188
        self.wr.now = now
 
189
        new_state = self.wr.get_alarm_state()
190
190
        self.assertEqual(new_state, 'ALARM')
191
191
 
192
192
        # only 3 samples (one old) -> NORMAL
193
193
        data.pop(0)
194
194
        data.append(WatchData(1, now - datetime.timedelta(seconds=400)))
195
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
195
        self.wr = watchrule.WatchRule(context=self.ctx,
196
196
                                      watch_name="testwatch",
197
197
                                      rule=rule,
198
198
                                      watch_data=data,
199
199
                                      stack_id=self.stack_id,
200
200
                                      last_evaluated=last)
201
 
        watcher.now = now
202
 
        new_state = watcher.get_alarm_state()
 
201
        self.wr.now = now
 
202
        new_state = self.wr.get_alarm_state()
203
203
        self.assertEqual(new_state, 'NORMAL')
204
204
 
205
205
    def test_sum(self):
216
216
        data.append(WatchData(23, now - datetime.timedelta(seconds=150)))
217
217
 
218
218
        # all < 40 -> NORMAL
219
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
219
        self.wr = watchrule.WatchRule(context=self.ctx,
220
220
                                      watch_name="testwatch",
221
221
                                      rule=rule,
222
222
                                      watch_data=data,
223
223
                                      stack_id=self.stack_id,
224
224
                                      last_evaluated=last)
225
 
        watcher.now = now
226
 
        new_state = watcher.get_alarm_state()
 
225
        self.wr.now = now
 
226
        new_state = self.wr.get_alarm_state()
227
227
        self.assertEqual(new_state, 'NORMAL')
228
228
 
229
229
        # sum > 100 -> ALARM
230
230
        data.append(WatchData(85, now - datetime.timedelta(seconds=150)))
231
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
231
        self.wr = watchrule.WatchRule(context=self.ctx,
232
232
                                      watch_name="testwatch",
233
233
                                      rule=rule,
234
234
                                      watch_data=data,
235
235
                                      stack_id=self.stack_id,
236
236
                                      last_evaluated=last)
237
 
        watcher.now = now
238
 
        new_state = watcher.get_alarm_state()
 
237
        self.wr.now = now
 
238
        new_state = self.wr.get_alarm_state()
239
239
        self.assertEqual(new_state, 'ALARM')
240
240
 
241
241
    def test_ave(self):
251
251
        data = [WatchData(117, now - datetime.timedelta(seconds=100))]
252
252
        data.append(WatchData(23, now - datetime.timedelta(seconds=150)))
253
253
 
254
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
254
        self.wr = watchrule.WatchRule(context=self.ctx,
255
255
                                      watch_name="testwatch",
256
256
                                      rule=rule,
257
257
                                      watch_data=data,
258
258
                                      stack_id=self.stack_id,
259
259
                                      last_evaluated=last)
260
 
        watcher.now = now
261
 
        new_state = watcher.get_alarm_state()
 
260
        self.wr.now = now
 
261
        new_state = self.wr.get_alarm_state()
262
262
        self.assertEqual(new_state, 'NORMAL')
263
263
 
264
264
        data.append(WatchData(195, now - datetime.timedelta(seconds=250)))
265
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
265
        self.wr = watchrule.WatchRule(context=self.ctx,
266
266
                                      watch_name="testwatch",
267
267
                                      rule=rule,
268
268
                                      watch_data=data,
269
269
                                      stack_id=self.stack_id,
270
270
                                      last_evaluated=last)
271
 
        watcher.now = now
272
 
        new_state = watcher.get_alarm_state()
 
271
        self.wr.now = now
 
272
        new_state = self.wr.get_alarm_state()
273
273
        self.assertEqual(new_state, 'ALARM')
274
274
 
 
275
    @utils.wr_delete_after
275
276
    def test_load(self):
276
277
        # Insert two dummy watch rules into the DB
277
 
        values = {'stack_id': self.stack_id,
278
 
                  'state': 'NORMAL',
279
 
                  'name': u'HttpFailureAlarm',
280
 
                  'rule': {u'EvaluationPeriods': u'1',
281
 
                           u'AlarmActions': [u'WebServerRestartPolicy'],
282
 
                           u'AlarmDescription': u'Restart the WikiDatabase',
283
 
                           u'Namespace': u'system/linux',
284
 
                           u'Period': u'300',
285
 
                           u'ComparisonOperator': u'GreaterThanThreshold',
286
 
                           u'Statistic': u'SampleCount',
287
 
                           u'Threshold': u'2',
288
 
                           u'MetricName': u'ServiceFailure'}}
289
 
        db_ret = db_api.watch_rule_create(self.ctx, values)
290
 
        self.assertNotEqual(db_ret, None)
291
 
        values['name'] = 'AnotherWatch'
292
 
        db_ret = db_api.watch_rule_create(self.ctx, values)
293
 
        self.assertNotEqual(db_ret, None)
 
278
        rule = {u'EvaluationPeriods': u'1',
 
279
                u'AlarmActions': [u'WebServerRestartPolicy'],
 
280
                u'AlarmDescription': u'Restart the WikiDatabase',
 
281
                u'Namespace': u'system/linux',
 
282
                u'Period': u'300',
 
283
                u'ComparisonOperator': u'GreaterThanThreshold',
 
284
                u'Statistic': u'SampleCount',
 
285
                u'Threshold': u'2',
 
286
                u'MetricName': u'ServiceFailure'}
 
287
        self.wr = []
 
288
        self.wr.append(watchrule.WatchRule(context=self.ctx,
 
289
                                           watch_name='HttpFailureAlarm',
 
290
                                           rule=rule,
 
291
                                           watch_data=[],
 
292
                                           stack_id=self.stack_id,
 
293
                                           state='NORMAL'))
 
294
        self.wr[0].store()
 
295
 
 
296
        self.wr.append(watchrule.WatchRule(context=self.ctx,
 
297
                                           watch_name='AnotherWatch',
 
298
                                           rule=rule,
 
299
                                           watch_data=[],
 
300
                                           stack_id=self.stack_id,
 
301
                                           state='NORMAL'))
 
302
        self.wr[1].store()
294
303
 
295
304
        # Then use WatchRule.load() to retrieve each by name
296
305
        # and check that the object properties match the data above
298
307
            wr = watchrule.WatchRule.load(self.ctx, wn)
299
308
            self.assertEqual(type(wr), watchrule.WatchRule)
300
309
            self.assertEqual(wr.name, wn)
301
 
            self.assertEqual(wr.state, values['state'])
302
 
            self.assertEqual(wr.rule, values['rule'])
 
310
            self.assertEqual(wr.state, 'NORMAL')
 
311
            self.assertEqual(wr.rule, rule)
303
312
            self.assertEqual(wr.timeperiod, datetime.timedelta(
304
 
                             seconds=int(values['rule']['Period'])))
305
 
 
306
 
        # Cleanup
307
 
        db_api.watch_rule_delete(self.ctx, 'HttpFailureAlarm')
308
 
        db_api.watch_rule_delete(self.ctx, 'AnotherWatch')
309
 
 
 
313
                             seconds=int(rule['Period'])))
 
314
 
 
315
    @utils.wr_delete_after
310
316
    def test_store(self):
311
317
        rule = {u'EvaluationPeriods': u'1',
312
318
                u'AlarmActions': [u'WebServerRestartPolicy'],
317
323
                u'Statistic': u'SampleCount',
318
324
                u'Threshold': u'2',
319
325
                u'MetricName': u'ServiceFailure'}
320
 
        wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest',
321
 
                                 stack_id=self.stack_id, rule=rule)
322
 
        wr.store()
 
326
        self.wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest',
 
327
                                      stack_id=self.stack_id, rule=rule)
 
328
        self.wr.store()
323
329
 
324
330
        dbwr = db_api.watch_rule_get_by_name(self.ctx, 'storetest')
325
331
        self.assertNotEqual(dbwr, None)
327
333
        self.assertEqual(dbwr.state, watchrule.WatchRule.NODATA)
328
334
        self.assertEqual(dbwr.rule, rule)
329
335
 
330
 
        # Cleanup
331
 
        db_api.watch_rule_delete(self.ctx, 'storetest')
332
 
 
 
336
    @utils.wr_delete_after
333
337
    def test_evaluate(self):
334
338
        rule = {'EvaluationPeriods': '1',
335
339
                'MetricName': 'test_metric',
346
350
        # It's not time to evaluate, so should stay NODATA
347
351
        last = now - datetime.timedelta(seconds=299)
348
352
        data = WatchData(25, now - datetime.timedelta(seconds=150))
349
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
353
        self.wr = watchrule.WatchRule(context=self.ctx,
350
354
                                      watch_name="testwatch",
351
355
                                      rule=rule,
352
356
                                      watch_data=[data],
353
357
                                      stack_id=self.stack_id,
354
358
                                      last_evaluated=last)
355
359
 
356
 
        actions = watcher.evaluate()
357
 
        self.assertEqual(watcher.state, 'NODATA')
 
360
        actions = self.wr.evaluate()
 
361
        self.assertEqual(self.wr.state, 'NODATA')
358
362
        self.assertEqual(actions, [])
359
363
 
360
364
        # now - last == Period, so should set NORMAL
361
365
        last = now - datetime.timedelta(seconds=300)
362
366
        data = WatchData(25, now - datetime.timedelta(seconds=150))
363
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
367
        self.wr = watchrule.WatchRule(context=self.ctx,
364
368
                                      watch_name="testwatch",
365
369
                                      rule=rule,
366
370
                                      watch_data=[data],
367
371
                                      stack_id=self.stack_id,
368
372
                                      last_evaluated=last)
369
373
 
370
 
        actions = watcher.evaluate()
371
 
        self.assertEqual(watcher.state, 'NORMAL')
372
 
        self.assertEqual(watcher.last_evaluated, now)
 
374
        actions = self.wr.evaluate()
 
375
        self.assertEqual(self.wr.state, 'NORMAL')
 
376
        self.assertEqual(self.wr.last_evaluated, now)
373
377
        self.assertEqual(actions, [])
374
378
 
375
379
        # Now data breaches Threshold, so should set ALARM
376
380
        last = now - datetime.timedelta(seconds=300)
377
381
        data = WatchData(35, now - datetime.timedelta(seconds=150))
378
 
        watcher = watchrule.WatchRule(context=self.ctx,
379
 
                                      watch_name="testwatch",
380
 
                                      rule=rule,
381
 
                                      watch_data=[data],
382
 
                                      stack_id=self.stack_id,
383
 
                                      last_evaluated=last)
384
 
 
385
 
        actions = watcher.evaluate()
386
 
        self.assertEqual(watcher.state, 'ALARM')
387
 
        self.assertEqual(watcher.last_evaluated, now)
388
 
        self.assertEqual(actions, [])
389
 
 
 
382
        self.wr = watchrule.WatchRule(context=self.ctx,
 
383
                                      watch_name="testwatch",
 
384
                                      rule=rule,
 
385
                                      watch_data=[data],
 
386
                                      stack_id=self.stack_id,
 
387
                                      last_evaluated=last)
 
388
 
 
389
        actions = self.wr.evaluate()
 
390
        self.assertEqual(self.wr.state, 'ALARM')
 
391
        self.assertEqual(self.wr.last_evaluated, now)
 
392
        self.assertEqual(actions, [])
 
393
 
 
394
    @utils.wr_delete_after
 
395
    def test_evaluate_suspend(self):
 
396
        rule = {'EvaluationPeriods': '1',
 
397
                'MetricName': 'test_metric',
 
398
                'Period': '300',
 
399
                'Statistic': 'Maximum',
 
400
                'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
 
401
                'Threshold': '30'}
 
402
 
 
403
        now = timeutils.utcnow()
 
404
        self.m.StubOutWithMock(timeutils, 'utcnow')
 
405
        timeutils.utcnow().MultipleTimes().AndReturn(now)
 
406
        self.m.ReplayAll()
 
407
 
 
408
        # Now data breaches Threshold, but we're suspended
 
409
        last = now - datetime.timedelta(seconds=300)
 
410
        data = WatchData(35, now - datetime.timedelta(seconds=150))
 
411
        self.wr = watchrule.WatchRule(context=self.ctx,
 
412
                                      watch_name="testwatch",
 
413
                                      rule=rule,
 
414
                                      watch_data=[data],
 
415
                                      stack_id=self.stack_id,
 
416
                                      last_evaluated=last)
 
417
 
 
418
        self.wr.state_set(self.wr.SUSPENDED)
 
419
 
 
420
        actions = self.wr.evaluate()
 
421
        self.assertEqual(self.wr.state, self.wr.SUSPENDED)
 
422
        self.assertEqual(actions, [])
 
423
 
 
424
    @utils.wr_delete_after
390
425
    def test_rule_actions_alarm_normal(self):
391
426
        rule = {'EvaluationPeriods': '1',
392
427
                'MetricName': 'test_metric',
402
437
        # Set data so rule evaluates to NORMAL state
403
438
        last = now - datetime.timedelta(seconds=300)
404
439
        data = WatchData(25, now - datetime.timedelta(seconds=150))
405
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
440
        self.wr = watchrule.WatchRule(context=self.ctx,
406
441
                                      watch_name="testwatch",
407
442
                                      rule=rule,
408
443
                                      watch_data=[data],
409
444
                                      stack_id=self.stack_id,
410
445
                                      last_evaluated=last)
411
446
 
412
 
        actions = watcher.evaluate()
413
 
        self.assertEqual(watcher.state, 'NORMAL')
 
447
        actions = self.wr.evaluate()
 
448
        self.assertEqual(self.wr.state, 'NORMAL')
414
449
        self.assertEqual(actions, [])
415
450
        self.m.VerifyAll()
416
451
 
 
452
    @utils.wr_delete_after
417
453
    def test_rule_actions_alarm_alarm(self):
418
454
        rule = {'EvaluationPeriods': '1',
419
455
                'MetricName': 'test_metric',
429
465
        # Set data so rule evaluates to ALARM state
430
466
        last = now - datetime.timedelta(seconds=300)
431
467
        data = WatchData(35, now - datetime.timedelta(seconds=150))
432
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
468
        self.wr = watchrule.WatchRule(context=self.ctx,
433
469
                                      watch_name="testwatch",
434
470
                                      rule=rule,
435
471
                                      watch_data=[data],
436
472
                                      stack_id=self.stack_id,
437
473
                                      last_evaluated=last)
438
474
 
439
 
        actions = watcher.evaluate()
440
 
        self.assertEqual(watcher.state, 'ALARM')
 
475
        actions = self.wr.evaluate()
 
476
        self.assertEqual(self.wr.state, 'ALARM')
441
477
        self.assertEqual(actions, ['DummyAction'])
442
478
 
443
 
        # re-set last_evaluated so the rule will be evaluated again,
444
 
        # but since we're already in ALARM state, we should not generate
445
 
        # any additional actions
 
479
        # re-set last_evaluated so the rule will be evaluated again.
446
480
        last = now - datetime.timedelta(seconds=300)
447
 
        watcher.last_evaluated = last
448
 
        actions = watcher.evaluate()
449
 
        self.assertEqual(watcher.state, 'ALARM')
450
 
        self.assertEqual(actions, [])
 
481
        self.wr.last_evaluated = last
 
482
        actions = self.wr.evaluate()
 
483
        self.assertEqual(self.wr.state, 'ALARM')
 
484
        self.assertEqual(actions, ['DummyAction'])
451
485
        self.m.VerifyAll()
452
486
 
 
487
    @utils.wr_delete_after
453
488
    def test_rule_actions_alarm_two_actions(self):
454
489
        rule = {'EvaluationPeriods': '1',
455
490
                'MetricName': 'test_metric',
465
500
        # Set data so rule evaluates to ALARM state
466
501
        last = now - datetime.timedelta(seconds=300)
467
502
        data = WatchData(35, now - datetime.timedelta(seconds=150))
468
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
503
        self.wr = watchrule.WatchRule(context=self.ctx,
469
504
                                      watch_name="testwatch",
470
505
                                      rule=rule,
471
506
                                      watch_data=[data],
472
507
                                      stack_id=self.stack_id,
473
508
                                      last_evaluated=last)
474
509
 
475
 
        actions = watcher.evaluate()
476
 
        self.assertEqual(watcher.state, 'ALARM')
 
510
        actions = self.wr.evaluate()
 
511
        self.assertEqual(self.wr.state, 'ALARM')
477
512
        self.assertEqual(actions, ['DummyAction', 'DummyAction'])
478
513
        self.m.VerifyAll()
479
514
 
 
515
    @utils.wr_delete_after
480
516
    def test_rule_actions_ok_alarm(self):
481
517
        rule = {'EvaluationPeriods': '1',
482
518
                'MetricName': 'test_metric',
491
527
 
492
528
        # On creation the rule evaluates to NODATA state
493
529
        last = now - datetime.timedelta(seconds=300)
494
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
530
        self.wr = watchrule.WatchRule(context=self.ctx,
495
531
                                      watch_name="testwatch",
496
532
                                      rule=rule,
497
533
                                      watch_data=[],
498
534
                                      stack_id=self.stack_id,
499
535
                                      last_evaluated=last)
500
536
 
501
 
        actions = watcher.evaluate()
502
 
        self.assertEqual(watcher.state, 'NODATA')
 
537
        actions = self.wr.evaluate()
 
538
        self.assertEqual(self.wr.state, 'NODATA')
503
539
        self.assertEqual(actions, [])
504
540
 
505
541
        # Move time forward and add data below threshold so we transition from
510
546
        self._action_set_stubs(now)
511
547
 
512
548
        data = WatchData(25, now - datetime.timedelta(seconds=150))
513
 
        watcher.watch_data = [data]
 
549
        self.wr.watch_data = [data]
514
550
 
515
 
        actions = watcher.evaluate()
516
 
        self.assertEqual(watcher.state, 'NORMAL')
 
551
        actions = self.wr.evaluate()
 
552
        self.assertEqual(self.wr.state, 'NORMAL')
517
553
        self.assertEqual(actions, ['DummyAction'])
518
554
        self.m.VerifyAll()
519
555
 
 
556
    @utils.wr_delete_after
520
557
    def test_rule_actions_nodata(self):
521
558
        rule = {'EvaluationPeriods': '1',
522
559
                'MetricName': 'test_metric',
532
569
        # Set data so rule evaluates to ALARM state
533
570
        last = now - datetime.timedelta(seconds=300)
534
571
        data = WatchData(35, now - datetime.timedelta(seconds=150))
535
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
572
        self.wr = watchrule.WatchRule(context=self.ctx,
536
573
                                      watch_name="testwatch",
537
574
                                      rule=rule,
538
575
                                      watch_data=[data],
539
576
                                      stack_id=self.stack_id,
540
577
                                      last_evaluated=last)
541
578
 
542
 
        actions = watcher.evaluate()
543
 
        self.assertEqual(watcher.state, 'ALARM')
 
579
        actions = self.wr.evaluate()
 
580
        self.assertEqual(self.wr.state, 'ALARM')
544
581
        self.assertEqual(actions, [])
545
582
 
546
583
        # Move time forward and don't add data so we transition from
550
587
        self.m.UnsetStubs()
551
588
        self._action_set_stubs(now)
552
589
 
553
 
        actions = watcher.evaluate()
554
 
        self.assertEqual(watcher.state, 'NODATA')
 
590
        actions = self.wr.evaluate()
 
591
        self.assertEqual(self.wr.state, 'NODATA')
555
592
        self.assertEqual(actions, ['DummyAction'])
556
593
        self.m.VerifyAll()
557
594
 
 
595
    @utils.wr_delete_after
558
596
    def test_create_watch_data(self):
559
597
        rule = {u'EvaluationPeriods': u'1',
560
598
                u'AlarmDescription': u'test alarm',
563
601
                u'Statistic': u'SampleCount',
564
602
                u'Threshold': u'2',
565
603
                u'MetricName': u'CreateDataMetric'}
566
 
        wr = watchrule.WatchRule(context=self.ctx,
567
 
                                 watch_name='create_data_test',
568
 
                                 stack_id=self.stack_id, rule=rule)
 
604
        self.wr = watchrule.WatchRule(context=self.ctx,
 
605
                                      watch_name='create_data_test',
 
606
                                      stack_id=self.stack_id, rule=rule)
569
607
 
570
 
        wr.store()
 
608
        self.wr.store()
571
609
 
572
610
        data = {u'CreateDataMetric': {"Unit": "Counter",
573
611
                                      "Value": "1",
574
612
                                      "Dimensions": []}}
575
 
        wr.create_watch_data(data)
 
613
        self.wr.create_watch_data(data)
576
614
 
577
615
        dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test')
578
616
        self.assertEqual(dbwr.watch_data[0].data, data)
584
622
        # correctly get a list of all datapoints where watch_rule_id ==
585
623
        # watch_rule.id, so leave it as a single-datapoint test for now.
586
624
 
587
 
        # Cleanup
588
 
        db_api.watch_rule_delete(self.ctx, 'create_data_test')
 
625
    @utils.wr_delete_after
 
626
    def test_create_watch_data_suspended(self):
 
627
        rule = {u'EvaluationPeriods': u'1',
 
628
                u'AlarmDescription': u'test alarm',
 
629
                u'Period': u'300',
 
630
                u'ComparisonOperator': u'GreaterThanThreshold',
 
631
                u'Statistic': u'SampleCount',
 
632
                u'Threshold': u'2',
 
633
                u'MetricName': u'CreateDataMetric'}
 
634
        self.wr = watchrule.WatchRule(context=self.ctx,
 
635
                                      watch_name='create_data_test',
 
636
                                      stack_id=self.stack_id, rule=rule,
 
637
                                      state=watchrule.WatchRule.SUSPENDED)
 
638
 
 
639
        self.wr.store()
 
640
 
 
641
        data = {u'CreateDataMetric': {"Unit": "Counter",
 
642
                                      "Value": "1",
 
643
                                      "Dimensions": []}}
 
644
        self.wr.create_watch_data(data)
 
645
 
 
646
        dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test')
 
647
        self.assertEqual(dbwr.watch_data, [])
 
648
 
 
649
    def test_destroy(self):
 
650
        rule = {'EvaluationPeriods': '1',
 
651
                'MetricName': 'test_metric',
 
652
                'AlarmActions': ['DummyAction'],
 
653
                'Period': '300',
 
654
                'Statistic': 'Maximum',
 
655
                'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
 
656
                'Threshold': '30'}
 
657
 
 
658
        last = timeutils.utcnow()
 
659
        self.wr = watchrule.WatchRule(context=self.ctx,
 
660
                                      watch_name="testwatch_destroy",
 
661
                                      rule=rule,
 
662
                                      watch_data=[],
 
663
                                      stack_id=self.stack_id,
 
664
                                      last_evaluated=last)
 
665
 
 
666
        self.wr.store()
 
667
 
 
668
        check = watchrule.WatchRule.load(context=self.ctx,
 
669
                                         watch_name="testwatch_destroy")
 
670
        self.assertTrue(isinstance(check, watchrule.WatchRule))
 
671
 
 
672
        self.wr.destroy()
 
673
        self.assertRaises(exception.WatchRuleNotFound,
 
674
                          watchrule.WatchRule.load, context=self.ctx,
 
675
                          watch_name="testwatch_destroy")
 
676
 
 
677
    def test_state_set(self):
 
678
        rule = {'EvaluationPeriods': '1',
 
679
                'MetricName': 'test_metric',
 
680
                'AlarmActions': ['DummyAction'],
 
681
                'Period': '300',
 
682
                'Statistic': 'Maximum',
 
683
                'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
 
684
                'Threshold': '30'}
 
685
 
 
686
        last = timeutils.utcnow()
 
687
        watcher = watchrule.WatchRule(context=self.ctx,
 
688
                                      watch_name="testwatch_set_state",
 
689
                                      rule=rule,
 
690
                                      watch_data=[],
 
691
                                      stack_id=self.stack_id,
 
692
                                      last_evaluated=last)
 
693
 
 
694
        watcher.state_set(watcher.SUSPENDED)
 
695
        self.assertEqual(watcher.state, watcher.SUSPENDED)
 
696
 
 
697
        check = watchrule.WatchRule.load(context=self.ctx,
 
698
                                         watch_name="testwatch_set_state")
 
699
        self.assertEqual(check.state, watchrule.WatchRule.SUSPENDED)
589
700
 
590
701
    def test_set_watch_state(self):
591
702
        rule = {'EvaluationPeriods': '1',
601
712
 
602
713
        # Set data so rule evaluates to ALARM state
603
714
        last = now - datetime.timedelta(seconds=200)
604
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
715
        self.wr = watchrule.WatchRule(context=self.ctx,
605
716
                                      watch_name="testwatch",
606
717
                                      rule=rule,
607
718
                                      watch_data=[],
608
719
                                      stack_id=self.stack_id,
609
720
                                      last_evaluated=last)
610
721
 
611
 
        actions = watcher.set_watch_state(watchrule.WatchRule.NODATA)
612
 
        self.assertEqual(actions, [])
613
 
 
614
 
        actions = watcher.set_watch_state(watchrule.WatchRule.NORMAL)
615
 
        self.assertEqual(actions, [])
616
 
 
617
 
        actions = watcher.set_watch_state(watchrule.WatchRule.ALARM)
 
722
        actions = self.wr.set_watch_state(watchrule.WatchRule.NODATA)
 
723
        self.assertEqual(actions, [])
 
724
 
 
725
        actions = self.wr.set_watch_state(watchrule.WatchRule.NORMAL)
 
726
        self.assertEqual(actions, [])
 
727
 
 
728
        actions = self.wr.set_watch_state(watchrule.WatchRule.ALARM)
618
729
        self.assertEqual(actions, ['DummyAction'])
619
730
        self.m.VerifyAll()
620
731
 
630
741
        now = timeutils.utcnow()
631
742
 
632
743
        last = now - datetime.timedelta(seconds=200)
633
 
        watcher = watchrule.WatchRule(context=self.ctx,
 
744
        self.wr = watchrule.WatchRule(context=self.ctx,
634
745
                                      watch_name="testwatch",
635
746
                                      rule=rule,
636
747
                                      watch_data=[],
637
748
                                      stack_id=self.stack_id,
638
749
                                      last_evaluated=last)
639
750
 
640
 
        self.assertRaises(ValueError, watcher.set_watch_state, None)
 
751
        self.assertRaises(ValueError, self.wr.set_watch_state, None)
641
752
 
642
 
        self.assertRaises(ValueError, watcher.set_watch_state, "BADSTATE")
 
753
        self.assertRaises(ValueError, self.wr.set_watch_state, "BADSTATE")