feat(deep-scan): IR-parity port — refreshed status + counter, re-queue completed paths in deep mode, honest UX — Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/test_scan_deep_requeue.py

@@ -0,0 +1,109 @@
+"""Deep scan re-queues already-completed ImportTasks.
+
+Operator-flagged 2026-05-25: deep scan used to skip everything that
+already had a non-failed ImportTask row, making a deep re-scan a no-op
+when no new files were added. That defeated the entire point of deep
+scan (re-apply sidecar metadata to existing rows). The skip-set now
+splits by mode — quick keeps the old "any non-failed" semantics; deep
+skips ONLY actively-in-flight statuses.
+"""
+
+import pytest
+from PIL import Image
+from sqlalchemy import func, select
+
+from backend.app.models import ImportBatch, ImportSettings, ImportTask
+from backend.app.tasks.scan import scan_directory
+
+pytestmark = pytest.mark.integration
+
+
+def _img(path):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    Image.new("RGB", (40, 40), (10, 200, 80)).save(path, "JPEG")
+
+
+def test_deep_scan_requeues_completed_task(db_sync, tmp_path, monkeypatch):
+    """Quick scan then deep scan of the same /import: the file completed
+    in the first run should be re-enqueued by the deep run (different
+    ImportTask id, same source_path)."""
+    import_root = tmp_path / "import"
+    settings = db_sync.execute(
+        select(ImportSettings).where(ImportSettings.id == 1)
+    ).scalar_one()
+    settings.import_scan_path = str(import_root)
+    db_sync.commit()
+
+    src = import_root / "Mae" / "p.jpg"
+    _img(src)
+
+    from backend.app import celery_app
+
+    celery_app.celery.conf.task_always_eager = False  # explicit
+    try:
+        first_batch_id = scan_directory.run(triggered_by="manual", mode="quick")
+        first_task = db_sync.execute(
+            select(ImportTask).where(ImportTask.batch_id == first_batch_id)
+        ).scalar_one()
+        # Simulate the worker having finished it.
+        first_task.status = "complete"
+        db_sync.commit()
+
+        # Now deep scan: the SAME file should get a NEW ImportTask row.
+        second_batch_id = scan_directory.run(triggered_by="manual", mode="deep")
+        assert second_batch_id != first_batch_id
+
+        new_tasks_in_second_batch = db_sync.execute(
+            select(func.count())
+            .select_from(ImportTask)
+            .where(ImportTask.batch_id == second_batch_id)
+        ).scalar_one()
+        assert new_tasks_in_second_batch == 1, (
+            "deep scan did not re-queue the completed file"
+        )
+
+        # And the second batch's task should be for the same source_path
+        # as the first (proves it's a re-queue, not a different file).
+        sp = db_sync.execute(
+            select(ImportTask.source_path)
+            .where(ImportTask.batch_id == second_batch_id)
+        ).scalar_one()
+        assert sp == str(src)
+    finally:
+        celery_app.celery.conf.task_always_eager = False
+
+
+def test_quick_scan_does_not_requeue_completed_task(db_sync, tmp_path):
+    """The flip side: quick scan still keeps the old skip semantics —
+    a file with a completed ImportTask row from a prior batch is NOT
+    re-enqueued on a fresh quick scan."""
+    import_root = tmp_path / "import"
+    settings = db_sync.execute(
+        select(ImportSettings).where(ImportSettings.id == 1)
+    ).scalar_one()
+    settings.import_scan_path = str(import_root)
+    db_sync.commit()
+
+    src = import_root / "Mae" / "q.jpg"
+    _img(src)
+
+    first_batch_id = scan_directory.run(triggered_by="manual", mode="quick")
+    first_task = db_sync.execute(
+        select(ImportTask).where(ImportTask.batch_id == first_batch_id)
+    ).scalar_one()
+    first_task.status = "complete"
+    db_sync.commit()
+
+    second_batch_id = scan_directory.run(triggered_by="manual", mode="quick")
+    second_batch_count = db_sync.execute(
+        select(func.count())
+        .select_from(ImportTask)
+        .where(ImportTask.batch_id == second_batch_id)
+    ).scalar_one()
+    assert second_batch_count == 0, (
+        "quick scan re-queued an already-completed task — should have skipped"
+    )
+
+    # And the second batch should self-finalize (files_seen=0).
+    second_batch = db_sync.get(ImportBatch, second_batch_id)
+    assert second_batch.status == "complete"