374 lines
16 KiB
Python
374 lines
16 KiB
Python
# 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))
|
|
|
|
def test_min_length_with_map(self):
|
|
schema = {'min_length': 1}
|
|
constraint = Constraint('prop', Schema.MAP, schema)
|
|
try:
|
|
constraint.validate({"k": "v"})
|
|
except Exception as ex:
|
|
self.fail(ex)
|
|
|
|
def test_max_length_with_map(self):
|
|
schema = {'max_length': 1}
|
|
constraint = Constraint('prop', Schema.MAP, schema)
|
|
try:
|
|
constraint.validate({"k": "v"})
|
|
except Exception as ex:
|
|
self.fail(ex)
|