diff options
Diffstat (limited to 'tests/test_cfparse.py')
| -rw-r--r-- | tests/test_cfparse.py | 187 |
1 files changed, 187 insertions, 0 deletions
diff --git a/tests/test_cfparse.py b/tests/test_cfparse.py new file mode 100644 index 0000000..732234e --- /dev/null +++ b/tests/test_cfparse.py @@ -0,0 +1,187 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Test suite to test the :mod:`parse_type.cfparse` module. +""" + +from __future__ import absolute_import +from .parse_type_test import ParseTypeTestCase, parse_number, unittest +from parse_type.cfparse import Parser +from parse_type.cardinality_field \ + import MissingTypeError, CardinalityFieldTypeBuilder + + +# ----------------------------------------------------------------------------- +# TEST CASE: +# ----------------------------------------------------------------------------- +class TestParser(ParseTypeTestCase): + """ + Test :class:`parse_type.cfparse.Parser`. + Ensure that: + + * parser can parse fields with CardinalityField part + even when these special type variants are not provided. + + * parser creates missing type converter variants for CardinalityFields + as long as the primary type converter for cardinality=1 is provided. + """ + SPECIAL_FIELD_TYPES_DATA = [ + ("{number1:Number?}", ["Number?"]), + ("{number2:Number+}", ["Number+"]), + ("{number3:Number*}", ["Number*"]), + ("{number1:Number?} {number2:Number+} {number3:Number*}", + ["Number?", "Number+", "Number*"]), + ] + + def test_parser__can_parse_normal_fields(self): + existing_types = dict(Number=parse_number) + schema = "Number: {number:Number}" + parser = Parser(schema, existing_types) + self.assert_match(parser, "Number: 42", "number", 42) + self.assert_match(parser, "Number: 123", "number", 123) + self.assert_mismatch(parser, "Number: ") + self.assert_mismatch(parser, "Number: XXX") + self.assert_mismatch(parser, "Number: -123") + + def test_parser__can_parse_cardinality_field_optional(self): + # -- CARDINALITY: 0..1 = zero_or_one = optional + existing_types = dict(Number=parse_number) + self.assertFalse("Number?" in existing_types) + + # -- ENSURE: Missing type variant is created. + schema = "OptionalNumber: {number:Number?}" + parser = Parser(schema, existing_types) + self.assertTrue("Number?" in existing_types) + + # -- ENSURE: Newly created type variant is usable. + self.assert_match(parser, "OptionalNumber: 42", "number", 42) + self.assert_match(parser, "OptionalNumber: 123", "number", 123) + self.assert_match(parser, "OptionalNumber: ", "number", None) + self.assert_mismatch(parser, "OptionalNumber:") + self.assert_mismatch(parser, "OptionalNumber: XXX") + self.assert_mismatch(parser, "OptionalNumber: -123") + + def test_parser__can_parse_cardinality_field_many(self): + # -- CARDINALITY: 1..* = one_or_more = many + existing_types = dict(Number=parse_number) + self.assertFalse("Number+" in existing_types) + + # -- ENSURE: Missing type variant is created. + schema = "List: {numbers:Number+}" + parser = Parser(schema, existing_types) + self.assertTrue("Number+" in existing_types) + + # -- ENSURE: Newly created type variant is usable. + self.assert_match(parser, "List: 42", "numbers", [42]) + self.assert_match(parser, "List: 1, 2, 3", "numbers", [1, 2, 3]) + self.assert_match(parser, "List: 4,5,6", "numbers", [4, 5, 6]) + self.assert_mismatch(parser, "List: ") + self.assert_mismatch(parser, "List:") + self.assert_mismatch(parser, "List: XXX") + self.assert_mismatch(parser, "List: -123") + + def test_parser__can_parse_cardinality_field_many_with_own_type_builder(self): + # -- CARDINALITY: 1..* = one_or_more = many + class MyCardinalityFieldTypeBuilder(CardinalityFieldTypeBuilder): + listsep = ';' + + type_builder = MyCardinalityFieldTypeBuilder + existing_types = dict(Number=parse_number) + self.assertFalse("Number+" in existing_types) + + # -- ENSURE: Missing type variant is created. + schema = "List: {numbers:Number+}" + parser = Parser(schema, existing_types, type_builder=type_builder) + self.assertTrue("Number+" in existing_types) + + # -- ENSURE: Newly created type variant is usable. + # NOTE: Use other list separator. + self.assert_match(parser, "List: 42", "numbers", [42]) + self.assert_match(parser, "List: 1; 2; 3", "numbers", [1, 2, 3]) + self.assert_match(parser, "List: 4;5;6", "numbers", [4, 5, 6]) + self.assert_mismatch(parser, "List: ") + self.assert_mismatch(parser, "List:") + self.assert_mismatch(parser, "List: XXX") + self.assert_mismatch(parser, "List: -123") + + def test_parser__can_parse_cardinality_field_many0(self): + # -- CARDINALITY: 0..* = zero_or_more = many0 + existing_types = dict(Number=parse_number) + self.assertFalse("Number*" in existing_types) + + # -- ENSURE: Missing type variant is created. + schema = "List0: {numbers:Number*}" + parser = Parser(schema, existing_types) + self.assertTrue("Number*" in existing_types) + + # -- ENSURE: Newly created type variant is usable. + self.assert_match(parser, "List0: 42", "numbers", [42]) + self.assert_match(parser, "List0: 1, 2, 3", "numbers", [1, 2, 3]) + self.assert_match(parser, "List0: ", "numbers", []) + self.assert_mismatch(parser, "List0:") + self.assert_mismatch(parser, "List0: XXX") + self.assert_mismatch(parser, "List0: -123") + + + def test_create_missing_types__without_cardinality_fields_in_schema(self): + schemas = ["{}", "{:Number}", "{number3}", "{number4:Number}", "XXX"] + existing_types = {} + for schema in schemas: + new_types = Parser.create_missing_types(schema, existing_types) + self.assertEqual(len(new_types), 0) + self.assertEqual(new_types, {}) + + def test_create_missing_types__raises_error_if_primary_type_is_missing(self): + # -- HINT: primary type is not provided in type_dict (existing_types) + existing_types = {} + for schema, missing_types in self.SPECIAL_FIELD_TYPES_DATA: + with self.assertRaises(MissingTypeError): + Parser.create_missing_types(schema, existing_types) + + def test_create_missing_types__if_special_types_are_missing(self): + existing_types = dict(Number=parse_number) + for schema, missing_types in self.SPECIAL_FIELD_TYPES_DATA: + new_types = Parser.create_missing_types(schema, existing_types) + self.assertSequenceEqual(set(new_types.keys()), set(missing_types)) + + def test_create_missing_types__if_special_types_exist(self): + existing_types = dict(Number=parse_number) + for schema, missing_types in self.SPECIAL_FIELD_TYPES_DATA: + # -- FIRST STEP: Prepare + new_types = Parser.create_missing_types(schema, existing_types) + self.assertGreater(len(new_types), 0) + + # -- SECOND STEP: Now all needed special types should exist. + existing_types2 = existing_types.copy() + existing_types2.update(new_types) + new_types2 = Parser.create_missing_types(schema, existing_types2) + self.assertEqual(len(new_types2), 0) + + +# ----------------------------------------------------------------------------- +# MAIN: +# ----------------------------------------------------------------------------- +if __name__ == '__main__': + unittest.main() + + +# Copyright (c) 2012-2013 by Jens Engel (https://github/jenisys/parse_type) +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. |