"""Tests for utils.service_errors."""

import pytest

from src.constants import common_errors
from src.constants import common_fields
from src.constants import http_statuses
from src.utils import service_errors


class FakeResponse():
    """Fake http response."""

    def __init__(
            self, status_code=http_statuses.OK, data=None,
            error_code=None, error_message=None):
        """Class init function."""
        if error_code and error_message:
            data = {}
            data[common_fields.RESPONSE_CODE] = error_code
            data[common_fields.RESPONSE_MESSAGE] = error_message
        self.status_code = status_code
        self.data = data
        self.error_code = error_code
        self.error_message = error_message

    def json(self):
        """Return wrapped data as dict."""
        return self.data


@pytest.mark.parametrize(
    'func_result, retry_count, func_call, sleep_call, is_error', (
        (FakeResponse(data={'d': 10}), 5, 1, 0, False),
        (FakeResponse(status_code=http_statuses.NOT_FOUND), 5, 1, 0, False),
        (FakeResponse(
            status_code=http_statuses.ERROR,
            error_code='c', error_message='m'),
         4, 4, 4, True),
        (FakeResponse(status_code=http_statuses.ERROR), 5, 5, 5, True),
    )
)
def test_handle_errors(
        func_result, retry_count, func_call, sleep_call, is_error, mocker):
    """Test handle_errors decorator."""
    args = ('a', 1)
    kwargs = {'b': 2}
    mocked_time = mocker.patch('src.utils.service_errors.time')
    mocked_sleep = mocked_time.sleep
    mocked_log = mocker.patch('src.utils.error_log.log_error_by_func')
    mocked_capture_msg = mocker.patch(
        'src.utils.service_errors.capture_message')
    mocked_func = mocker.Mock()
    mocked_func.return_value = func_result
    wrapped_func = service_errors.handle_errors(retry_count)(mocked_func)
    result = wrapped_func(*args, **kwargs)
    if is_error:
        error = common_errors.OWS_REQUEST_ERROR.format(
            func_result.status_code, func_result.error_code,
            func_result.error_message)
        mocked_log.assert_called_once_with(error, mocked_func, *args, **kwargs)
        assert mocked_capture_msg.call_count == 1
        assert mocked_capture_msg.call_args == ((error,), dict(level='error'))
    else:
        assert result == func_result.data
    assert mocked_func.call_count == func_call
    assert mocked_func.call_args_list == [
        (args, kwargs) for i in range(0, func_call)]
    assert mocked_sleep.call_count == sleep_call