"""Tests for Validation."""

import copy
import json
import os
import re

from jsonschema import Draft3Validator

from blacklist_manager.constants import error
from blacklist_manager.validation import validation


def test_json_validator_loads_a_schema():
    """Test that json validator loads an arbitrary file."""
    path = os.path.dirname(__file__)
    with open(os.path.join(path, 'sample_schema.json')) as f:
        schema = validation.json_validator(json.load(f)).schema

    assert schema.get('properties').get('some_property').\
        get('type') == 'string'


def test_add_error_to_errors():
    """Test creating a standard validation errors object."""
    initial_errors_object = {}

    mutated_object = validation.add_error_to_errors(
        initial_errors_object, 'square', '4_sided', True,
        'Shape does not have 4 sides.')
    assert mutated_object == initial_errors_object == {
        'square': {
            'validator': '4_sided', 'validator_value': True,
            'message': 'Shape does not have 4 sides.'}}


def test_validation_success(
        monkeypatch, example_data_to_validate,
        example_validation_schema):
    """Test example validation is successful using a validator."""
    response = validation.validate(
        data=example_data_to_validate,
        validator=Draft3Validator(example_validation_schema))

    assert response.status == 200


def test_validation_error(
        monkeypatch, example_data_to_validate,
        example_validation_schema):
    """Test example validation fails using our validator.

    It should return error messages in our desired format.
    """
    mutated_data = copy.copy(example_data_to_validate)
    mutated_data.pop('apple')
    mutated_data['orange'] = 333333
    mutated_data['banana'] = '12345678901'
    mutated_data['mango'] = 3333333
    mutated_data['pizza'] = 'party'

    response = validation.validate(
        data=mutated_data,
        validator=Draft3Validator(example_validation_schema))
    message = response.errors.get('message')

    assert response.status == 500
    assert response.errors.get('code') == error.VALIDATION_ERROR
    assert 'required' == message.get('apple').get('validator')
    assert 'type' == message.get('orange').get('validator')
    assert 'maxLength' in message.get('banana').get('validator')
    assert 'pizza' in message.get('additionalProperties').get('message')


def test_remove_zero_width_space_characters(
        example_blacklist_data_hidden_chars,):
    """Test removal of hidden characters in blacklist word inputs."""
    # Assert that there is a \u200b zero width space character in the input word
    match_before_sanitize = re.search(
        re.compile('[\u200b]', re.U), example_blacklist_data_hidden_chars['word'])
    assert match_before_sanitize is not None

    response = validation.remove_zero_width_space_characters(
        example_blacklist_data_hidden_chars)

    # Assert there are no \u200b characters in the input word after sanitizing
    match_after_sanitize = re.search(
        re.compile('[\u200b]', re.U), response['word'])
    assert match_after_sanitize is None


def test_remove_zero_width_space_characters_no_issues(
        example_blacklist_data_no_hidden_chars):
    """Test that remove_hidden_characters method doesn't remove regular characters."""
    input_word = example_blacklist_data_no_hidden_chars['word']

    response = validation.remove_zero_width_space_characters(
        example_blacklist_data_no_hidden_chars
    )

    assert response['word'] == input_word