Fix health check crash and integration test failures (DNS + CI)

## Summary

- Fix `/v1/meta/status` health check crash: `check_all_rir_status()` did not exist; replaced with `get_rir_server_status()`
- Fix 6 DNS `rir_client` functions accepting plain `str` args when `api.py` and tests pass Pydantic model objects (`DNSResolveInput`, `DNSEnumerateInput`, etc.), causing `AttributeError` on `.strip()`
- Fix integration test attribute mismatches: `result.errors` vs `.error`, `result.a_records` vs `.records`, `result.checked_count` vs `.lists_checked`, `result.consistent` vs `.propagation_complete`

Author: duksh

api.py

@@ -229,8 +229,8 @@ async def meta_cache(request: Request):
 @limiter.limit(_DEFAULT_RATE)
 async def meta_status(request: Request):
     """Pings all 5 RIR RDAP servers and returns their status."""
-    statuses = await rir_client.check_all_rir_status()
-    return [s.model_dump() for s in statuses]
+    statuses = await rir_client.get_rir_server_status()
+    return statuses
 
 
 # ──────────────────────────────────────────────────────────────

rir_client.py

@@ -2060,12 +2060,12 @@ async def _dns_query(name: str, rdtype: str, resolver: Optional[dns.asyncresolve
 
 # ── E1 — Forward & Reverse DNS Resolution ────────────────────
 
-async def dns_resolve(target: str) -> DNSResolveResult:
+async def dns_resolve(inp: "DNSResolveInput") -> DNSResolveResult:
     """
     Resolve A/AAAA records for a domain, or PTR records for an IP address.
     For IP inputs, also correlates with RDAP owner to flag PTR mismatches.
     """
-    target = target.strip()
+    target = inp.target.strip()
     is_ip = False
     errors: list[str] = []
 
@@ -2126,12 +2126,12 @@ async def dns_resolve(target: str) -> DNSResolveResult:
 
 # ── E2 — Full DNS Record Enumeration ─────────────────────────
 
-async def dns_enumerate(domain: str) -> DNSEnumerateResult:
+async def dns_enumerate(inp: "DNSEnumerateInput") -> DNSEnumerateResult:
     """
     Fetch all common DNS record types (A, AAAA, MX, NS, SOA, TXT, CAA,
     DNSKEY, SRV, CNAME) for a domain. Flags SPF and DMARC values from TXT.
     """
-    domain = domain.strip().lower()
+    domain = inp.domain.strip().lower()
     record_types = ["A", "AAAA", "MX", "NS", "SOA", "TXT", "CAA", "DNSKEY", "SRV", "CNAME"]
     records: dict[str, list[DNSRecord]] = {}
     errors: list[str] = []
@@ -2192,7 +2192,7 @@ async def _fetch(rtype: str) -> list[DNSRecord]:
 
 # ── E3 — DNSSEC Chain Validation ─────────────────────────────
 
-async def dns_dnssec(domain: str) -> DNSSECResult:
+async def dns_dnssec(inp: "DNSSECInput") -> DNSSECResult:
     """
     Check DNSSEC deployment for a domain.
     Returns SECURE / INSECURE / BOGUS / INDETERMINATE.
@@ -2202,7 +2202,7 @@ async def dns_dnssec(domain: str) -> DNSSECResult:
     BOGUS:         Records present but RRSIG expiry issues or mismatch.
     INDETERMINATE: Cannot determine status (query failures).
     """
-    domain = domain.strip().lower()
+    domain = inp.domain.strip().lower()
     errors: list[str] = []
     has_dnskey = False
     has_rrsig = False
@@ -2268,12 +2268,12 @@ async def dns_dnssec(domain: str) -> DNSSECResult:
 
 # ── E4 — DNSBL Blocklist Checking ────────────────────────────
 
-async def dns_dnsbl(ip: str) -> DNSBLResult:
+async def dns_dnsbl(inp: "DNSBLInput") -> DNSBLResult:
     """
     Check an IPv4 address against 30 DNS blocklists in parallel.
     Uses pure DNS A-record lookups — no external APIs or keys needed.
     """
-    ip = ip.strip()
+    ip = inp.ip.strip()
     errors: list[str] = []
 
     # Reverse the IP octets for DNSBL queries: 1.2.3.4 → 4.3.2.1
@@ -2324,12 +2324,12 @@ async def _check_one(zone: str, desc: str) -> DNSBLEntry:
 
 # ── E5 — Email Security Record Analysis ──────────────────────
 
-async def dns_email_security(domain: str) -> EmailSecurityResult:
+async def dns_email_security(inp: "EmailSecurityInput") -> EmailSecurityResult:
     """
     Comprehensive email security audit: SPF, DMARC, DKIM, MX.
     All pure DNS — no external APIs or keys needed.
     """
-    domain = domain.strip().lower()
+    domain = inp.domain.strip().lower()
     errors: list[str] = []
     recommendations: list[str] = []
 
@@ -2455,13 +2455,13 @@ async def _probe_dkim(selector: str) -> Optional[str]:
 
 # ── E7 — DNS Propagation Check ───────────────────────────────
 
-async def dns_propagation(domain: str, record_type: str = "A") -> DNSPropagationResult:
+async def dns_propagation(inp: "DNSPropagationInput") -> DNSPropagationResult:
     """
     Query the same domain from 10 geographically distributed public
     resolvers and compare results to detect propagation lag.
     """
-    domain = domain.strip().lower()
-    record_type = record_type.upper()
+    domain = inp.domain.strip().lower()
+    record_type = inp.record_type.upper()
     errors: list[str] = []
     entries: list[PropagationEntry] = []
 

test_integration.py

@@ -563,18 +563,18 @@ async def test_dns_resolve():
     print("  Expect: A records with 1.1.1.x IPs, RDAP holder = APNIC/Cloudflare")
     try:
         from models import DNSResolveInput
-        inp = DNSResolveInput(target="cloudflare.com", record_type="A")
+        inp = DNSResolveInput(target="cloudflare.com")
         result = await rir_client.dns_resolve(inp)
 
-        if result.error:
-            fail("DNS resolve cloudflare.com", result.error); return
+        if result.errors:
+            fail("DNS resolve cloudflare.com", result.errors[0]); return
 
-        ok("Records returned", f"{len(result.records)} A record(s)") if result.records else fail("Records returned", "empty")
-        ips = [r.value for r in result.records]
+        ips = result.a_records
+        ok("Records returned", f"{len(ips)} A record(s)") if ips else fail("Records returned", "empty")
         has_cloudflare_ip = any(ip.startswith("1.1.1.") or ip.startswith("104.") for ip in ips)
         ok("Cloudflare IP returned", f"IPs: {ips[:3]}") if has_cloudflare_ip else ok("A records returned", f"IPs: {ips[:3]}")
-        if result.rdap_correlation:
-            ok("RDAP correlation present", f"holder={result.rdap_correlation.get('holder','?')}")
+        if result.rdap_org:
+            ok("RDAP correlation present", f"org={result.rdap_org}")
         else:
             skip("RDAP correlation", "No correlation (may be normal if RDAP lookup skipped)")
     except Exception:
@@ -611,7 +611,7 @@ async def test_dns_dnssec():
         inp = DNSSECInput(domain="cloudflare.com")
         result = await rir_client.dns_dnssec(inp)
 
-        ok(f"DNSSEC status: {result.status}", f"chain_valid={result.chain_valid}, dnskey_count={result.dnskey_count}")
+        ok(f"DNSSEC status: {result.status}", f"has_dnskey={result.has_dnskey}, has_rrsig={result.has_rrsig}, has_ds={result.has_ds}")
         if result.status == "SECURE":
             ok("DNSSEC chain is SECURE")
         elif result.status == "INSECURE":
@@ -634,7 +634,7 @@ async def test_dns_dnsbl():
         result = await rir_client.dns_dnsbl(inp)
 
         listed = [e for e in result.entries if e.listed]
-        ok(f"Checked {result.lists_checked} blocklists", f"{len(listed)} listed")
+        ok(f"Checked {result.checked_count} blocklists", f"{len(listed)} listed")
         if len(listed) == 0:
             ok("1.1.1.1 is CLEAN across all lists")
         elif len(listed) <= 2:
@@ -654,14 +654,14 @@ async def test_dns_email_security():
         inp = EmailSecurityInput(domain="cloudflare.com")
         result = await rir_client.dns_email_security(inp)
 
-        ok("SPF present", result.spf_record[:80] if result.spf_record else "—") if result.spf_present else fail("SPF present", "Missing SPF record")
-        ok("DMARC present", result.dmarc_record[:80] if result.dmarc_record else "—") if result.dmarc_present else fail("DMARC present", "Missing DMARC record")
+        ok("SPF present", result.spf_record[:80] if result.spf_record else "—") if result.spf_valid else fail("SPF present", "Missing SPF record")
+        ok("DMARC present", f"policy={result.dmarc_policy}") if result.dmarc_present else fail("DMARC present", "Missing DMARC record")
         if result.dmarc_policy in ("reject", "quarantine"):
             ok(f"DMARC policy is strong", f"p={result.dmarc_policy}")
         else:
             skip("DMARC policy strength", f"p={result.dmarc_policy}")
         ok(f"MX records found", f"{len(result.mx_records)} MX record(s)") if result.mx_records else skip("MX records", "No MX (may query subdomains)")
-        ok(f"Risk level assessed", f"{result.risk_level} (score={result.score})")
+        ok(f"Risk level assessed", f"{result.risk_level}")
     except Exception:
         fail("Email security", traceback.format_exc()[-120:])
 
@@ -675,10 +675,10 @@ async def test_dns_propagation():
         inp = DNSPropagationInput(domain="cloudflare.com", record_type="A")
         result = await rir_client.dns_propagation(inp)
 
-        ok(f"Queried {len(result.results)} resolvers", f"majority_answer={result.majority_answer[:2] if result.majority_answer else '?'}")
-        answered = [e for e in result.results if e.answers]
-        ok(f"Resolvers answered", f"{len(answered)}/{len(result.results)} returned records") if answered else fail("Resolvers answered", "None returned records")
-        if result.propagation_complete:
+        ok(f"Queried {len(result.entries)} resolvers", f"majority_answer={result.majority_answer[:2] if result.majority_answer else '?'}")
+        answered = [e for e in result.entries if e.response]
+        ok(f"Resolvers answered", f"{len(answered)}/{len(result.entries)} returned records") if answered else fail("Resolvers answered", "None returned records")
+        if result.consistent:
             ok("Propagation complete (majority agree)")
         else:
             skip("Propagation complete", "Some resolvers diverging — transient or expected")