260705_2

tests/test_b05_route_repository.py

@@ -0,0 +1,148 @@
+import json
+import unittest
+from typing import Any
+from uuid import UUID
+
+from B05_wf2_Route.B05_wf2_Route_Repository import (
+    confirm_route,
+    create_route,
+    create_route_statistics,
+    get_latest_route,
+    insert_route_points,
+)
+
+
+class FakeCursor:
+    def __init__(self, *, lastrowid: int = 0, row: tuple[Any, ...] | None = None) -> None:
+        self.query = ""
+        self.arguments: Any = ()
+        self.many_rows: list[tuple[Any, ...]] = []
+        self.lastrowid = lastrowid
+        self._row = row
+
+    async def __aenter__(self) -> "FakeCursor":
+        return self
+
+    async def __aexit__(self, *_exc: Any) -> None:
+        return None
+
+    async def execute(self, query: str, arguments: Any = None) -> None:
+        self.query = query
+        self.arguments = arguments or ()
+
+    async def executemany(self, query: str, rows: list[tuple[Any, ...]]) -> None:
+        self.query = query
+        self.many_rows = rows
+
+    async def fetchone(self) -> tuple[Any, ...] | None:
+        return self._row
+
+
+class FakeConnection:
+    def __init__(self, cursor: FakeCursor) -> None:
+        self._cursor = cursor
+
+    def cursor(self) -> FakeCursor:
+        return self._cursor
+
+
+PROJECT_ID = UUID("550e8400-e29b-41d4-a716-446655440000")
+
+
+class CreateRouteTest(unittest.IsolatedAsyncioTestCase):
+    async def test_create(self) -> None:
+        cursor = FakeCursor(lastrowid=7)
+        route_id = await create_route(  # type: ignore[arg-type]
+            FakeConnection(cursor),
+            project_id=PROJECT_ID,
+            surface_model_id=22,
+            total_length_m=100.0,
+            start_chainage_m=0.0,
+            end_chainage_m=100.0,
+            grade_percent=[2.5, 1.8],
+            constraints={"max_grade": 0.14},
+            algorithm_params={"weights": {"dist": 1.0}},
+            route_data_path="B05_wf2_Route/route/route_main.geojson",
+        )
+        self.assertEqual(route_id, 7)
+        self.assertIn("INSERT INTO routes", cursor.query)
+        self.assertEqual(cursor.arguments[0], str(PROJECT_ID))
+        self.assertEqual(json.loads(cursor.arguments[6]), [2.5, 1.8])
+
+    async def test_rejects_path_outside_stage(self) -> None:
+        with self.assertRaises(ValueError):
+            await create_route(  # type: ignore[arg-type]
+                FakeConnection(FakeCursor(lastrowid=1)),
+                project_id=PROJECT_ID,
+                surface_model_id=None,
+                total_length_m=None,
+                start_chainage_m=None,
+                end_chainage_m=None,
+                grade_percent=None,
+                constraints=None,
+                algorithm_params=None,
+                route_data_path="B04_wf1_Surface/x.geojson",
+            )
+
+
+class RoutePointsTest(unittest.IsolatedAsyncioTestCase):
+    async def test_insert_many(self) -> None:
+        cursor = FakeCursor()
+        count = await insert_route_points(  # type: ignore[arg-type]
+            FakeConnection(cursor),
+            7,
+            [
+                {"chainage_m": 0.0, "elevation_m": 5.0, "slope_percent": 0.0, "sequence_num": 0},
+                {"chainage_m": 10.0, "elevation_m": 5.3, "slope_percent": 3.0, "sequence_num": 1},
+            ],
+        )
+        self.assertEqual(count, 2)
+        self.assertEqual(len(cursor.many_rows), 2)
+        self.assertEqual(cursor.many_rows[0][0], 7)
+
+    async def test_insert_empty(self) -> None:
+        count = await insert_route_points(FakeConnection(FakeCursor()), 7, [])  # type: ignore[arg-type]
+        self.assertEqual(count, 0)
+
+
+class RouteStatisticsTest(unittest.IsolatedAsyncioTestCase):
+    async def test_create(self) -> None:
+        cursor = FakeCursor(lastrowid=3)
+        stat_id = await create_route_statistics(  # type: ignore[arg-type]
+            FakeConnection(cursor),
+            route_id=7,
+            min_slope=0.0,
+            max_slope=7.0,
+            mean_slope=3.5,
+            cost_score=12.3,
+        )
+        self.assertEqual(stat_id, 3)
+        self.assertIn("INSERT INTO route_statistics", cursor.query)
+
+
+class LatestRouteTest(unittest.IsolatedAsyncioTestCase):
+    async def test_found(self) -> None:
+        import datetime
+
+        row = (
+            7,
+            "CONFIRMED",
+            100.0,
+            "B05_wf2_Route/route/route_main.geojson",
+            datetime.datetime(2026, 7, 5, 12, 0, 0),
+        )
+        result = await get_latest_route(FakeConnection(FakeCursor(row=row)), PROJECT_ID)  # type: ignore[arg-type]
+        self.assertEqual(result["id"], 7)
+        self.assertEqual(result["status"], "CONFIRMED")
+
+    async def test_none(self) -> None:
+        result = await get_latest_route(FakeConnection(FakeCursor(row=None)), PROJECT_ID)  # type: ignore[arg-type]
+        self.assertIsNone(result)
+
+
+class ConfirmRouteTest(unittest.IsolatedAsyncioTestCase):
+    async def test_confirm(self) -> None:
+        cursor = FakeCursor()
+        await confirm_route(FakeConnection(cursor), 7)  # type: ignore[arg-type]
+        self.assertIn("UPDATE routes SET status = 'CONFIRMED'", cursor.query)
+        self.assertEqual(cursor.arguments[0], 7)