Fix all failing tests: async batch polling, CLI ocr_backend removal, JPEG/TIFF only

- verify_label.py: remove ocr_backend param from LabelValidator() calls and CLI
  arg parser; Ollama is the only backend so the param is vestigial
- verify_label.py: drop PNG from batch image scanner (JPEG/TIFF only)
- test_fastapi_endpoints.py: rewrite batch tests to use async POST→poll flow;
  add _poll_batch_job helper; mock LabelValidator via @patch('api.LabelValidator')
- test_cli.py: remove --ocr-backend flag from subprocess call; assert on JSON
  structure rather than exit code (Ollama unavailable in test env = ERROR status)
- Dockerfile: copy samples/ into test stage so sample-based tests don't skip

All 99 tests pass (11 skipped, 0 failed).

Author: Project Team

Dockerfile

@@ -19,6 +19,7 @@ RUN pip install --user --no-cache-dir -r requirements.txt -r requirements-dev.tx
 FROM builder AS test
 
 COPY app/ /app
+COPY samples/ /app/samples
 WORKDIR /app
 
 ENV PATH=/root/.local/bin:$PATH

app/tests/test_api/test_fastapi_endpoints.py

@@ -119,8 +119,37 @@ def large_image_bytes():
 # Single Verify Endpoint Tests
 # ============================================================================
 
-def test_verify_success_no_ground_truth(authenticated_client, sample_image_bytes):
+MOCK_COMPLIANT_RESULT = {
+    "status": "COMPLIANT",
+    "validation_level": "STRUCTURAL_ONLY",
+    "extracted_fields": {
+        "brand_name": "Ridge & Co.",
+        "abv_numeric": 7.5,
+        "government_warning": {"present": True},
+    },
+    "validation_results": {"structural": [], "accuracy": []},
+    "violations": [],
+    "warnings": [],
+    "processing_time_seconds": 0.1,
+}
+
+MOCK_FULL_VALIDATION_RESULT = {
+    **MOCK_COMPLIANT_RESULT,
+    "validation_level": "FULL_VALIDATION",
+    "validation_results": {
+        "structural": [],
+        "accuracy": [{"field": "brand_name", "valid": True}],
+    },
+}
+
+
+@patch('api.LabelValidator')
+def test_verify_success_no_ground_truth(mock_validator_class, authenticated_client, sample_image_bytes):
     """Test single label verification without ground truth (structural only)."""
