refactor(api): unify scheme query endpoints

tests/api/test_leakage_endpoints.py

@@ -1,7 +1,5 @@
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
-from types import SimpleNamespace
-
 from app.api.v1.endpoints import leakage as leakage_endpoint
 
 
@@ -35,34 +33,3 @@ def test_identify_leakage_success(monkeypatch):
     )
     assert response.status_code == 200
     assert response.json()["area_count"] == 0
-
-
-def test_query_leakage_schemes_success(monkeypatch):
-    monkeypatch.setattr(
-        leakage_endpoint,
-        "list_leakage_identify_schemes",
-        lambda network, query_date=None: [
-            {"scheme_name": "dma_001", "scheme_type": "dma_leak_identification"}
-        ],
-    )
-    client = _build_client()
-    response = client.get("/api/v1/leakage/schemes/", params={"network": "demo"})
-    assert response.status_code == 200
-    assert response.json()[0]["scheme_name"] == "dma_001"
-
-
-def test_query_leakage_scheme_detail_success(monkeypatch):
-    monkeypatch.setattr(
-        leakage_endpoint,
-        "get_leakage_identify_scheme_detail",
-        lambda network, scheme_name: {
-            "scheme_name": scheme_name,
-            "rows": [{"Area": "1", "LeakageFlow_m3_per_s": 0.1}],
-        },
-    )
-    client = _build_client()
-    response = client.get(
-        "/api/v1/leakage/schemes/dma_001", params={"network": "demo"}
-    )
-    assert response.status_code == 200
-    assert response.json()["scheme_name"] == "dma_001"

tests/api/test_schemes_endpoints.py

@@ -0,0 +1,102 @@
+from datetime import date
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.api.v1.endpoints import schemes as schemes_endpoint
+
+
+def _build_client() -> TestClient:
+    app = FastAPI()
+    app.include_router(schemes_endpoint.router, prefix="/api/v1")
+    return TestClient(app)
+
+
+def test_get_schemes_forwards_optional_scheme_type(monkeypatch):
+    captured = {}
+
+    def fake_get_all_schemes(network, scheme_type=None, query_date=None):
+        captured["network"] = network
+        captured["scheme_type"] = scheme_type
+        captured["query_date"] = query_date
+        return [
+            {
+                "scheme_id": 1,
+                "scheme_name": "burst_case",
+                "scheme_type": scheme_type,
+            }
+        ]
+
+    monkeypatch.setattr(schemes_endpoint, "get_all_schemes", fake_get_all_schemes)
+
+    response = _build_client().get(
+        "/api/v1/schemes",
+        params={"network": "demo", "scheme_type": "burst_analysis"},
+    )
+
+    assert response.status_code == 200
+    assert captured == {
+        "network": "demo",
+        "scheme_type": "burst_analysis",
+        "query_date": None,
+    }
+    assert response.json()[0]["scheme_type"] == "burst_analysis"
+
+
+def test_get_schemes_forwards_query_date(monkeypatch):
+    captured = {}
+
+    def fake_get_all_schemes(network, scheme_type=None, query_date=None):
+        captured["network"] = network
+        captured["scheme_type"] = scheme_type
+        captured["query_date"] = query_date
+        return []
+
+    monkeypatch.setattr(schemes_endpoint, "get_all_schemes", fake_get_all_schemes)
+
+    response = _build_client().get(
+        "/api/v1/schemes",
+        params={
+            "network": "demo",
+            "scheme_type": "dma_leak_identification",
+            "query_date": "2026-01-02T00:00:00+08:00",
+        },
+    )
+
+    assert response.status_code == 200
+    assert captured == {
+        "network": "demo",
+        "scheme_type": "dma_leak_identification",
+        "query_date": date(2026, 1, 2),
+    }
+
+
+def test_get_scheme_detail_forwards_scheme_type(monkeypatch):
+    captured = {}
+
+    def fake_query_scheme_detail(name, scheme_name, scheme_type=None):
+        captured["name"] = name
+        captured["scheme_name"] = scheme_name
+        captured["scheme_type"] = scheme_type
+        return {
+            "scheme_name": scheme_name,
+            "scheme_type": scheme_type,
+            "rows": [{"Area": "1", "LeakageFlow_m3_per_s": 0.1}],
+        }
+
+    monkeypatch.setattr(
+        schemes_endpoint, "query_scheme_detail", fake_query_scheme_detail
+    )
+
+    response = _build_client().get(
+        "/api/v1/schemes/dma_001",
+        params={"network": "demo", "scheme_type": "dma_leak_identification"},
+    )
+
+    assert response.status_code == 200
+    assert captured == {
+        "name": "demo",
+        "scheme_name": "dma_001",
+        "scheme_type": "dma_leak_identification",
+    }
+    assert response.json()["scheme_name"] == "dma_001"

