v0.3.15-pre.006

crates/ksp-app-raw-transaction-ingest-desk/unit_tests/dto_route.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/dto_route.rs
-// version: 1
+// version: 2
 
 #[test]
 fn pre_005_route_ids_are_exact_and_stably_ordered() {
@@ -25,3 +25,36 @@ fn pre_005_route_states_are_exact_without_runtime_claims() {
         assert_eq!(value, serde_json::json!(["unavailable", "configured", "starting", "running", "stopping", "stopped", "faulted"]));
     }
 }
+
+#[test]
+fn pre_006_unavailable_reason_codes_are_exact_and_safe() {
+    let values = [
+        crate::RawIngestRouteUnavailableReason::ProfileUnresolved,
+        crate::RawIngestRouteUnavailableReason::NetworkMismatch,
+        crate::RawIngestRouteUnavailableReason::MissingHttpGetTransaction,
+        crate::RawIngestRouteUnavailableReason::MissingHttpBlockScan,
+        crate::RawIngestRouteUnavailableReason::MissingWsLogsCapability,
+        crate::RawIngestRouteUnavailableReason::MissingWsBlockCapability,
+        crate::RawIngestRouteUnavailableReason::MissingHeliusTransactionCapability,
+        crate::RawIngestRouteUnavailableReason::MissingYellowstoneGrpc,
+        crate::RawIngestRouteUnavailableReason::MissingRequiredSecret,
+    ];
+    let serialized = serde_json::to_value(values);
+    assert!(serialized.is_ok());
+    if let std::result::Result::Ok(serialized) = serialized {
+        assert_eq!(
+            serialized,
+            serde_json::json!([
+                "profile_unresolved",
+                "network_mismatch",
+                "missing_http_get_transaction",
+                "missing_http_block_scan",
+                "missing_ws_logs_capability",
+                "missing_ws_block_capability",
+                "missing_helius_transaction_capability",
+                "missing_yellowstone_grpc",
+                "missing_required_secret"
+            ])
+        );
+    }
+}

crates/ksp-app-raw-transaction-ingest-desk/unit_tests/route_inventory.rs

@@ -0,0 +1,112 @@
+// file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/route_inventory.rs
+// version: 1
+
+#[test]
+fn pre_006_route_requirement_projection_is_fail_closed_and_ordered() {
+    let route = super::route_with_requirements(
+        crate::RawIngestRouteId::StandardLogsHydrated,
+        "devnet",
+        &[
+            (false, crate::RawIngestRouteUnavailableReason::MissingWsLogsCapability),
+            (false, crate::RawIngestRouteUnavailableReason::MissingHttpGetTransaction),
+        ],
+    );
+    assert!(!route.selectable);
+    assert_eq!(route.state, crate::RawIngestRouteState::Unavailable);
+    assert_eq!(route.reason, std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingWsLogsCapability));
+    assert_eq!(route.network.as_deref(), std::option::Option::Some("devnet"));
+    let configured = super::route_with_requirements(
+        crate::RawIngestRouteId::HttpBlockPolling,
+        "mainnet",
+        &[(true, crate::RawIngestRouteUnavailableReason::MissingHttpBlockScan)],
+    );
+    assert!(configured.selectable);
+    assert_eq!(configured.state, crate::RawIngestRouteState::Configured);
+    assert_eq!(configured.reason, std::option::Option::None);
+}
+
+#[test]
+fn pre_006_unavailable_profile_projects_all_five_routes_without_physical_material() {
+    let profile = super::unavailable_profile(
+        "provider_profile",
+        false,
+        std::option::Option::Some("testnet"),
+        crate::RawIngestRouteUnavailableReason::MissingRequiredSecret,
+    );
+    assert_eq!(profile.routes.len(), 5);
+    assert_eq!(profile.network.as_deref(), std::option::Option::Some("testnet"));
+    for route in profile.routes {
+        assert!(!route.selectable);
+        assert_eq!(route.reason, std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingRequiredSecret));
+    }
+}
+
+#[test]
+fn pre_006_committed_devnet_public_inventory_proves_only_config_composability() {
+    let arguments = std::vec::Vec::<std::ffi::OsString>::new();
+    let management = crate::config_management(arguments.as_slice());
+    assert!(management.is_ok());
+    let management = match management {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let inventory = crate::build_route_inventory(&management, 7);
+    assert!(inventory.is_ok());
+    let inventory = match inventory {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(inventory.generation, 7);
+    assert_eq!(inventory.default_profile, "devnet_public");
+    let profile = inventory.profiles.iter().find(|profile| return profile.profile_id == "devnet_public");
+    assert!(profile.is_some());
+    let profile = match profile {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(profile.is_default);
+    assert_eq!(profile.network.as_deref(), std::option::Option::Some("devnet"));
+    assert_eq!(profile.routes.len(), 5);
+    assert_route(
+        profile,
+        crate::RawIngestRouteId::YellowstoneHydrated,
+        false,
+        std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingYellowstoneGrpc),
+    );
+    assert_route(profile, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
+    assert_route(
+        profile,
+        crate::RawIngestRouteId::StandardBlockDirect,
+        false,
+        std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingWsBlockCapability),
+    );
+    assert_route(
+        profile,
+        crate::RawIngestRouteId::HeliusTransactionHydrated,
+        false,
+        std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingHeliusTransactionCapability),
+    );
+    assert_route(profile, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
+    let serialized = serde_json::to_string(&inventory);
+    assert!(serialized.is_ok());
+    if let std::result::Result::Ok(serialized) = serialized {
+        for forbidden in ["http://", "https://", "ws://", "wss://", "api-key", "x-token", "connection_uri", "source_key", "endpoint_name"] {
+            assert!(!serialized.contains(forbidden), "safe inventory leaked forbidden marker {forbidden}");
+        }
+    }
+}
+
+fn assert_route(
+    profile: &crate::RawIngestProfileInventoryDto,
+    route_id: crate::RawIngestRouteId,
+    selectable: bool,
+    reason: std::option::Option<crate::RawIngestRouteUnavailableReason>,
+) {
+    let route = profile.routes.iter().find(|route| return route.route_id == route_id);
+    assert!(route.is_some());
+    if let std::option::Option::Some(route) = route {
+        assert_eq!(route.selectable, selectable);
+        assert_eq!(route.reason, reason);
+        assert_eq!(route.state, if selectable { crate::RawIngestRouteState::Configured } else { crate::RawIngestRouteState::Unavailable });
+    }
+}