def test_make_variant__with_color_or_person(self):
type_converters = [parse_color, parse_person_choice]
parse_variant2 = TypeBuilder.make_variant(type_converters)
schema = "Variant2: {variant:Color_or_Person}"
parser = parse.Parser(schema, dict(Color_or_Person=parse_variant2))
# -- TYPE 1: Color
self.assert_match(parser, "Variant2: red", "variant", Color.red)
self.assert_match(parser, "Variant2: blue", "variant", Color.blue)
# -- TYPE 2: Person
self.assert_match(parser, "Variant2: Alice", "variant", "Alice")
self.assert_match(parser, "Variant2: Bob", "variant", "Bob")
self.assert_match(parser, "Variant2: Charly", "variant", "Charly")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Variant2: __Alice__")
self.assert_mismatch(parser, "Variant2: Alice ")
self.assert_mismatch(parser, "Variant2: Alice2")
self.assert_mismatch(parser, "Variant2: red2")
# -- PERFORM TESTS:
self.ensure_can_parse_all_enum_values(parser,
parse_color, "Variant2: %s", "variant")
self.ensure_can_parse_all_choices(parser,
parse_person_choice, "Variant2: %s", "variant")
def test_make_variant__with_color_or_person(self):
type_converters = [parse_color, parse_person_choice]
parse_variant2 = TypeBuilder.make_variant(type_converters)
schema = "Variant2: {variant:Color_or_Person}"
parser = parse.Parser(schema, dict(Color_or_Person=parse_variant2))
# -- TYPE 1: Color
self.assert_match(parser, "Variant2: red", "variant", Color.red)
self.assert_match(parser, "Variant2: blue", "variant", Color.blue)
# -- TYPE 2: Person
self.assert_match(parser, "Variant2: Alice", "variant", "Alice")
self.assert_match(parser, "Variant2: Bob", "variant", "Bob")
self.assert_match(parser, "Variant2: Charly", "variant", "Charly")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Variant2: __Alice__")
self.assert_mismatch(parser, "Variant2: Alice ")
self.assert_mismatch(parser, "Variant2: Alice2")
self.assert_mismatch(parser, "Variant2: red2")
# -- PERFORM TESTS:
self.ensure_can_parse_all_enum_values(parser, parse_color,
"Variant2: %s", "variant")
self.ensure_can_parse_all_choices(parser, parse_person_choice,
"Variant2: %s", "variant")
def test_make_variant__with_strict_raises_error_on_case_mismatch(self):
# -- NEEDS:
# * re_opts=0 (IGNORECASE disabled)
# * strict=True, allow that an error is raised
type_converters = [parse_number, parse_yesno]
parse_variant = TypeBuilder.make_variant(type_converters,
strict=True, re_opts=0)
schema = "Variant: {variant:YesNo_or_Number}"
parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))
self.assertRaises(AssertionError, parser.parse, "Variant: YES")
def test_make_variant__with_strict_raises_error_on_case_mismatch(self):
# -- NEEDS:
# * re_opts=0 (IGNORECASE disabled)
# * strict=True, allow that an error is raised
type_converters = [parse_number, parse_yesno]
parse_variant = TypeBuilder.make_variant(type_converters,
strict=True,
re_opts=0)
schema = "Variant: {variant:YesNo_or_Number}"
parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))
self.assertRaises(AssertionError, parser.parse, "Variant: YES")
def test_make_variant__without_strict_may_return_none_on_case_mismatch(self):
# -- NEEDS:
# * re_opts=0 (IGNORECASE disabled)
# * strict=False, otherwise an error is raised
type_converters = [parse_number, parse_yesno]
parse_variant = TypeBuilder.make_variant(type_converters, re_opts=0,
strict=False)
schema = "Variant: {variant:YesNo_or_Number}"
parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))
result = parser.parse("Variant: No")
self.assertNotEqual(result, None)
self.assertEqual(result["variant"], None)
def test_make_variant__without_strict_may_return_none_on_case_mismatch(
self):
# -- NEEDS:
# * re_opts=0 (IGNORECASE disabled)
# * strict=False, otherwise an error is raised
type_converters = [parse_number, parse_yesno]
parse_variant = TypeBuilder.make_variant(type_converters,
re_opts=0,
strict=False)
schema = "Variant: {variant:YesNo_or_Number}"
parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))
result = parser.parse("Variant: No")
self.assertNotEqual(result, None)
self.assertEqual(result["variant"], None)
def test_make_variant__with_strict_and_compiled_raises_error_on_case_mismatch(self):
# XXX re_opts=0 seems to work differently.
# -- NEEDS:
# * re_opts=0 (IGNORECASE disabled)
# * strict=True, allow that an error is raised
type_converters = [parse_number, parse_yesno]
# -- ENSURE: coverage for cornercase.
parse_number.matcher = re.compile(parse_number.pattern)
parse_variant = TypeBuilder.make_variant(type_converters,
compiled=True, re_opts=0, strict=True)
schema = "Variant: {variant:YesNo_or_Number}"
parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))
# XXX self.assertRaises(AssertionError, parser.parse, "Variant: YES")
result = parser.parse("Variant: Yes")
self.assertNotEqual(result, None)
self.assertEqual(result["variant"], True)
def test_make_variant__with_strict_and_compiled_raises_error_on_case_mismatch(
self):
# XXX re_opts=0 seems to work differently.
# -- NEEDS:
# * re_opts=0 (IGNORECASE disabled)
# * strict=True, allow that an error is raised
type_converters = [parse_number, parse_yesno]
# -- ENSURE: coverage for cornercase.
parse_number.matcher = re.compile(parse_number.pattern)
parse_variant = TypeBuilder.make_variant(type_converters,
compiled=True,
re_opts=0,
strict=True)
schema = "Variant: {variant:YesNo_or_Number}"
parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))
# XXX self.assertRaises(AssertionError, parser.parse, "Variant: YES")
result = parser.parse("Variant: Yes")
self.assertNotEqual(result, None)
self.assertEqual(result["variant"], True)
def test_make_variant__with_strict(self):
# -- SKIP: IGNORECASE checks which would raise an error in strict mode.
type_converters = [parse_number, parse_yesno]
parse_variant = TypeBuilder.make_variant(type_converters, strict=True)
self.check_parse_variant_number_or_yesno(parse_variant,
with_ignorecase=False)
def test_make_variant__with_re_opts_IGNORECASE(self):
type_converters = [parse_number, parse_yesno]
parse_variant3 = TypeBuilder.make_variant(type_converters,
re_opts=re.IGNORECASE)
self.check_parse_variant_number_or_yesno(parse_variant3)
def test_make_variant__compiled(self):
# -- REVERSED ORDER VARIANT:
type_converters = [parse_number, parse_yesno]
parse_variant2 = TypeBuilder.make_variant(type_converters,
compiled=True)
self.check_parse_variant_number_or_yesno(parse_variant2)
def test_make_variant__compiled(self):
# -- REVERSED ORDER VARIANT:
type_converters = [parse_number, parse_yesno]
parse_variant2 = TypeBuilder.make_variant(type_converters,
compiled=True)
self.check_parse_variant_number_or_yesno(parse_variant2)
def test_make_variant__with_strict(self):
# -- SKIP: IGNORECASE checks which would raise an error in strict mode.
type_converters = [parse_number, parse_yesno]
parse_variant = TypeBuilder.make_variant(type_converters, strict=True)
self.check_parse_variant_number_or_yesno(parse_variant,
with_ignorecase=False)
def test_make_variant__with_re_opts_IGNORECASE(self):
type_converters = [parse_number, parse_yesno]
parse_variant3 = TypeBuilder.make_variant(type_converters,
re_opts=re.IGNORECASE)
self.check_parse_variant_number_or_yesno(parse_variant3)
def test_make_variant__uncompiled(self):
type_converters = [parse_yesno, parse_number]
parse_variant1 = TypeBuilder.make_variant(type_converters)
self.check_parse_variant_number_or_yesno(parse_variant1)
class TestParserWithManyTypedFields(ParseTypeTestCase):
parse_variant1 = TypeBuilder.make_variant([parse_number, parse_yesno])
parse_variant1.name = "Number_or_YesNo"
parse_variant2 = TypeBuilder.make_variant(
[parse_color, parse_person_choice])
parse_variant2.name = "Color_or_PersonChoice"
TYPE_CONVERTERS = [
parse_number,
parse_yesno,
parse_color,
parse_person_choice,
parse_variant1,
parse_variant2,
]
def test_parse_with_many_named_fields(self):
type_dict = build_type_dict(self.TYPE_CONVERTERS)
schema = """\
Number: {number:Number}
YesNo: {answer:YesNo}
Color: {color:Color}
Person: {person:PersonChoice}
Variant1: {variant1:Number_or_YesNo}
Variant2: {variant2:Color_or_PersonChoice}
"""
parser = parse.Parser(schema, type_dict)
text = """\
Number: 12
YesNo: yes
Color: red
Person: Alice
Variant1: 42
Variant2: Bob
"""
expected = dict(number=12,
answer=True,
color=Color.red,
person="Alice",
variant1=42,
variant2="Bob")
result = parser.parse(text)
self.assertIsNotNone(result)
self.assertEqual(result.named, expected)
def test_parse_with_many_unnamed_fields(self):
type_dict = build_type_dict(self.TYPE_CONVERTERS)
schema = """\
Number: {:Number}
YesNo: {:YesNo}
Color: {:Color}
Person: {:PersonChoice}
"""
# -- OMIT: XFAIL, due to group_index delta counting => Parser problem.
# Variant2: {:Color_or_PersonChoice}
# Variant1: {:Number_or_YesNo}
parser = parse.Parser(schema, type_dict)
text = """\
Number: 12
YesNo: yes
Color: red
Person: Alice
"""
# SKIP: Variant2: Bob
# SKIP: Variant1: 42
expected = [
12,
True,
Color.red,
"Alice",
] # -- SKIP: "Bob", 42 ]
result = parser.parse(text)
self.assertIsNotNone(result)
self.assertEqual(result.fixed, tuple(expected))
def test_parse_with_many_unnamed_fields_with_variants(self):
from parse_type.parse import Parser as Parser2
type_dict = build_type_dict(self.TYPE_CONVERTERS)
schema = """\
Number: {:Number}
YesNo: {:YesNo}
Color: {:Color}
Person: {:PersonChoice}
Variant2: {:Color_or_PersonChoice}
Variant1: {:Number_or_YesNo}
"""
# -- OMIT: XFAIL, due to group_index delta counting => Parser problem.
parser = Parser2(schema, type_dict)
text = """\
Number: 12
YesNo: yes
Color: red
Person: Alice
Variant2: Bob
Variant1: 42
"""
expected = [12, True, Color.red, "Alice", "Bob", 42]
result = parser.parse(text)
self.assertIsNotNone(result)
self.assertEqual(result.fixed, tuple(expected))
def test_make_variant__uncompiled(self):
type_converters = [parse_yesno, parse_number]
parse_variant1 = TypeBuilder.make_variant(type_converters)
self.check_parse_variant_number_or_yesno(parse_variant1)