tests/unit/test_burst_location_service.py

@@ -197,7 +197,7 @@ def test_run_burst_location_uses_single_timerange_with_burst_source_split(monkey
     monkeypatch.setattr(
         module,
         "query_scheme_list",
-        lambda name: [
+        lambda name, scheme_type=None: [
             (
                 1,
                 "BurstSchemeA",

tests/unit/test_scheme_list_filter.py

@@ -0,0 +1,133 @@
+from app.services import scheme_management, tjnetwork
+
+
+class _FakeCursor:
+    def __init__(self):
+        self.calls = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_exc_info):
+        return False
+
+    def execute(self, statement, params=None):
+        self.calls.append((str(statement), params))
+
+    def fetchall(self):
+        return []
+
+
+class _FakeConnection:
+    def __init__(self, cursor):
+        self._cursor = cursor
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_exc_info):
+        return False
+
+    def cursor(self):
+        return self._cursor
+
+
+def test_query_scheme_list_pushes_scheme_type_into_sql(monkeypatch):
+    cursor = _FakeCursor()
+    monkeypatch.setattr(
+        scheme_management, "get_pgconn_string", lambda db_name=None: "postgres://test"
+    )
+    monkeypatch.setattr(
+        scheme_management.psycopg, "connect", lambda _conn_string: _FakeConnection(cursor)
+    )
+
+    assert scheme_management.query_scheme_list("demo", scheme_type="burst_analysis") == []
+
+    statement, params = cursor.calls[0]
+    assert "WHERE scheme_type = %s" in statement
+    assert params == ("burst_analysis",)
+
+
+def test_get_all_schemes_filters_central_scheme_list_by_type(monkeypatch):
+    captured = {}
+
+    def fake_query_scheme_list(name, scheme_type=None, query_date=None):
+        captured["name"] = name
+        captured["scheme_type"] = scheme_type
+        captured["query_date"] = query_date
+        return [
+            (
+                7,
+                "burst_case",
+                "burst_analysis",
+                "alice",
+                "2026-01-01T00:00:00+08:00",
+                "2026-01-01T01:00:00+08:00",
+                {"burst_ID": ["P1"]},
+            )
+        ]
+
+    monkeypatch.setattr(
+        scheme_management, "query_scheme_list", fake_query_scheme_list
+    )
+
+    result = tjnetwork.get_all_schemes("demo", scheme_type="burst_analysis")
+
+    assert captured == {
+        "name": "demo",
+        "scheme_type": "burst_analysis",
+        "query_date": None,
+    }
+    assert result == [
+        {
+            "scheme_id": 7,
+            "scheme_name": "burst_case",
+            "scheme_type": "burst_analysis",
+            "username": "alice",
+            "create_time": "2026-01-01T00:00:00+08:00",
+            "scheme_start_time": "2026-01-01T01:00:00+08:00",
+            "scheme_detail": {"burst_ID": ["P1"]},
+        }
+    ]
+
+
+def test_query_scheme_detail_rejects_wrong_specialized_type(monkeypatch):
+    monkeypatch.setattr(
+        scheme_management,
+        "query_burst_detection_scheme_detail",
+        lambda name, scheme_name: {
+            "scheme_name": scheme_name,
+            "scheme_type": "burst_analysis",
+            "network": name,
+        },
+    )
+
+    assert (
+        scheme_management.query_scheme_detail(
+            "demo",
+            "same_name",
+            scheme_type="burst_detection",
+        )
+        == {}
+    )
+
+
+def test_query_scheme_detail_rejects_wrong_network(monkeypatch):
+    monkeypatch.setattr(
+        scheme_management,
+        "query_burst_location_scheme_detail",
+        lambda name, scheme_name: {
+            "scheme_name": scheme_name,
+            "scheme_type": "burst_location",
+            "network": "other_network",
+        },
+    )
+
+    assert (
+        scheme_management.query_scheme_detail(
+            "demo",
+            "same_name",
+            scheme_type="burst_location",
+        )
+        == {}
+    )