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