"""v1.6.3 background loops survive any failure and report readiness.""" from __future__ import annotations import asyncio import logging import sqlite3 from pathlib import Path from fastapi.testclient import TestClient from app import main as main_module from app.discovery import DiscoveryManager from app.discovery_store import DiscoveryStore from app.loops import LoopRegistry, run_periodic from app.store import Store def test_a_failing_cycle_is_logged_and_the_loop_keeps_running(caplog) -> None: calls: list[int] = [] async def work() -> None: calls.append(len(calls)) if len(calls) == 1: # The failure that used to end the observation loop silently. raise sqlite3.OperationalError("database is locked") async def scenario() -> LoopRegistry: registry = LoopRegistry() task = asyncio.create_task( run_periodic("observation", work, interval_seconds=0.01, registry=registry, max_backoff_seconds=0.01) ) while len(calls) < 3: await asyncio.sleep(0.005) status = registry.snapshot()[0] task.cancel() try: await task except asyncio.CancelledError: pass assert registry.snapshot() == [] # unregistered on shutdown return status loop_logger = logging.getLogger("servicemap.loops") loop_logger.addHandler(caplog.handler) try: status = asyncio.run(scenario()) finally: loop_logger.removeHandler(caplog.handler) assert len(calls) >= 3 assert status["healthy"] is True assert status["consecutive_failures"] == 0 assert "OperationalError: database is locked" in status["last_error"] assert "Background loop observation failed" in caplog.text def test_a_loop_without_recent_success_is_reported_unhealthy() -> None: registry = LoopRegistry() status = registry.register("observation", 60) status.started_at -= 10_000 assert registry.all_healthy() is False status.paused = True # e.g. demo mode: idle on purpose, not stalled assert registry.all_healthy() is True def test_ready_endpoint_reports_database_and_loops(tmp_path: Path) -> None: main_module.store = Store(str(tmp_path / "servicemap.db")) main_module.discovery_store = DiscoveryStore(main_module.store) main_module.discovery_manager = DiscoveryManager(main_module.store, main_module.discovery_store) client = TestClient(main_module.app) response = client.get("/ready") assert response.status_code == 200 assert response.json()["database"] == "ok" stalled = main_module.loop_registry.register("observation-test", 60) stalled.started_at -= 10_000 try: response = client.get("/ready") assert response.status_code == 503 body = response.json() assert body["status"] == "not_ready" assert any(item["name"] == "observation-test" and not item["healthy"] for item in body["loops"]) finally: main_module.loop_registry.unregister("observation-test") def test_zero_observation_interval_does_not_register_observer(tmp_path: Path, monkeypatch) -> None: store = Store(str(tmp_path / "servicemap.db")) monkeypatch.setattr(main_module, "store", store) monkeypatch.setattr(main_module, "OBSERVATION_INTERVAL", 0) monkeypatch.setattr(main_module, "DISCOVERY_INTERVAL", 0) monkeypatch.setattr(main_module, "PROBE_INTERVAL", 0) monkeypatch.setattr(main_module, "BACKUP_INTERVAL_HOURS", 0) with TestClient(main_module.app) as client: assert all(item["name"] != "observation" for item in client.get("/ready").json()["loops"]) def test_maintenance_prunes_observations_of_old_runs_and_checkpoints(tmp_path: Path) -> None: store = Store(str(tmp_path / "servicemap.db")) discovery = DiscoveryStore(store) with sqlite3.connect(store.path) as db: for index in range(12): db.execute( "INSERT INTO discovery_runs (id, status, started_at) VALUES (?, 'completed', ?)", (f"run-{index:02d}", f"2026-11-{index + 1:02d}T00:00:00+00:00"), ) db.execute( "INSERT INTO discovery_sources (id, source_type, source_id, first_seen_at, last_seen_at) " "VALUES ('src', 'docker', 'c1', '2026-11-01T00:00:00+00:00', '2026-11-01T00:00:00+00:00')" ) for index in range(12): db.execute( "INSERT INTO discovery_observations (id, run_id, source_id, source_type, source_name, lifecycle, " "change_type, observed_at) VALUES (?, ?, 'src', 'docker', 'c1', 'active', 'unchanged', ?)", (f"obs-{index}", f"run-{index:02d}", f"2026-11-{index + 1:02d}T00:00:00+00:00"), ) db.execute( "INSERT INTO topology_change_events (id, event_type, detail, created_at) " "VALUES ('old', 'dependency_added', 'x', '2020-01-01T00:00:00+00:00')" ) assert discovery.prune_observations(10) == 2 assert discovery.prune_change_events(90) == 1 store.checkpoint() with sqlite3.connect(store.path) as db: remaining = {row[0] for row in db.execute("SELECT run_id FROM discovery_observations")} runs = db.execute("SELECT COUNT(*) FROM discovery_runs").fetchone()[0] assert remaining == {f"run-{index:02d}" for index in range(2, 12)} assert runs == 12 # runs are kept; suggestions reference them