"""Tests for Handlers."""
from unittest.mock import MagicMock
from unittest.mock import patch

import application
from oto import response

from product_configuration import handlers
from product_configuration.logic import product_configuration

from tests.testutils.test_helpers import parse_json


def test_get_distribution_format_media_formats_success(
        mocker, distribution_format_media_formats):
    """Test get distribution_format media formats succeed."""
    mocker.patch.object(
        product_configuration,
        'get_distribution_format_media_formats',
        return_value=response.Response(
            message={'foo': 'bar'}))

    with application.app.test_request_context():
        handler_response = handlers.get_distribution_format_media_formats()
        handler_message = parse_json(handler_response)
        assert handler_response.status_code == 200
        assert handler_message == {'foo': 'bar'}


@patch('product_configuration.handlers.g', spec=['log'])
def test_exception_handler(mock_g, app_context):
    """Verify exception_Handler returns 500 status code and json payload."""
    message = (
        'The server encountered an internal error '
        'and was unable to complete your request.')
    mock_error = MagicMock()
    server_response = handlers.exception_handler(mock_error)
    mock_g.log.exception.assert_called_with(mock_error)

    # assert status code is 500
    assert server_response.status_code == 500

    # assert json payload
    response_message = parse_json(server_response)
    assert response_message['message'] == message
    assert response_message['code'] == response.error.ERROR_CODE_INTERNAL_ERROR


def test_get_distribution_format_media_success(
        mocker, client, distribution_format_media_types):
    """Test successful response for distribution format media types request."""
    mocker.patch.object(
        product_configuration, 'get_distribution_format_media_types',
        return_value=response.Response(
            status=200, message={'items': distribution_format_media_types}))

    with application.app.test_request_context():
        result = handlers.get_distribution_format_media()
        assert result.status_code == 200

        result_data = parse_json(result).get('items')
        assert result_data == distribution_format_media_types


def test_get_distribution_format_media_db_failure(mocker, client):
    """Test failure response for distribution format media types request."""
    mocker.patch.object(
        product_configuration, 'get_distribution_format_media_types',
        return_value=response.create_fatal_response())

    with application.app.test_request_context():
        result = handlers.get_distribution_format_media()

        assert result.status_code == 500


def test_get_distribution_formats_success(
        mocker, client, distribution_formats):
    """Test successful response for distribution formats request."""
    mocker.patch.object(
        product_configuration, 'get_distribution_formats',
        return_value=response.Response(
            message={'items': distribution_formats}))

    with application.app.test_request_context():
        result = handlers.get_distribution_formats()

        assert result.status_code == 200

        result_data = parse_json(result).get('items')

        assert result_data == distribution_formats


def test_get_distribution_formats_db_failure(mocker, client):
    """Test failure response for distribution formats request."""
    mocker.patch.object(
        product_configuration, 'get_distribution_formats',
        return_value=response.create_fatal_response())

    with application.app.test_request_context():
        result = handlers.get_distribution_formats()

        assert result.status_code == 500


def test_get_public_distribution_formats_success(
        mocker, client, distribution_formats):
    """Test successful response for distribution formats request."""
    mocker.patch.object(
        product_configuration, 'get_distribution_formats',
        return_value=response.Response(
            message={'items': distribution_formats}))

    with application.app.test_request_context():
        result = handlers.get_public_distribution_formats()

        assert result.status_code == 200

        result_data = parse_json(result).get('items')

        assert result_data == distribution_formats


def test_get_public_distribution_formats_db_failure(mocker, client):
    """Test failure response for distribution formats request."""
    mocker.patch.object(
        product_configuration, 'get_distribution_formats',
        return_value=response.create_fatal_response())

    with application.app.test_request_context():
        result = handlers.get_public_distribution_formats()

        assert result.status_code == 500


def test_get_supply_chains_success(
        mocker, client, supply_chain_configuration_schema):
    """Test successful response for supply chain configuration schema request.""" # noqa
    mocker.patch.object(
        product_configuration, 'get_supply_chain_configuration_schemas',
        return_value=response.Response(
            message=supply_chain_configuration_schema))

    with application.app.test_request_context():
        result = handlers.get_supply_chains()

        assert result.status_code == 200

        result_data = parse_json(result)

        assert result_data == supply_chain_configuration_schema


