initial openlane project

tests/test_db.py

@@ -6,10 +6,10 @@ from pathlib import Path
 
 from sqlalchemy import select
 
-from iaai_scraper.core.config import Settings
-from iaai_scraper.storage.db import PersistenceService
-from iaai_scraper.storage.models import Car, Image, SyncRun
-from iaai_scraper.storage.schemas import CarRecord, ImageRecord
+from openlane_scraper.core.config import Settings
+from openlane_scraper.storage.db import PersistenceService
+from openlane_scraper.storage.models import Car, Image, SyncRun
+from openlane_scraper.storage.schemas import CarRecord, ImageRecord
 
 
 class TestPersistenceServiceIntegration(unittest.TestCase):
@@ -31,18 +31,18 @@ class TestPersistenceServiceIntegration(unittest.TestCase):
     @staticmethod
     def _record(origin_id: str, *, price: int = 1000) -> CarRecord:
         return CarRecord(
-            parser_id=f"iaai:{origin_id}",
+            parser_id=f"openlane:{origin_id}",
             brand="Toyota",
             model="Camry",
             year=2014,
             price=price,
-            origin_url=f"https://www.iaai.com/VehicleDetail/{origin_id}~US",
-            origin_id=origin_id,
+            origin_url=f"https://app.openlane.com/vehicles/{origin_id}",
+            origin_id=f"openlane:{origin_id}",
             slug=f"toyota-camry-{origin_id}",
             images=[
                 ImageRecord(
-                    fullres_image="https://vis.iaai.com/resizer?imageKeys=1&width=845&height=633",
-                    preview_image="https://vis.iaai.com/resizer?imageKeys=1&width=400&height=300",
+                    fullres_image="https://images.openlane.com/full/1.jpg",
+                    preview_image="https://images.openlane.com/thumb/1.jpg",
                     order_index=0,
                 )
             ],
@@ -79,8 +79,8 @@ class TestPersistenceServiceIntegration(unittest.TestCase):
         second = self._record("888")
         second.images = [
             ImageRecord(
-                fullres_image="https://vis.iaai.com/resizer?imageKeys=2&width=845&height=633",
-                preview_image="https://vis.iaai.com/resizer?imageKeys=2&width=400&height=300",
+                fullres_image="https://images.openlane.com/full/2.jpg",
+                preview_image="https://images.openlane.com/thumb/2.jpg",
                 order_index=0,
             )
         ]
@@ -90,7 +90,7 @@ class TestPersistenceServiceIntegration(unittest.TestCase):
             images = session.execute(select(Image)).scalars().all()
 
         self.assertEqual(len(images), 1)
-        self.assertIn("imageKeys=2", images[0].fullres_image)
+        self.assertIn("full/2", images[0].fullres_image)
 
     def test_start_sync_run_marks_stale_running_runs_as_failed(self) -> None:
         first_run_id = self.persistence.start_sync_run("lane-a")
@@ -108,11 +108,11 @@ class TestPersistenceServiceIntegration(unittest.TestCase):
 
     def test_upsert_falls_back_to_origin_url_to_prevent_duplicates(self) -> None:
         first = self._record("OLD-ID")
-        first.origin_url = "https://www.iaai.com/VehicleDetail/45089484~US"
+        first.origin_url = "https://app.openlane.com/vehicles/45089484"
         self.persistence.upsert_car(first)
 
         second = self._record("NEW-ID")
-        second.origin_url = "https://www.iaai.com/VehicleDetail/45089484~US"
+        second.origin_url = "https://app.openlane.com/vehicles/45089484"
         result = self.persistence.upsert_car(second)
 
         self.assertEqual(result["action"], "updated")
@@ -120,7 +120,7 @@ class TestPersistenceServiceIntegration(unittest.TestCase):
             cars = session.execute(select(Car)).scalars().all()
 
         self.assertEqual(len(cars), 1)
-        self.assertEqual(cars[0].origin_id, "NEW-ID")
+        self.assertEqual(cars[0].origin_id, "openlane:NEW-ID")
 
 
 if __name__ == "__main__":

tests/test_listing.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from iaai_scraper.browser.pace import HumanPacer
-from iaai_scraper.core.config import Settings
-from iaai_scraper.browser.listing import ListingCollector
-
-
-class _FakePage:
-    def __init__(self, counts: dict[str, int]) -> None:
-        self._counts = counts
-        self._evaluate_result = False
-        self._evaluate_values: list[object] = []
-
-    class _Locator:
-        def __init__(self, count_value: int) -> None:
-            self._count_value = count_value
-
-        def count(self) -> int:
-            return self._count_value
-
-    def locator(self, selector: str) -> "_FakePage._Locator":
-        return _FakePage._Locator(self._counts.get(selector, 0))
-
-    def evaluate(self, _script: str):
-        if self._evaluate_values:
-            return self._evaluate_values.pop(0)
-        return self._evaluate_result
-
-
-class TestListingUnit(unittest.TestCase):
-    def test_pagination_detection_and_page_number(self) -> None:
-        # Есть кнопка Next → True.
-        self.assertTrue(ListingCollector._has_next_page(_FakePage({"a[aria-label*='Next']":  1})))
-        # Нет селекторов → False.
-        self.assertFalse(ListingCollector._has_next_page(_FakePage({})))
-        # Числовая пагинация через JS → True только если evaluate явно нашёл next.
-        page = _FakePage({})
-        page._evaluate_result = True
-        self.assertTrue(ListingCollector._has_next_page(page))
-        # Номер текущей страницы.
-        page2 = _FakePage({})
-        page2._evaluate_values = [5]
-        self.assertEqual(ListingCollector._get_current_page_number(page2), 5)
-
-    def test_extract_vehicle_links_from_html_finds_detail_urls(self) -> None:
-        collector = ListingCollector(Settings(), HumanPacer(Settings()))
-        html = """
-        <div>
-            <h4><a href=\"/VehicleDetail/45184893~US\">Car 1</a></h4>
-            <script>window.__data = {\"href\":\"\\/VehicleDetail\\/45171480~US\"}</script>
-        </div>
-        """
-
-        links = collector._extract_vehicle_links_from_html(html)
-
-        self.assertEqual(
-            links,
-            [
-                ("https://www.iaai.com/VehicleDetail/45184893~US", "45184893"),
-                ("https://www.iaai.com/VehicleDetail/45171480~US", "45171480"),
-            ],
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_mapper.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import unittest
+
+from openlane_scraper.openlane.mapper import (
+    map_openlane_record,
+    map_openlane_records,
+    _parse_mileage,
+    _parse_engine_volume_cc,
+    _generate_slug,
+)
+
+
+class TestMapOpenLaneRecord(unittest.TestCase):
+    def _sample_record(self, **overrides) -> dict:
+        base = {
+            "id": "12345",
+            "make": "Toyota",
+            "model": "Camry",
+            "year": 2020,
+            "mileage": 45000,
+            "price": 18500,
+            "color": "White",
+            "body_type": "sedan",
+            "transmission": "automatic",
+            "drivetrain": "fwd",
+            "vin": "1HGBH41JXMN109186",
+            "url": "https://app.openlane.com/vehicles/12345",
+            "images": [
+                {"full": "https://img.openlane.com/1_full.jpg", "thumbnail": "https://img.openlane.com/1_thumb.jpg"},
+                {"full": "https://img.openlane.com/2_full.jpg", "thumbnail": "https://img.openlane.com/2_thumb.jpg"},
+            ],
+        }
+        base.update(overrides)
+        return base
+
+    def test_basic_mapping(self) -> None:
+        record = self._sample_record()
+        result = map_openlane_record(record)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.brand, "TOYOTA")
+        self.assertEqual(result.model, "CAMRY")
+        self.assertEqual(result.year, 2020)
+        self.assertEqual(result.price, 18500)
+        self.assertEqual(result.mileage, 45000)
+        self.assertEqual(result.color, "white")
+        self.assertEqual(result.body_type, "SEDAN")
+        self.assertEqual(result.gearbox, "AT")
+        self.assertEqual(result.drive, "FWD")
+        self.assertEqual(result.origin, "OPENLANE")
+        self.assertEqual(result.origin_id, "openlane:12345")
+        self.assertEqual(result.origin_url, "https://app.openlane.com/vehicles/12345")
+        self.assertEqual(result.evaluation, "1HGBH41JXMN109186")
+        self.assertEqual(len(result.images), 2)
+        self.assertEqual(result.images[0].fullres_image, "https://img.openlane.com/1_full.jpg")
+        self.assertEqual(result.images[0].preview_image, "https://img.openlane.com/1_thumb.jpg")
+
+    def test_missing_id_returns_none(self) -> None:
+        record = {"make": "Toyota", "model": "Camry"}
+        self.assertIsNone(map_openlane_record(record))
+
+    def test_missing_brand_returns_none(self) -> None:
+        record = {"id": "123", "model": "Camry"}
+        self.assertIsNone(map_openlane_record(record))
+
+    def test_missing_model_returns_none(self) -> None:
+        record = {"id": "123", "make": "Toyota"}
+        self.assertIsNone(map_openlane_record(record))
+
+    def test_vin_as_id_fallback(self) -> None:
+        record = self._sample_record()
+        del record["id"]
+        record["vin"] = "WBAPH5C52BA012345"
+        result = map_openlane_record(record)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.origin_id, "openlane:WBAPH5C52BA012345")
+
+    def test_existing_openlane_prefix_is_normalized(self) -> None:
+        record = self._sample_record(id="openlane:777")
+        result = map_openlane_record(record)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.origin_id, "openlane:777")
+
+    def test_whitespace_id_is_normalized(self) -> None:
+        record = self._sample_record(id="  888  ")
+        result = map_openlane_record(record)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.origin_id, "openlane:888")
+
+    def test_image_url_strings(self) -> None:
+        record = self._sample_record(images=["https://a.com/1.jpg", "https://a.com/2.jpg"])
+        result = map_openlane_record(record)
+        self.assertEqual(len(result.images), 2)
+        self.assertEqual(result.images[0].fullres_image, "https://a.com/1.jpg")
+
+    def test_image_deduplication(self) -> None:
+        record = self._sample_record(images=[
+            {"full": "https://a.com/same.jpg"},
+            {"full": "https://a.com/same.jpg"},
+            {"full": "https://a.com/other.jpg"},
+        ])
+        result = map_openlane_record(record)
+        self.assertEqual(len(result.images), 2)
+
+    def test_vehicle_images_api_format(self) -> None:
+        record = self._sample_record(images=[
+            {
+                "url": "https://a.com/original.jpg",
+                "large_resolution_url": "https://a.com/large.jpg",
+                "low_resolution_url": "https://a.com/medium.jpg",
+            }
+        ])
+        result = map_openlane_record(record)
+        self.assertEqual(len(result.images), 1)
+        self.assertEqual(result.images[0].fullres_image, "https://a.com/original.jpg")
+        self.assertEqual(result.images[0].preview_image, "https://a.com/medium.jpg")
+
+    def test_default_url_generation(self) -> None:
+        record = self._sample_record()
+        del record["url"]
+        result = map_openlane_record(record)
+        self.assertEqual(result.origin_url, "https://app.openlane.com/vehicles/12345")
+
+    def test_nested_vehicle_fields(self) -> None:
+        record = {
+            "id": "999",
+            "vehicle": {
+                "make": "BMW",
+                "model": "X5",
+                "year": 2022,
+                "mileage": 10000,
+            },
+        }
+        result = map_openlane_record(record)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.brand, "BMW")
+        self.assertEqual(result.model, "X5")
+        self.assertEqual(result.year, 2022)
+
+    def test_map_records_filters_invalid(self) -> None:
+        records = [
+            self._sample_record(id="1"),
+            {"no_id": True},
+            self._sample_record(id="2"),
+        ]
+        results = map_openlane_records(records)
+        self.assertEqual(len(results), 2)
+
+    def test_sale_type_mapping(self) -> None:
+        record = self._sample_record(sale_type="buy_now")
+        result = map_openlane_record(record)
+        self.assertEqual(result.selling_type, "STOCK")
+
+        record2 = self._sample_record(sale_type="tender")
+        result2 = map_openlane_record(record2)
+        self.assertEqual(result2.selling_type, "TENDER")
+
+
+class TestParseMileage(unittest.TestCase):
+    def test_integer(self) -> None:
+        self.assertEqual(_parse_mileage(45000), 45000)
+
+    def test_string_with_commas(self) -> None:
+        self.assertEqual(_parse_mileage("45,000 miles"), 45000)
+
+    def test_none_returns_zero(self) -> None:
+        self.assertEqual(_parse_mileage(None), 0)
+
+    def test_float(self) -> None:
+        self.assertEqual(_parse_mileage(45000.5), 45000)
+
+
+class TestParseEngineVolume(unittest.TestCase):
+    def test_liters_float(self) -> None:
+        self.assertEqual(_parse_engine_volume_cc(2.5), 2500)
+
+    def test_cc_int(self) -> None:
+        self.assertEqual(_parse_engine_volume_cc(2500), 2500)
+
+    def test_string_liters(self) -> None:
+        self.assertEqual(_parse_engine_volume_cc("2.5L"), 2500)
+
+    def test_none(self) -> None:
+        self.assertIsNone(_parse_engine_volume_cc(None))
+
+
+class TestGenerateSlug(unittest.TestCase):
+    def test_basic(self) -> None:
+        slug = _generate_slug(2020, "TOYOTA", "CAMRY", "openlane:123")
+        self.assertEqual(slug, "2020-toyota-camry-openlane-123")
+
+    def test_no_year(self) -> None:
+        slug = _generate_slug(None, "BMW", "X5", "openlane:456")
+        self.assertEqual(slug, "bmw-x5-openlane-456")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_mappers.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from iaai_scraper.parsing.mapper import CarMapper
-
-
-class TestCarMapper(unittest.TestCase):
-    def setUp(self) -> None:
-        self.mapper = CarMapper()
-
-    def test_deduplicates_images_by_image_key(self) -> None:
-        urls = [
-            "https://vis.iaai.com/resizer?imageKeys=1&width=200&height=150",
-            "https://vis.iaai.com/resizer?imageKeys=1&width=845&height=633",
-            "https://vis.iaai.com/resizer?imageKeys=2&width=400&height=300",
-        ]
-
-        record = self.mapper.map_to_car_record(
-            vehicle_url="https://www.iaai.com/VehicleDetail/123~US",
-            vehicle_summary={"make": "Honda", "model": "Civic", "image_urls": urls},
-            payload_insights={"vehicle_core": {}, "pricing": {}, "damage": {}, "auction": {}, "images": {}},
-        )
-
-        self.assertEqual(len(record.images), 2)
-        self.assertIn("width=845", record.images[0].fullres_image)
-        self.assertIn("height=633", record.images[0].fullres_image)
-
-    def test_no_damage_marker_is_not_damaged(self) -> None:
-        record = self.mapper.map_to_car_record(
-            vehicle_url="https://www.iaai.com/VehicleDetail/123~US",
-            vehicle_summary={"make": "Ford", "model": "Focus"},
-            payload_insights={
-                "vehicle_core": {},
-                "pricing": {},
-                "damage": {"primary": "normal wear"},
-                "auction": {},
-                "images": {},
-            },
-        )
-
-        self.assertFalse(record.is_damaged)
-
-    def test_unknown_empty_values_and_normalization(self) -> None:
-        record = self.mapper.map_to_car_record(
-            vehicle_url="https://www.iaai.com/VehicleDetail/999~US",
-            vehicle_summary={"make": "  ", "model": None, "drive": "???", "gearbox": "unknown"},
-            payload_insights={"vehicle_core": {}, "pricing": {}, "damage": {}, "auction": {}, "images": {}},
-        )
-        self.assertEqual(record.brand, "UNKNOWN")
-        self.assertEqual(record.model, "UNKNOWN")
-        self.assertEqual(record.drive, "NA")
-        self.assertEqual(record.gearbox, "NA")
-
-        # Нормализация регистра и пробелов.
-        record2 = self.mapper.map_to_car_record(
-            vehicle_url="https://www.iaai.com/VehicleDetail/888~US",
-            vehicle_summary={"make": "Honda", "model": "Civic", "drive": "  Front Wheel Drive  ", "gearbox": " AUTOMATIC "},
-            payload_insights={"vehicle_core": {}, "pricing": {}, "damage": {}, "auction": {}, "images": {}},
-        )
-        self.assertEqual(record2.drive, "FWD")
-        self.assertEqual(record2.gearbox, "AT")
-
-    def test_price_and_currency_parsing(self) -> None:
-        record = self.mapper.map_to_car_record(
-            vehicle_url="https://www.iaai.com/VehicleDetail/777~US",
-            vehicle_summary={"make": "Toyota", "model": "Corolla"},
-            payload_insights={
-                "vehicle_core": {},
-                "pricing": {"buy_now": "USD 4,500 - 5,200"},
-                "damage": {},
-                "auction": {},
-                "images": {},
-            },
-        )
-        self.assertEqual(record.price, 5200)
-
-        record2 = self.mapper.map_to_car_record(
-            vehicle_url="https://www.iaai.com/VehicleDetail/778~US",
-            vehicle_summary={"make": "Toyota", "model": "Corolla"},
-            payload_insights={
-                "vehicle_core": {},
-                "pricing": {"buy_now": "€4.500,00"},
-                "damage": {},
-                "auction": {},
-                "images": {},
-            },
-        )
-        self.assertEqual(record2.currency, "EUR")
-        self.assertEqual(record2.price, 4500)
-
-
-if __name__ == "__main__":
-    unittest.main()

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()

