fix(test): rename dispatch test honestly + add serializer regression tests (#238)

Addresses Codex review findings:

1. Rename dispatch_covers_all_registered_endpoints → registry_metadata_integrity.
   The test never called the generated dispatcher — it validated registry
   metadata only. The doc comment now explains that dispatch-registry
   alignment is guaranteed at build time (shared ParsedEndpoints source),
   not by this test.

2. Add 3 MCP serializer field-parity regression tests:
   - serialize_quote_ticks_includes_condition_and_midpoint_fields
   - serialize_trade_quote_ticks_includes_extended_fields
   - serialize_greeks_ticks_includes_all_22_greeks
   Each asserts specific JSON keys exist, catching future field loss.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: userFRM

crates/thetadatadx/src/endpoint.rs

@@ -480,53 +480,40 @@ mod tests {
         );
     }
 
-    /// Verify every endpoint in the registry is handled by the generated
-    /// dispatch function (returns `InvalidParams` for missing args, NOT
-    /// `UnknownEndpoint`). This catches codegen bugs where a registry
-    /// entry has no corresponding match arm.
-    #[tokio::test]
-    async fn dispatch_covers_all_registered_endpoints() {
+    /// Verify registry metadata integrity: 61 endpoints, no duplicates,
+    /// all categories present, no empty descriptions or rest_paths.
+    ///
+    /// Note: dispatch-registry alignment (every registry name has a
+    /// generated match arm) is guaranteed at build time — both are
+    /// generated from the same `ParsedEndpoints` vec in
+    /// `build_support/endpoints.rs`. A name mismatch is structurally
+    /// impossible without a build failure. This test validates the
+    /// registry's content, not dispatch coverage.
+    #[test]
+    fn registry_metadata_integrity() {
         use crate::registry::ENDPOINTS;
 
-        // We don't have a live client, so we can't call invoke_endpoint
-        // directly. Instead, verify that `invoke_generated_endpoint` with
-        // empty args returns InvalidParams (meaning the name was matched
-        // and arg extraction started) rather than UnknownEndpoint.
-        //
-        // This requires a ThetaDataDx instance — but we only need the
-        // dispatch to reach the arg-extraction phase, which happens before
-        // any gRPC call. Unfortunately the generated function signature
-        // requires &ThetaDataDx, so we test a weaker property: the
-        // endpoint name set in the registry matches what the generated
-        // dispatch accepts. Both are generated from the same TOML source,
-        // so a mismatch indicates a codegen bug.
-        //
-        // The build-time uncovered-RPC check (endpoints.rs) provides the
-        // compile-time guarantee. This test verifies the runtime registry
-        // is consistent.
         let registry_names: std::collections::HashSet<&str> =
             ENDPOINTS.iter().map(|e| e.name).collect();
         assert_eq!(
             registry_names.len(),
             ENDPOINTS.len(),
             "duplicate names in ENDPOINTS"
         );
-        // Verify expected count (catches silent endpoint loss)
         assert_eq!(
             ENDPOINTS.len(),
             61,
             "expected 61 endpoints, got {}",
             ENDPOINTS.len()
         );
-        // Verify all categories are represented
         let categories: std::collections::HashSet<&str> =
             ENDPOINTS.iter().map(|e| e.category).collect();
-        assert!(categories.contains("stock"));
-        assert!(categories.contains("option"));
-        assert!(categories.contains("index"));
-        assert!(categories.contains("calendar"));
-        assert!(categories.contains("rate"));
-        // Verify every endpoint has non-empty description and rest_path
+        for expected in ["stock", "option", "index", "calendar", "rate"] {
+            assert!(
+                categories.contains(expected),
+                "missing category: {expected}"
+            );
+        }
         for ep in ENDPOINTS {
             assert!(
                 !ep.description.is_empty(),
@@ -538,6 +525,8 @@ mod tests {
                 "endpoint {} has empty rest_path",
                 ep.name
             );
+            // Every endpoint must have at least a name and return type
+            assert!(!ep.name.is_empty(), "found endpoint with empty name");
         }
     }
 }

tools/mcp/src/main.rs

@@ -1152,7 +1152,7 @@ mod tests {
     use std::collections::HashSet;
 
     use super::*;
-    use tdbe::types::tick::{EodTick, GreeksTick};
+    use tdbe::types::tick::{EodTick, GreeksTick, QuoteTick, TradeQuoteTick};
 
     fn sample_eod_tick(expiration: i32, strike: f64, right: i32) -> EodTick {
         EodTick {
@@ -1456,4 +1456,124 @@ mod tests {
             "single-contract rows should not emit wildcard-only right metadata"
         );
     }
+
+    // ── Serializer field-parity regression tests ──────────────────────
+    // These catch future field loss by asserting specific keys exist in
+    // the serialized JSON output.
+
+    #[test]
+    fn serialize_quote_ticks_includes_condition_and_midpoint_fields() {
+        let tick = QuoteTick {
+            ms_of_day: 0,
+            bid_size: 100,
+            bid_exchange: 11,
+            bid: 150.0,
+            bid_condition: 1,
+            ask_size: 200,
+            ask_exchange: 12,
+            ask: 151.0,
+            ask_condition: 2,
+            date: 20260410,
+            expiration: 0,
+            strike: 0.0,
+            right: 0,
+            midpoint: 150.5,
+        };
+        let payload = serialize_quote_ticks(&[tick]);
+        let row = payload["ticks"].as_array().unwrap().first().unwrap();
+        for key in [
+            "bid_condition",
+            "ask_condition",
+            "midpoint",
+            "bid_exchange",
+            "ask_exchange",
+        ] {
+            assert!(row.get(key).is_some(), "missing key: {key}");
+        }
+    }
+
+    #[test]
+    fn serialize_trade_quote_ticks_includes_extended_fields() {
+        let tick = TradeQuoteTick {
+            ms_of_day: 0,
+            sequence: 1,
+            ext_condition1: 10,
+            ext_condition2: 20,
+            ext_condition3: 30,
+            ext_condition4: 40,
+            condition: 1,
+            size: 100,
+            exchange: 11,
+            price: 150.0,
+            condition_flags: 0,
+            price_flags: 0,
+            volume_type: 1,
+            records_back: 0,
+            quote_ms_of_day: 34_200_000,
+            bid_size: 100,
+            bid_exchange: 11,
+            bid: 149.0,
+            bid_condition: 1,
+            ask_size: 200,
+            ask_exchange: 12,
+            ask: 151.0,
+            ask_condition: 2,
+            date: 20260410,
+            expiration: 0,
+            strike: 0.0,
+            right: 0,
+        };
+        let payload = serialize_trade_quote_ticks(&[tick]);
+        let row = payload["ticks"].as_array().unwrap().first().unwrap();
+        for key in [
+            "quote_ms_of_day",
+            "bid_exchange",
+            "ask_exchange",
+            "bid_condition",
+            "ask_condition",
+            "ext_condition1",
+            "ext_condition2",
+            "ext_condition3",
+            "ext_condition4",
+            "condition_flags",
+            "price_flags",
+            "volume_type",
+            "records_back",
+        ] {
+            assert!(row.get(key).is_some(), "missing key: {key}");
+        }
+    }
+
+    #[test]
+    fn serialize_greeks_ticks_includes_all_22_greeks() {
+        let tick = sample_greeks_tick(0, 0.0, 0);
+        let payload = serialize_greeks_ticks(&[tick]);
+        let row = payload["ticks"].as_array().unwrap().first().unwrap();
+        for key in [
+            "implied_volatility",
+            "delta",
+            "gamma",
+            "theta",
+            "vega",
+            "rho",
+            "iv_error",
+            "vanna",
+            "charm",
+            "vomma",
+            "veta",
+            "speed",
+            "zomma",
+            "color",
+            "ultima",
+            "d1",
+            "d2",
+            "dual_delta",
+            "dual_gamma",
+            "epsilon",
+            "lambda",
+            "vera",
+        ] {
+            assert!(row.get(key).is_some(), "missing Greek: {key}");
+        }
+    }
 }