← Back to branch summary

~ubuntu-branches/ubuntu/saucy/heat/saucy-updates

« back to all changes in this revision

Viewing changes to heat/tests/test_engine_service.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-08 15:23:59 UTC
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: package-import@ubuntu.com-20130808152359-187gmaw0nx1oduxy
Tags: upstream-2013.2~b2.a186.g2b4b248
Import upstream version 2013.2~b2.a186.g2b4b248

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_engine_service.py
22
22
 
23
23
from oslo.config import cfg
24
24
 
25
 
from heat.common import config
26
 
from heat.common import context
27
25
from heat.engine import environment
28
26
from heat.common import exception
29
27
from heat.tests.v1_1 import fakes
35
33
from heat.engine import service
36
34
from heat.engine.properties import Properties
37
35
from heat.engine.resources import instance as instances
 
36
from heat.engine import resource as rsrs
38
37
from heat.engine import watchrule
39
38
from heat.openstack.common import threadgroup
40
39
from heat.tests.common import HeatTestCase
41
40
from heat.tests import utils
 
41
from heat.tests.utils import dummy_context
42
42
from heat.tests.utils import setup_dummy_db
43
43
 
44
44
 
67
67
}
68
68
'''
69
69
 
 
70
alarm_template = '''
 
71
{
 
72
  "AWSTemplateFormatVersion" : "2010-09-09",
 
73
  "Description" : "alarming",
 
74
  "Resources" : {
 
75
    "service_alarm": {
 
76
      "Type": "AWS::CloudWatch::Alarm",
 
77
      "Properties": {
 
78
        "EvaluationPeriods": "1",
 
79
        "AlarmActions": [],
 
80
        "AlarmDescription": "do the thing",
 
81
        "Namespace": "dev/null",
 
82
        "Period": "300",
 
83
        "ComparisonOperator": "GreaterThanThreshold",
 
84
        "Statistic": "SampleCount",
 
85
        "Threshold": "2",
 
86
        "MetricName": "ServiceFailure"
 
87
      }
 
88
    }
 
89
  }
 
90
}
 
91
'''
 
92
 
 
93
policy_template = '''
 
94
{
 
95
  "AWSTemplateFormatVersion" : "2010-09-09",
 
96
  "Description" : "alarming",
 
97
  "Resources" : {
 
98
    "WebServerScaleDownPolicy" : {
 
99
      "Type" : "AWS::AutoScaling::ScalingPolicy",
 
100
      "Properties" : {
 
101
        "AdjustmentType" : "ChangeInCapacity",
 
102
        "AutoScalingGroupName" : "",
 
103
        "Cooldown" : "60",
 
104
        "ScalingAdjustment" : "-1"
 
105
      }
 
106
    }
 
107
  }
 
108
}
 
