"""Tests for service utils."""

import json

from oto import response as oto_response
from oto import status as response_code
import pytest
import requests

from conflict_manager.constants import services
from conflict_manager.exceptions import ServiceResponseError
from conflict_manager.utils import service_utils


def _make_error_response(content, status_code):
    """Create error response from another ows service.

    Args:
        content: data that should be returned in response.content
        status_code (int): HTTP status code

    Returns:
        oto.Response: response object
    """
    response = requests.Response()
    response.status_code = status_code
    response._content = content
    return response


def test_process_error_response():
    """Test error response from ows service processed correctly."""
    error_response_content = {
        'message': 'Failed to process request',
        'code': 'Test Error'
    }
    error_response = _make_error_response(
        json.dumps(error_response_content).encode('utf-8'),
        response_code.BAD_REQUEST)
    with pytest.raises(ServiceResponseError):
        service_utils.process_response(
            error_response, services.OWS_TRACK)


def test_process_error_response_handles_invalid_json():
    """Test error response with invalid json handled properly."""
    error_response = _make_error_response(
        '{'.encode('utf-8'), response_code.INTERNAL_ERROR)

    try:
        service_utils.process_response(
            error_response, services.OWS_TRACK)
    except ServiceResponseError as e:
        assert e.status_code == response_code.INTERNAL_ERROR
        assert e.message == '{'
        assert e.error_code == services.SERVICE_ERROR_CODES[services.OWS_TRACK]


def test_get_from_ows_service(mocker):
    """Test successful request to a microservice."""
    expected_message = {
        'tuid': 2
    }
    successful_response = mocker.MagicMock(
        json=lambda: expected_message, status_code=200)
    mocker.patch('owsrequest.request.get', return_value=successful_response)
    response = service_utils.get_from_ows_service(
        services.OWS_TRACK, '/track/2')
    assert isinstance(response, oto_response.Response)
    assert response.status == response_code.OK
    assert response.message == expected_message


def test_get_from_ows_service_error(mocker):
    """Test error request to a microservice."""
    error_response_content = {
        'message': 'Failed to process request',
        'code': 'Test Error'
    }
    error_response = mocker.MagicMock(
        json=lambda: error_response_content, status_code=500)
    mocker.patch('owsrequest.request.get', return_value=error_response)

    try:
        service_utils.get_from_ows_service(services.OWS_TRACK, '/track/2')
    except ServiceResponseError as e:
        assert e.status_code == response_code.INTERNAL_ERROR
        assert e.message == error_response_content
        assert e.error_code == services.SERVICE_ERROR_CODES[services.OWS_TRACK]