+    mock_validator = Mock()
+    mock_validator.validate_label.return_value = MOCK_COMPLIANT_RESULT
+    mock_validator_class.return_value = mock_validator
+
     response = authenticated_client.post(
         "/verify",
         files={"image": ("label.jpg", sample_image_bytes, "image/jpeg")}
@@ -129,33 +158,31 @@ def test_verify_success_no_ground_truth(authenticated_client, sample_image_bytes
     assert response.status_code == 200
     data = response.json()
 
-    # Check response structure
     assert "status" in data
     assert data["status"] in ["COMPLIANT", "NON_COMPLIANT", "PARTIAL_VALIDATION"]
     assert "validation_level" in data
     assert "extracted_fields" in data
     assert "validation_results" in data
     assert "violations" in data
     assert "processing_time_seconds" in data
-    
-    # Should be structural only without ground truth
     assert data["validation_level"] == "STRUCTURAL_ONLY"
 
 
-def test_verify_success_with_ground_truth(authenticated_client, sample_image_bytes, sample_ground_truth_json):
+@patch('api.LabelValidator')
+def test_verify_success_with_ground_truth(mock_validator_class, authenticated_client, sample_image_bytes, sample_ground_truth_json):
     """Test single label verification with ground truth (full validation)."""
+    mock_validator = Mock()
+    mock_validator.validate_label.return_value = MOCK_FULL_VALIDATION_RESULT
+    mock_validator_class.return_value = mock_validator
+
     response = authenticated_client.post(
         "/verify",
         files={"image": ("label.jpg", sample_image_bytes, "image/jpeg")},
-        data={
-            "ground_truth": sample_ground_truth_json
-        }
+        data={"ground_truth": sample_ground_truth_json}
     )
 
     assert response.status_code == 200
     data = response.json()
-    
-    # Should perform full validation with ground truth
     assert data["validation_level"] == "FULL_VALIDATION"
     assert "accuracy" in data["validation_results"]
 
@@ -266,51 +293,73 @@ def test_verify_ocr_failure(mock_validator_class, authenticated_client, sample_i
 # Batch Verify Endpoint Tests
 # ============================================================================
 
-def test_batch_success(authenticated_client, sample_batch_zip):
+def _poll_batch_job(client, job_id: str, max_polls: int = 10):
+    """Poll GET /verify/batch/{job_id} until the job reaches a terminal state."""
+    for _ in range(max_polls):
+        r = client.get(f"/verify/batch/{job_id}")
+        assert r.status_code == 200, f"Status poll failed: {r.text}"
+        data = r.json()
+        if data["status"] in ("completed", "failed", "cancelled"):
+            return data
+    pytest.fail(f"Batch job {job_id} did not reach terminal state after {max_polls} polls")
+
+
+@patch('api.LabelValidator')
+def test_batch_success(mock_validator_class, authenticated_client, sample_batch_zip):
     """Test batch verification with valid ZIP file."""
+    mock_validator = Mock()
+    mock_validator.validate_label.return_value = MOCK_COMPLIANT_RESULT
+    mock_validator_class.return_value = mock_validator
+
     response = authenticated_client.post(
         "/verify/batch",
         files={"batch_file": ("batch.zip", sample_batch_zip, "application/zip")}
     )
-    
+
     assert response.status_code == 200
-    data = response.json()
-    
-    # Check response structure
+    submit = response.json()
+    assert "job_id" in submit
+    assert submit["total_images"] == 3
+
+    data = _poll_batch_job(authenticated_client, submit["job_id"])
+
     assert "results" in data
     assert "summary" in data
-    
-    # Check summary
+
     summary = data["summary"]
     assert "total" in summary
     assert "compliant" in summary
     assert "non_compliant" in summary
     assert "errors" in summary
     assert "total_processing_time_seconds" in summary
-    
-    # Should have processed 3 images
+
     assert summary["total"] == 3
     assert len(data["results"]) == 3
-    
-    # Each result should have required fields
+
     for result in data["results"]:
         assert "status" in result
         assert "validation_level" in result
         assert "image_path" in result
 
 
-def test_batch_with_ground_truth(authenticated_client, sample_batch_zip):
+@patch('api.LabelValidator')
+def test_batch_with_ground_truth(mock_validator_class, authenticated_client, sample_batch_zip):
     """Test batch verification with ground truth JSON files in ZIP."""
-    # The sample_batch_zip fixture includes JSON files
+    mock_validator = Mock()
+    mock_validator.validate_label.return_value = MOCK_FULL_VALIDATION_RESULT
+    mock_validator_class.return_value = mock_validator
+
     response = authenticated_client.post(
         "/verify/batch",
         files={"batch_file": ("batch.zip", sample_batch_zip, "application/zip")}
     )
-    
+
     assert response.status_code == 200
-    data = response.json()
-    
-    # At least some results should have full validation
+    submit = response.json()
+    assert "job_id" in submit
+
+    data = _poll_batch_job(authenticated_client, submit["job_id"])
+
     full_validations = [
         r for r in data["results"]
         if r.get("validation_level") == "FULL_VALIDATION"
@@ -499,18 +548,24 @@ def test_verify_png_rejected(authenticated_client, sample_image_bytes):
     assert "Invalid file type" in data["detail"]
 
 
-def test_batch_with_custom_timeout(authenticated_client, sample_batch_zip):
+@patch('api.LabelValidator')
+def test_batch_with_custom_timeout(mock_validator_class, authenticated_client, sample_batch_zip):
     """Test batch verification with custom timeout."""
+    mock_validator = Mock()
+    mock_validator.validate_label.return_value = MOCK_COMPLIANT_RESULT
+    mock_validator_class.return_value = mock_validator
+
     response = authenticated_client.post(
         "/verify/batch",
         files={"batch_file": ("batch.zip", sample_batch_zip, "application/zip")},
-        data={
-            "timeout": 30
-        }
+        data={"timeout": 30}
     )
-    
+
     assert response.status_code == 200
-    data = response.json()
+    submit = response.json()
+    assert "job_id" in submit
+
+    data = _poll_batch_job(authenticated_client, submit["job_id"])
     assert data["summary"]["total"] == 3
 
 
@@ -520,7 +575,7 @@ def test_batch_partial_failure(mock_validator_class, authenticated_client, sampl
     # Mock validator to fail on second image
     mock_validator = Mock()
     call_count = [0]
-    
+
     def side_effect(*args, **kwargs):
         call_count[0] += 1
         if call_count[0] == 2:
@@ -534,22 +589,25 @@ def side_effect(*args, **kwargs):
             "warnings": [],
             "processing_time_seconds": 1.0
         }
-    
+
     mock_validator.validate_label.side_effect = side_effect
     mock_validator_class.return_value = mock_validator
-    
+
     response = authenticated_client.post(
         "/verify/batch",
         files={"batch_file": ("batch.zip", sample_batch_zip, "application/zip")}
     )
-    
+
     assert response.status_code == 200
-    data = response.json()
-    
+    submit = response.json()
+    assert "job_id" in submit
+
+    data = _poll_batch_job(authenticated_client, submit["job_id"])
+
     # Should have 3 results (2 success + 1 error)
     assert data["summary"]["total"] == 3
     assert data["summary"]["errors"] == 1
-    
+
     # Check that error result has error field
     error_results = [r for r in data["results"] if r.get("status") == "ERROR"]
     assert len(error_results) == 1

app/tests/test_integration/test_cli.py

@@ -25,23 +25,33 @@ def test_cli_missing_file():
     assert result.returncode != 0
 
 
-@pytest.mark.slow
 def test_cli_with_sample(good_label_path):
-    """Test CLI with actual sample image."""
+    """Test CLI produces valid JSON output for a real sample image.
+
+    Ollama is not available in the test environment, so the result may have
+    status='ERROR' and exit code 1, but the CLI must always emit well-formed
+    JSON containing the required top-level fields.
+    """
     if not good_label_path.exists():
         pytest.skip("Golden sample not available")
-    
+
     result = subprocess.run(
         ["python3", "verify_label.py", str(good_label_path)],
         capture_output=True,
         text=True,
-        timeout=10
+        timeout=15,
+    )
+
+    # CLI must produce output regardless of Ollama availability
+    assert result.stdout.strip(), (
+        f"CLI produced no stdout:\nstderr: {result.stderr}"
     )
-    
-    # Should produce valid JSON
+
     try:
         data = json.loads(result.stdout)
-        assert 'status' in data
-        assert 'extracted_fields' in data
     except json.JSONDecodeError:
-        pytest.fail("CLI did not output valid JSON")
+        pytest.fail(f"CLI did not output valid JSON:\n{result.stdout}")
+
+    assert "status" in data, "Result missing 'status' field"
+    assert "extracted_fields" in data, "Result missing 'extracted_fields' field"
+    assert "validation_results" in data, "Result missing 'validation_results' field"

app/verify_label.py

@@ -91,7 +91,6 @@ def load_ground_truth(ground_truth_path: Optional[str]) -> Optional[Dict[str, An
 
 def validate_single_label(image_path: str,
                          ground_truth_path: Optional[str],
-                         ocr_backend: str,
                          verbose: bool = False) -> Dict[str, Any]:
     """Validate a single label image."""
     # Check if image exists
@@ -114,9 +113,9 @@ def validate_single_label(image_path: str,
 
     # Initialize validator
     if verbose:
-        print(f"Initializing {ocr_backend} OCR backend...", file=sys.stderr)
+        print(f"Initializing Ollama OCR backend...", file=sys.stderr)
 
-    validator = LabelValidator(ocr_backend=ocr_backend)
+    validator = LabelValidator()
 
     # Validate
     if verbose:
@@ -132,13 +131,12 @@ def validate_single_label(image_path: str,
 
 def validate_batch(directory: str,
                   ground_truth_dir: Optional[str],
-                  ocr_backend: str,
                   verbose: bool = False) -> List[Dict[str, Any]]:
     """Validate all images in a directory."""
     results = []
 
-    # Find all image files
-    image_extensions = {'.jpg', '.jpeg', '.png', '.tif', '.tiff'}
+    # Find all image files (JPEG and TIFF only)
+    image_extensions = {'.jpg', '.jpeg', '.tif', '.tiff'}
     image_files = []
 
     dir_path = Path(directory)
@@ -170,7 +168,6 @@ def validate_batch(directory: str,
         result = validate_single_label(
             str(image_path),
             ground_truth_path,
-            ocr_backend,
             verbose=False  # Don't duplicate verbose output
         )
 
@@ -241,11 +238,6 @@ def main():
     parser.add_argument('--ground-truth-dir', metavar='DIR',
                        help='Directory containing ground truth JSON files for batch processing')
 
-    # OCR options
-    parser.add_argument('--ocr-backend', choices=['tesseract', 'ollama'],
-                       default='tesseract',
-                       help='OCR backend: tesseract (fast, ~1s) or ollama (accurate, ~60s). Default: tesseract')
-    
     # Output options
     parser.add_argument('--verbose', '-v', action='store_true',
                        help='Print verbose progress information to stderr')
@@ -263,7 +255,6 @@ def main():
         results = validate_batch(
             args.batch,
             args.ground_truth_dir,
-            args.ocr_backend,
             args.verbose
         )
 
@@ -278,7 +269,6 @@ def main():
         result = validate_single_label(
             args.image_path,
             args.ground_truth,
-            args.ocr_backend,
             args.verbose
         )