add tests

tests/test_openlane.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from openlane_scraper.core.config import OpenLaneConfig
+from openlane_scraper.openlane.checkpoint import OpenLaneCheckpoint, OpenLaneCheckpointStore
+from openlane_scraper.openlane.client import OpenLaneClient
+from openlane_scraper.openlane.writer import OpenLaneResultWriter
+
+
+class TestOpenLaneCheckpointStore(unittest.TestCase):
+    def test_save_and_load_checkpoint(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            path = Path(tmp_dir) / "checkpoint.json"
+            store = OpenLaneCheckpointStore(path)
+            checkpoint = OpenLaneCheckpoint(
+                max_pages=512,
+                completed_pages=[1, 2, 3],
+                failed_pages=[7],
+                total_records=99,
+                last_saved_at="2026-04-20T00:00:00+00:00",
+            )
+
+            store.save(checkpoint)
+            loaded = store.load(max_pages=512)
+
+            self.assertEqual(loaded.max_pages, 512)
+            self.assertEqual(loaded.completed_pages, [1, 2, 3])
+            self.assertEqual(loaded.failed_pages, [7])
+            self.assertEqual(loaded.total_records, 99)
+            self.assertEqual(loaded.last_saved_at, "2026-04-20T00:00:00+00:00")
+
+
+class TestOpenLaneWriter(unittest.TestCase):
+    def test_append_and_finalize_outputs(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            jsonl_path = Path(tmp_dir) / "openlane.jsonl"
+            aggregated_path = Path(tmp_dir) / "openlane_aggregated.json"
+            writer = OpenLaneResultWriter(jsonl_path, aggregated_path)
+
+            written = writer.append_page(1, [{"id": 1}, {"id": 2}])
+            self.assertEqual(written, 2)
+
+            summary = writer.finalize(max_pages=10, completed_pages=[1], failed_pages=[2])
+
+            self.assertEqual(summary["total_records"], 2)
+            self.assertEqual(summary["total_pages_completed"], 1)
+            self.assertEqual(summary["total_pages_failed"], 1)
+            self.assertTrue(aggregated_path.exists())
+
+            payload = json.loads(aggregated_path.read_text(encoding="utf-8"))
+            self.assertEqual(payload["items"][0]["page"], 1)
+            self.assertEqual(payload["items"][0]["record"]["id"], 1)
+
+
+class TestOpenLaneConfig(unittest.TestCase):
+    def test_retry_schedule_defaults(self) -> None:
+        config = OpenLaneConfig()
+        self.assertGreaterEqual(len(config.retry_schedule_seconds), 1)
+        self.assertEqual(tuple(float(x) for x in config.retry_schedule_seconds), config.retry_schedule_seconds)
+
+    def test_storage_state_defaults(self) -> None:
+        config = OpenLaneConfig()
+        self.assertTrue(config.storage_state_file)
+        self.assertIn("artifacts/openlane", config.storage_state_file)
+        self.assertIsInstance(config.persist_storage_state, bool)
+
+
+class TestOpenLaneClient(unittest.TestCase):
+    def test_extract_records_from_common_shapes(self) -> None:
+        self.assertEqual(
+            OpenLaneClient._extract_records({"results": [{"id": 1}, {"id": 2}]}),
+            [{"id": 1}, {"id": 2}],
+        )
+        self.assertEqual(
+            OpenLaneClient._extract_records({"data": {"items": [{"id": 3}]}}),
+            [{"id": 3}],
+        )
+        self.assertEqual(
+            OpenLaneClient._extract_records({"vehicles": [{"id": 4}]}),
+            [{"id": 4}],
+        )
+        self.assertEqual(OpenLaneClient._extract_records({"data": {"foo": "bar"}}), [])
+
+    def test_extract_vehicle_images_from_common_shapes(self) -> None:
+        payload = {
+            "vehicle_images": [
+                {"url": "https://img/1.png", "low_resolution_url": "https://img/1_small.png"},
+            ]
+        }
+        self.assertEqual(
+            OpenLaneClient._extract_vehicle_images(payload),
+            [{"url": "https://img/1.png", "low_resolution_url": "https://img/1_small.png"}],
+        )
+
+        payload_nested = {
+            "data": {
+                "images": [
+                    {"url": "https://img/2.png"},
+                ]
+            }
+        }
+        self.assertEqual(
+            OpenLaneClient._extract_vehicle_images(payload_nested),
+            [{"url": "https://img/2.png"}],
+        )
+
+        self.assertEqual(OpenLaneClient._extract_vehicle_images({"data": {"foo": 1}}), [])
+
+    def test_extract_vehicle_images_batch_helper_normalization(self) -> None:
+        # Косвенно проверяем нормализацию входа под батчевый метод
+        ids = [" 123 ", "123", 456, "", None]
+        normalized = []
+        seen = set()
+        for v in ids:
+            s = str(v).strip()
+            if not s or s in seen:
+                continue
+            seen.add(s)
+            normalized.append(s)
+
+        self.assertEqual(normalized, ["123", "456", "None"])
+
+
+if __name__ == "__main__":
+    unittest.main()