"""
Test for schema
===============

Sanity tests for regex and rules in schema
"""

import re


from ows_accounting.validation import json_validators


def _make_pattern(json_schema, property_name):
    """Build regex pattern based on data from JSON schema.

    Args:
        json_schema (dict): JSON schema with properties
        property_name (str): key for accessing pattern inside of schema
            properties

    Returns:
        pattern: compiled regular expression
    """
    expression = json_schema['properties'][property_name]['pattern']
    pattern = re.compile(expression)
    return pattern


def test_trim_spaces():
    """Strict matching. No extraneous spaces.
    """

    data = json_validators.REPORT_GET_VALIDATOR
    expression = \
        data['properties']['transaction_types']['pattern']
    pattern = re.compile(expression)
    leading_space = "  lalala"
    trailing_space = "lalala "
    trimmed_text = "DT"
    comma_text = "DT,AB,CD"

    assert not pattern.match(leading_space)
    assert not pattern.match(trailing_space)
    assert pattern.match(comma_text)
    assert pattern.match(trimmed_text)


def test_periods():
    """Strict matching. No extraneous spaces.
    """

    data = json_validators.REPORT_GET_VALIDATOR
    expression = data['properties']['periods']['pattern']
    pattern = re.compile(expression)
    single_period = '980'
    multiple_periods = '980,210,120'
    trailing_comma = '980,210,120,'
    leading_space = ' 980,100'
    trailing_space = '980,100 '
    between_space = '980, 100, 800'

    assert pattern.match(single_period)
    assert pattern.match(multiple_periods)
    assert not pattern.match(trailing_comma)
    assert not pattern.match(leading_space)
    assert not pattern.match(trailing_space)
    assert not pattern.match(between_space)


def test_group_match():
    """Strict matching in defined groups.
    """

    data = json_validators.REPORT_GET_VALIDATOR
    expression = data['properties']['file_type']['pattern']
    pattern = re.compile(expression)
    leading_space = ' TXT'
    trailing_space = 'xls  '
    invalid_string = 'choochoo'

    assert not pattern.match(leading_space)
    assert not pattern.match(trailing_space)
    assert not pattern.match(invalid_string)


def test_transactions():
    """Alphanumeric, case insensitive transaction type checking.
    """
    pattern_get = _make_pattern(
        json_validators.REPORT_GET_VALIDATOR,
        property_name='transaction_types')
    pattern_post = _make_pattern(
        json_validators.REPORT_POST_VALIDATOR,
        property_name='transaction_types')

    single_transaction = 'DT'
    multiple_transactions = 'DT,a2b,dt'
    trailing_comma = 'ab,d3,DT,'
    leading_space = ' DT,AB'
    trailing_space = 'CD,AA '
    between_space = 'AA, BB, cc'
    specified_all_caps = 'ALL'
    specified_lowercase = 'all'
    specified_physical_all_caps = 'PHYSICAL'
    specified_physical_lowercase = 'physical'
    empty_data = ''

    allowed_transaction_types = [
        single_transaction,
        multiple_transactions,
        # specified transaction types
        specified_all_caps,
        specified_lowercase,
        specified_physical_all_caps,
        specified_physical_lowercase,
    ]

    restricted_transaction_types = [
        trailing_comma,
        leading_space,
        trailing_space,
        between_space,
        empty_data,
    ]
    # validate GET and POST patterns
    for pattern in (pattern_get, pattern_post):
        for transaction_type in allowed_transaction_types:
            assert pattern.match(transaction_type)

        for transaction_type in restricted_transaction_types:
            assert not pattern.match(transaction_type)