← Back to branch summary

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

« back to all changes in this revision

Viewing changes to heat/tests/test_parameters.py

  • Committer: Package Import Robot
  • Author(s): James Page, Chuck Short, James Page
  • Date: 2013-08-08 15:23:59 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20130808152359-9jgqjp23kssvc3x9
Tags: 2013.2~b2.a186.g2b4b248-0ubuntu1
[ Chuck Short ]
* debian/patches/rename-quantumclient.patch: Dropped no longer needed. 
* debian/control: Add python-oslo.sphinx

[ James Page ]
* New upstream snapshot.
* d/watch: Updated to track releases on launchpad.
* d/control: Drop BD in pep8, no longer required.
* d/control,rules: Drop use of openstack-pkg-tools, revert use of xz
  compression for debs.
* d/control,*.config,*.templates,po: Drop use of debconf/dbconfig-common
  to configure heat.
* d/*.upstart: Add upstart configurations for Ubuntu.
* d/p/default-kombu.patch: Switch default messaging from qpid to
  kombu.
* d/p/default-sqlite.patch: Use sqlite as default database option.
* d/control: Add python-ceilometerclient to BD's.
* d/rules: Fail package build for unit test failures.
* d/*.install: Directly install configuration files to /etc/heat.
* d/control: Update VCS locations to ubuntu-server-dev branches.
* d/heat-common.{install,manpages}: Include new binaries and associated
  manpages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_parameters.py
18
18
 
19
19
from heat.common import exception
20
20
from heat.engine import parameters
 
21
from heat.engine import template
21
22
 
22
23
 
23
24
class ParameterTest(testtools.TestCase):
 
25
 
 
26
    def new_parameter(self, name, schema, value=None,
 
27
                      validate_value=True):
 
28
        tmpl = template.Template({template.PARAMETERS: {name:
 
29
                                                        schema}})
 
30
        schema = tmpl.param_schemata()[name]
 
31
        return parameters.Parameter(name, schema, value,
 
32
                                    validate_value)
 
33
 
24
34
    def test_new_string(self):
25
 
        p = parameters.Parameter('p', {'Type': 'String'}, validate_value=False)
 
35
        p = self.new_parameter('p', {'Type': 'String'}, validate_value=False)
26
36
        self.assertTrue(isinstance(p, parameters.StringParam))
27
37
 
28
38
    def test_new_number(self):
29
 
        p = parameters.Parameter('p', {'Type': 'Number'}, validate_value=False)
 
39
        p = self.new_parameter('p', {'Type': 'Number'}, validate_value=False)
30
40
        self.assertTrue(isinstance(p, parameters.NumberParam))
31
41
 
32
42
    def test_new_list(self):
33
 
        p = parameters.Parameter('p', {'Type': 'CommaDelimitedList'},
34
 
                                 validate_value=False)
 
43
        p = self.new_parameter('p', {'Type': 'CommaDelimitedList'},
 
44
                               validate_value=False)
35
45
        self.assertTrue(isinstance(p, parameters.CommaDelimitedListParam))
36
46
 
37
47
    def test_new_json(self):
38
 
        p = parameters.Parameter('p', {'Type': 'Json'}, validate_value=False)
 
48
        p = self.new_parameter('p', {'Type': 'Json'}, validate_value=False)
39
49
        self.assertTrue(isinstance(p, parameters.JsonParam))
40
50
 
41
51
    def test_new_bad_type(self):
42
 
        self.assertRaises(ValueError, parameters.Parameter,
43
 
                          'p', {'Type': 'List'})
 
52
        self.assertRaises(ValueError, self.new_parameter, 'p',
 
53
                          {'Type': 'List'})
44
54
 
45
55
    def test_new_no_type(self):
46
 
        self.assertRaises(KeyError, parameters.Parameter,
 
56
        self.assertRaises(KeyError, self.new_parameter,
47
57
                          'p', {'Default': 'blarg'})
48
58
 
49
59
    def test_default_no_override(self):
50
 
        p = parameters.Parameter('defaulted', {'Type': 'String',
51
 
                                               'Default': 'blarg'})
 
60
        p = self.new_parameter('defaulted', {'Type': 'String',
 
61
                                             'Default': 'blarg'})
52
62
        self.assertTrue(p.has_default())
53
63
        self.assertEqual(p.default(), 'blarg')
54
64
        self.assertEqual(p.value(), 'blarg')
55
65
 
56
66
    def test_default_override(self):
57
 
        p = parameters.Parameter('defaulted',
58
 
                                 {'Type': 'String',
59
 
                                  'Default': 'blarg'},
60
 
                                 'wibble')
 
67
        p = self.new_parameter('defaulted',
 
68
                               {'Type': 'String',
 
69
                                'Default': 'blarg'},
 
70
                               'wibble')
61
71
        self.assertTrue(p.has_default())
62
72
        self.assertEqual(p.default(), 'blarg')
63
73
        self.assertEqual(p.value(), 'wibble')
68
78
                  'ConstraintDescription': 'wibble',
69
79
                  'Default': 'bar'}
70
80
        try:
71
 
            parameters.Parameter('p', schema, 'foo')
 
81
            self.new_parameter('p', schema, 'foo')
72
82
        except ValueError as ve:
73
83
            msg = str(ve)
74
84
            self.assertNotEqual(msg.find('wibble'), -1)
76
86
            self.fail('ValueError not raised')
77
87
 
78
88
    def test_no_echo_true(self):
79
 
        p = parameters.Parameter('anechoic',
80
 
                                 {'Type': 'String',
81
 
                                 'NoEcho': 'true'},
82
 
                                 'wibble')
 
89
        p = self.new_parameter('anechoic',
 
90
                               {'Type': 'String',
 
91
                                'NoEcho': 'true'},
 
92
                               'wibble')
83
93
        self.assertTrue(p.no_echo())
84
94
        self.assertNotEqual(str(p), 'wibble')
85
95
 
86
96
    def test_no_echo_true_caps(self):
87
 
        p = parameters.Parameter('anechoic',
88
 
                                 {'Type': 'String',
89
 
                                 'NoEcho': 'TrUe'},
90
 
                                 'wibble')
 
97
        p = self.new_parameter('anechoic',
 
98
                               {'Type': 'String',
 
99
                                'NoEcho': 'TrUe'},
 
100
                               'wibble')
91
101
        self.assertTrue(p.no_echo())
92
102
        self.assertNotEqual(str(p), 'wibble')
93
103
 
94
104
    def test_no_echo_false(self):
95
 
        p = parameters.Parameter('echoic',
96
 
                                 {'Type': 'String',
97
 
                                 'NoEcho': 'false'},
98
 
                                 'wibble')
 
105
        p = self.new_parameter('echoic',
 
106
                               {'Type': 'String',
 
107
                                'NoEcho': 'false'},
 
108
                               'wibble')
99
109
        self.assertFalse(p.no_echo())
100
110
        self.assertEqual(str(p), 'wibble')
101
111
 
102
112
    def test_description(self):
103
113
        description = 'Description of the parameter'
104
 
        p = parameters.Parameter('p', {'Type': 'String',
105
 
                                       'Description': description},
106
 
                                 validate_value=False)
 
114
        p = self.new_parameter('p', {'Type': 'String',
 
115
                                     'Description': description},
 
116
                               validate_value=False)
107
117
        self.assertEqual(p.description(), description)
108
118
 
109
119
    def test_no_description(self):
110
 
        p = parameters.Parameter('p', {'Type': 'String'}, validate_value=False)
 
120
        p = self.new_parameter('p', {'Type': 'String'}, validate_value=False)
111
121
        self.assertEqual(p.description(), '')
112
122
 
113
123
    def test_string_len_good(self):
114
124
        schema = {'Type': 'String',
115
125
                  'MinLength': '3',
116
126
                  'MaxLength': '3'}
117
 
        p = parameters.Parameter('p', schema, 'foo')
 
127
        p = self.new_parameter('p', schema, 'foo')
118
128
        self.assertEqual(p.value(), 'foo')
119
129
 
120
130
    def test_string_underflow(self):
122
132
                  'ConstraintDescription': 'wibble',
123
133
                  'MinLength': '4'}
124
134
        try:
125
 
            parameters.Parameter('p', schema, 'foo')
 
135
            self.new_parameter('p', schema, 'foo')
126
136
        except ValueError as ve:
127
137
            msg = str(ve)
128
138
            self.assertNotEqual(msg.find('wibble'), -1)
134
144
                  'ConstraintDescription': 'wibble',
135
145
                  'MaxLength': '2'}
136
146
        try:
137
 
            parameters.Parameter('p', schema, 'foo')
 
147
            self.new_parameter('p', schema, 'foo')
138
148
        except ValueError as ve:
139
149
            msg = str(ve)
140
150
            self.assertNotEqual(msg.find('wibble'), -1)
144
154
    def test_string_pattern_good(self):
145
155
        schema = {'Type': 'String',
146
156
                  'AllowedPattern': '[a-z]*'}
147
 
        p = parameters.Parameter('p', schema, 'foo')
 
157
        p = self.new_parameter('p', schema, 'foo')
148
158
        self.assertEqual(p.value(), 'foo')
149
159
 
150
160
    def test_string_pattern_bad_prefix(self):
152
162
                  'ConstraintDescription': 'wibble',
153
163
                  'AllowedPattern': '[a-z]*'}
154
164
        try:
155
 
            parameters.Parameter('p', schema, '1foo')
 
165
            self.new_parameter('p', schema, '1foo')
156
166
        except ValueError as ve:
157
167
            msg = str(ve)
158
168
            self.assertNotEqual(msg.find('wibble'), -1)
164
174
                  'ConstraintDescription': 'wibble',
165
175
                  'AllowedPattern': '[a-z]*'}
166
176
        try:
167
 
            parameters.Parameter('p', schema, 'foo1')
 
177
            self.new_parameter('p', schema, 'foo1')
168
178
        except ValueError as ve:
169
179
            msg = str(ve)
170
180
            self.assertNotEqual(msg.find('wibble'), -1)
174
184
    def test_string_value_list_good(self):
175
185
        schema = {'Type': 'String',
176
186
                  'AllowedValues': ['foo', 'bar', 'baz']}
177
 
        p = parameters.Parameter('p', schema, 'bar')
 
187
        p = self.new_parameter('p', schema, 'bar')
178
188
        self.assertEqual(p.value(), 'bar')
179
189
 
180
190
    def test_string_value_list_bad(self):
182
192
                  'ConstraintDescription': 'wibble',
183
193
                  'AllowedValues': ['foo', 'bar', 'baz']}
184
194
        try:
185
 
            parameters.Parameter('p', schema, 'blarg')
 
195
            self.new_parameter('p', schema, 'blarg')
186
196
        except ValueError as ve:
187
197
            msg = str(ve)
188
198
            self.assertNotEqual(msg.find('wibble'), -1)
193
203
        schema = {'Type': 'Number',
194
204
                  'MinValue': '3',
195
205
                  'MaxValue': '3'}
196
 
        p = parameters.Parameter('p', schema, '3')
 
206
        p = self.new_parameter('p', schema, '3')
197
207
        self.assertEqual(p.value(), '3')
198
208
 
199
209
    def test_number_float_good(self):
200
210
        schema = {'Type': 'Number',
201
211
                  'MinValue': '3.0',
202
212
                  'MaxValue': '3.0'}
203
 
        p = parameters.Parameter('p', schema, '3.0')
 
213
        p = self.new_parameter('p', schema, '3.0')
204
214
        self.assertEqual(p.value(), '3.0')
205
215
 
206
216
    def test_number_low(self):
208
218
                  'ConstraintDescription': 'wibble',
209
219
                  'MinValue': '4'}
210
220
        try:
211
 
            parameters.Parameter('p', schema, '3')
 
221
            self.new_parameter('p', schema, '3')
212
222
        except ValueError as ve:
213
223
            msg = str(ve)
214
224
            self.assertNotEqual(msg.find('wibble'), -1)
220
230
                  'ConstraintDescription': 'wibble',
221
231
                  'MaxValue': '2'}
222
232
        try:
223
 
            parameters.Parameter('p', schema, '3')
 
233
            self.new_parameter('p', schema, '3')
224
234
        except ValueError as ve:
225
235
            msg = str(ve)
226
236
            self.assertNotEqual(msg.find('wibble'), -1)
230
240
    def test_number_value_list_good(self):
231
241
        schema = {'Type': 'Number',
232
242
                  'AllowedValues': ['1', '3', '5']}
233
 
        p = parameters.Parameter('p', schema, '5')
 
243
        p = self.new_parameter('p', schema, '5')
234
244
        self.assertEqual(p.value(), '5')
235
245
 
236
246
    def test_number_value_list_bad(self):
238
248
                  'ConstraintDescription': 'wibble',
239
249
                  'AllowedValues': ['1', '3', '5']}
240
250
        try:
241
 
            parameters.Parameter('p', schema, '2')
 
251
            self.new_parameter('p', schema, '2')
242
252
        except ValueError as ve:
243
253
            msg = str(ve)
244
254
            self.assertNotEqual(msg.find('wibble'), -1)
248
258
    def test_list_value_list_good(self):
249
259
        schema = {'Type': 'CommaDelimitedList',
250
260
                  'AllowedValues': ['foo', 'bar', 'baz']}
251
 
        p = parameters.Parameter('p', schema, 'baz,foo,bar')
 
261
        p = self.new_parameter('p', schema, 'baz,foo,bar')
252
262
        self.assertEqual(p.value(), 'baz,foo,bar')
253
263
 
254
264
    def test_list_value_list_bad(self):
256
266
                  'ConstraintDescription': 'wibble',
257
267
                  'AllowedValues': ['foo', 'bar', 'baz']}
258
268
        try:
259
 
            parameters.Parameter('p', schema, 'foo,baz,blarg')
 
269
            self.new_parameter('p', schema, 'foo,baz,blarg')
260
270
        except ValueError as ve:
261
271
            msg = str(ve)
262
272
            self.assertNotEqual(msg.find('wibble'), -1)
268
278
        schema = {'Type': 'Json'}
269
279
        val = {"foo": "bar", "items": [1, 2, 3]}
270
280
        val_s = json.dumps(val)
271
 
        p = parameters.Parameter('p', schema, val)
 
281
        p = self.new_parameter('p', schema, val)
272
282
        self.assertEqual(val_s, p.value())
273
283
        self.assertEqual(val, p.parsed)
274
284
 
278
288
                  'ConstraintDescription': 'wibble'}
279
289
        val = {"foo": "bar", "not_json": len}
280
290
        try:
281
 
            parameters.Parameter('p', schema, val)
 
291
            self.new_parameter('p', schema, val)
282
292
        except ValueError as verr:
283
293
            self.assertIn('Value must be valid JSON', str(verr))
284
294
        else:
289
299
        schema = {'Type': 'Json'}
290
300
        val = {"foo": "bar", "items": [1, 2, 3]}
291
301
        val_s = json.dumps(val)
292
 
        p = parameters.Parameter('p', schema, val_s)
 
302
        p = self.new_parameter('p', schema, val_s)
293
303
        self.assertEqual(val_s, p.value())
294
304
        self.assertEqual(val, p.parsed)
295
305
 
299
309
                  'ConstraintDescription': 'wibble'}
300
310
        val = "I am not a map"
301
311
        try:
302
 
            parameters.Parameter('p', schema, val)
 
312
            self.new_parameter('p', schema, val)
303
313
        except ValueError as verr:
304
314
            self.assertIn('Value must be valid JSON', str(verr))
305
315
        else:
311
321
                  'AllowedValues': ["foo", "bar", "baz"]}
312
322
        val = {"foo": "bar", "baz": [1, 2, 3]}
313
323
        val_s = json.dumps(val)
314
 
        p = parameters.Parameter('p', schema, val_s)
 
324
        p = self.new_parameter('p', schema, val_s)
315
325
        self.assertEqual(val_s, p.value())
316
326
        self.assertEqual(val, p.parsed)
317
327
 
321
331
                  'AllowedValues': ["foo", "bar", "baz"]}
322
332
        val = {"foo": "bar", "items": [1, 2, 3]}
323
333
        try:
324
 
            parameters.Parameter('p', schema, val)
 
334
            self.new_parameter('p', schema, val)
325
335
        except ValueError as verr:
326
336
            self.assertIn("items", str(verr))
327
337
        else:
333
343
                  'MinLength': 3}
334
344
        val = {"foo": "bar", "items": [1, 2, 3]}
335
345
        try:
336
 
            parameters.Parameter('p', schema, val)
 
346
            self.new_parameter('p', schema, val)
337
347
        except ValueError as verr:
338
348
            self.assertIn('underflows', str(verr))
339
349
        else:
345
355
                  'MaxLength': 1}
346
356
        val = {"foo": "bar", "items": [1, 2, 3]}
347
357
        try:
348
 
            parameters.Parameter('p', schema, val)
 
358
            self.new_parameter('p', schema, val)
349
359
        except ValueError as verr:
350
360
            self.assertIn('overflows', str(verr))
351
361
        else:
354
364
    def test_missing_param(self):
355
365
        '''Test missing user parameter.'''
356
366
        self.assertRaises(exception.UserParameterMissing,
357
 
                          parameters.Parameter, 'p',
 
367
                          self.new_parameter, 'p',
358
368
                          {'Type': 'String'})
359
369
 
360
370
 
370
380
 
371
381
 
372
382
class ParametersTest(testtools.TestCase):
 
383
    def new_parameters(self, stack_name, tmpl, user_params={}, stack_id=None,
 
384
                       validate_value=True):
 
385
        tmpl = template.Template(tmpl)
 
386
        return parameters.Parameters(stack_name, tmpl, user_params, stack_id,
 
387
                                     validate_value)
 
388
 
373
389
    def test_pseudo_params(self):
374
 
        params = parameters.Parameters('test_stack', {"Parameters": {}})
 
390
        params = self.new_parameters('test_stack', {"Parameters": {}})
375
391
 
376
392
        self.assertEqual(params['AWS::StackName'], 'test_stack')
377
393
        self.assertEqual(params['AWS::StackId'], 'None')
378
394
        self.assertTrue('AWS::Region' in params)
379
395
 
380
396
    def test_pseudo_param_stackid(self):
381
 
        params = parameters.Parameters('test_stack', {'Parameters': {}},
382
 
                                       stack_id='123::foo')
 
397
        params = self.new_parameters('test_stack', {'Parameters': {}},
 
398
                                     stack_id='123::foo')
383
399
 
384
400
        self.assertEqual(params['AWS::StackId'], '123::foo')
385
401
        params.set_stack_id('456::bar')
386
402
        self.assertEqual(params['AWS::StackId'], '456::bar')
387
403
 
388
404
    def test_schema_invariance(self):
389
 
        params1 = parameters.Parameters('test', params_schema,
390
 
                                        {'User': 'foo',
391
 
                                         'Defaulted': 'wibble'})
 
405
        params1 = self.new_parameters('test', params_schema,
 
406
                                      {'User': 'foo',
 
407
                                       'Defaulted': 'wibble'})
392
408
        self.assertEqual(params1['Defaulted'], 'wibble')
393
409
 
394
 
        params2 = parameters.Parameters('test', params_schema,
395
 
                                        {'User': 'foo'})
 
410
        params2 = self.new_parameters('test', params_schema, {'User': 'foo'})
396
411
        self.assertEqual(params2['Defaulted'], 'foobar')
397
412
 
398
413
    def test_to_dict(self):
399
414
        template = {'Parameters': {'Foo': {'Type': 'String'},
400
415
                                   'Bar': {'Type': 'Number', 'Default': '42'}}}
401
 
        params = parameters.Parameters('test_params', template, {'Foo': 'foo'})
 
416
        params = self.new_parameters('test_params', template, {'Foo': 'foo'})
402
417
 
403
418
        as_dict = dict(params)
404
419
        self.assertEqual(as_dict['Foo'], 'foo')
409
424
    def test_map(self):
410
425
        template = {'Parameters': {'Foo': {'Type': 'String'},
411
426
                                   'Bar': {'Type': 'Number', 'Default': '42'}}}
412
 
        params = parameters.Parameters('test_params', template, {'Foo': 'foo'})
 
427
        params = self.new_parameters('test_params', template, {'Foo': 'foo'})
413
428
 
414
429
        expected = {'Foo': False,
415
430
                    'Bar': True,
422
437
    def test_map_str(self):
423
438
        template = {'Parameters': {'Foo': {'Type': 'String'},
424
439
                                   'Bar': {'Type': 'Number'}}}
425
 
        params = parameters.Parameters('test_params', template, {
426
 
            'Foo': 'foo', 'Bar': 42})
 
440
        params = self.new_parameters('test_params', template,
 
441
                                     {'Foo': 'foo', 'Bar': 42})
427
442
 
428
443
        expected = {'Foo': 'foo',
429
444
                    'Bar': '42',
436
451
    def test_unknown_params(self):
437
452
        user_params = {'Foo': 'wibble'}
438
453
        self.assertRaises(exception.UnknownUserParameter,
439
 
                          parameters.Parameters,
 
454
                          self.new_parameters,
440
455
                          'test',
441
456
                          params_schema,
442
457
                          user_params)
444
459
    def test_missing_params(self):
445
460
        user_params = {}
446
461
        self.assertRaises(exception.UserParameterMissing,
447
 
                          parameters.Parameters,
 
462
                          self.new_parameters,
448
463
                          'test',
449
464
                          params_schema,
450
465
                          user_params)