109
'''
 
110
 
70
111
 
71
112
def create_context(mocks, user='stacks_test_user',
72
 
                   tenant='test_admin', password='stacks_test_password'):
73
 
    ctx = context.get_admin_context()
 
113
                   tenant_id='test_admin', password='stacks_test_password'):
 
114
    ctx = dummy_context()
74
115
    mocks.StubOutWithMock(ctx, 'username')
75
116
    mocks.StubOutWithMock(ctx, 'tenant_id')
76
117
    mocks.StubOutWithMock(ctx, 'password')
77
118
    ctx.username = user
78
 
    ctx.tenant_id = tenant
 
119
    ctx.tenant_id = tenant_id
79
120
    ctx.password = password
80
121
    return ctx
81
122
 
88
129
    return stack
89
130
 
90
131
 
 
132
def get_stack(stack_name, ctx, template):
 
133
    t = template_format.parse(template)
 
134
    template = parser.Template(t)
 
135
    stack = parser.Stack(ctx, stack_name, template)
 
136
    return stack
 
137
 
 
138
 
91
139
def setup_mocks(mocks, stack):
92
140
    fc = fakes.FakeClient()
93
141
    mocks.StubOutWithMock(instances.Instance, 'nova')
173
221
 
174
222
    def add_timer(self, interval, callback, initial_delay=None,
175
223
                  *args, **kwargs):
176
 
        pass
 
224
        self.threads.append(callback)
177
225
 
178
226
    def add_thread(self, callback, *args, **kwargs):
179
227
        self.threads.append(callback)
180
 
        pass
181
228
 
182
229
    def stop(self):
183
230
        pass
186
233
        pass
187
234
 
188
235
 
189
 
class stackCreateTest(HeatTestCase):
 
236
class StackCreateTest(HeatTestCase):
190
237
    def setUp(self):
191
 
        super(stackCreateTest, self).setUp()
 
238
        super(StackCreateTest, self).setUp()
192
239
        setup_dummy_db()
193
240
 
194
241
    def test_wordpress_single_instance_stack_create(self):
203
250
        self.assertNotEqual(stack.resources['WebServer'].ipaddress, '0.0.0.0')
204
251
 
205
252
    def test_wordpress_single_instance_stack_delete(self):
206
 
        ctx = create_context(self.m, tenant='test_delete_tenant')
 
253
        ctx = create_context(self.m)
207
254
        stack = get_wordpress_stack('test_stack', ctx)
208
255
        fc = setup_mocks(self.m, stack)
209
256
        self.m.ReplayAll()
230
277
        self.assertEqual('COMPLETE', db_s.status, )
231
278
 
232
279
 
233
 
class stackServiceCreateUpdateDeleteTest(HeatTestCase):
 
280
class StackServiceCreateUpdateDeleteTest(HeatTestCase):
234
281
 
235
282
    def setUp(self):
236
 
        super(stackServiceCreateUpdateDeleteTest, self).setUp()
237
 
        self.username = 'stack_service_create_test_user'
238
 
        self.tenant = 'stack_service_create_test_tenant'
 
283
        super(StackServiceCreateUpdateDeleteTest, self).setUp()
239
284
        setup_dummy_db()
240
 
        self.ctx = create_context(self.m, self.username, self.tenant)
 
285
        self.ctx = create_context(self.m)
241
286
 
242
287
        self.man = service.EngineService('a-host', 'a-topic')
243
288
 
368
413
    def test_stack_delete(self):
369
414
        stack_name = 'service_delete_test_stack'
370
415
        stack = get_wordpress_stack(stack_name, self.ctx)
371
 
        sid = stack.store()
372
 
 
373
 
        s = db_api.stack_get(self.ctx, sid)
374
 
        self.m.StubOutWithMock(parser.Stack, 'load')
375
 
 
376
 
        parser.Stack.load(self.ctx, stack=s).AndReturn(stack)
 
416
        stack.status = "COMPLETE"
 
417
        stack.store()
377
418
 
378
419
        self.man.tg = DummyThreadGroup()
379
420
 
383
424
                         self.man.delete_stack(self.ctx, stack.identifier()))
384
425
        self.m.VerifyAll()
385
426
 
 
427
    def test_stack_delete_action_in_progress_err(self):
 
428
        '''
 
429
        Test that deleting a stack with an action in progress results in
 
430
        an ActionInProgress exception.
 
431
 
 
432
        '''
 
433
        stack_name = 'service_delete_action_in_progress_err'
 
434
        stack = get_wordpress_stack(stack_name, self.ctx)
 
435
        stack.status = "IN_PROGRESS"
 
436
        stack.store()
 
437
 
 
438
        self.assertRaises(exception.ActionInProgress,
 
439
                          self.man.delete_stack,
 
440
                          self.ctx,
 
441
                          stack.identifier())
 
442
 
386
443
    def test_stack_delete_nonexist(self):
387
444
        stack_name = 'service_delete_nonexist_test_stack'
388
445
        stack = get_wordpress_stack(stack_name, self.ctx)
389
446
 
390
 
        self.m.ReplayAll()
391
 
 
392
447
        self.assertRaises(exception.StackNotFound,
393
448
                          self.man.delete_stack,
394
449
                          self.ctx, stack.identifier())
395
 
        self.m.VerifyAll()
396
450
 
397
451
    def test_stack_update(self):
398
452
        stack_name = 'service_update_test_stack'
400
454
        template = '{ "Template": "data" }'
401
455
 
402
456
        old_stack = get_wordpress_stack(stack_name, self.ctx)
 
457
        old_stack.status = 'COMPLETE'
403
458
        sid = old_stack.store()
404
459
        s = db_api.stack_get(self.ctx, sid)
405
460
 
432
487
        self.assertTrue(result['stack_id'])
433
488
        self.m.VerifyAll()
434
489
 
 
490
    def test_stack_update_action_in_progress_err(self):
 
491
        '''
 
492
        Test that updating a stack with an action in progress results
 
493
        in an ActionInProgress exception.
 