def test_get_supply_chain_configurations_success(
        mocker, client, proper_supply_chain_configurations):
    """Test successful response for supply chain configurations request."""
    mocker.patch.object(
        product_configuration, 'get_supply_chain_configurations',
        return_value=response.Response(
            message=proper_supply_chain_configurations))

    with application.app.test_request_context():
        result = handlers.get_supply_chain_configurations(1)

        assert result.status_code == 200

        result_data = parse_json(result)

        assert result_data == proper_supply_chain_configurations


def test_get_supply_chain_configurations_failure(
        mocker, client, proper_supply_chain_configurations):
    """Test unsuccessful response for supply chain configurations request."""
    mocker.patch.object(
        product_configuration, 'get_supply_chain_configurations',
        return_value=response.create_not_found_response())

    with application.app.test_request_context():
        result = handlers.get_supply_chain_configurations(1)

        assert result.status_code == 404


def test_get_supply_chain_configuration_success(
        mocker, client, proper_supply_chain_configurations):
    """Test successful response for a single supply chain configuration request.""" # noqa
    mocker.patch.object(
        product_configuration, 'get_supply_chain_configuration',
        return_value=response.Response(
            message=proper_supply_chain_configurations[0]))

    with application.app.test_request_context():
        result = handlers.get_supply_chain_configuration(1, 1)

        assert result.status_code == 200

        result_data = parse_json(result)

        assert result_data == proper_supply_chain_configurations[0]


def test_get_supply_chain_configuration_failure(
        mocker, client, proper_supply_chain_configurations):
    """Test successful response for a single supply chain configuration request.""" # noqa
    mocker.patch.object(
        product_configuration, 'get_supply_chain_configuration',
        return_value=response.create_not_found_response())

    with application.app.test_request_context():
        result = handlers.get_supply_chain_configuration(1, 1)

        assert result.status_code == 404


def test_get_supply_chains_defaults_success(
        mocker, client, supply_chain_dafault_types_logic,
        supply_chain_dafault_types_handle):
    """Test successful response for supply chain defaults request."""
    mocker.patch.object(
        product_configuration, 'get_supply_chain_defaults',
        return_value=response.Response(
            status=200, message=supply_chain_dafault_types_logic))

    with application.app.test_request_context():
        result = handlers.get_supply_chains_defaults()
        assert result.status_code == 200

        result_data = parse_json(result)
        assert result_data == supply_chain_dafault_types_handle


def test_get_supply_chains_defaults_db_failure(mocker, client):
    """Test failure response for supply chain defaults request."""
    mocker.patch.object(
        product_configuration, 'get_supply_chain_defaults',
        return_value=response.create_fatal_response())

    with application.app.test_request_context():
        result = handlers.get_supply_chains_defaults()

        assert result.status_code == 500


def test_get_distribution_format_by_distribution_format_id(
        mocker, client, distribution_format_value):
    """Test successful response for distribution format request."""
    mocker.patch.object(
        product_configuration,
        'get_distribution_format_by_distribution_format_id',
        return_value=response.Response(
            status=200, message=distribution_format_value))
    distribution_format_id = 'abc'
    with application.app.test_request_context():
        result = handlers. \
            get_distribution_format_by_distribution_format_id(
                distribution_format_id)
        assert result.status_code == 200

        result_data = parse_json(result)
        assert result_data == distribution_format_value


def test_get_distribution_format_by_distribution_format_id_failure(
        mocker, client, distribution_format_value):
    """Test unsuccessful response for distribution format request."""
    mocker.patch.object(
        product_configuration,
        'get_distribution_format_by_distribution_format_id',
        return_value=response.create_not_found_response())
    distribution_format_id = 'abc'
    with application.app.test_request_context():
        result = handlers. get_distribution_format_by_distribution_format_id(
            distribution_format_id)
        assert result.status_code == 404