ForcePilot/backend/test/unit/channels/test_twitch_helix.py

from __future__ import annotations

from unittest.mock import AsyncMock, Mock

import aiohttp
import pytest

from yuxi.channels.adapters.twitch.helix import HelixClient


def _make_mock_resp(status: int, data: dict | None = None, body: str = "error"):
    mock_resp = AsyncMock()
    mock_resp.status = status
    if data is not None:
        mock_resp.json = AsyncMock(return_value=data)
    mock_resp.text = AsyncMock(return_value=body)
    mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
    mock_resp.__aexit__ = AsyncMock(return_value=None)
    return mock_resp


def _build_session(request_mock=None):
    session = AsyncMock()
    session.closed = False
    if request_mock is not None:
        session.request = request_mock
    else:
        session.request = Mock(return_value=_make_mock_resp(200))
    return session


class TestHelixGet:
    @pytest.mark.asyncio
    async def test_get_200_returns_data(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(return_value=_make_mock_resp(200, {"data": [{"id": "123"}]}))
        )
        result = await client._get("/helix/users", login="testuser")
        assert result == {"data": [{"id": "123"}]}

    @pytest.mark.asyncio
    async def test_get_401_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(Mock(return_value=_make_mock_resp(401)))
        result = await client._get("/helix/users")
        assert result is None

    @pytest.mark.asyncio
    async def test_get_404_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(Mock(return_value=_make_mock_resp(404)))
        result = await client._get("/helix/users")
        assert result is None

    @pytest.mark.asyncio
    async def test_get_500_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(return_value=_make_mock_resp(500, body="Internal Server Error"))
        )
        result = await client._get("/helix/users")
        assert result is None

    @pytest.mark.asyncio
    async def test_get_connection_error_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(side_effect=aiohttp.ClientError("Connection refused"))
        )
        result = await client._get("/helix/users")
        assert result is None


class TestHelixPost:
    @pytest.mark.asyncio
    async def test_create_eventsub_subscription_200(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(return_value=_make_mock_resp(200, {"data": [{"id": "sub_123"}]}))
        )
        result = await client.create_eventsub_subscription({"type": "channel.follow"})
        assert result == "sub_123"

    @pytest.mark.asyncio
    async def test_create_eventsub_409_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(Mock(return_value=_make_mock_resp(409)))
        result = await client.create_eventsub_subscription({"type": "channel.follow"})
        assert result is None

    @pytest.mark.asyncio
    async def test_create_eventsub_429_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(Mock(return_value=_make_mock_resp(429)))
        result = await client.create_eventsub_subscription({"type": "channel.follow"})
        assert result is None

    @pytest.mark.asyncio
    async def test_create_eventsub_connection_error_returns_none(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(side_effect=aiohttp.ClientError("Connection refused"))
        )
        result = await client.create_eventsub_subscription({"type": "channel.follow"})
        assert result is None

    @pytest.mark.asyncio
    async def test_delete_eventsub_subscription_204(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(Mock(return_value=_make_mock_resp(204)))
        result = await client.delete_eventsub_subscription("sub_123")
        assert result is True

    @pytest.mark.asyncio
    async def test_delete_eventsub_connection_error(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(side_effect=aiohttp.ClientError("Connection refused"))
        )
        result = await client.delete_eventsub_subscription("sub_123")
        assert result is False


class TestHelixToken:
    @pytest.mark.asyncio
    async def test_get_app_access_token_200(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(return_value=_make_mock_resp(200, {"access_token": "app_token_123"}))
        )
        result = await client.get_app_access_token("secret")
        assert result is not None

    @pytest.mark.asyncio
    async def test_get_app_access_token_connection_error(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(side_effect=aiohttp.ClientError("Connection refused"))
        )
        result = await client.get_app_access_token("secret")
        assert result is None

    @pytest.mark.asyncio
    async def test_refresh_user_token_200(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(
                return_value=_make_mock_resp(
                    200, {"access_token": "new_token", "refresh_token": "new_refresh"}
                )
            )
        )
        result = await client.refresh_user_token("secret", "refresh_123")
        assert result is not None

    @pytest.mark.asyncio
    async def test_refresh_user_token_connection_error(self):
        client = HelixClient(client_id="test_id", access_token="test_token")
        client._session = _build_session(
            Mock(side_effect=aiohttp.ClientError("Connection refused"))
        )
        result = await client.refresh_user_token("secret", "refresh_123")
        assert result is None