"""Tests for validation module."""

import json
from unittest import mock

import pytest

from assets.constants import error
from assets.constants import field_const
from assets.validation import json_schema
from assets.validation.schema import body


@pytest.fixture
def fixture_function(request):
    """Function to mock real endpoint handler."""
    @json_schema.validate_body(request, body.post_asset_schema)
    def function():
        return 'test_result'
    return function()


@pytest.fixture
def valid_post_asset_body():
    """Function that returns valid post_asset body.

    Returns:
        dict: Body dict.
    """
    return {
        field_const.ASSET_TYPE: 'WAV',
        field_const.PRODUCT_ID: 12345,
        field_const.UPC: '12321',
        field_const.TRACK_UNIQUE_ID: 54321,
        field_const.FILENAME: 'filename.jpg',
        field_const.TOKEN: 'unique_token'
    }


def test_post_asset_validate_body_success(valid_post_asset_body):
    """Assert that validate_body succeeds when body is valid."""
    request = mock.Mock()
    request.get_json = lambda: valid_post_asset_body

    assert 'test_result' == fixture_function(request)


@pytest.mark.parametrize('missing_field', [
    field_const.ASSET_TYPE, field_const.PRODUCT_ID, field_const.UPC,
    field_const.TRACK_UNIQUE_ID, field_const.FILENAME, field_const.TOKEN
])
def test_post_asset_validate_body_missing_field_fail(
        valid_post_asset_body, missing_field):
    """Assert that validate_body fail when field is missing."""
    request = mock.Mock()
    del valid_post_asset_body[missing_field]
    request.get_json = lambda: valid_post_asset_body

    response = fixture_function(request)
    assert response.status_code == 400

    response_json = json.loads(response.data.decode())
    assert response_json['code'] == error.ERROR_CODE_BODY_VALIDATION


@pytest.mark.parametrize('integer_field', [
    field_const.PRODUCT_ID, field_const.TRACK_UNIQUE_ID
])
def test_post_asset_validate_integer_field_fail(
        valid_post_asset_body, integer_field):
    """Assert that validate_body fail when int field is string."""
    request = mock.Mock()
    valid_post_asset_body[integer_field] = 'some_string'
    request.get_json = lambda: valid_post_asset_body

    response = fixture_function(request)
    assert response.status_code == 400

    response_json = json.loads(response.data.decode())
    assert response_json['code'] == error.ERROR_CODE_BODY_VALIDATION


def test_post_asset_validate_extra_field_fail(valid_post_asset_body):
    """Assert that validate_body fail unknown field."""
    request = mock.Mock()
    valid_post_asset_body['extra_field'] = 'some_string'
    request.get_json = lambda: valid_post_asset_body

    response = fixture_function(request)
    assert response.status_code == 400

    response_json = json.loads(response.data.decode())
    assert response_json['code'] == error.ERROR_CODE_BODY_VALIDATION


def test_post_asset_validate_upc_leading_zeros_success(valid_post_asset_body):
    """Assert that validate_body success upc leading zeros."""
    request = mock.Mock()
    valid_post_asset_body[field_const.UPC] = '000123'
    request.get_json = lambda: valid_post_asset_body

    assert 'test_result' == fixture_function(request)


def test_post_asset_validate_upc_alpha_failure(valid_post_asset_body):
    """Assert that validate_body fail upc alpha."""
    request = mock.Mock()
    valid_post_asset_body[field_const.UPC] = 'a upc'
    request.get_json = lambda: valid_post_asset_body

    response = fixture_function(request)
    assert response.status_code == 400


@pytest.fixture
def fixture_post_status_function(request):
    """Function to mock real endpoint handler."""
    @json_schema.validate_body(request, body.post_asset_status_schema)
    def function():
        return 'test_result'
    return function()


@pytest.fixture
def valid_post_asset_status_body():
    """Function that returns valid post_asset_status body.

    Returns:
        dict: Body dict.
    """
    return {
        field_const.FILENAME: 'unique_filename.ext',
        field_const.STATUS: 'success',
        field_const.DESCRIPTION: 'Success description',
        field_const.MESSAGE: {
            'function': 'some_function',
            'status': 'success',
            'description': 'Success description',
            'input': {
                'key': 'unique_filename.ext'
            }
        }
    }


def test_post_asset_status_validate_body_success(valid_post_asset_status_body):
    """Assert that validate_body succeeds when body is valid."""
    request = mock.Mock()
    request.get_json = lambda: valid_post_asset_status_body
    assert 'test_result' == fixture_post_status_function(request)


@pytest.mark.parametrize('missing_field', [
    field_const.FILENAME,
    field_const.STATUS,
    field_const.MESSAGE
])
def test_post_asset_status_validate_body_failure(
        missing_field, valid_post_asset_status_body):
    """Assert that validate_body fails when field is missing."""
    request = mock.Mock()
    valid_post_asset_status_body.pop(missing_field)
    request.get_json = lambda: valid_post_asset_status_body
    result = fixture_post_status_function(request)
    assert result.status_code == 400


def test_post_asset_status_validate_body_message_failure(
        valid_post_asset_status_body):
    """Assert that validate_body fails when message is string."""
    request = mock.Mock()
    valid_post_asset_status_body['message'] = 123
    request.get_json = lambda: valid_post_asset_status_body
    result = fixture_post_status_function(request)
    assert result.status_code == 400