"""Unit tests for datasources lifecycle and dependency getters."""

import asyncio
from unittest.mock import AsyncMock, MagicMock

from contributor.api import datasources
from pytest_mock import MockerFixture


def test_datasources_lifespan_initializes_and_tears_down_neo4j_and_redis(
    mocker: MockerFixture,
) -> None:
    datasources.DATA_SOURCES.clear()

    mock_ows_client = MagicMock()
    mock_auth_backend = MagicMock()
    mock_neo4j_driver = MagicMock()
    mock_redis_connector = MagicMock()
    mock_splitio_client = MagicMock()
    mock_redis_connector.close = AsyncMock()

    mocker.patch.object(datasources.config, "CACHE_USE_REDIS", True)
    mocker.patch.object(datasources.config, "REDIS_HOST", "redis.example")
    mocker.patch.object(datasources.config, "REDIS_PORT", 6380)
    mocker.patch.object(datasources.config, "NEO4J_URL", "neo4j://example")
    mocker.patch.object(datasources.config, "NEO4J_USERNAME", "user")
    mocker.patch.object(datasources.config, "NEO4J_PASSWORD", "pass")

    ows_client_constructor = mocker.patch.object(
        datasources,
        "OwsClient",
        return_value=mock_ows_client,
    )
    auth_backend_factory = mocker.patch.object(
        datasources,
        "setup_authorization_backend",
        return_value=mock_auth_backend,
    )
    neo4j_driver_factory = mocker.patch.object(
        datasources.GraphDatabase,
        "driver",
        return_value=mock_neo4j_driver,
    )
    redis_connector_factory = mocker.patch.object(
        datasources,
        "RedisConnector",
        return_value=mock_redis_connector,
    )
    splitio_client_factory = mocker.patch.object(
        datasources,
        "splitio_client_factory",
        return_value=mock_splitio_client,
    )

    async def _run() -> None:
        async with datasources.datasources_lifespan(app=None) as injected_sources:
            assert injected_sources[datasources.OWS_CLIENT_KEY] is mock_ows_client
            assert (
                injected_sources[datasources.AUTHORIZATION_BACKEND_KEY]
                is mock_auth_backend
            )
            assert injected_sources[datasources.NEO4J_DRIVER_KEY] is mock_neo4j_driver
            assert (
                injected_sources[datasources.REDIS_CONNECTOR_KEY]
                is mock_redis_connector
            )
            assert (
                injected_sources[datasources.SPLITIO_CLIENT_KEY] is mock_splitio_client
            )

            assert datasources.get_authorization_backend() is mock_auth_backend
            assert datasources.get_neo4j_driver() is mock_neo4j_driver
            assert datasources.get_redis_client() is mock_redis_connector
            assert datasources.get_splitio_client() is mock_splitio_client

    asyncio.run(_run())

    ows_client_constructor.assert_called_once()
    auth_backend_factory.assert_called_once_with(mock_ows_client)
    neo4j_driver_factory.assert_called_once_with(
        "neo4j://example",
        auth=("user", "pass"),
    )
    redis_connector_factory.assert_called_once_with(
        redis_host="redis.example",
        redis_port=6380,
        use_redis_cache=True,
    )
    splitio_client_factory.assert_called_once_with()

    mock_redis_connector.close.assert_awaited_once()
    mock_neo4j_driver.close.assert_called_once()
    assert datasources.DATA_SOURCES == {}


def test_datasources_lifespan_initializes_redis_connector_when_cache_disabled(
    mocker: MockerFixture,
) -> None:
    datasources.DATA_SOURCES.clear()

    mock_ows_client = MagicMock()
    mock_auth_backend = MagicMock()
    mock_redis_connector = MagicMock()
    mock_splitio_client = MagicMock()
    mock_redis_connector.close = AsyncMock()

    mocker.patch.object(datasources.config, "CACHE_USE_REDIS", False)
    mocker.patch.object(datasources.config, "NEO4J_URL", None)

    mocker.patch.object(
        datasources,
        "OwsClient",
        return_value=mock_ows_client,
    )
    mocker.patch.object(
        datasources,
        "setup_authorization_backend",
        return_value=mock_auth_backend,
    )
    neo4j_driver_factory = mocker.patch.object(datasources.GraphDatabase, "driver")
    redis_connector_factory = mocker.patch.object(
        datasources,
        "RedisConnector",
        return_value=mock_redis_connector,
    )
    splitio_client_factory = mocker.patch.object(
        datasources,
        "splitio_client_factory",
        return_value=mock_splitio_client,
    )

    async def _run() -> None:
        async with datasources.datasources_lifespan(app=None) as injected_sources:
            assert datasources.NEO4J_DRIVER_KEY not in injected_sources
            assert (
                injected_sources[datasources.REDIS_CONNECTOR_KEY]
                is mock_redis_connector
            )
            assert (
                injected_sources[datasources.SPLITIO_CLIENT_KEY] is mock_splitio_client
            )
            assert datasources.get_neo4j_driver() is None
            assert datasources.get_redis_client() is mock_redis_connector
            assert datasources.get_splitio_client() is mock_splitio_client

    asyncio.run(_run())

    neo4j_driver_factory.assert_not_called()
    redis_connector_factory.assert_called_once_with(
        redis_host=datasources.config.REDIS_HOST,
        redis_port=datasources.config.REDIS_PORT,
        use_redis_cache=False,
    )
    splitio_client_factory.assert_called_once_with()
    mock_redis_connector.close.assert_awaited_once()
    assert datasources.DATA_SOURCES == {}