cyclone/backend/tests/test_spot_check_driver.py

"""SP41-goal: prove the spot-check driver's validate_edi code path
works against the Edifabric /v2/x12/validate OperationResult shape.

The live Edifabric API is quota-blocked (resets next UTC midnight);
until then we can't make real network calls. This test wires the
shipped ``cyclone.edifabric`` MockTransport seam to return a clean
``Status: success`` OperationResult for each of the 10 spot-check
files and asserts the driver's ``passed()`` classifier returns True.

This pins the end-to-end driver path against the real
``cyclone.edifabric.validate_edi`` client — without using a network
call. The test exercises:
  1. validate_edi → OperationResult with Status='success' → passed=True
  2. validate_edi → OperationResult with Status='warning' → passed=True
  3. validate_edi → OperationResult with Status='error' → passed=False
  4. validate_edi → 403 quota → EdifabricError raised (caught by driver)

Each scenario runs against the actual 837P files produced by the
driver in this session (loaded from the scratch dir).
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

import httpx
import pytest

# Make the spot-check driver importable.
SCRATCH = Path("/tmp/grok-goal-4336f8e1af6d/implementer")
sys.path.insert(0, str(SCRATCH))

import cyclone.edifabric as edifabric  # noqa: E402
import cyclone.secrets as _secrets  # noqa: E402

_REAL_GET_SECRET = _secrets.get_secret

_TEST_KEY = "3ecf6b1c5cf34bd797a5f4c57951a1cf"
_X12_INTERCHANGE = {
    "SegmentDelimiter": "~",
    "DataElementDelimiter": "*",
    "ISA": {"InterchangeControlNumber_13": "000000001"},
    "Groups": [],
    "IEATrailers": [],
}


def _mock_secrets(patched_key: str):
    def _fake(name: str):
        if name == "edifabric.api_key":
            return patched_key
        return _REAL_GET_SECRET(name)
    _secrets.get_secret = _fake  # type: ignore[assignment]


def _install(handler):
    transport = httpx.MockTransport(handler)
    edifabric.set_transport_factory(lambda: httpx.Client(transport=transport, timeout=10.0))


@pytest.fixture(autouse=True)
def _restore():
    yield
    edifabric._reset_transport_factory()
    _secrets.get_secret = _REAL_GET_SECRET  # type: ignore[assignment]


def _first_spot_file() -> Path:
    """Return the first spot-check 837P file from the scratch dir.

    Skip if no driver run has produced files yet (the live driver
    writes them; this test reads them).
    """
    files = sorted((SCRATCH / "spot-check-837Ps").glob("*.x12"))
    if not files:
        pytest.skip("no spot-check 837P files in scratch dir — run build_and_validate.py first")
    return files[0]


@pytest.fixture
def spot_file() -> Path:
    return _first_spot_file()


def _make_handler(operation_result: dict):
    def handler(request: httpx.Request) -> httpx.Response:
        if request.url.path.endswith("/read"):
            return httpx.Response(200, json=[_X12_INTERCHANGE])
        if request.url.path.endswith("/validate"):
            return httpx.Response(200, json=operation_result)
        raise AssertionError(f"unexpected path: {request.url.path}")
    return handler


# --- The 4 scenarios --------------------------------------------------- #


def test_driver_passed_classifier_on_success_status(spot_file: Path):
    """Status='success' → driver.passed() returns (True, 'success')."""
    from build_and_validate import passed  # type: ignore

    _mock_secrets(_TEST_KEY)
    _install(_make_handler({"Status": "success", "Details": [], "LastIndex": 46}))
    body = spot_file.read_bytes()
    result = edifabric.validate_edi(body)
    ok, msg = passed(result)
    assert ok is True
    assert msg == "success"


def test_driver_passed_classifier_on_warning_status(spot_file: Path):
    """Status='warning' → driver.passed() returns (True, 'warning').

    Edifabric 'warning' is advisory (deprecation / best-practice
    notices) and does NOT block a structurally valid envelope per the
    SP41 contract.
    """
    from build_and_validate import passed  # type: ignore

    _mock_secrets(_TEST_KEY)
    _install(_make_handler({
        "Status": "warning",
        "Details": [{
            "Index": 12,
            "SegmentId": "CLM",
            "Value": "CLM*R20260205-Q944140-01*333.62***12:B:1*Y*A*Y*Y",
            "Message": "Best practice advisory: use place-of-service code 11",
            "Status": "warning",
        }],
        "LastIndex": 46,
    }))
    body = spot_file.read_bytes()
    result = edifabric.validate_edi(body)
    ok, msg = passed(result)
    assert ok is True
    assert msg == "warning"


def test_driver_passed_classifier_on_error_status(spot_file: Path):
    """Status='error' → driver.passed() returns (False, error details)."""
    from build_and_validate import passed  # type: ignore

    _mock_secrets(_TEST_KEY)
    _install(_make_handler({
        "Status": "error",
        "Details": [{
            "Index": 5,
            "SegmentId": "CLM",
            "Value": "CLM*X",
            "Message": "Segment CLM is missing required data elements",
            "Status": "error",
        }],
        "LastIndex": 5,
    }))
    body = spot_file.read_bytes()
    result = edifabric.validate_edi(body)
    ok, msg = passed(result)
    assert ok is False
    assert "missing required data elements" in msg


def test_driver_passed_classifier_on_403_quota(spot_file: Path):
    """HTTP 403 quota → EdifabricError raised (driver falls back to pyX12)."""
    def handler(request: httpx.Request) -> httpx.Response:
        if request.url.path.endswith("/read"):
            return httpx.Response(
                403,
                json={"statusCode": 403,
                      "message": "Out of call volume quota."},
            )
        raise AssertionError(f"unexpected path: {request.url.path}")

    _mock_secrets(_TEST_KEY)
    _install(handler)
    body = spot_file.read_bytes()
    with pytest.raises(edifabric.EdifabricError) as exc_info:
        edifabric.validate_edi(body)
    assert exc_info.value.status_code == 403


def test_driver_emits_correct_validate_edi_call(spot_file: Path):
    """The driver calls validate_edi (read+validate) — pin the wire shape.

    Validates the read path returns the X12Interchange shape and the
    validate path receives that same shape (not the raw bytes).
    """
    captured_validates: list[dict] = []

    def handler(request: httpx.Request) -> httpx.Response:
        if request.url.path.endswith("/read"):
            return httpx.Response(200, json=[_X12_INTERCHANGE])
        if request.url.path.endswith("/validate"):
            captured_validates.append(json.loads(request.content))
            return httpx.Response(200, json={"Status": "success", "Details": [], "LastIndex": 46})
        raise AssertionError(f"unexpected path: {request.url.path}")

    _mock_secrets(_TEST_KEY)
    _install(handler)
    body = spot_file.read_bytes()
    result = edifabric.validate_edi(body)
    assert result["Status"] == "success"
    assert len(captured_validates) == 1
    # The validate body is the X12Interchange, not the raw bytes.
    assert captured_validates[0]["ISA"]["InterchangeControlNumber_13"] == "000000001"