#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Test suite  for parse_type.py

REQUIRES: parse >= 1.8.4 ('pattern' attribute support)
"""

from __future__ import absolute_import
import re
import unittest
import parse
from .parse_type_test import ParseTypeTestCase
from .parse_type_test \
    import parse_number, parse_yesno, parse_person_choice, parse_color, Color
from parse_type import TypeBuilder, build_type_dict
from enum import Enum


# -----------------------------------------------------------------------------
# TEST CASE: TestTypeBuilder4Enum
# -----------------------------------------------------------------------------
class TestTypeBuilder4Enum(ParseTypeTestCase):

    TYPE_CONVERTERS = [ parse_yesno ]

    def test_parse_enum_yesno(self):
        extra_types = build_type_dict([ parse_yesno ])
        schema = "Answer: {answer:YesNo}"
        parser = parse.Parser(schema, extra_types)

        # -- PERFORM TESTS:
        self.ensure_can_parse_all_enum_values(parser,
                parse_yesno, "Answer: %s", "answer")

        # -- VALID:
        self.assert_match(parser, "Answer: yes", "answer", True)
        self.assert_match(parser, "Answer: no",  "answer", False)

        # -- IGNORE-CASE: In parsing, calls type converter function !!!
        self.assert_match(parser, "Answer: YES", "answer", True)

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __YES__", "answer")
        self.assert_mismatch(parser, "Answer: yes ",    "answer")
        self.assert_mismatch(parser, "Answer: yes ZZZ", "answer")

    def test_make_enum_with_dict(self):
        parse_nword = TypeBuilder.make_enum({"one": 1, "two": 2, "three": 3})
        parse_nword.name = "NumberAsWord"

        extra_types = build_type_dict([ parse_nword ])
        schema = "Answer: {number:NumberAsWord}"
        parser = parse.Parser(schema, extra_types)

        # -- PERFORM TESTS:
        self.ensure_can_parse_all_enum_values(parser,
            parse_nword, "Answer: %s", "number")

        # -- VALID:
        self.assert_match(parser, "Answer: one", "number", 1)
        self.assert_match(parser, "Answer: two", "number", 2)

        # -- IGNORE-CASE: In parsing, calls type converter function !!!
        self.assert_match(parser, "Answer: THREE", "number", 3)

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __one__", "number")
        self.assert_mismatch(parser, "Answer: one ",    "number")
        self.assert_mismatch(parser, "Answer: one_",    "number")
        self.assert_mismatch(parser, "Answer: one ZZZ", "number")

    def test_make_enum_with_enum_class(self):
        """
        Use :meth:`parse_type.TypeBuilder.make_enum()` with enum34 classes.
        """
        class Color(Enum):
            red = 1
            green = 2
            blue = 3

        parse_color = TypeBuilder.make_enum(Color)
        parse_color.name = "Color"
        schema = "Answer: {color:Color}"
        parser = parse.Parser(schema, dict(Color=parse_color))

        # -- PERFORM TESTS:
        self.ensure_can_parse_all_enum_values(parser,
                parse_color, "Answer: %s", "color")

        # -- VALID:
        self.assert_match(parser, "Answer: red",   "color", Color.red)
        self.assert_match(parser, "Answer: green", "color", Color.green)
        self.assert_match(parser, "Answer: blue",  "color", Color.blue)

        # -- IGNORE-CASE: In parsing, calls type converter function !!!
        self.assert_match(parser, "Answer: RED", "color", Color.red)

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __RED__", "color")
        self.assert_mismatch(parser, "Answer: red ",    "color")
        self.assert_mismatch(parser, "Answer: redx",    "color")
        self.assert_mismatch(parser, "Answer: redx ZZZ", "color")


# -----------------------------------------------------------------------------
# TEST CASE: TestTypeBuilder4Choice
# -----------------------------------------------------------------------------
class TestTypeBuilder4Choice(ParseTypeTestCase):

    def test_parse_choice_persons(self):
        extra_types = build_type_dict([ parse_person_choice ])
        schema = "Answer: {answer:PersonChoice}"
        parser = parse.Parser(schema, extra_types)

        # -- PERFORM TESTS:
        self.assert_match(parser, "Answer: Alice", "answer", "Alice")
        self.assert_match(parser, "Answer: Bob",   "answer", "Bob")
        self.ensure_can_parse_all_choices(parser,
                    parse_person_choice, "Answer: %s", "answer")

        # -- IGNORE-CASE: In parsing, calls type converter function !!!
        # SKIP-WART: self.assert_match(parser, "Answer: BOB", "answer", "BOB")

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __Alice__", "answer")
        self.assert_mismatch(parser, "Answer: Alice ",    "answer")
        self.assert_mismatch(parser, "Answer: Alice ZZZ", "answer")

    def test_make_choice(self):
        parse_choice = TypeBuilder.make_choice(["one", "two", "three"])
        parse_choice.name = "NumberWordChoice"
        extra_types = build_type_dict([ parse_choice ])
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, extra_types)

        # -- PERFORM TESTS:
        self.assert_match(parser, "Answer: one", "answer", "one")
        self.assert_match(parser, "Answer: two", "answer", "two")
        self.ensure_can_parse_all_choices(parser,
                    parse_choice, "Answer: %s", "answer")

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __one__", "answer")
        self.assert_mismatch(parser, "Answer: one ",    "answer")
        self.assert_mismatch(parser, "Answer: one ZZZ", "answer")

    def test_make_choice__anycase_accepted_case_sensitity(self):
        # -- NOTE: strict=False => Disable errors due to case-mismatch.
        parse_choice = TypeBuilder.make_choice(["one", "two", "three"],
                                               strict=False)
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))

        # -- PERFORM TESTS:
        # NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
        self.assert_match(parser, "Answer: one",   "answer", "one")
        self.assert_match(parser, "Answer: TWO",   "answer", "TWO")
        self.assert_match(parser, "Answer: Three", "answer", "Three")

    def test_make_choice__samecase_match_or_error(self):
        # -- NOTE: strict=True => Enable errors due to case-mismatch.
        parse_choice = TypeBuilder.make_choice(["One", "TWO", "three"],
                                               strict=True)
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))

        # -- PERFORM TESTS: Case matches.
        # NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
        self.assert_match(parser, "Answer: One",   "answer", "One")
        self.assert_match(parser, "Answer: TWO",   "answer", "TWO")
        self.assert_match(parser, "Answer: three", "answer", "three")

        # -- PERFORM TESTS: EXACT-CASE MISMATCH
        case_mismatch_input_data = ["one", "ONE", "Two", "two", "Three" ]
        for input_value in case_mismatch_input_data:
            input_text = "Answer: %s" % input_value
            with self.assertRaises(ValueError):
                parser.parse(input_text)

    def test_make_choice__anycase_accepted_lowercase_enforced(self):
        # -- NOTE: strict=True => Enable errors due to case-mismatch.
        parse_choice = TypeBuilder.make_choice(["one", "two", "three"],
                            transform=lambda x: x.lower(), strict=True)
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))

        # -- PERFORM TESTS:
        # NOTE: Parser uses re.IGNORECASE flag
        # => Any case accepted, but result is in lower case.
        self.assert_match(parser, "Answer: one",   "answer", "one")
        self.assert_match(parser, "Answer: TWO",   "answer", "two")
        self.assert_match(parser, "Answer: Three", "answer", "three")

    def test_make_choice__with_transform(self):
        transform = lambda x: x.upper()
        parse_choice = TypeBuilder.make_choice(["ONE", "two", "Three"],
                                               transform)
        self.assertSequenceEqual(parse_choice.choices, ["ONE", "TWO", "THREE"])
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))

        # -- PERFORM TESTS:
        self.assert_match(parser, "Answer: one", "answer", "ONE")
        self.assert_match(parser, "Answer: two", "answer", "TWO")
        self.ensure_can_parse_all_choices(parser,
                    parse_choice, "Answer: %s", "answer")

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __one__", "answer")
        self.assert_mismatch(parser, "Answer: one ",    "answer")
        self.assert_mismatch(parser, "Answer: one ZZZ", "answer")

    def test_make_choice2(self):
        # -- strict=False: Disable errors due to case mismatch.
        parse_choice2 = TypeBuilder.make_choice2(["zero", "one", "two"],
                                                 strict=False)
        parse_choice2.name = "NumberWordChoice2"
        extra_types = build_type_dict([ parse_choice2 ])
        schema = "Answer: {answer:NumberWordChoice2}"
        parser = parse.Parser(schema, extra_types)

        # -- PERFORM TESTS:
        self.assert_match(parser, "Answer: zero", "answer", (0, "zero"))
        self.assert_match(parser, "Answer: one",  "answer", (1, "one"))
        self.assert_match(parser, "Answer: two",  "answer", (2, "two"))
        self.ensure_can_parse_all_choices2(parser,
                parse_choice2, "Answer: %s", "answer")

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Answer: __one__", "answer")
        self.assert_mismatch(parser, "Answer: one ",    "answer")
        self.assert_mismatch(parser, "Answer: one ZZZ", "answer")

    def test_make_choice2__with_transform(self):
        transform = lambda x: x.lower()
        parse_choice2 = TypeBuilder.make_choice2(["ZERO", "one", "Two"],
                                        transform=transform)
        self.assertSequenceEqual(parse_choice2.choices, ["zero", "one", "two"])
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice2))

        # -- PERFORM TESTS:
        # NOTE: Parser uses re.IGNORECASE => Any case is accepted.
        self.assert_match(parser, "Answer: zERO", "answer", (0, "zero"))
        self.assert_match(parser, "Answer: ONE", "answer",  (1, "one"))
        self.assert_match(parser, "Answer: Two", "answer",  (2, "two"))

    def test_make_choice2__samecase_match_or_error(self):
        # -- NOTE: strict=True => Enable errors due to case-mismatch.
        parse_choice2 = TypeBuilder.make_choice2(["Zero", "one", "TWO"],
                                                 strict=True)
        schema = "Answer: {answer:NumberWordChoice}"
        parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice2))

        # -- PERFORM TESTS: Case matches.
        # NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
        self.assert_match(parser, "Answer: Zero", "answer", (0, "Zero"))
        self.assert_match(parser, "Answer: one",  "answer", (1, "one"))
        self.assert_match(parser, "Answer: TWO",  "answer", (2, "TWO"))

        # -- PERFORM TESTS: EXACT-CASE MISMATCH
        case_mismatch_input_data = ["zero", "ZERO", "One", "ONE", "two" ]
        for input_value in case_mismatch_input_data:
            input_text = "Answer: %s" % input_value
            with self.assertRaises(ValueError):
                parser.parse(input_text)

# -----------------------------------------------------------------------------
# TEST CASE: TestTypeBuilder4Variant
# -----------------------------------------------------------------------------
class TestTypeBuilder4Variant(ParseTypeTestCase):

    TYPE_CONVERTERS = [ parse_number, parse_yesno ]

    def check_parse_variant_number_or_yesno(self, parse_variant,
                                            with_ignorecase=True):
        schema = "Variant: {variant:YesNo_or_Number}"
        parser = parse.Parser(schema, dict(YesNo_or_Number=parse_variant))

        # -- TYPE 1: YesNo
        self.assert_match(parser, "Variant: yes", "variant", True)
        self.assert_match(parser, "Variant: no",  "variant", False)
        # -- IGNORECASE problem => re_opts
        if with_ignorecase:
            self.assert_match(parser, "Variant: YES", "variant", True)

        # -- TYPE 2: Number
        self.assert_match(parser, "Variant: 0",  "variant",  0)
        self.assert_match(parser, "Variant: 1",  "variant",  1)
        self.assert_match(parser, "Variant: 12", "variant", 12)
        self.assert_match(parser, "Variant: 42", "variant", 42)

        # -- PARSE MISMATCH:
        self.assert_mismatch(parser, "Variant: __YES__")
        self.assert_mismatch(parser, "Variant: yes ")
        self.assert_mismatch(parser, "Variant: yes ZZZ")
        self.assert_mismatch(parser, "Variant: -1")

        # -- PERFORM TESTS:
        self.ensure_can_parse_all_enum_values(parser,
                    parse_yesno, "Variant: %s", "variant")

    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)

    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_re_opts_0(self):
        # -- SKIP: IGNORECASE checks which would raise an error in strict mode.
        type_converters = [parse_number, parse_yesno]
        parse_variant3 = TypeBuilder.make_variant(type_converters, re_opts=0)
        self.check_parse_variant_number_or_yesno(parse_variant3,
                                                 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__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_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__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__without_strict_and_compiled_may_return_none_on_case_mismatch(self):
        # XXX re_opts=0 seems to work differently.
        # -- 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,
                                        compiled=True, re_opts=0, strict=True)
        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"], False)


    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")


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):
        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 = parse.Parser(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))


# -----------------------------------------------------------------------------
# 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.