1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import yaml
from toscaparser.common import exception
from toscaparser.elements.constraints import Constraint
from toscaparser.elements.constraints import Schema
from toscaparser.tests.base import TestCase
from toscaparser.utils.gettextutils import _
from toscaparser.utils import yamlparser
class ConstraintTest(TestCase):
def test_schema_dict(self):
tpl_snippet = '''
cpus:
type: integer
description: Number of CPUs for the server.
'''
schema = yamlparser.simple_parse(tpl_snippet)
cpus_schema = Schema('cpus', schema['cpus'])
self.assertEqual(len(cpus_schema), 2)
self.assertEqual('integer', cpus_schema.type)
self.assertEqual('Number of CPUs for the server.',
cpus_schema.description)
self.assertEqual(True, cpus_schema.required)
self.assertIsNone(cpus_schema.default)
def test_schema_not_dict(self):
tpl_snippet = '''
cpus:
- type: integer
- description: Number of CPUs for the server.
'''
schema = yamlparser.simple_parse(tpl_snippet)
error = self.assertRaises(exception.InvalidSchemaError, Schema,
'cpus', schema['cpus'])
self.assertEqual(_('Schema definition of "cpus" must be a dict.'),
str(error))
def test_schema_miss_type(self):
tpl_snippet = '''
cpus:
description: Number of CPUs for the server.
'''
schema = yamlparser.simple_parse(tpl_snippet)
error = self.assertRaises(exception.InvalidSchemaError, Schema,
'cpus', schema['cpus'])
self.assertEqual(_('Schema definition of "cpus" must have a "type" '
'attribute.'), str(error))
def test_schema_none_description(self):
tpl_snippet = '''
cpus:
type: integer
'''
schema = yamlparser.simple_parse(tpl_snippet)
cpus_schema = Schema('cpus', schema['cpus'])
self.assertEqual('', cpus_schema.description)
def test_invalid_constraint_type(self):
schema = {'invalid_type': 2}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('Invalid property "invalid_type".'),
str(error))
def test_invalid_prop_type(self):
schema = {'length': 5}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('Property "length" is not valid for data type '
'"integer".'), str(error))
def test_invalid_validvalues(self):
schema = {'valid_values': 2}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('The property "valid_values" expects a list.'),
str(error))
def test_validvalues_validate(self):
schema = {'valid_values': [2, 4, 6, 8]}
constraint = Constraint('prop', Schema.INTEGER, schema)
self.assertIsNone(constraint.validate(4))
def test_validvalues_validate_fail(self):
schema = {'valid_values': [2, 4, 6, 8]}
constraint = Constraint('prop', Schema.INTEGER, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 5)
self.assertEqual(_('The value "5" of property "prop" is not valid. '
'Expected a value from "[2, 4, 6, 8]".'),
str(error))
def test_invalid_in_range(self):
snippet = 'in_range: {2, 6}'
schema = yaml.load(snippet)
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('The property "in_range" expects a list.'),
str(error))
def test_in_range_min_max(self):
schema = {'in_range': [2, 6]}
constraint = Constraint('prop', Schema.INTEGER, schema)
self.assertEqual(2, constraint.min)
self.assertEqual(6, constraint.max)
def test_in_range_validate(self):
schema = {'in_range': [2, 6]}
constraint = Constraint('prop', Schema.INTEGER, schema)
self.assertIsNone(constraint.validate(2))
self.assertIsNone(constraint.validate(4))
self.assertIsNone(constraint.validate(6))
def test_in_range_validate_fail(self):
schema = {'in_range': [2, 6]}
constraint = Constraint('prop', Schema.INTEGER, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 8)
self.assertEqual(_('The value "8" of property "prop" is out of range '
'"(min:2, max:6)".'), str(error))
def test_equal_validate(self):
schema = {'equal': 4}
constraint = Constraint('prop', Schema.INTEGER, schema)
self.assertIsNone(constraint.validate(4))
def test_equal_validate_fail(self):
schema = {'equal': 4}
constraint = Constraint('prop', Schema.INTEGER, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 8)
self.assertEqual('The value "8" of property "prop" is not equal to '
'"4".', str(error))
def test_greater_than_validate(self):
schema = {'greater_than': 4}
constraint = Constraint('prop', Schema.INTEGER, schema)
self.assertIsNone(constraint.validate(6))
def test_greater_than_validate_fail(self):
schema = {'greater_than': 4}
constraint = Constraint('prop', Schema.INTEGER, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 3)
self.assertEqual(_('The value "3" of property "prop" must be greater '
'than "4".'), str(error))
error = self.assertRaises(exception.ValidationError,
constraint.validate, 4)
self.assertEqual(_('The value "4" of property "prop" must be greater '
'than "4".'), str(error))
def test_greater_than_invalid(self):
snippet = 'greater_than: {4}'
schema = yaml.load(snippet)
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('The property "greater_than" expects comparable '
'values.'), str(error))
def test_greater_or_equal_validate(self):
schema = {'greater_or_equal': 3.9}
constraint = Constraint('prop', Schema.FLOAT, schema)
self.assertIsNone(constraint.validate(3.9))
self.assertIsNone(constraint.validate(4.0))
def test_greater_or_equal_validate_fail(self):
schema = {'greater_or_equal': 3.9}
constraint = Constraint('prop', Schema.FLOAT, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 3.0)
self.assertEqual(_('The value "3.0" of property "prop" must be '
'greater than or equal to "3.9".'),
str(error))
error = self.assertRaises(exception.ValidationError,
constraint.validate, 3.8)
self.assertEqual(_('The value "3.8" of property "prop" must be '
'greater than or equal to "3.9".'),
str(error))
def test_greater_or_equal_invalid(self):
snippet = 'greater_or_equal: {3.9}'
schema = yaml.load(snippet)
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('The property "greater_or_equal" expects '
'comparable values.'), str(error))
def test_less_than_validate(self):
schema = {'less_than': datetime.date(2014, 0o7, 25)}
constraint = Constraint('prop', Schema.TIMESTAMP, schema)
self.assertIsNone(constraint.validate(datetime.date(2014, 0o7, 20)))
self.assertIsNone(constraint.validate(datetime.date(2014, 0o7, 24)))
def test_less_than_validate_fail(self):
schema = {'less_than': datetime.date(2014, 0o7, 25)}
constraint = Constraint('prop', Schema.TIMESTAMP, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate,
datetime.date(2014, 0o7, 25))
self.assertEqual(_('The value "2014-07-25" of property "prop" must be '
'less than "2014-07-25".'),
str(error))
error = self.assertRaises(exception.ValidationError,
constraint.validate,
datetime.date(2014, 0o7, 27))
self.assertEqual(_('The value "2014-07-27" of property "prop" must be '
'less than "2014-07-25".'),
str(error))
def test_less_than_invalid(self):
snippet = 'less_than: {3.9}'
schema = yaml.load(snippet)
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('The property "less_than" expects comparable '
'values.'), str(error))
def test_less_or_equal_validate(self):
schema = {'less_or_equal': 4}
constraint = Constraint('prop', Schema.INTEGER, schema)
self.assertIsNone(constraint.validate(4))
self.assertIsNone(constraint.validate(3))
def test_less_or_equal_validate_fail(self):
schema = {'less_or_equal': 4}
constraint = Constraint('prop', Schema.INTEGER, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 5)
self.assertEqual(_('The value "5" of property "prop" must be less '
'than or equal to "4".'), str(error))
def test_less_or_equal_invalid(self):
snippet = 'less_or_equal: {3.9}'
schema = yaml.load(snippet)
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.INTEGER,
schema)
self.assertEqual(_('The property "less_or_equal" expects comparable '
'values.'), str(error))
def test_invalid_length(self):
schema = {'length': 'four'}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.STRING,
schema)
self.assertEqual(_('The property "length" expects an integer.'),
str(error))
schema = {'length': 4.5}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.STRING,
schema)
self.assertEqual(_('The property "length" expects an integer.'),
str(error))
def test_length_validate(self):
schema = {'length': 4}
constraint = Constraint('prop', Schema.STRING, schema)
self.assertIsNone(constraint.validate('abcd'))
def test_length_validate_fail(self):
schema = {'length': 4}
constraint = Constraint('prop', Schema.STRING, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 'abc')
self.assertEqual(_('Length of value "abc" of property "prop" must '
'be equal to "4".'), str(error))
error = self.assertRaises(exception.ValidationError,
constraint.validate,
'abcde')
self.assertEqual(_('Length of value "abcde" of property "prop" must '
'be equal to "4".'), str(error))
def test_invalid_min_length(self):
schema = {'min_length': 'four'}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.STRING,
schema)
self.assertEqual(_('The property "min_length" expects an integer.'),
str(error))
def test_min_length_validate(self):
schema = {'min_length': 4}
constraint = Constraint('prop', Schema.STRING, schema)
self.assertIsNone(constraint.validate('abcd'))
self.assertIsNone(constraint.validate('abcde'))
def test_min_length_validate_fail(self):
schema = {'min_length': 4}
constraint = Constraint('prop', Schema.STRING, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 'abc')
self.assertEqual(_('Length of value "abc" of property "prop" must '
'be at least "4".'), str(error))
def test_invalid_max_length(self):
schema = {'max_length': 'four'}
error = self.assertRaises(exception.InvalidSchemaError, Constraint,
'prop', Schema.STRING,
schema)
self.assertEqual(_('The property "max_length" expects an integer.'),
str(error))
def test_max_length_validate(self):
schema = {'max_length': 4}
constraint = Constraint('prop', Schema.STRING, schema)
self.assertIsNone(constraint.validate('abcd'))
self.assertIsNone(constraint.validate('abc'))
def test_max_length_validate_fail(self):
schema = {'max_length': 4}
constraint = Constraint('prop', Schema.STRING, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate,
'abcde')
self.assertEqual(_('Length of value "abcde" of property "prop" '
'must be no greater than "4".'),
str(error))
def test_pattern_validate(self):
schema = {'pattern': '[0-9]*'}
constraint = Constraint('prop', Schema.STRING, schema)
self.assertIsNone(constraint.validate('123'))
def test_pattern_validate_fail(self):
schema = {'pattern': '[0-9]*'}
constraint = Constraint('prop', Schema.STRING, schema)
error = self.assertRaises(exception.ValidationError,
constraint.validate, 'abc')
self.assertEqual(_('The value "abc" of property "prop" does not '
'match pattern "[0-9]*".'), str(error))
|
