fix scraper flow

tests/test_worker_tasks.py

@@ -1,215 +1,15 @@
 from __future__ import annotations
 
+import json
+from dataclasses import replace
 import unittest
 from unittest.mock import MagicMock, patch
 
 from iaai_scraper.worker import tasks
-
-
-def make_settings_stub(*, parallel_segments: bool = False) -> MagicMock:
-    settings_stub = MagicMock()
-    settings_stub.celery.parallel_segments = parallel_segments
-    settings_stub.celery.task_soft_time_limit = 3300
-    settings_stub.celery.task_time_limit = 3600
-    settings_stub.celery.task_stall_timeout_seconds = 600
-    settings_stub.listing.listing_segments_json = "ignored"
-    settings_stub.discovery.mode = "listing"
-    settings_stub.discovery.hourly_mode = "rolling_refresh"
-    return settings_stub
+from iaai_scraper.core.config import settings as base_settings
 
 
 class TestWorkerTaskLockHelpers(unittest.TestCase):
-    def test_sync_listing_task_uses_hourly_sitemap_even_when_mode_is_not_sitemap(self) -> None:
-        settings_stub = make_settings_stub(parallel_segments=False)
-        settings_stub.discovery.mode = "listing"
-        settings_stub.discovery.hourly_mode = "rolling_refresh"
-
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
-             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, "_hourly_sitemap_rolling_refresh_sync", return_value={
-                 "status": "success",
-                 "run_id": None,
-                 "cars_upserted": 25,
-                 "cars_failed": 0,
-                 "images_upserted": 50,
-                 "skipped_existing": 100,
-                 "elapsed_seconds": None,
-                 "failures": [],
-                 "hourly_mode": "sitemap_rolling_refresh",
-                 "discovered_urls": 105,
-                 "new_urls": 5,
-                 "refresh_urls": 20,
-                 "sold_marked": 2,
-             }) as hourly_sync, \
-             patch.object(tasks.sync_listing_task, "update_state"):
-            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())
-
-            tasks.sync_listing_task.push_request(id="task-hourly-force-sitemap")
-            try:
-                result = tasks.sync_listing_task.run()
-            finally:
-                tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        self.assertEqual(result["hourly_mode"], "sitemap_rolling_refresh")
-        hourly_sync.assert_called_once()
-        release_lock.assert_called_once()
-
-    def test_sync_listing_task_uses_hourly_sitemap_rolling_refresh_after_bootstrap(self) -> None:
-        settings_stub = make_settings_stub(parallel_segments=False)
-        settings_stub.discovery.mode = "sitemap"
-        settings_stub.discovery.hourly_mode = "rolling_refresh"
-
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
-             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, "_hourly_sitemap_rolling_refresh_sync", return_value={
-                 "status": "success",
-                 "run_id": None,
-                 "cars_upserted": 25,
-                 "cars_failed": 0,
-                 "images_upserted": 50,
-                 "skipped_existing": 100,
-                 "elapsed_seconds": None,
-                 "failures": [],
-                 "hourly_mode": "sitemap_rolling_refresh",
-                 "discovered_urls": 105,
-                 "new_urls": 5,
-                 "refresh_urls": 20,
-                 "sold_marked": 2,
-             }) as hourly_sync, \
-             patch.object(tasks.sync_listing_task, "update_state"):
-            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())
-
-            tasks.sync_listing_task.push_request(id="task-hourly")
-            try:
-                result = tasks.sync_listing_task.run()
-            finally:
-                tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        self.assertEqual(result["hourly_mode"], "sitemap_rolling_refresh")
-        hourly_sync.assert_called_once()
-        release_lock.assert_called_once()
-
-    def test_sync_listing_task_can_use_hourly_sitemap_diff_when_configured(self) -> None:
-        settings_stub = make_settings_stub(parallel_segments=False)
-        settings_stub.discovery.mode = "sitemap"
-        settings_stub.discovery.hourly_mode = "diff"
-
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
-             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, "_hourly_sitemap_diff_sync", return_value={
-                 "status": "success",
-                 "run_id": None,
-                 "cars_upserted": 5,
-                 "cars_failed": 0,
-                 "images_upserted": 10,
-                 "skipped_existing": 100,
-                 "elapsed_seconds": None,
-                 "failures": [],
-                 "hourly_mode": "sitemap_diff",
-                 "discovered_urls": 105,
-                 "new_urls": 5,
-                 "sold_marked": 2,
-             }) as hourly_sync, \
-             patch.object(tasks.sync_listing_task, "update_state"):
-            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())
-
-            tasks.sync_listing_task.push_request(id="task-hourly-diff")
-            try:
-                result = tasks.sync_listing_task.run()
-            finally:
-                tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        self.assertEqual(result["hourly_mode"], "sitemap_diff")
-        hourly_sync.assert_called_once()
-        release_lock.assert_called_once()
-
-    def test_sync_listing_task_forces_sitemap_full_scan_in_bootstrap(self) -> None:
-        settings_stub = make_settings_stub(parallel_segments=False)
-        settings_stub.discovery.mode = "listing"
-
-        with patch.object(tasks, "_get_persistence") as get_persistence, \
-             patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
-             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=[{"make": "HONDA"}]):
-            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())
-
-            sync_listing_mock = MagicMock(return_value={
-                "run_id": 99,
-                "status": "success",
-                "full_scan_completed": True,
-                "cars_upserted": 10,
-                "cars_failed": 0,
-                "images_upserted": 20,
-                "skipped_existing": 0,
-                "elapsed_seconds": 1.0,
-                "failures": [],
-            })
-            sync_listing_segmented_mock = MagicMock(side_effect=AssertionError("segmented path should not be used"))
-            scraper = MagicMock()
-            scraper.sync_listing = sync_listing_mock
-            scraper.sync_listing_segmented = sync_listing_segmented_mock
-            scraper_ctx = MagicMock()
-            scraper_ctx.__enter__.return_value = scraper
-            scraper_ctx.__exit__.return_value = None
-
-            with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
-                tasks.sync_listing_task.push_request(id="task-bootstrap-sitemap")
-                try:
-                    result = tasks.sync_listing_task.run()
-                finally:
-                    tasks.sync_listing_task.pop_request()
-
-        self.assertEqual(result["status"], "success")
-        sync_listing_mock.assert_called_once_with(
-            make=None,
-            model=None,
-            lane="iaai_cars",
-            limit=None,
-            only_new=False,
-        )
-        sync_listing_segmented_mock.assert_not_called()
-        release_lock.assert_called_once()
-
     def test_lock_acquire_refresh_release(self) -> None:
         redis_client = MagicMock()
 
