From c8201c119ec686e79797721156767685fe848aca Mon Sep 17 00:00:00 2001 From: shangxdy Date: Thu, 7 Apr 2016 14:08:49 -0400 Subject: Update tosca lib to version 0.5 Use tosca-parser and heat-translator to analyze to the basic nfv-tosca type definitions, and use simple tosca new feature such as policy, group and trigger, which are now supported by the latest version of tosca-parser and heat-translator. JIRA:PARSER-18 Change-Id: I797bcacbb5b32005d0aeb0f3f32851ac96e30f01 Signed--off-by: shangxdy Signed-off-by: shangxdy --- .../toscaparser/tests/test_constraints.py | 373 +++++++++++++++++++++ 1 file changed, 373 insertions(+) create mode 100644 tosca2heat/tosca-parser/toscaparser/tests/test_constraints.py (limited to 'tosca2heat/tosca-parser/toscaparser/tests/test_constraints.py') diff --git a/tosca2heat/tosca-parser/toscaparser/tests/test_constraints.py b/tosca2heat/tosca-parser/toscaparser/tests/test_constraints.py new file mode 100644 index 0000000..07cb910 --- /dev/null +++ b/tosca2heat/tosca-parser/toscaparser/tests/test_constraints.py @@ -0,0 +1,373 @@ +# 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) -- cgit 1.2.3-korg