← Back to branch summary

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

« back to all changes in this revision

Viewing changes to heat/tests/test_stack_resource.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-09-08 21:51:19 UTC
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: package-import@ubuntu.com-20130908215119-7tcek6gn73275x5k
Tags: upstream-2013.2~b3
Import upstream version 2013.2~b3

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_stack_resource.py
12
12
#    License for the specific language governing permissions and limitations
13
13
#    under the License.
14
14
 
 
15
 
 
16
import mox
 
17
 
15
18
from heat.common import template_format
16
19
from heat.common import exception
17
20
from heat.engine import environment
23
26
from heat.openstack.common import uuidutils
24
27
from heat.tests.common import HeatTestCase
25
28
from heat.tests import generic_resource as generic_rsrc
26
 
from heat.tests.utils import dummy_context
27
 
from heat.tests.utils import setup_dummy_db
28
 
from heat.tests.utils import stack_delete_after
 
29
from heat.tests import utils
 
30
 
29
31
 
30
32
ws_res_snippet = {"Type": "some_magic_type",
31
33
                  "metadata": {
32
34
                      "key": "value",
33
35
                      "some": "more stuff"}}
34
36
 
35
 
wp_template = '''
 
37
param_template = '''
36
38
{
37
 
  "AWSTemplateFormatVersion" : "2010-09-09",
38
 
  "Description" : "WordPress",
39
39
  "Parameters" : {
40
40
    "KeyName" : {
41
41
      "Description" : "KeyName",
45
45
  },
46
46
  "Resources" : {
47
47
    "WebServer": {
48
 
      "Type": "AWS::EC2::Instance",
49
 
      "metadata": {"Fn::ResourceFacade": "Metadata"},
50
 
      "Properties": {
51
 
        "ImageId" : "F17-x86_64-gold",
52
 
        "InstanceType"   : "m1.large",
53
 
        "KeyName"        : "test",
54
 
        "UserData"       : "wordpress"
55
 
      }
 
48
      "Type": "GenericResource",
 
49
      "Properties": {}
56
50
    }
57
51
  }
58
52
}
59
53
'''
60
54
 
61
55
 
62
 
generic_template = '''
 
56
simple_template = '''
63
57
{
64
 
  "AWSTemplateFormatVersion" : "2010-09-09",
65
 
  "Description" : "WordPress",
66
58
  "Parameters" : {},
67
59
  "Resources" : {
68
60
    "WebServer": {
95
87
 
96
88
    def setUp(self):
97
89
        super(StackResourceTest, self).setUp()
98
 
        setup_dummy_db()
 
90
        utils.setup_dummy_db()
99
91
        resource._register_class('some_magic_type',
100
92
                                 MyStackResource)
101
93
        resource._register_class('GenericResource',
102
94
                                 generic_rsrc.GenericResource)
103
95
        t = parser.Template({template.RESOURCES:
104
96
                             {"provider_resource": ws_res_snippet}})
105
 
        self.parent_stack = parser.Stack(dummy_context(), 'test_stack', t,
106
 
                                         stack_id=uuidutils.generate_uuid())
 
97
        self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack',
 
98
                                         t, stack_id=uuidutils.generate_uuid())
107
99
        self.parent_resource = MyStackResource('test',
108
100
                                               ws_res_snippet,
109
101
                                               self.parent_stack)
110
 
        self.templ = template_format.parse(wp_template)
111
 
        self.generic_template = template_format.parse(generic_template)
 
102
        self.templ = template_format.parse(param_template)
 
103
        self.simple_template = template_format.parse(simple_template)
112
104
 
113
 
    @stack_delete_after
 
105
    @utils.stack_delete_after
114
106
    def test_create_with_template_ok(self):
115
107
        self.parent_resource.create_with_template(self.templ,
116
108
                                                  {"KeyName": "key"})
122
114
        self.assertEqual(self.templ, self.stack.t.t)
123
115
        self.assertEqual(self.stack.id, self.parent_resource.resource_id)
124
116
 
125
 
    @stack_delete_after
 
117
    @utils.stack_delete_after
 
118
    def test_create_with_template_validates(self):
 
119
        """
 
120
        Creating a stack with a template validates the created stack, so that
 
121
        an invalid template will cause an error to be raised.
 
122
        """
 
123
        # Make a parameter key with the same name as the resource to cause a
 
124
        # simple validation error
 
125
        template = self.simple_template.copy()
 
126
        template['Parameters']['WebServer'] = {'Type': 'String'}
 
127
        self.assertRaises(
 
128
            exception.StackValidationFailed,
 
129
            self.parent_resource.create_with_template,
 
130
            template, {'WebServer': 'foo'})
 
131
 
 
132
    @utils.stack_delete_after
 
133
    def test_update_with_template_validates(self):
 
134
        """Updating a stack with a template validates the created stack."""
 
135
        create_result = self.parent_resource.create_with_template(
 
136
            self.simple_template, {})
 
137
        while not create_result.step():
 
138
            pass
 
139
 
 
140
        template = self.simple_template.copy()
 
141
        template['Parameters']['WebServer'] = {'Type': 'String'}
 
142
        self.assertRaises(
 
143
            exception.StackValidationFailed,
 
144
            self.parent_resource.update_with_template,
 
145
            template, {'WebServer': 'foo'})
 
146
 
 
147
    @utils.stack_delete_after
126
148
    def test_update_with_template_ok(self):
127
149
        """
128
150
        The update_with_template method updates the nested stack with the
129
151
        given template and user parameters.
130
152
        """
131
153
        create_result = self.parent_resource.create_with_template(
132
 
            self.generic_template, {})
 
154
            self.simple_template, {})
133
155
        while not create_result.step():
134
156
            pass
135
157
        self.stack = self.parent_resource.nested()
136
158
 
137
 
        new_templ = self.generic_template.copy()
 
159
        new_templ = self.simple_template.copy()
138
160
        inst_snippet = new_templ["Resources"]["WebServer"].copy()
139
161
        new_templ["Resources"]["WebServer2"] = inst_snippet
140
 
        update_result = self.parent_resource.update_with_template(
 
162
        updater = self.parent_resource.update_with_template(
141
163
            new_templ, {})
 
164
        updater.run_to_completion()
 
165
        self.assertEqual(True,
 
166
                         self.parent_resource.check_update_complete(updater))
142
167
        self.assertEqual(self.stack.state, ('UPDATE', 'COMPLETE'))
143
168
        self.assertEqual(set(self.stack.resources.keys()),
144
169
                         set(["WebServer", "WebServer2"]))
145
170
 
146
 
    @stack_delete_after
 
171
        # The stack's owner_id is maintained.
 
172
        saved_stack = parser.Stack.load(
 
173
            self.parent_stack.context, self.stack.id)
 
174
        self.assertEqual(saved_stack.owner_id, self.parent_stack.id)
 
175
 
 
176
    @utils.stack_delete_after
 
177
    def test_update_with_template_state_err(self):
 
178
        """
 
179
        update_with_template_state_err method should raise error when update
 
180
        task is done but the nested stack is in (UPDATE, FAILED) state.
 
181
        """
 
182
        create_creator = self.parent_resource.create_with_template(
 
183
            self.simple_template, {})
 
184
        create_creator.run_to_completion()
 
185
        self.stack = self.parent_resource.nested()
 
186
 
 
187
        new_templ = self.simple_template.copy()
 
188
        inst_snippet = new_templ["Resources"]["WebServer"].copy()
 
189
        new_templ["Resources"]["WebServer2"] = inst_snippet
 
190
 
 
191
        def update_task():
 
192
            yield
 
193
            self.stack.state_set(parser.Stack.UPDATE, parser.Stack.FAILED, '')
 
194
 
 
195
        self.m.StubOutWithMock(self.stack, 'update_task')
 
196
        self.stack.update_task(mox.IgnoreArg()).AndReturn(update_task())
 
197
        self.m.ReplayAll()
 
198
 
 
199
        updater = self.parent_resource.update_with_template(new_templ, {})
 
200
        updater.run_to_completion()
 
201
        self.assertEqual((self.stack.UPDATE, self.stack.FAILED),
 
202
                         self.stack.state)
 
203
        ex = self.assertRaises(exception.Error,
 
204
                               self.parent_resource.check_update_complete,
 
205
                               updater)
 
206
        self.assertEqual('Nested stack update failed: ', str(ex))
 
207
 
 
208
        self.m.VerifyAll()
 
209
 
 
210
    @utils.stack_delete_after
147
211
    def test_load_nested_ok(self):
148
212
        self.parent_resource.create_with_template(self.templ,
149
213
                                                  {"KeyName": "key"})
159
223
        self.parent_resource.nested()
160
224
        self.m.VerifyAll()
161
225
 
162
 
    @stack_delete_after
 
226
    @utils.stack_delete_after
163
227
    def test_load_nested_non_exist(self):
164
228
        self.parent_resource.create_with_template(self.templ,
165
229
                                                  {"KeyName": "key"})
210
274
 
211
275
        self.m.VerifyAll()
212
276
 
213
 
    @stack_delete_after
 
277
    @utils.stack_delete_after
214
278
    def test_create_complete_state_err(self):
215
279
        """
216
280
        check_create_complete should raise error when create task is
236
300
        self.m.StubOutWithMock(parser, 'Stack')
237
301
        parser.Stack(ctx, phy_id, templ, env, timeout_mins=None,
238
302
                     disable_rollback=True,
239
 
                     parent_resource=self.parent_resource)\
 
303
                     parent_resource=self.parent_resource,
 
304
                     owner_id=self.parent_stack.id)\
240
305
            .AndReturn(self.stack)
241
306
 
242
307
        st_set = self.stack.state_set
258
323
        # Restore state_set to let clean up proceed
259
324
        self.stack.state_set = st_set
260
325
 
261
 
    @stack_delete_after
 
326
    @utils.stack_delete_after
262
327
    def test_suspend_complete_state_err(self):
263
328
        """
264
329
        check_suspend_complete should raise error when suspend task is
288
353
        # Restore state_set to let clean up proceed
289
354
        self.stack.state_set = st_set
290
355
 
291
 
    @stack_delete_after
 
356
    @utils.stack_delete_after
292
357
    def test_resume_complete_state_err(self):
293
358
        """
294
359
        check_resume_complete should raise error when resume task is