Nora
286 lines
9.7 KiB
Python
286 lines
9.7 KiB
Python
"""SP39: tests for the `cyclone resubmissions status` CLI."""
|
|
from __future__ import annotations
|
|
|
|
from datetime import datetime, timezone
|
|
|
|
from click.testing import CliRunner
|
|
|
|
from cyclone import db as cycl_db
|
|
from cyclone.cli import resubmissions_status_cmd
|
|
from cyclone.db import Resubmission
|
|
|
|
|
|
def _seed_one(claim_id: str = "claim-1", batch_id: str = "batch-1",
|
|
icn: str = "000000001") -> None:
|
|
cycl_db.init_db()
|
|
with cycl_db.SessionLocal()() as s:
|
|
s.add(Resubmission(
|
|
claim_id=claim_id,
|
|
batch_id=batch_id,
|
|
resubmitted_at=datetime.now(timezone.utc),
|
|
source_corrected_path=f"/tmp/{claim_id}.x12",
|
|
interchange_control_number=icn,
|
|
group_control_number="1",
|
|
))
|
|
s.commit()
|
|
|
|
|
|
def _cleanup(batch_id: str) -> None:
|
|
with cycl_db.SessionLocal()() as s:
|
|
s.query(Resubmission).filter(Resubmission.batch_id == batch_id).delete()
|
|
s.commit()
|
|
|
|
|
|
def test_no_resubmissions_prints_message_and_exits_0():
|
|
cycl_db.init_db()
|
|
runner = CliRunner()
|
|
result = runner.invoke(
|
|
resubmissions_status_cmd,
|
|
["--batch-id", "no-such-batch-zzz"],
|
|
)
|
|
assert result.exit_code == 0, result.output
|
|
assert "no resubmissions recorded" in result.output
|
|
|
|
|
|
def test_one_resubmission_prints_status_row():
|
|
try:
|
|
_seed_one(claim_id="claim-A", batch_id="batch-A")
|
|
runner = CliRunner()
|
|
result = runner.invoke(
|
|
resubmissions_status_cmd,
|
|
["--batch-id", "batch-A"],
|
|
)
|
|
assert result.exit_code == 0, result.output
|
|
assert "claim-A" in result.output
|
|
assert "pending_999" in result.output # no inbound ack yet
|
|
assert "batch-A" in result.output
|
|
finally:
|
|
_cleanup("batch-A")
|
|
|
|
|
|
def test_limit_truncates_output():
|
|
try:
|
|
for i in range(5):
|
|
_seed_one(
|
|
claim_id=f"claim-L{i}", batch_id="batch-L",
|
|
icn=f"00000000{i}",
|
|
)
|
|
runner = CliRunner()
|
|
result = runner.invoke(
|
|
resubmissions_status_cmd,
|
|
["--batch-id", "batch-L", "--limit", "2"],
|
|
)
|
|
assert result.exit_code == 0, result.output
|
|
assert "more" in result.output
|
|
# Only 2 rows printed in the table (plus 1 "(N more)" line).
|
|
body_lines = [
|
|
ln for ln in result.output.splitlines()
|
|
if ln.startswith("claim-L")
|
|
]
|
|
assert len(body_lines) == 2
|
|
finally:
|
|
_cleanup("batch-L")
|
|
|
|
|
|
def test_status_reflects_paid_when_remittance_links():
|
|
"""When a remittance.claim_id links to the resubmitted claim,
|
|
the payment column shows 'paid'."""
|
|
try:
|
|
from cyclone.db import Remittance
|
|
from decimal import Decimal
|
|
_seed_one(claim_id="claim-P", batch_id="batch-P")
|
|
with cycl_db.SessionLocal()() as s:
|
|
s.add(Remittance(
|
|
id="remit-P-1",
|
|
batch_id="batch-P",
|
|
payer_claim_control_number="claim-P",
|
|
claim_id="claim-P",
|
|
status_code="1",
|
|
status_label="Processed as Primary",
|
|
total_charge=Decimal("100.00"),
|
|
total_paid=Decimal("80.00"),
|
|
adjustment_amount=Decimal("0"),
|
|
claim_level_adjustment_amount=Decimal("0"),
|
|
received_at=datetime.now(timezone.utc),
|
|
))
|
|
s.commit()
|
|
runner = CliRunner()
|
|
result = runner.invoke(
|
|
resubmissions_status_cmd,
|
|
["--batch-id", "batch-P"],
|
|
)
|
|
assert result.exit_code == 0, result.output
|
|
assert "claim-P" in result.output
|
|
assert "paid" in result.output
|
|
finally:
|
|
from cyclone.db import Remittance as _R
|
|
with cycl_db.SessionLocal()() as s:
|
|
s.query(_R).filter(_R.id == "remit-P-1").delete()
|
|
s.commit()
|
|
_cleanup("batch-P")
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# SP39: `cyclone resubmit-rejected-claims` instruments Resubmission rows.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _seed_clearhouse_stub_false(tmp_path) -> None:
|
|
"""Seed the clearhouse singleton and flip ``sftp_block.stub=False``
|
|
with a non-routable host so the CLI proceeds past the guard and
|
|
the paramiko stub below intercepts the connection."""
|
|
import json
|
|
from cyclone import db as db_mod
|
|
from cyclone.db import ClearhouseORM
|
|
from cyclone.store import store as cycl_store
|
|
cycl_store.ensure_clearhouse_seeded()
|
|
with db_mod.SessionLocal()() as s:
|
|
ch = s.get(ClearhouseORM, 1)
|
|
assert ch is not None, "ensure_clearhouse_seeded should have created it"
|
|
block = json.loads(json.dumps(ch.sftp_block_json))
|
|
block["stub"] = False
|
|
block["host"] = "stub.invalid"
|
|
ch.sftp_block_json = block
|
|
s.commit()
|
|
|
|
|
|
def test_resubmit_rejected_claims_inserts_resubmission_row(tmp_path, monkeypatch):
|
|
"""SP39: after a successful upload, one Resubmission row per claim
|
|
is inserted with the parent dir's batch_id and the parsed envelope
|
|
control numbers."""
|
|
import sys
|
|
import types
|
|
from cyclone.cli import resubmit_rejected_claims
|
|
from cyclone.parsers.parse_837 import parse as parse_837_text
|
|
from cyclone.parsers.payer import PayerConfig
|
|
from cyclone.store import store as cycl_store
|
|
|
|
_seed_clearhouse_stub_false(tmp_path)
|
|
|
|
# Build a parseable 837P file (CO_TXIX payer, single claim).
|
|
cfg = PayerConfig.co_medicaid()
|
|
sample = tmp_path / "batch-deadbeef-1-claims"
|
|
sample.mkdir()
|
|
file_path = sample / "tp1-837P-test-1of1.x12"
|
|
src_text = open("tests/fixtures/co_medicaid_837p.txt").read()
|
|
file_path.write_text(src_text)
|
|
|
|
parsed = parse_837_text(src_text, cfg)
|
|
assert parsed.claims, "fixture must produce at least one claim"
|
|
first_claim_id = parsed.claims[0].claim_id
|
|
|
|
# Replace paramiko with a fake whose stat() raises (file not on
|
|
# remote yet, so the CLI takes the upload branch).
|
|
fake_paramiko = types.ModuleType("paramiko")
|
|
|
|
class _FakeSFTP:
|
|
def stat(self, path):
|
|
raise IOError("not found")
|
|
def put(self, local, remote):
|
|
return None
|
|
|
|
class _FakeSSH:
|
|
def open_sftp(self):
|
|
return _FakeSFTP()
|
|
def set_missing_host_key_policy(self, policy):
|
|
return None
|
|
def connect(self, *a, **kw):
|
|
return None
|
|
def close(self):
|
|
return None
|
|
|
|
fake_paramiko.SSHClient = lambda: _FakeSSH()
|
|
fake_paramiko.AutoAddPolicy = lambda: None
|
|
monkeypatch.setitem(sys.modules, "paramiko", fake_paramiko)
|
|
|
|
captured: list[dict] = []
|
|
monkeypatch.setattr(
|
|
cycl_store, "record_resubmission",
|
|
lambda **kw: captured.append(kw) or True,
|
|
)
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(resubmit_rejected_claims, [
|
|
"--ingest-dir", str(tmp_path),
|
|
"--limit", "1",
|
|
"--no-validate",
|
|
])
|
|
assert result.exit_code == 0, (
|
|
f"CLI exited {result.exit_code}, output={result.output!r}, "
|
|
f"exception={result.exception!r}"
|
|
)
|
|
assert len(captured) >= 1, (
|
|
f"expected record_resubmission to be called, got {captured!r}"
|
|
)
|
|
call = captured[0]
|
|
assert call["claim_id"] == first_claim_id, call
|
|
assert call["batch_id"] == "deadbeef", call
|
|
assert "deadbeef-1-claims" in call["source_corrected_path"], call
|
|
assert call["interchange_control_number"], call
|
|
assert call["group_control_number"], call
|
|
|
|
|
|
def test_resubmit_idempotency_does_not_create_duplicate_rows(tmp_path, monkeypatch):
|
|
"""A second run against the same file (now on the SFTP) does NOT
|
|
insert a second Resubmission row — only the original upload branch
|
|
writes, matching the audit-log behavior."""
|
|
from cyclone.cli import resubmit_rejected_claims
|
|
from cyclone.store import store as cycl_store
|
|
import sys
|
|
import types
|
|
|
|
_seed_clearhouse_stub_false(tmp_path)
|
|
|
|
# Set up: one corrected file.
|
|
sample = tmp_path / "batch-cafebabe-1-claims"
|
|
sample.mkdir()
|
|
file_path = sample / "tp1-837P-test-1of1.x12"
|
|
src_text = open("tests/fixtures/co_medicaid_837p.txt").read()
|
|
file_path.write_text(src_text)
|
|
on_remote_size = len(src_text.encode())
|
|
|
|
# Build a paramiko fake where stat() returns matching size so the
|
|
# CLI takes the skip branch. The CLI only reads ``st_size`` off the
|
|
# return value, so a simple duck-typed object suffices.
|
|
fake_paramiko = types.ModuleType("paramiko")
|
|
|
|
class _FakeAttr:
|
|
def __init__(self, size: int) -> None:
|
|
self.st_size = size
|
|
|
|
class _FakeSFTPAlready:
|
|
def stat(self, path):
|
|
return _FakeAttr(on_remote_size)
|
|
|
|
def put(self, local, remote):
|
|
raise AssertionError("should not put when file already on remote")
|
|
|
|
class _FakeSSHAlready:
|
|
def open_sftp(self):
|
|
return _FakeSFTPAlready()
|
|
def set_missing_host_key_policy(self, policy):
|
|
return None
|
|
def connect(self, *a, **kw):
|
|
return None
|
|
def close(self):
|
|
return None
|
|
|
|
fake_paramiko.SSHClient = lambda: _FakeSSHAlready()
|
|
fake_paramiko.AutoAddPolicy = lambda: None
|
|
monkeypatch.setitem(sys.modules, "paramiko", fake_paramiko)
|
|
|
|
captured: list[dict] = []
|
|
monkeypatch.setattr(
|
|
cycl_store, "record_resubmission",
|
|
lambda **kw: captured.append(kw) or True,
|
|
)
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(resubmit_rejected_claims, [
|
|
"--ingest-dir", str(tmp_path),
|
|
"--limit", "1",
|
|
"--no-validate",
|
|
])
|
|
# On the skip path, record_resubmission should NOT be called.
|
|
assert captured == [], f"expected no record_resubmission on skip, got {captured!r}"
|
|
assert "skipped" in result.output, result.output
|