494
 
 
495
        '''
 
496
        stack_name = 'service_update_action_in_progress_err_test_stack'
 
497
        params = {'foo': 'bar'}
 
498
        template = '{ "Template": "data" }'
 
499
 
 
500
        old_stack = get_wordpress_stack(stack_name, self.ctx)
 
501
        old_stack.status = 'IN_PROGRESS'
 
502
        old_stack.store()
 
503
 
 
504
        self.assertRaises(
 
505
            exception.ActionInProgress,
 
506
            self.man.update_stack,
 
507
            self.ctx, old_stack.identifier(),
 
508
            template, params, None, {})
 
509
 
435
510
    def test_stack_update_verify_err(self):
436
511
        stack_name = 'service_update_verify_err_test_stack'
437
512
        params = {'foo': 'bar'}
438
513
        template = '{ "Template": "data" }'
439
514
 
440
515
        old_stack = get_wordpress_stack(stack_name, self.ctx)
 
516
        old_stack.status = 'COMPLETE'
441
517
        old_stack.store()
442
518
        sid = old_stack.store()
443
519
        s = db_api.stack_get(self.ctx, sid)
503
579
                          None, {})
504
580
 
505
581
 
506
 
class stackServiceSuspendResumeTest(HeatTestCase):
 
582
class StackServiceSuspendResumeTest(HeatTestCase):
507
583
 
508
584
    def setUp(self):
509
 
        super(stackServiceSuspendResumeTest, self).setUp()
510
 
        self.username = 'stack_service_suspend_test_user'
511
 
        self.tenant = 'stack_service_suspend_test_tenant'
 
585
        super(StackServiceSuspendResumeTest, self).setUp()
512
586
        setup_dummy_db()
513
 
        self.ctx = create_context(self.m, self.username, self.tenant)
 
587
        self.ctx = create_context(self.m)
514
588
 
515
589
        self.man = service.EngineService('a-host', 'a-topic')
516
590
 
571
645
        self.m.VerifyAll()
572
646
 
573
647
 
574
 
class stackServiceTest(HeatTestCase):
 
648
class StackServiceTest(HeatTestCase):
575
649
 
576
650
    def setUp(self):
577
 
        super(stackServiceTest, self).setUp()
578
 
 
579
 
        config.register_engine_opts()
580
 
        self.username = 'stack_service_test_user'
581
 
        self.tenant = 'stack_service_test_tenant'
582
 
 
583
 
        self.ctx = create_context(self.m, self.username, self.tenant)
 
651
        super(StackServiceTest, self).setUp()
 
652
 
 
653
        self.ctx = create_context(self.m,
 
654
                                  tenant_id='stack_service_test_tenant')
584
655
        self.eng = service.EngineService('a-host', 'a-topic')
585
656
        cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role')
586
657
 
625
696
        self.assertEqual(self.stack.id,
626
697
                         db_api.stack_get_by_name(self.ctx,
627
698
                                                  self.stack.name).id)
628
 
        ctx2 = create_context(self.m, self.username,
629
 
                              'stack_service_test_tenant2')
 
699
        ctx2 = create_context(self.m, tenant_id='stack_service_test_tenant2')
630
700
        self.assertEqual(None, db_api.stack_get_by_name(ctx2, self.stack.name))
631
701
 
632
702
    @stack_context('service_event_list_test_stack')
1052
1122
 
1053
1123
        self.m.VerifyAll()
1054
1124
 
 
1125
    def test_signal_reception(self):
 
1126
        stack = get_stack('signal_reception',
 
1127
                          self.ctx,
 
1128
                          policy_template)
 
1129
        self.stack = stack
 
1130
        self.m.ReplayAll()
 
1131
        stack.store()
 
1132
        stack.create()
 
1133
        test_data = {'food': 'yum'}
 
1134
 
 
1135
        self.m.StubOutWithMock(service.EngineService, '_get_stack')
 
1136
        s = db_api.stack_get(self.ctx, self.stack.id)
 
1137
        service.EngineService._get_stack(self.ctx,
 
1138
                                         self.stack.identifier()).AndReturn(s)
 
1139
 
 
1140
        self.m.StubOutWithMock(db_api, 'user_creds_get')
 
1141
        db_api.user_creds_get(mox.IgnoreArg()).MultipleTimes().AndReturn(
 
1142
            self.ctx.to_dict())
 
1143
 
 
1144
        self.m.StubOutWithMock(rsrs.Resource, 'signal')
 
1145
        rsrs.Resource.signal(mox.IgnoreArg()).AndReturn(None)
 
1146
        self.m.ReplayAll()
 
1147
 
 
1148
        result = self.eng.resource_signal(self.ctx,
 
1149
                                          dict(self.stack.identifier()),
 
1150
                                          'WebServerScaleDownPolicy',
 
1151
                                          test_data)
 
1152
        self.m.VerifyAll()
 
1153
        self.stack.delete()
 
1154
 
 
1155
    def test_signal_reception_no_resource(self):
 
1156
        stack = get_stack('signal_reception_no_resource',
 
1157
                          self.ctx,
 
1158
                          policy_template)
 
1159
        self.stack = stack
 
1160
        self.m.ReplayAll()
 
1161
        stack.store()
 
1162
        stack.create()
 
1163
        test_data = {'food': 'yum'}
 
1164
 
 
1165
        self.m.StubOutWithMock(service.EngineService, '_get_stack')
 
1166
        s = db_api.stack_get(self.ctx, self.stack.id)
 
1167
        service.EngineService._get_stack(self.ctx,
 
1168
                                         self.stack.identifier()).AndReturn(s)
 
1169
 
 
1170
        self.m.StubOutWithMock(db_api, 'user_creds_get')
 
1171
        db_api.user_creds_get(mox.IgnoreArg()).MultipleTimes().AndReturn(
 
1172
            self.ctx.to_dict())
 
1173
        self.m.ReplayAll()
 
1174
 
 
1175
        self.assertRaises(exception.ResourceNotFound,
 
1176
                          self.eng.resource_signal, self.ctx,
 
1177
                          dict(self.stack.identifier()),
 
1178
                          'resource_does_not_exist',
 
1179
                          test_data)
 
1180
        self.m.VerifyAll()
 
1181
        self.stack.delete()
 
1182
 
1055
1183
    @stack_context('service_metadata_test_stack')
1056
1184
    def test_metadata(self):
1057
1185
        test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'}
1062
1190
        service.EngineService._get_stack(self.ctx,
1063
1191
                                         self.stack.identifier()).AndReturn(s)
1064
1192
        self.m.StubOutWithMock(instances.Instance, 'metadata_update')
 
1193
        self.m.StubOutWithMock(db_api, 'user_creds_get')
1065
1194
        instances.Instance.metadata_update(new_metadata=test_metadata)
 
1195
        db_api.user_creds_get(mox.IgnoreArg()).MultipleTimes().AndReturn(
 
1196
            self.ctx.to_dict())
1066
1197
        self.m.ReplayAll()
1067
1198
 
1068
1199
        result = self.eng.metadata_update(self.ctx,
1106
1237
 
1107
1238
        self.m.VerifyAll()
1108
1239
 
 
1240
    @stack_context('periodic_watch_task_not_created')
 
1241
    def test_periodic_watch_task_not_created(self):
 
1242
        self.eng.stg[self.stack.id] = DummyThreadGroup()
 
1243
        self.eng._start_watch_task(self.stack.id, self.ctx)
 
1244
        self.assertEqual([], self.eng.stg[self.stack.id].threads)
 
1245
 
 
1246
    def test_periodic_watch_task_created(self):
 
1247
        stack = get_stack('period_watch_task_created',
 
1248
                          create_context(self.m),
 
1249
                          alarm_template)
 
1250
        self.stack = stack
 
1251
        self.m.ReplayAll()
 
1252
        stack.store()
 
1253
        stack.create()
 
1254
        self.eng.stg[stack.id] = DummyThreadGroup()
 
1255
        self.eng._start_watch_task(stack.id, self.ctx)
 
1256
        self.assertEqual([self.eng._periodic_watcher_task],
 
1257
                         self.eng.stg[stack.id].threads)
 
1258
        self.stack.delete()
 
1259
 
1109
1260
    @stack_context('service_show_watch_test_stack', False)
1110
1261
    @utils.wr_delete_after
1111
1262
    def test_show_watch(self):
1220
1371
                                      state='NORMAL')
1221
1372
        self.wr.store()
1222
1373
 
1223
 
        class DummyAction:
1224
 
            alarm = "dummyfoo"
 
1374
        class DummyAction(object):
 
1375
            signal = "dummyfoo"
1225
1376
 
1226
1377
        dummy_action = DummyAction()
1227
1378
        self.m.StubOutWithMock(parser.Stack, '__getitem__')
1253
1404
                                          watch_name="OverrideAlarm",
1254
1405
                                          state=state)
1255
1406
        self.assertEqual(state, result[engine_api.WATCH_STATE_VALUE])
1256
 
        self.assertEqual([DummyAction.alarm],
 
1407
        self.assertEqual([DummyAction.signal],
1257
1408
                         self.eng.stg[self.stack.id].threads)
1258
1409
 
1259
1410
        self.m.VerifyAll()