broker-sync/tests/providers/test_trading212.py

from __future__ import annotations

from datetime import UTC, datetime
from decimal import Decimal
from pathlib import Path
from typing import Any

import httpx
import pytest

from broker_sync.models import Account, AccountType, ActivityType
from broker_sync.providers.trading212 import (
    Trading212AuthError,
    Trading212Error,
    Trading212Provider,
)

_ISA = Account(
    id="t212-isa",
    name="Trading212 ISA",
    account_type=AccountType.ISA,
    currency="GBP",
    provider="trading212",
)
_GIA = Account(
    id="t212-invest",
    name="Trading212 Invest",
    account_type=AccountType.GIA,
    currency="GBP",
    provider="trading212",
)


def _fill(
    *,
    fill_id: str = "fill-1",
    order_id: str = "order-1",
    ticker: str = "VUAGl_EQ",
    currency: str = "GBP",
    price: str = "85.5",
    quantity: str = "2.0",
    filled_at: str = "2026-04-01T10:30:00.000Z",
) -> dict[str, Any]:
    return {
        "type": "MARKET",
        "id": 123,
        "fill": {
            "id": fill_id,
            "price": price,
            "quantity": quantity,
            "filledAt": filled_at,
        },
        "order": {
            "id": order_id,
            "ticker": ticker,
            "currency": currency,
        },
    }


def _page(items: list[dict[str, Any]], next_path: str | None = None) -> dict[str, Any]:
    return {"items": items, "nextPagePath": next_path}


def _provider(
    *,
    checkpoint_dir: Path,
    transport: httpx.MockTransport,
    accounts: list[tuple[Account, str]] | None = None,
) -> Trading212Provider:
    return Trading212Provider(
        accounts=accounts or [(_ISA, "isa-key")],
        checkpoint_dir=checkpoint_dir,
        transport=transport,
    )


async def _collect(provider: Trading212Provider) -> list[Any]:
    out = []
    async for a in provider.fetch():
        out.append(a)
    return out


# -- auth header shape --


async def test_auth_header_is_literal_api_key(tmp_path: Path) -> None:
    seen: list[str | None] = []

    def handler(req: httpx.Request) -> httpx.Response:
        seen.append(req.headers.get("Authorization"))
        return httpx.Response(200, json=_page([]))

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    await _collect(p)
    assert seen == ["isa-key"]
    # Not the Bearer-prefixed variant other APIs use.
    assert "Bearer" not in (seen[0] or "")


# -- single fill → Activity mapping --


async def test_buy_fill_becomes_buy_activity(tmp_path: Path) -> None:

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(200, json=_page([_fill()]))

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    acts = await _collect(p)
    assert len(acts) == 1
    a = acts[0]
    assert a.activity_type is ActivityType.BUY
    assert a.external_id == "t212:fill:fill-1"
    assert a.symbol == "VUAG"
    assert a.quantity == Decimal("2.0")
    assert a.unit_price == Decimal("85.5")
    assert a.currency == "GBP"
    assert a.account_id == "t212-isa"
    assert a.account_type is AccountType.ISA
    assert a.date == datetime(2026, 4, 1, 10, 30, tzinfo=UTC)


async def test_negative_quantity_becomes_sell(tmp_path: Path) -> None:

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(200, json=_page([_fill(quantity="-3.0")]))

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    acts = await _collect(p)
    assert acts[0].activity_type is ActivityType.SELL
    # Quantity is stored as absolute.
    assert acts[0].quantity == Decimal("3.0")


async def test_null_fill_is_skipped(tmp_path: Path) -> None:
    cancelled = {
        "type": "MARKET",
        "id": 999,
        "fill": None,
        "order": {
            "id": "o-cancelled",
            "ticker": "VUAGl_EQ",
            "currency": "GBP"
        },
    }

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(200, json=_page([cancelled, _fill()]))

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    acts = await _collect(p)
    assert len(acts) == 1
    assert acts[0].external_id == "t212:fill:fill-1"


# -- since filter --


async def test_since_drops_older_fills(tmp_path: Path) -> None:
    old = _fill(fill_id="old", filled_at="2020-01-01T00:00:00.000Z")
    new = _fill(fill_id="new", filled_at="2026-04-01T10:30:00.000Z")

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(200, json=_page([new, old]))

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    since = datetime(2026, 1, 1, tzinfo=UTC)
    out = [a async for a in p.fetch(since=since)]
    assert [a.external_id for a in out] == ["t212:fill:new"]


# -- error types --


async def test_401_raises_auth_error(tmp_path: Path) -> None:

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(401, json={"error": "bad key"})

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    with pytest.raises(Trading212AuthError):
        await _collect(p)


async def test_403_raises_generic_error(tmp_path: Path) -> None:

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(403, json={"error": "forbidden"})

    p = _provider(checkpoint_dir=tmp_path, transport=httpx.MockTransport(handler))
    with pytest.raises(Trading212Error):
        await _collect(p)


# -- name + accounts contract --


def test_provider_name() -> None:
    assert Trading212Provider.name == "trading212"


def test_accounts_returns_registered_pairs(tmp_path: Path) -> None:

    def handler(req: httpx.Request) -> httpx.Response:
        return httpx.Response(200, json=_page([]))

    p = _provider(
        checkpoint_dir=tmp_path,
        transport=httpx.MockTransport(handler),
        accounts=[(_ISA, "isa-key"), (_GIA, "gia-key")],
    )
    accs = p.accounts()
    assert [a.id for a in accs] == ["t212-isa", "t212-invest"]