tests/test_parser.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from iaai_scraper.parsing.parser import VehicleParser
-
-
-class TestVehicleParserUnit(unittest.TestCase):
-    def setUp(self) -> None:
-        self.parser = VehicleParser()
-
-    def test_parse_dom_pairs_and_title(self) -> None:
-        dom_text = """
-        Stock #:
-        45089484
-        Primary Damage:
-        Front End
-        Odometer:
-        50,123 mi (Actual)
-        """
-        result = self.parser._parse_dom_key_value_pairs(dom_text)
-        self.assertEqual(result.get("lot_number"), "45089484")
-        self.assertEqual(result.get("primary_damage"), "Front End")
-        self.assertEqual(result.get("odometer"), "50,123 mi (Actual)")
-
-        parsed = self.parser._parse_title_for_year_make_model("2014 TOYOTA CAMRY for sale", "")
-        self.assertEqual(parsed["year"], "2014")
-        self.assertEqual(parsed["make"], "TOYOTA")
-        self.assertEqual(parsed["model"], "CAMRY")
-
-    def test_extract_image_urls_filters_and_deduplicates(self) -> None:
-        vehicle_url = "https://www.iaai.com/VehicleDetail/45089484~US"
-        payloads = [{"imageUrls": [
-            "https://vis.iaai.com/resizer?imageKeys=45089484~SID1&width=845&height=633",
-            "https://vis.iaai.com/resizer?imageKeys=45089484~SID1&width=845&height=633",
-            "https://vis.iaai.com/resizer?imageKeys=99999999~SID2&width=845&height=633",
-        ]}]
-        urls = self.parser._extract_image_urls(payloads, "", vehicle_url)
-        self.assertEqual(len(urls), 1)
-        self.assertIn("45089484", urls[0])
-
-    def test_dom_hints_and_access_notes_detect_antibot(self) -> None:
-        hints = self.parser._dom_hints("Please verify you are human. CAPTCHA. Incapsula access denied.")
-        self.assertTrue(hints["has_captcha_text"])
-        self.assertTrue(hints["has_antibot_text"])
-
-        summary = {"vin": "", "image_urls": [], "note": "Incapsula access denied. Verify you are human."}
-        notes = self.parser._build_access_notes(summary, [])
-        self.assertTrue(notes["possible_captcha"])
-        self.assertTrue(notes["possible_antibot"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_scraper.py

@@ -1,273 +0,0 @@
-from __future__ import annotations
-
-import unittest
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-from iaai_scraper.core.config import Settings
-from iaai_scraper.core.exceptions import AntiBotDetectedError, SiteStructureChangedError
-from iaai_scraper.scraper import IAAIScraper
-from iaai_scraper.storage.schemas import CarRecord
-
-
-def make_db_record(origin_id: str) -> dict[str, object]:
-    return CarRecord(
-        parser_id=f"iaai:{origin_id}",
-        brand="Toyota",
-        model="Camry",
-        origin_url=f"https://www.iaai.com/VehicleDetail/{origin_id}~US",
-        origin_id=origin_id,
-        slug=f"toyota-camry-{origin_id}",
-    ).model_dump(mode="json")
-
-
-class TestScraperSync(unittest.TestCase):
-    def _make_scraper(self) -> IAAIScraper:
-        s = Settings()
-        s.log_level = "CRITICAL"
-        s.database.url = "sqlite://"
-        return IAAIScraper(s)
-
-    def test_sync_vehicle_uses_db_record(self) -> None:
-        scraper = self._make_scraper()
-        scraper.persistence.create_tables = MagicMock()
-        scraper.persistence.start_sync_run = MagicMock(return_value=1)
-        scraper.persistence.finish_sync_run = MagicMock()
-        scraper.persistence.upsert_car = MagicMock(return_value={"action": "inserted", "images_upserted": 0})
-        scraper.scrape_vehicle_detail = MagicMock(return_value={"db_record": make_db_record("111")})
-
-        result = scraper.sync_vehicle("https://www.iaai.com/VehicleDetail/111~US")
-
-        self.assertEqual(result["status"], "success")
-        self.assertIn("trace_id", result)
-        scraper.persistence.upsert_car.assert_called_once()
-
-    def test_only_new_routing_legacy_and_streaming(self) -> None:
-        # Legacy path: only_new без listing_url.
-        scraper = self._make_scraper()
-        scraper.persistence.create_tables = MagicMock()
-        scraper.persistence.start_sync_run = MagicMock(return_value=2)
-        scraper.persistence.finish_sync_run = MagicMock()
-        scraper.persistence.get_existing_urls_and_ids = MagicMock(return_value=(
-            {"https://www.iaai.com/VehicleDetail/111~US"}, {"iaai:222"},
-        ))
-        scraper.collect_listing = MagicMock(return_value={
-            "vehicle_urls": [
-                "https://www.iaai.com/VehicleDetail/111~US",
-                "https://www.iaai.com/VehicleDetail/222~US",
-                "https://www.iaai.com/VehicleDetail/333~US",
-            ]
-        })
-        scraper.sync_batch = MagicMock(return_value={
-            "cars_upserted": 1, "cars_failed": 0, "images_upserted": 0, "failures": [],
-        })
-        result = scraper.sync_listing(only_new=True)
-        self.assertEqual(result["skipped_existing"], 2)
-        self.assertEqual(result["cars_upserted"], 1)
-
-        # Streaming path: only_new + listing_url.
-        scraper2 = self._make_scraper()
-        scraper2.persistence.create_tables = MagicMock()
-        scraper2.persistence.start_sync_run = MagicMock(return_value=6)
-        scraper2.persistence.finish_sync_run = MagicMock()
-        scraper2.collect_listing = MagicMock(side_effect=AssertionError("legacy path should not be used"))
-        scraper2._sync_listing_streaming = MagicMock(return_value={
-            "listing": {"vehicles_collected": 10, "early_stopped": False, "truncated_by_time_budget": False},
-            "total": 10, "skipped_existing": 0, "cars_upserted": 10, "cars_failed": 0,
-            "images_upserted": 20, "failures": [], "all_listing_origin_urls": set(),
-        })
-        result2 = scraper2.sync_listing(
-            only_new=True,
-            listing_url="https://www.iaai.com/Vehiclelisting/Cars?Make=TOYOTA",
-            year_min=2020, year_max=2027,
-        )
-        self.assertEqual(result2["cars_upserted"], 10)
-        scraper2._sync_listing_streaming.assert_called_once()
-        scraper2.collect_listing.assert_not_called()
-
-    def test_segmented_sync_calls_per_segment_and_resumes(self) -> None:
-        scraper = self._make_scraper()
-        scraper.persistence.create_tables = MagicMock()
-        scraper.persistence.start_sync_run = MagicMock(return_value=3)
-        scraper.persistence.finish_sync_run = MagicMock()
-
-        call_args_log: list[dict] = []
-        def _fake_sync_listing(**kwargs):
-            call_args_log.append(kwargs)
-            return {
-                "status": "success", "cars_upserted": 5, "cars_failed": 0,
-                "images_upserted": 10, "skipped_existing": 0,
-                "listing": {"vehicles_collected": 50}, "failures": [],
-            }
-
-        scraper.sync_listing = MagicMock(side_effect=_fake_sync_listing)
-        segments = [
-            {"make": "TOYOTA", "year_min": 2020, "year_max": 2027},
-            {"make": "FORD", "year_min": None, "year_max": None},
-            {"make": "HONDA", "year_min": None, "year_max": None},
-        ]
-
-        # Resume: пропускаем TOYOTA, начинаем сразу с FORD.
-        result = scraper.sync_listing_segmented(
-            segments=segments, start_segment=1,
-        )
-
-        self.assertEqual(result["segments_completed"], 2)  # FORD + HONDA
-        self.assertEqual(result["cars_upserted"], 10)
-        # URL содержит бренд.
-        self.assertIn("FORD", call_args_log[0]["listing_url"])
-        self.assertIn("HONDA", call_args_log[1]["listing_url"])
-
-    def test_segmented_sync_does_not_mark_full_scan_completed_when_segment_failed(self) -> None:
-        scraper = self._make_scraper()
-        scraper.sync_listing = MagicMock(side_effect=[
-            {
-                "status": "failed",
-                "full_scan_completed": False,
-                "cars_upserted": 0,
-                "cars_failed": 0,
-                "images_upserted": 0,
-                "skipped_existing": 0,
-                "listing": {"vehicles_collected": 0},
-                "failures": [{"vehicle_url": "segment", "error": "resume failed"}],
-            },
-            {
-                "status": "success",
-                "full_scan_completed": True,
-                "cars_upserted": 1,
-                "cars_failed": 0,
-                "images_upserted": 0,
-                "skipped_existing": 0,
-                "listing": {"vehicles_collected": 10},
-                "failures": [],
-            },
-        ])
-
-        result = scraper.sync_listing_segmented(
-            segments=[
-                {"make": "EAGLE", "year_min": None, "year_max": None},
-                {"make": "FORD", "year_min": None, "year_max": None},
-            ]
-        )
-
-        self.assertFalse(result["full_scan_completed"])
-        self.assertEqual(result["status"], "partial_success")
-
-    def test_build_segment_listing_url(self) -> None:
-        base = "https://www.iaai.com/Vehiclelisting/Cars"
-        self.assertEqual(
-            IAAIScraper._build_segment_listing_url(base, "TOYOTA"),
-            "https://www.iaai.com/Vehiclelisting/Cars?Make=TOYOTA",
-        )
-        self.assertEqual(
-            IAAIScraper._build_segment_listing_url(base, "LAND ROVER"),
-            "https://www.iaai.com/Vehiclelisting/Cars?Make=LAND%20ROVER",
-        )
-        self.assertEqual(IAAIScraper._build_segment_listing_url(base, None), base)
-        self.assertEqual(IAAIScraper._build_segment_listing_url(base, ""), base)
-
-    def test_guard_and_protection_detection(self) -> None:
-        with self.assertRaises(AntiBotDetectedError):
-            IAAIScraper._raise_if_blocked_or_incomplete(
-                {"dom_hints": {"has_captcha_text": True, "has_antibot_text": False},
-                 "access_notes": {}, "vehicle_summary": {}},
-                "https://www.iaai.com/VehicleDetail/999~US",
-            )
-        with self.assertRaises(SiteStructureChangedError):
-            IAAIScraper._raise_if_blocked_or_incomplete(
-                {"dom_hints": {"has_captcha_text": False, "has_antibot_text": False},
-                 "access_notes": {"possible_captcha": False, "possible_antibot": False},
-                 "vehicle_summary": {}},
-                "https://www.iaai.com/VehicleDetail/999~US",
-            )
-        self.assertTrue(IAAIScraper._is_protection_or_network_error(RuntimeError("NS_ERROR_NET_INTERRUPT")))
-        self.assertTrue(IAAIScraper._is_protection_or_network_error(RuntimeError("captcha challenge")))
-        self.assertFalse(IAAIScraper._is_protection_or_network_error(RuntimeError("plain validation error")))
-
-    def test_close_resets_browser_state(self) -> None:
-        scraper = self._make_scraper()
-        http_pool = MagicMock()
-        scraper._http_pool = http_pool
-        scraper.context = MagicMock()
-        scraper.browser = MagicMock()
-        scraper.playwright = MagicMock()
-        scraper.close()
-        http_pool.clear.assert_called_once()
-        self.assertIsNone(scraper.context)
-        self.assertIsNone(scraper.browser)
-
-    def test_recover_empty_listing_page(self) -> None:
-        scraper = self._make_scraper()
-        page = MagicMock()
-        page_result = SimpleNamespace(
-            vehicle_links=[SimpleNamespace(href="https://www.iaai.com/VehicleDetail/123~US")],
-        )
-        scraper.listing_collector.collect_current_page = MagicMock(return_value=page_result)
-        scraper.listing_collector.open_cars_listing = MagicMock()
-
-        # Страница > 1: reload.
-        _, urls = scraper._recover_empty_listing_page(
-            page, page_number=5, all_raw_urls=[], seen_urls=set(),
-        )
-        page.reload.assert_called_once()
-        self.assertEqual(len(urls), 1)
-
-        # Страница 1: переоткрытие листинга.
-        page.reset_mock()
-        _, urls = scraper._recover_empty_listing_page(
-            page, page_number=1, all_raw_urls=[], seen_urls=set(),
-        )
-        scraper.listing_collector.open_cars_listing.assert_called_once()
-        page.reload.assert_not_called()
-
-    def test_sync_listing_always_starts_from_page_one(self) -> None:
-        scraper = self._make_scraper()
-        scraper.settings.celery.batch_size = 1
-
-        page = MagicMock()
-        page_result = SimpleNamespace(
-            page_number=1,
-            vehicle_links=[SimpleNamespace(href="https://www.iaai.com/VehicleDetail/999~US", lot_number="999")],
-            next_page_detected=False,
-        )
-
-        scraper._get_page_with_warmup = MagicMock(return_value=page)
-        # Pagination-resume убран: _reopen_listing_and_resume не должен вызываться.
-        scraper._reopen_listing_and_resume = MagicMock(
-            side_effect=AssertionError("pagination resume must not be used")
-        )
-        scraper.listing_collector.open_cars_listing = MagicMock()
-        scraper.listing_collector.apply_filters = MagicMock(return_value={
-            "make": None,
-            "model": None,
-            "year_min": None,
-            "year_max": None,
-        })
-        scraper.listing_collector.collect_current_page = MagicMock(return_value=page_result)
-        scraper._extract_page_urls = MagicMock(return_value=["https://www.iaai.com/VehicleDetail/999~US"])
-        scraper.sync_batch = MagicMock(return_value={
-            "cars_upserted": 1,
-            "cars_failed": 0,
-            "images_upserted": 0,
-            "failures": [],
-        })
-
-        result = scraper._sync_listing_streaming(
-            make=None,
-            model=None,
-            lane="iaai_cars",
-            limit=None,
-            effective_only_new=False,
-            started_at=0.0,
-            listing_url="https://www.iaai.com/Vehiclelisting/Cars?Make=EAGLE",
-        )
-
-        scraper.listing_collector.open_cars_listing.assert_called_once()
-        scraper._reopen_listing_and_resume.assert_not_called()
-        scraper.sync_batch.assert_called_once()
-        self.assertEqual(result["cars_upserted"], 1)
-        self.assertEqual(result["total"], 1)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_scraper_images.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import unittest
+
+from openlane_scraper.scraper import OpenLaneScraper
+from openlane_scraper.storage.schemas import ImageRecord
+
+
+class TestScraperImageHelpers(unittest.TestCase):
+    def test_build_image_records_supports_image_large_and_image(self) -> None:
+        payload = [
+            {
+                "image": "https://img.cdn/vehicle-medium-1.jpg",
+                "image_large": "https://img.cdn/vehicle-large-1.jpg",
+            },
+            {
+                "image": "https://img.cdn/vehicle-medium-2.jpg",
+                "large_resolution_url": "https://img.cdn/vehicle-large-2.jpg",
+                "low_resolution_url": "https://img.cdn/vehicle-low-2.jpg",
+            },
+        ]
+
+        records = OpenLaneScraper._build_image_records(payload)
+
+        self.assertEqual(len(records), 2)
+        self.assertEqual(records[0].fullres_image, "https://img.cdn/vehicle-large-1.jpg")
+        self.assertEqual(records[0].preview_image, "https://img.cdn/vehicle-medium-1.jpg")
+        self.assertEqual(records[1].fullres_image, "https://img.cdn/vehicle-large-2.jpg")
+        self.assertEqual(records[1].preview_image, "https://img.cdn/vehicle-low-2.jpg")
+
+    def test_merge_image_records_keeps_unique_and_reindexes(self) -> None:
+        existing = [
+            ImageRecord(
+                fullres_image="https://img.cdn/1.jpg",
+                preview_image="https://img.cdn/1_small.jpg",
+                order_index=10,
+            ),
+            ImageRecord(
+                fullres_image="https://img.cdn/2.jpg",
+                preview_image="https://img.cdn/2_small.jpg",
+                order_index=11,
+            ),
+        ]
+        fetched = [
+            ImageRecord(
+                fullres_image="https://img.cdn/2.jpg",
+                preview_image="https://img.cdn/2_small_new.jpg",
+                order_index=0,
+            ),
+            ImageRecord(
+                fullres_image="https://img.cdn/3.jpg",
+                preview_image="https://img.cdn/3_small.jpg",
+                order_index=1,
+            ),
+        ]
+
+        merged = OpenLaneScraper._merge_image_records(existing, fetched)
+
+        self.assertEqual([img.fullres_image for img in merged], [
+            "https://img.cdn/2.jpg",
+            "https://img.cdn/3.jpg",
+            "https://img.cdn/1.jpg",
+        ])
+        self.assertEqual([img.order_index for img in merged], [0, 1, 2])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_utils.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import unittest
 
-from iaai_scraper.core.utils import deep_find_key
-from iaai_scraper.core.config import parse_listing_segments, IAAI_DEFAULT_MAKES, _LARGE_MAKES, _YEAR_SPLITS
+from openlane_scraper.core.utils import deep_find_key
 
 
 class TestDeepFindKey(unittest.TestCase):
@@ -21,55 +20,5 @@ class TestDeepFindKey(unittest.TestCase):
         self.assertEqual(deep_find_key(deep_payload, {"target"}, max_depth=8), ["value"])
 
 
-class TestParseListingSegments(unittest.TestCase):
-    def test_empty_and_invalid_return_empty(self) -> None:
-        self.assertEqual(parse_listing_segments(""), [])
-        self.assertEqual(parse_listing_segments("  "), [])
-        self.assertEqual(parse_listing_segments("invalid"), [])
-
-    def test_auto_segments_complete_coverage(self) -> None:
-        """auto: все бренды покрыты, крупные разбиты по годам, годы без дыр."""
-        segs = parse_listing_segments("auto")
-
-        # Точное число сегментов.
-        expected = len(_LARGE_MAKES) * len(_YEAR_SPLITS) + (len(IAAI_DEFAULT_MAKES) - len(_LARGE_MAKES))
-        self.assertEqual(len(segs), expected)
-
-        # Все бренды из списка присутствуют.
-        makes_in_segments = {s["make"] for s in segs}
-        for make in IAAI_DEFAULT_MAKES:
-            self.assertIn(make, makes_in_segments)
-
-        # Крупные бренды разбиты на 3 сегмента с годами.
-        toyota = [s for s in segs if s["make"] == "TOYOTA"]
-        self.assertEqual(len(toyota), 3)
-        for s in toyota:
-            self.assertIsNotNone(s["year_min"])
-
-        # Мелкие бренды без годов.
-        lexus = [s for s in segs if s["make"] == "LEXUS"]
-        self.assertEqual(len(lexus), 1)
-        self.assertIsNone(lexus[0]["year_min"])
-
-        # Годовые диапазоны покрывают 1950-2027.
-        years = set()
-        for yr_min, yr_max in _YEAR_SPLITS:
-            years.update(range(yr_min, yr_max + 1))
-        for year in range(1950, 2027):
-            self.assertIn(year, years)
-
-    def test_json_input_formats(self) -> None:
-        # Массив строк.
-        segs = parse_listing_segments('["toyota", "ford"]')
-        self.assertEqual(len(segs), 2)
-        self.assertEqual(segs[0]["make"], "TOYOTA")
-
-        # Массив объектов с годами.
-        segs = parse_listing_segments('[{"make":"BMW","year_min":2020,"year_max":2025}]')
-        self.assertEqual(segs[0]["make"], "BMW")
-        self.assertEqual(segs[0]["year_min"], 2020)
-        self.assertEqual(segs[0]["year_max"], 2025)
-
-
 if __name__ == "__main__":
     unittest.main()

tests/test_worker_tasks.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import unittest
 from unittest.mock import MagicMock, patch
 
-from iaai_scraper.worker import tasks
+from openlane_scraper.worker import tasks
 
 
 class TestWorkerTaskLockHelpers(unittest.TestCase):
@@ -52,8 +52,10 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
              patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
              patch.object(tasks, "_release_lock_if_owner") as release_lock, \
              patch.object(tasks.sync_listing_task, "update_state"), \
+             patch("openlane_scraper.worker.tasks.time.sleep"), \
              patch.object(tasks, "_run_browser_job", return_value={
                  "run_id": 7,
+                 "status": "success",
                  "cars_upserted": 2,
                  "cars_failed": 0,
                  "images_upserted": 4,
@@ -71,7 +73,7 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
 
             tasks.sync_listing_task.push_request(id="task-123")
             try:
-                result = tasks.sync_listing_task.run(make="Toyota")
+                result = tasks.sync_listing_task.run()
             finally:
                 tasks.sync_listing_task.pop_request()
 
@@ -117,8 +119,10 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
              patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
              patch.object(tasks, "_release_lock_if_owner") as release_lock, \
              patch.object(tasks.sync_listing_task, "update_state"), \
+             patch("openlane_scraper.worker.tasks.time.sleep"), \
              patch.object(tasks, "_run_browser_job", return_value={
                  "run_id": 9,
+                 "status": "success",
                  "cars_upserted": 3,
                  "cars_failed": 0,
                  "images_upserted": 5,
@@ -136,7 +140,7 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
 
             tasks.sync_listing_task.push_request(id="task-456")
             try:
-                result = tasks.sync_listing_task.run(make="Honda")
+                result = tasks.sync_listing_task.run()
             finally:
                 tasks.sync_listing_task.pop_request()
 
@@ -145,278 +149,41 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
         self.assertEqual(acquire_lock.call_count, 2)
         release_lock.assert_called_once()
 
-    def test_checkpoint_save_load_roundtrip(self) -> None:
-        storage: dict[str, str] = {}
-
-        def _fake_set(key, value, ex=None):
-            storage[key] = value
-            return True
-
-        redis_client = MagicMock()
-        redis_client.set.side_effect = _fake_set
-        redis_client.get.side_effect = lambda key: storage.get(key)
-
-        tasks._save_last_completed_segment(redis_client, 12)
-
-        self.assertEqual(tasks._load_last_completed_segment(redis_client), 12)
-        self.assertEqual(redis_client.set.call_args.kwargs["ex"], tasks.SYNC_LISTING_CHECKPOINT_TTL_SECONDS)
-
-    def test_load_checkpoint_clears_invalid_payload(self) -> None:
-        redis_client = MagicMock()
-        redis_client.get.return_value = "{not-a-number"
-
-        self.assertIsNone(tasks._load_last_completed_segment(redis_client))
-        redis_client.delete.assert_called_once_with(tasks.SYNC_LISTING_CHECKPOINT_KEY)
-
-    def test_load_checkpoint_empty_when_missing(self) -> None:
-        redis_client = MagicMock()
-        redis_client.get.return_value = None
-
-        self.assertIsNone(tasks._load_last_completed_segment(redis_client))
-        redis_client.delete.assert_not_called()
-
-    def test_sync_listing_resumes_from_next_segment_during_bootstrap(self) -> None:
-        segments = [
-            {"make": "ACURA"},
-            {"make": "AUDI"},
-            {"make": "BMW"},
-            {"make": "EAGLE"},
-        ]
+    def test_bootstrap_forces_full_scan(self) -> None:
         with patch.object(tasks, "_get_persistence") as get_persistence, \
              patch.object(tasks, "_get_redis") as get_redis, \
              patch.object(tasks, "_acquire_lock", return_value=True), \
              patch.object(tasks, "_is_full_scan_done", return_value=False), \
+             patch.object(tasks, "_set_full_scan_done") as set_done, \
              patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
-             patch.object(tasks, "_release_lock_if_owner") as release_lock, \
-             patch.object(tasks, "_run_browser_job", side_effect=lambda fn: fn()), \
+             patch.object(tasks, "_release_lock_if_owner"), \
              patch.object(tasks.sync_listing_task, "update_state"), \
-             patch("iaai_scraper.worker.tasks.parse_listing_segments", return_value=segments):
-            get_persistence.return_value = MagicMock()
-            redis_client = MagicMock()
-            redis_client.get.side_effect = lambda key: (
-                "1" if key == tasks.SYNC_LISTING_CHECKPOINT_KEY else None
-            )
-            get_redis.return_value = redis_client
-            start_heartbeat.return_value = (MagicMock(), MagicMock())
-
-            sync_segmented_mock = MagicMock(return_value={
-                "run_id": 11, "status": "success", "full_scan_completed": True,
-                "cars_upserted": 1, "cars_failed": 0, "images_upserted": 0,
-                "skipped_existing": 0, "elapsed_seconds": 1.0, "failures": [],
-            })
-            scraper_ctx = MagicMock()
-            scraper_ctx.__enter__.return_value.sync_listing_segmented = sync_segmented_mock
-            scraper_ctx.__exit__.return_value = None
-
-            with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
-                tasks.sync_listing_task.push_request(id="task-resume-seg")
-                try:
-                    result = tasks.sync_listing_task.run()
-                finally:
-                    tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        # last_completed=1 → start_segment=2 (AUDI завершён, возобновляем с BMW).
-        self.assertEqual(sync_segmented_mock.call_args.kwargs["start_segment"], 2)
-        self.assertEqual(sync_segmented_mock.call_args.kwargs["start_page"], 1)
-        release_lock.assert_called_once()
-
-    def test_sync_listing_ignores_checkpoint_after_full_scan_completed(self) -> None:
-        segments = [{"make": "ACURA"}, {"make": "AUDI"}]
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "_acquire_lock", return_value=True), \
-             patch.object(tasks, "_is_full_scan_done", return_value=True), \
-             patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
-             patch.object(tasks, "_release_lock_if_owner") as release_lock, \
-             patch.object(tasks, "_clear_sync_checkpoint") as clear_checkpoint, \
-             patch.object(tasks, "_run_browser_job", side_effect=lambda fn: fn()), \
-             patch.object(tasks.sync_listing_task, "update_state"), \
-             patch("iaai_scraper.worker.tasks.parse_listing_segments", return_value=segments):
-            get_persistence.return_value = MagicMock()
-            redis_client = MagicMock()
-            # Оставшийся чекпоинт не должен использоваться.
-            redis_client.get.side_effect = lambda key: (
-                "0" if key == tasks.SYNC_LISTING_CHECKPOINT_KEY else None
-            )
-            get_redis.return_value = redis_client
-            start_heartbeat.return_value = (MagicMock(), MagicMock())
-
-            sync_segmented_mock = MagicMock(return_value={
-                "run_id": 14, "status": "success", "full_scan_completed": True,
-                "cars_upserted": 1, "cars_failed": 0, "images_upserted": 0,
-                "skipped_existing": 0, "elapsed_seconds": 1.0, "failures": [],
-            })
-            scraper_ctx = MagicMock()
-            scraper_ctx.__enter__.return_value.sync_listing_segmented = sync_segmented_mock
-            scraper_ctx.__exit__.return_value = None
-
-            with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
-                tasks.sync_listing_task.push_request(id="task-792")
-                try:
-                    result = tasks.sync_listing_task.run()
-                finally:
-                    tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        self.assertEqual(sync_segmented_mock.call_args.kwargs["start_segment"], 0)
-        self.assertIsNone(sync_segmented_mock.call_args.kwargs["progress_callback"])
-        clear_checkpoint.assert_called()
-        release_lock.assert_called_once()
-
-    def test_sync_listing_checkpoint_beyond_segments_restarts_from_zero(self) -> None:
-        segments = [{"make": "ACURA"}, {"make": "AUDI"}]
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "_acquire_lock", return_value=True), \
-             patch.object(tasks, "_is_full_scan_done", return_value=False), \
-             patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
-             patch.object(tasks, "_release_lock_if_owner") as release_lock, \
-             patch.object(tasks, "_run_browser_job", side_effect=lambda fn: fn()), \
-             patch.object(tasks.sync_listing_task, "update_state"), \
-             patch("iaai_scraper.worker.tasks.parse_listing_segments", return_value=segments):
-            get_persistence.return_value = MagicMock()
-            redis_client = MagicMock()
-            redis_client.get.side_effect = lambda key: (
-                "99" if key == tasks.SYNC_LISTING_CHECKPOINT_KEY else None
-            )
-            get_redis.return_value = redis_client
-            start_heartbeat.return_value = (MagicMock(), MagicMock())
-
-            sync_segmented_mock = MagicMock(return_value={
-                "run_id": 15, "status": "success", "full_scan_completed": True,
-                "cars_upserted": 0, "cars_failed": 0, "images_upserted": 0,
-                "skipped_existing": 0, "elapsed_seconds": 1.0, "failures": [],
-            })
-            scraper_ctx = MagicMock()
-            scraper_ctx.__enter__.return_value.sync_listing_segmented = sync_segmented_mock
-            scraper_ctx.__exit__.return_value = None
-
-            with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
-                tasks.sync_listing_task.push_request(id="task-beyond")
-                try:
-                    result = tasks.sync_listing_task.run()
-                finally:
-                    tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        self.assertEqual(sync_segmented_mock.call_args.kwargs["start_segment"], 0)
-        release_lock.assert_called_once()
-
-    def test_sync_listing_task_clears_checkpoint_on_hourly_run(self) -> None:
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "_acquire_lock", return_value=True), \
-             patch.object(tasks, "_is_full_scan_done", return_value=True), \
-             patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
-             patch.object(tasks, "_release_lock_if_owner") as release_lock, \
-             patch.object(tasks, "_clear_sync_checkpoint") as clear_checkpoint, \
+             patch("openlane_scraper.worker.tasks.time.sleep"), \
              patch.object(tasks, "_run_browser_job", return_value={
-                 "run_id": 13,
-                 "status": "partial_success",
-                 "full_scan_completed": True,
-                 "cars_upserted": 2,
-                 "cars_failed": 1,
-                 "images_upserted": 3,
+                 "run_id": 11,
+                 "status": "success",
+                 "cars_upserted": 5,
+                 "cars_failed": 0,
+                 "images_upserted": 10,
                  "skipped_existing": 0,
-                 "elapsed_seconds": 4.0,
-                 "failures": [{"vehicle_url": "v", "error": "e"}],
-             }), \
-             patch.object(tasks.sync_listing_task, "update_state"):
-            get_persistence.return_value = MagicMock()
+                 "elapsed_seconds": 3.0,
+             }):
+            persistence = MagicMock()
+            get_persistence.return_value = persistence
             redis_client = MagicMock()
-            redis_client.get.return_value = None
             get_redis.return_value = redis_client
             start_heartbeat.return_value = (MagicMock(), MagicMock())
 
-            tasks.sync_listing_task.push_request(id="task-791")
+            tasks.sync_listing_task.push_request(id="task-bootstrap")
             try:
-                result = tasks.sync_listing_task.run(make="Toyota")
+                result = tasks.sync_listing_task.run(only_new=True)
             finally:
                 tasks.sync_listing_task.pop_request()
 
-        self.assertEqual(result["status"], "partial_success")
-        # Hourly-ветка (full_scan_done=True) всегда удаляет оставшийся чекпоинт
-        # до браузерного job + после. Главное — вызов произошёл.
-        clear_checkpoint.assert_called()
-        release_lock.assert_called_once()
-
-    def test_try_set_followup_pending_deduplicates(self) -> None:
-        redis_client = MagicMock()
-        redis_client.set.side_effect = [True, False]
-
-        self.assertTrue(tasks._try_set_followup_pending(redis_client, ttl_seconds=120))
-        self.assertFalse(tasks._try_set_followup_pending(redis_client, ttl_seconds=120))
-
-    def test_bump_bootstrap_failure_streak_opens_circuit_breaker(self) -> None:
-        redis_client = MagicMock()
-        redis_client.incr.return_value = tasks.SYNC_LISTING_BOOTSTRAP_FAILURE_STREAK_LIMIT
-
-        streak, should_enqueue = tasks._bump_bootstrap_failure_streak(
-            redis_client,
-            reason="max_retries_exceeded",
-        )
-
-        self.assertEqual(streak, tasks.SYNC_LISTING_BOOTSTRAP_FAILURE_STREAK_LIMIT)
-        self.assertFalse(should_enqueue)
-        redis_client.expire.assert_called_once_with(
-            tasks.SYNC_LISTING_BOOTSTRAP_FAILURE_STREAK_KEY,
-            tasks.SYNC_LISTING_BOOTSTRAP_FAILURE_STREAK_TTL_SECONDS,
-        )
-
-    def test_bump_bootstrap_failure_streak_allows_retry_before_limit(self) -> None:
-        redis_client = MagicMock()
-        redis_client.incr.return_value = 1
-
-        streak, should_enqueue = tasks._bump_bootstrap_failure_streak(
-            redis_client,
-            reason="bootstrap_not_completed",
-        )
-
-        self.assertEqual(streak, 1)
-        self.assertTrue(should_enqueue)
-
-    def test_sync_listing_task_does_not_enqueue_followup_after_bootstrap_error_limit(self) -> None:
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "_acquire_lock", return_value=True), \
-             patch.object(tasks, "_is_full_scan_done", return_value=False), \
-             patch.object(tasks, "_start_lock_heartbeat") as start_heartbeat, \
-             patch.object(tasks, "_release_lock_if_owner") as release_lock, \
-             patch.object(tasks, "_try_set_followup_pending", return_value=True), \
-             patch.object(tasks, "_bump_bootstrap_failure_streak", return_value=(tasks.SYNC_LISTING_BOOTSTRAP_FAILURE_STREAK_LIMIT, False)) as bump_streak, \
-             patch.object(tasks, "_clear_followup_pending") as clear_pending, \
-             patch.object(tasks.sync_listing_task, "update_state"), \
-             patch.object(tasks, "_run_browser_job", return_value={
-                 "run_id": 99,
-                 "status": "failed",
-                 "full_scan_completed": False,
-                 "cars_upserted": 0,
-                 "cars_failed": 0,
-                 "images_upserted": 0,
-                 "skipped_existing": 0,
-                 "elapsed_seconds": 1.0,
-                 "failures": [{"vehicle_url": "listing", "error": "bad resume"}],
-                 "listing": {"vehicles_collected": 0},
-             }):
-            get_persistence.return_value = MagicMock()
-            redis_client = MagicMock()
-            redis_client.get.return_value = None
-            get_redis.return_value = redis_client
-            start_heartbeat.return_value = (MagicMock(), MagicMock())
-
-            with patch.object(tasks.sync_listing_task, "app", new=MagicMock()) as task_app:
-                tasks.sync_listing_task.push_request(id="task-900")
-                try:
-                    result = tasks.sync_listing_task.run()
-                finally:
-                    tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "failed")
-        bump_streak.assert_called_once()
-        clear_pending.assert_called()
-        task_app.send_task.assert_not_called()
+        self.assertEqual(result["status"], "success")
+        # Bootstrap should set full_scan_done to True on success.
+        set_done.assert_called_once_with(redis_client, True)
 
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()