@@ -378,17 +178,15 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
         self.assertIsNone(tasks._load_last_completed_segment(redis_client))
         redis_client.delete.assert_not_called()
 
-    def test_sync_listing_bootstrap_prefers_sitemap_over_segment_resume(self) -> None:
+    def test_sync_listing_resumes_from_next_segment_during_bootstrap(self) -> None:
         segments = [
             {"make": "ACURA"},
             {"make": "AUDI"},
             {"make": "BMW"},
             {"make": "EAGLE"},
         ]
-        settings_stub = make_settings_stub()
         with patch.object(tasks, "_get_persistence") as get_persistence, \
              patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
              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, \
@@ -404,15 +202,13 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
             get_redis.return_value = redis_client
             start_heartbeat.return_value = (MagicMock(), MagicMock())
 
-            sync_segmented_mock = MagicMock(side_effect=AssertionError("segmented path should not be used"))
-            sync_listing_mock = MagicMock(return_value={
+            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.__enter__.return_value.sync_listing = sync_listing_mock
             scraper_ctx.__exit__.return_value = None
 
             with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
@@ -423,42 +219,21 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
                     tasks.sync_listing_task.pop_request()
 
         self.assertEqual(result["status"], "success")
-        sync_listing_mock.assert_called_once_with(
-            make=None,
-            model=None,
-            lane="iaai_cars",
-            limit=None,
-            only_new=False,
-        )
-        sync_segmented_mock.assert_not_called()
+        # 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_hourly_path_ignores_checkpoint_after_full_scan_completed(self) -> None:
+    def test_sync_listing_ignores_checkpoint_after_full_scan_completed(self) -> None:
         segments = [{"make": "ACURA"}, {"make": "AUDI"}]
-        settings_stub = make_settings_stub()
         with patch.object(tasks, "_get_persistence") as get_persistence, \
              patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
              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, "_hourly_sitemap_rolling_refresh_sync", return_value={
-                 "status": "success",
-                 "run_id": None,
-                 "cars_upserted": 1,
-                 "cars_failed": 0,
-                 "images_upserted": 0,
-                 "skipped_existing": 0,
-                 "elapsed_seconds": None,
-                 "failures": [],
-                 "hourly_mode": "sitemap_rolling_refresh",
-                 "discovered_urls": 10,
-                 "new_urls": 1,
-                 "refresh_urls": 1,
-                 "sold_marked": 0,
-             }) as hourly_sync, \
+             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()
@@ -470,24 +245,32 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
             get_redis.return_value = redis_client
             start_heartbeat.return_value = (MagicMock(), MagicMock())
 
-            tasks.sync_listing_task.push_request(id="task-792")
-            try:
-                result = tasks.sync_listing_task.run()
-            finally:
-                tasks.sync_listing_task.pop_request()
+            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(result["hourly_mode"], "sitemap_rolling_refresh")
-        hourly_sync.assert_called_once()
+        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_bootstrap_ignores_beyond_segment_checkpoint(self) -> None:
+    def test_sync_listing_checkpoint_beyond_segments_restarts_from_zero(self) -> None:
         segments = [{"make": "ACURA"}, {"make": "AUDI"}]
-        settings_stub = make_settings_stub()
         with patch.object(tasks, "_get_persistence") as get_persistence, \
              patch.object(tasks, "_get_redis") as get_redis, \
-             patch.object(tasks, "Settings", return_value=settings_stub), \
              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, \
@@ -503,15 +286,13 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
             get_redis.return_value = redis_client
             start_heartbeat.return_value = (MagicMock(), MagicMock())
 
-            sync_segmented_mock = MagicMock(side_effect=AssertionError("segmented path should not be used"))
-            sync_listing_mock = MagicMock(return_value={
+            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.__enter__.return_value.sync_listing = sync_listing_mock
             scraper_ctx.__exit__.return_value = None
 
             with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
@@ -522,14 +303,7 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
                     tasks.sync_listing_task.pop_request()
 
         self.assertEqual(result["status"], "success")
-        sync_listing_mock.assert_called_once_with(
-            make=None,
-            model=None,
-            lane="iaai_cars",
-            limit=None,
-            only_new=False,
-        )
-        sync_segmented_mock.assert_not_called()
+        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:
@@ -606,38 +380,28 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
         self.assertTrue(should_enqueue)
 
     def test_sync_listing_task_does_not_enqueue_followup_after_bootstrap_error_limit(self) -> None:
-        settings_stub = make_settings_stub(parallel_segments=False)
         with patch.object(tasks, "_get_persistence") as get_persistence, \
-            patch.object(tasks, "_get_redis") as get_redis, \
-            patch.object(tasks, "Settings", return_value=settings_stub), \
-            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},
-                },
-            ):
+             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
@@ -656,6 +420,177 @@ class TestWorkerTaskLockHelpers(unittest.TestCase):
         clear_pending.assert_called()
         task_app.send_task.assert_not_called()
 
