from __future__ import annotations

import base64

from src import main
from src.commune_service import CommuneService
from src.normals_service import NormalsService
from src.tracking_service import TrackingService, set_current_search_id, set_tracker
from src.weather_service import WeatherService


def _auth_headers(username: str, password: str) -> dict[str, str]:
    token = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii")
    return {"Authorization": f"Basic {token}"}


def test_admin_requires_auth(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get("/admin/")

    assert response.status_code == 401
    assert "Basic" in response.headers.get("www-authenticate", "")


def test_admin_wrong_password(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get("/admin/", headers=_auth_headers("admin", "wrong"))

    assert response.status_code == 401


def test_admin_no_password_configured(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "")

    response = client.get("/admin/")

    assert response.status_code == 503


def test_admin_page_served(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get("/admin/", headers=_auth_headers("admin", "secret"))

    assert response.status_code == 200
    assert "text/html" in response.headers.get("content-type", "")
    assert "HistoMeteo Admin" in response.text


def test_admin_js_served(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get("/admin/admin.js", headers=_auth_headers("admin", "secret"))

    assert response.status_code == 200
    assert "application/javascript" in response.headers.get("content-type", "")


def test_admin_searches_api(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    tracker.create_search(
        search_id="s1",
        environment="beta",
        source="seo",
        search_type="period",
        commune_1="Gap",
        commune_1_slug="gap-05",
        start_date="2026-03-01",
        end_date="2026-03-07",
    )
    tracker.complete_search(search_id="s1", status="success", duration_ms=120)

    response = client.get(
        "/admin/api/searches",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    body = response.json()
    assert "searches" in body
    assert body["total"] >= 1

    tracker.close()
    set_tracker(None)


def test_admin_search_detail_api(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    tracker.create_search(
        search_id="detail-1",
        environment="beta",
        source="seo",
        search_type="period",
    )
    tracker.log_api_call(
        search_id="detail-1",
        service="weather",
        provider="open-meteo",
        endpoint="https://archive-api.open-meteo.com/v1/archive",
        params_summary="lat=1,lon=2",
        cache_key="weather:1:2",
        cache_status="miss",
        status_code=200,
        duration_ms=10,
        success=True,
        error_message=None,
    )

    response = client.get(
        "/admin/api/searches/detail-1",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    body = response.json()
    assert body["search"]["id"] == "detail-1"
    assert len(body["api_calls"]) == 1

    tracker.close()
    set_tracker(None)


def test_admin_search_not_found(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    response = client.get(
        "/admin/api/searches/unknown",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 404

    tracker.close()
    set_tracker(None)


def test_admin_dashboard_api(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    tracker.create_search(
        search_id="d1",
        environment="beta",
        source="api",
        search_type="period",
        commune_1="Paris",
        commune_1_slug="paris-75",
    )
    tracker.complete_search(search_id="d1", status="success", duration_ms=50)

    response = client.get(
        "/admin/api/dashboard",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    body = response.json()
    assert "searches_today" in body
    assert "api_calls_today" in body

    tracker.close()
    set_tracker(None)


def test_admin_noindex_header(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get("/admin/", headers=_auth_headers("admin", "secret"))

    assert response.status_code == 200
    assert response.headers.get("x-robots-tag") == "noindex"


def test_weather_search_creates_log(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    async def fake_weather(_lat: float, _lon: float, _start: str, _end: str):
        return {"data": [], "daily_summary": []}

    monkeypatch.setattr(main.weather_service, "get_weather", fake_weather)

    response = client.get(
        "/api/weather?lat=48.86&lon=2.35&start=2026-03-01&end=2026-03-02&commune=Paris&slug=paris-75"
    )

    detail = tracker.list_searches(limit=10, offset=0)

    assert response.status_code == 200
    assert detail["total"] == 1
    assert detail["searches"][0]["source"] == "api"

    tracker.close()
    set_tracker(None)


def test_tracking_failure_does_not_break(client, monkeypatch, tmp_path) -> None:
    tracker = TrackingService(tmp_path / "tracking.db")
    tracker.close()
    set_tracker(tracker)

    async def fake_weather(_lat: float, _lon: float, _start: str, _end: str):
        return {"data": [], "daily_summary": []}

    monkeypatch.setattr(main.weather_service, "get_weather", fake_weather)

    response = client.get("/api/weather?lat=48.86&lon=2.35&start=2026-03-01&end=2026-03-02")

    assert response.status_code == 200
    assert response.json()["data"] == []

    set_tracker(None)


def test_seo_route_creates_search_log(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    async def fake_prefetch_period(*_args, **_kwargs):
        return None

    monkeypatch.setattr(main, "prefetch_period", fake_prefetch_period)

    response = client.get("/meteo/paris-75/2026-03-01/2026-03-02")
    logs = tracker.list_searches(limit=10, offset=0)

    assert response.status_code == 200
    assert logs["total"] == 1
    assert logs["searches"][0]["source"] == "seo"
    assert logs["searches"][0]["search_type"] == "period"

    tracker.close()
    set_tracker(None)


def test_normals_cache_miss_creates_3_api_calls(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    class NormalsResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return {
                "elevation": 35,
                "daily": {
                    "time": ["1991-01-01"],
                    "temperature_2m_mean": [10.0],
                    "temperature_2m_max": [12.0],
                    "temperature_2m_min": [8.0],
                    "precipitation_sum": [1.0],
                },
            }

    class NormalsClient:
        async def get(self, *_args, **_kwargs):
            return NormalsResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "normals_service", NormalsService(client=NormalsClient()))

    async def fake_prefetch_period(_commune_service, _weather_service, normals_service, _slug, _start, _end):
        await normals_service.get_normals(48.86, 2.35, "2026-03-01", "2026-03-02")
        return None

    monkeypatch.setattr(main, "prefetch_period", fake_prefetch_period)

    response = client.get("/meteo/paris-75/2026-03-01/2026-03-02")
    searches = tracker.list_searches(limit=10, offset=0)
    detail = tracker.get_search_detail(searches["searches"][0]["id"])

    normals_calls = [c for c in (detail or {}).get("api_calls", []) if c.get("service") == "normals"]

    assert response.status_code == 200
    assert len(normals_calls) == 3

    tracker.close()
    set_tracker(None)


def test_commune_resolve_creates_api_call(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    class CommunesResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return [
                {
                    "nom": "Paris",
                    "codeDepartement": "75",
                    "centre": {"coordinates": [2.35, 48.86]},
                    "population": 100,
                    "surface": 100,
                    "departement": {"nom": "Paris"},
                    "region": {"nom": "Ile-de-France"},
                }
            ]

    class CommunesClient:
        async def get(self, *_args, **_kwargs):
            return CommunesResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "commune_service", CommuneService(client=CommunesClient()))

    async def fake_prefetch_period(commune_service, _weather_service, _normals_service, slug, _start, _end):
        await commune_service.resolve_slug(slug)
        return None

    monkeypatch.setattr(main, "prefetch_period", fake_prefetch_period)

    response = client.get("/meteo/paris-75/2026-03-01/2026-03-02")
    searches = tracker.list_searches(limit=10, offset=0)
    detail = tracker.get_search_detail(searches["searches"][0]["id"])
    commune_calls = [
        c
        for c in (detail or {}).get("api_calls", [])
        if c.get("service") == "communes" and c.get("provider") == "geo-api-gouv"
    ]

    assert response.status_code == 200
    assert len(commune_calls) >= 1

    tracker.close()
    set_tracker(None)


def test_cache_hit_creates_no_api_call(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    class WeatherResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return {
                "hourly": {
                    "time": ["2026-03-01T00:00"],
                    "temperature_2m": [10.0],
                    "precipitation": [0.0],
                    "relative_humidity_2m": [70],
                    "wind_speed_10m": [5.0],
                    "weather_code": [0],
                }
            }

    class WeatherClient:
        async def get(self, *_args, **_kwargs):
            return WeatherResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "weather_service", WeatherService(client=WeatherClient()))

    first = client.get(
        "/api/weather?lat=48.86&lon=2.35&start=2026-03-01&end=2026-03-01&commune=Paris&slug=paris-75"
    )
    second = client.get(
        "/api/weather?lat=48.86&lon=2.35&start=2026-03-01&end=2026-03-01&commune=Paris&slug=paris-75"
    )
    searches = tracker.list_searches(limit=10, offset=0)

    latest = searches["searches"][0]
    assert first.status_code == 200
    assert second.status_code == 200
    assert latest["total_api_calls"] == 0

    tracker.close()
    set_tracker(None)


def test_dashboard_returns_by_service(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    tracker.create_search(
        search_id="db1",
        environment="beta",
        source="api",
        search_type="period",
    )
    tracker.complete_search(search_id="db1", status="success", duration_ms=10)
    tracker.log_api_call(
        search_id="db1",
        service="weather",
        provider="open-meteo",
        endpoint="https://archive-api.open-meteo.com/v1/archive",
        params_summary=None,
        cache_key="k1",
        cache_status="miss",
        status_code=200,
        duration_ms=10,
        success=True,
        error_message=None,
    )
    tracker.log_api_call(
        search_id="db1",
        service="normals",
        provider="open-meteo",
        endpoint="https://archive-api.open-meteo.com/v1/archive",
        params_summary=None,
        cache_key=None,
        cache_status="miss",
        status_code=200,
        duration_ms=10,
        success=True,
        error_message=None,
    )
    tracker.log_api_call(
        search_id="db1",
        service="communes",
        provider="geo-api-gouv",
        endpoint="https://geo.api.gouv.fr/communes",
        params_summary=None,
        cache_key="k2",
        cache_status="miss",
        status_code=200,
        duration_ms=10,
        success=True,
        error_message=None,
    )

    response = client.get(
        "/admin/api/dashboard",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    body = response.json()
    assert body["api_calls_today"]["total"] == 3
    assert body["api_calls_today"]["by_service"]["weather"] == 1
    assert body["api_calls_today"]["by_service"]["normals"] == 1
    assert body["api_calls_today"]["by_service"]["communes"] == 1

    tracker.close()
    set_tracker(None)


def test_normals_api_tracks_without_search_context(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)
    set_current_search_id(None)

    class NormalsResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return {
                "elevation": 35,
                "daily": {
                    "time": ["1991-01-01"],
                    "temperature_2m_mean": [10.0],
                    "temperature_2m_max": [12.0],
                    "temperature_2m_min": [8.0],
                    "precipitation_sum": [1.0],
                },
            }

    class NormalsClient:
        async def get(self, *_args, **_kwargs):
            return NormalsResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "normals_service", NormalsService(client=NormalsClient()))

    response = client.get(
        "/api/normals?lat=48.86&lon=2.35&start=2026-03-01&end=2026-03-02"
    )
    logs = tracker.conn.execute(
        "SELECT search_id, service FROM api_call_logs WHERE service = 'normals'"
    ).fetchall()

    assert response.status_code == 200
    assert len(logs) == 3
    assert all(row["search_id"] is None for row in logs)

    tracker.close()
    set_tracker(None)


def test_annual_normals_api_tracks_without_search_context(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)
    set_current_search_id(None)

    class NormalsResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return {
                "elevation": 35,
                "daily": {
                    "time": ["1991-01-01"],
                    "temperature_2m_mean": [10.0],
                    "temperature_2m_max": [12.0],
                    "temperature_2m_min": [8.0],
                    "precipitation_sum": [1.0],
                },
            }

    class NormalsClient:
        async def get(self, *_args, **_kwargs):
            return NormalsResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "normals_service", NormalsService(client=NormalsClient()))

    response = client.get("/api/normals/annual?lat=48.86&lon=2.35")
    logs = tracker.conn.execute(
        "SELECT search_id, service FROM api_call_logs WHERE service = 'normals'"
    ).fetchall()

    assert response.status_code == 200
    assert len(logs) == 3
    assert all(row["search_id"] is None for row in logs)

    tracker.close()
    set_tracker(None)


def test_weather_in_og_image_tracks_without_search_context(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)
    set_current_search_id(None)

    class CommunesResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return [
                {
                    "nom": "Paris",
                    "codeDepartement": "75",
                    "centre": {"coordinates": [2.35, 48.86]},
                    "population": 100,
                    "surface": 100,
                    "departement": {"nom": "Paris"},
                    "region": {"nom": "Ile-de-France"},
                }
            ]

    class CommunesClient:
        async def get(self, *_args, **_kwargs):
            return CommunesResponse()

        async def aclose(self) -> None:
            return None

    class WeatherResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return {
                "hourly": {
                    "time": ["2026-03-01T00:00", "2026-03-01T01:00"],
                    "temperature_2m": [10.0, 11.0],
                    "precipitation": [0.0, 0.1],
                    "relative_humidity_2m": [70, 72],
                    "wind_speed_10m": [5.0, 6.0],
                    "weather_code": [0, 1],
                }
            }

    class WeatherClient:
        async def get(self, *_args, **_kwargs):
            return WeatherResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "commune_service", CommuneService(client=CommunesClient()))
    monkeypatch.setattr(main, "weather_service", WeatherService(client=WeatherClient()))
    monkeypatch.setattr(main.og_service, "generate", lambda **_kwargs: b"png")

    response = client.get("/api/og-image/paris-75/2026-03-01/2026-03-02")
    logs = tracker.conn.execute(
        """
        SELECT search_id, service
        FROM api_call_logs
        WHERE search_id IS NULL AND service IN ('weather', 'communes')
        """
    ).fetchall()

    assert response.status_code == 200
    assert len(logs) >= 1

    tracker.close()
    set_tracker(None)


def test_dashboard_api_includes_standalone(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    tracker.create_search(
        search_id="db2",
        environment="beta",
        source="api",
        search_type="period",
    )
    tracker.complete_search(search_id="db2", status="success", duration_ms=10)
    tracker.log_api_call(
        search_id="db2",
        service="weather",
        provider="open-meteo",
        endpoint="https://archive-api.open-meteo.com/v1/archive",
        params_summary=None,
        cache_key="k-attrib",
        cache_status="miss",
        status_code=200,
        duration_ms=10,
        success=True,
        error_message=None,
    )
    tracker.log_api_call(
        search_id=None,
        service="normals",
        provider="open-meteo",
        endpoint="https://archive-api.open-meteo.com/v1/archive",
        params_summary=None,
        cache_key=None,
        cache_status="miss",
        status_code=200,
        duration_ms=10,
        success=True,
        error_message=None,
    )

    response = client.get(
        "/admin/api/dashboard",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    body = response.json()
    assert body["api_calls_today"]["attributed"] == 1
    assert body["api_calls_today"]["standalone"] == 1

    tracker.close()
    set_tracker(None)


def test_admin_cache_endpoint_auth_required(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get("/admin/api/cache")

    assert response.status_code == 401


def test_admin_cache_endpoint(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    response = client.get(
        "/admin/api/cache",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    body = response.json()
    for key in ["weather", "normals", "communes_search", "communes_slug", "og_image"]:
        assert key in body
        assert "entries" in body[key]
        assert "total" in body[key]
        assert "max_entries" in body[key]
        assert "ttl_seconds" in body[key]


def test_admin_cache_reflects_entries(client, monkeypatch) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")

    class WeatherResponse:
        def __init__(self) -> None:
            self.status_code = 200

        def raise_for_status(self) -> None:
            return None

        def json(self):
            return {
                "hourly": {
                    "time": ["2026-03-01T00:00"],
                    "temperature_2m": [10.0],
                    "precipitation": [0.0],
                    "relative_humidity_2m": [70],
                    "wind_speed_10m": [5.0],
                    "weather_code": [0],
                }
            }

    class WeatherClient:
        async def get(self, *_args, **_kwargs):
            return WeatherResponse()

        async def aclose(self) -> None:
            return None

    monkeypatch.setattr(main, "weather_service", WeatherService(client=WeatherClient()))

    weather_res = client.get(
        "/api/weather?lat=48.86&lon=2.35&start=2026-03-01&end=2026-03-01&commune=Paris&slug=paris-75"
    )
    cache_res = client.get(
        "/admin/api/cache",
        headers=_auth_headers("admin", "secret"),
    )

    assert weather_res.status_code == 200
    assert cache_res.status_code == 200
    weather_section = cache_res.json()["weather"]
    assert weather_section["total"] >= 1
    assert weather_section["entries"][0]["hit_count"] == 0


def test_search_list_cache_badge_data(client, monkeypatch, tmp_path) -> None:
    monkeypatch.setattr(main, "ADMIN_PASSWORD", "secret")
    monkeypatch.setattr(main, "ADMIN_USERNAME", "admin")
    tracker = TrackingService(tmp_path / "tracking.db")
    set_tracker(tracker)

    tracker.create_search(
        search_id="cache-badge",
        environment="beta",
        source="api",
        search_type="period",
        commune_1="Paris",
        commune_1_slug="paris-75",
    )
    tracker.complete_search(
        search_id="cache-badge",
        status="success",
        duration_ms=12,
        total_api_calls=0,
    )

    response = client.get(
        "/admin/api/searches",
        headers=_auth_headers("admin", "secret"),
    )

    assert response.status_code == 200
    searches = response.json()["searches"]
    target = next(item for item in searches if item["id"] == "cache-badge")
    assert target["status"] == "success"
    assert target["total_api_calls"] == 0

    tracker.close()
    set_tracker(None)