Address test coverage gaps

Author: dbernstein

tests/manager/celery/tasks/test_lexile.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from unittest.mock import patch
+
+import pytest
 from pytest import LogCaptureFixture
 
 from palace.manager.celery.tasks import lexile
@@ -57,6 +60,41 @@ def test_run_lexile_db_update_queues_worker_when_configured(
         lexile.run_lexile_db_update.delay().wait()
         assert "Lexile DB update task queued" in caplog.text
 
+    def test_run_lexile_db_update_skipped_when_lock_already_held(
+        self,
+        db: DatabaseTransactionFixture,
+        celery_fixture: CeleryFixture,
+        redis_fixture: RedisFixture,
+        caplog: LogCaptureFixture,
+    ) -> None:
+        """Orchestrator skips when lock is already held (worker in progress)."""
+        db.integration_configuration(
+            protocol=LexileDBService,
+            goal=Goals.METADATA_GOAL,
+            settings=LexileDBSettings(
+                username="user",
+                password="pass",
+                base_url="https://api.example.com",
+            ),
+        )
+        caplog.set_level(LogLevel.info)
+        with patch.object(lexile.RedisLock, "locked", return_value=True):
+            lexile.run_lexile_db_update.delay().wait()
+        assert "Lexile DB update already in progress, skipping." in caplog.text
+        assert "Lexile DB update task queued" not in caplog.text
+
+    def test_lexile_db_update_task_skipped_when_not_configured(
+        self,
+        db: DatabaseTransactionFixture,
+        celery_fixture: CeleryFixture,
+        redis_fixture: RedisFixture,
+        caplog: LogCaptureFixture,
+    ) -> None:
+        """Worker skips when no Lexile DB integration exists."""
+        caplog.set_level(LogLevel.info)
+        lexile.lexile_db_update_task.delay(force=False).wait()
+        assert "Lexile DB update skipped" in caplog.text
+
     def test_lexile_db_update_task_adds_classification(
         self,
         db: DatabaseTransactionFixture,
@@ -179,3 +217,57 @@ def test_lexile_db_update_task_creates_timestamp(
         assert stamp is not None
         assert stamp.finish is not None
         assert "Processed" in (stamp.achievements or "")
+
+    def test_lexile_db_update_task_continues_to_next_batch(
+        self,
+        db: DatabaseTransactionFixture,
+        celery_fixture: CeleryFixture,
+        redis_fixture: RedisFixture,
+        http_client: MockHttpClientFixture,
+    ) -> None:
+        """Worker calls task.replace() with correct args when full batch returned."""
+        db.integration_configuration(
+            protocol=LexileDBService,
+            goal=Goals.METADATA_GOAL,
+            settings=LexileDBSettings(
+                username="user",
+                password="pass",
+                base_url="https://api.example.com",
+            ),
+        )
+        # Create exactly BATCH_SIZE (10) ISBNs so the task replaces to continue.
+        for i in range(lexile.BATCH_SIZE):
+            db.identifier(
+                identifier_type=Identifier.ISBN,
+                foreign_id=f"9780123456{i:03d}",
+            )
+
+        for i in range(lexile.BATCH_SIZE):
+            http_client.queue_response(
+                200,
+                content={
+                    "meta": {"total_count": 1},
+                    "objects": [{"lexile": 600 + i}],
+                },
+            )
+
+        replace_calls: list[tuple] = []
+
+        def capture_replace(*args: object, **kwargs: object) -> None:
+            replace_calls.append((args, kwargs))
+            raise RuntimeError("Replace captured (avoid actual replacement)")
+
+        with patch.object(
+            lexile.lexile_db_update_task, "replace", side_effect=capture_replace
+        ):
+            with pytest.raises(RuntimeError, match="Replace captured"):
+                lexile.lexile_db_update_task.delay(force=False).wait()
+
+        assert len(replace_calls) == 1
+        (args, kwargs) = replace_calls[0]
+        assert len(args) == 1
+        sig = args[0]
+        assert sig.kwargs.get("force") is False
+        assert sig.kwargs.get("offset") == lexile.BATCH_SIZE
+        assert "timestamp_id" in sig.kwargs
+        assert sig.kwargs["timestamp_id"] is not None