+    def test_sync_listing_task_soft_timeout_deduplicates_continuation(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", return_value=(MagicMock(), MagicMock())), \
+             patch.object(tasks, "_release_lock_if_owner"), \
+             patch.object(tasks, "_run_browser_job", side_effect=tasks.SoftTimeLimitExceeded()), \
+             patch.object(tasks, "_try_set_followup_pending", return_value=False) as set_pending, \
+             patch.object(tasks.sync_listing_task, "update_state"):
+            get_persistence.return_value = MagicMock()
+            redis_client = MagicMock()
+            redis_client.get.return_value = None
+            get_redis.return_value = redis_client
+
+            with patch.object(tasks.sync_listing_task, "app", new=MagicMock()) as task_app:
+                tasks.sync_listing_task.push_request(id="task-soft-timeout")
+                try:
+                    result = tasks.sync_listing_task.run(make="Toyota")
+                finally:
+                    tasks.sync_listing_task.pop_request()
+
+        self.assertEqual(result["status"], "timed_out")
+        set_pending.assert_called_once()
+        task_app.send_task.assert_not_called()
+
+    def test_sync_listing_task_stops_immediate_bootstrap_continuation_after_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", return_value=(MagicMock(), MagicMock())), \
+             patch.object(tasks, "_release_lock_if_owner"), \
+             patch.object(tasks, "_try_set_followup_pending", return_value=True), \
+             patch.object(tasks, "_bump_bootstrap_continuation_streak", return_value=(999, False)), \
+             patch.object(tasks, "_set_full_scan_done") as set_full_scan_done, \
+             patch.object(tasks, "_clear_sync_checkpoint") as clear_checkpoint, \
+             patch.object(tasks.sync_listing_task, "update_state"), \
+             patch.object(tasks, "_run_browser_job", return_value={
+                 "run_id": 101,
+                 "status": "partial_success",
+                 "full_scan_completed": False,
+                 "cars_upserted": 2,
+                 "cars_failed": 0,
+                 "images_upserted": 1,
+                 "skipped_existing": 0,
+                 "elapsed_seconds": 1.0,
+                 "failures": [],
+                 "listing": {"vehicles_collected": 2},
+             }):
+            get_persistence.return_value = MagicMock()
+            redis_client = MagicMock()
+            redis_client.get.return_value = None
+            get_redis.return_value = redis_client
+
+            with patch.object(tasks.sync_listing_task, "app", new=MagicMock()) as task_app:
+                tasks.sync_listing_task.push_request(id="task-breaker-stop")
+                try:
+                    result = tasks.sync_listing_task.run()
+                finally:
+                    tasks.sync_listing_task.pop_request()
+
+        self.assertEqual(result["status"], "partial_success")
+        # Сначала bootstrap помечается незавершённым, затем breaker переключает на hourly.
+        self.assertTrue(any(call.args == (redis_client, False) for call in set_full_scan_done.call_args_list))
+        self.assertTrue(any(call.args == (redis_client, True) for call in set_full_scan_done.call_args_list))
+        clear_checkpoint.assert_called_once()
+        task_app.send_task.assert_not_called()
+
+    def test_sync_listing_task_always_full_scan_forces_bootstrap_even_after_done(self) -> None:
+        with patch.object(tasks, "_get_persistence") as get_persistence, \
+             patch.object(tasks, "_get_redis") as get_redis, \
+             patch.object(
+                 tasks,
+                 "Settings",
+                 return_value=replace(
+                     base_settings,
+                     discovery=replace(base_settings.discovery, always_full_scan=True),
+                 ),
+             ), \
+             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, "_set_full_scan_done") as set_full_scan_done, \
+             patch.object(tasks.sync_listing_task, "update_state"), \
+             patch.object(tasks, "_run_browser_job") as run_job, \
+             patch("iaai_scraper.worker.tasks.parse_listing_segments", return_value=[]):
+            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())
+
+            run_job.return_value = {
+                "run_id": 17,
+                "status": "success",
+                "full_scan_completed": True,
+                "cars_upserted": 1,
+                "cars_failed": 0,
+                "images_upserted": 0,
+                "skipped_existing": 0,
+                "elapsed_seconds": 1.0,
+                "failures": [],
+            }
+
+            tasks.sync_listing_task.push_request(id="task-always-full")
+            try:
+                result = tasks.sync_listing_task.run()
+            finally:
+                tasks.sync_listing_task.pop_request()
+
+        self.assertEqual(result["status"], "success")
+        set_full_scan_done.assert_called_with(redis_client, False)
+        release_lock.assert_called_once()
+
+    def test_sync_listing_task_always_full_scan_uses_segmented_resume_path(self) -> None:
+        segments = [{"make": "TOYOTA"}, {"make": "FORD"}, {"make": "HONDA"}]
+        with patch.object(tasks, "_get_persistence") as get_persistence, \
+             patch.object(tasks, "_get_redis") as get_redis, \
+             patch.object(
+                 tasks,
+                 "Settings",
+                 return_value=replace(
+                     base_settings,
+                     discovery=replace(base_settings.discovery, always_full_scan=True),
+                 ),
+             ), \
+             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, "_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": 18,
+                "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.__enter__.return_value.sync_listing = MagicMock()
+            scraper_ctx.__exit__.return_value = None
+
+            with patch.object(tasks, "IAAIScraper", return_value=scraper_ctx):
+                tasks.sync_listing_task.push_request(id="task-always-full-resume")
+                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"], 1)
+        self.assertEqual(sync_segmented_mock.call_args.kwargs["start_page"], 1)
+        release_lock.assert_called_once()
+
 
 if __name__ == "__main__":
     unittest.main()