"""Common fixtures."""

import importlib

import pytest


@pytest.fixture()
def decorator_patch(request, mocker):
    """Patch decorators."""
    module = getattr(request.module, 'mock_module')
    mocker.patch('src.utils.error_log.log_record_not_found', lambda f: f)
    importlib.reload(module)
    yield
    mocker.stopall()
    importlib.reload(module)


@pytest.fixture()
def patch_session(mocker):
    """Patch text and session scope functions."""
    _sentinel = ()

    def wrapped(
            module, connector, execute_value=None, fetchone_value=_sentinel):
        # patch text function
        mocked_sqlalchemy_text = mocker.patch(
            'src.models.{}.sqlalchemy.text'.format(module))
        mocked_sqlalchemy_text.side_effect = lambda x: x
        # patch session
        mocked_session = mocker.Mock()
        mocked_execute = mocked_session.execute
        if fetchone_value != _sentinel:
            # We're mocking a single result value from DB.
            mocked_result = mocker.Mock()
            mocked_execute.return_value = mocked_result
            mocked_result.fetchone.return_value = fetchone_value
        else:
            # We're mocking a multiple result value from DB to iterate on.
            mocked_all = mocker.Mock()
            mocked_all.all.return_value = execute_value
            mocked_mapping = mocker.Mock()
            mocked_mapping.mappings.return_value = mocked_all
            mocked_execute.return_value = mocked_mapping

        mocked_context = mocker.Mock()
        mocked_context.__enter__ = mocker.Mock(
            return_value=mocked_session)
        mocked_context.__exit__ = mocker.Mock(return_value=None)
        mocker.patch(
            'src.connectors.{}.session_scope'.format(connector),
            return_value=mocked_context)
        return mocked_session
    return wrapped


@pytest.fixture()
def patch_request(mocker):
    """Patch requests."""
    def wrapped(method, result, status):
        mocked_response = mocker.Mock()
        mocked_response.status_code = status
        mocked_response.json.return_value = result
        mocked_get = mocker.patch(
            'src.connectors.request.{}'.format(method))
        mocked_get.return_value = mocked_response
        return mocked_get
    return wrapped