v0.3.15-pre.003

crates/ksp-config-lib/unit_tests/composite.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-config-lib/unit_tests/composite.rs
-// version: 4
+// version: 5
 
 const TEST_COMPOSITE_FILENAME: &str = "examples/composite.example.json";
 const TEST_COMPOSITE_FILE_ID: &str = "cfg.composite.test";
@@ -128,6 +128,71 @@ fn duplicate_component_ids_are_rejected_inside_one_composite_profile() {
     cleanup_fixture(&fixture);
 }
 
+#[test]
+fn v0_3_15_pre_003_raw_ingest_composite_keeps_transport_and_store_networks_coherent() {
+    let workspace = workspace_root();
+    let bootstrap = crate::ConfigBootstrapOptions::from_paths(workspace.join("config"), workspace.join("config/schemas"));
+    assert!(bootstrap.is_ok(), "committed Config roots should be valid: {bootstrap:?}");
+    let registry = crate::ConfigFileRegistry::defaults();
+    assert!(registry.is_ok(), "default Config registry should be valid: {registry:?}");
+    let file_id = crate::ConfigFileId::new(crate::FILE_ID_COMPOSITE_KSP_APP_RAW_TRANSACTION_INGEST_DESK);
+    assert!(file_id.is_ok(), "Raw Transaction Ingest Desk composite file_id should be valid: {file_id:?}");
+    let (bootstrap, registry, file_id) = match (bootstrap, registry, file_id) {
+        (std::result::Result::Ok(bootstrap), std::result::Result::Ok(registry), std::result::Result::Ok(file_id)) => (bootstrap, registry, file_id),
+        _ => return,
+    };
+    let engine = crate::ConfigDocumentEngine::new(bootstrap, registry);
+    let mut process = std::collections::BTreeMap::<String, String>::new();
+    process.insert("KSP_SECRET_HELIUS_API_KEY".to_owned(), "helius-composite-canary".to_owned());
+    process.insert("KSP_SECRET_ORBITFLARE_DEVNET_GRPC_X_TOKEN".to_owned(), "orbitflare-composite-canary".to_owned());
+    process.insert("KSP_SECRET_PUBLICNODE_MAINNET_GRPC_X_TOKEN".to_owned(), "publicnode-mainnet-composite-canary".to_owned());
+    process.insert("KSP_SECRET_PUBLICNODE_TESTNET_GRPC_X_TOKEN".to_owned(), "publicnode-testnet-composite-canary".to_owned());
+    let environment = crate::ConfigEnvironment::from_maps(process, std::collections::BTreeMap::new());
+    for (profile_id, expected_network) in [
+        ("devnet_public", "devnet"),
+        ("helius_devnet", "devnet"),
+        ("orbitflare_devnet", "devnet"),
+        ("mainnet_public", "mainnet"),
+        ("helius_mainnet", "mainnet"),
+        ("publicnode_mainnet", "mainnet"),
+        ("publicnode_testnet", "testnet"),
+    ] {
+        let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some(profile_id));
+        assert!(composite.is_ok(), "Raw Ingest composite profile {profile_id} should resolve: {composite:?}");
+        let composite = match composite {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => continue,
+        };
+        assert_eq!(composite.profile_id(), profile_id);
+        let transport_component = composite.component("transport");
+        let store_component = composite.component("store");
+        assert!(transport_component.is_some(), "profile {profile_id} should contain Transport");
+        assert!(store_component.is_some(), "profile {profile_id} should contain Store");
+        let (transport_component, store_component) = match (transport_component, store_component) {
+            (std::option::Option::Some(transport), std::option::Option::Some(store)) => (transport, store),
+            _ => continue,
+        };
+        assert_eq!(transport_component.resolved().profile_id(), profile_id);
+        assert_eq!(store_component.resolved().profile_id(), expected_network);
+        let transport = engine.resolve_transport_config_profile(transport_component.resolved(), &environment);
+        let store = engine.resolve_store_config_profile(store_component.resolved(), &environment);
+        assert!(transport.is_ok(), "Transport profile {profile_id} should map: {transport:?}");
+        assert!(store.is_ok(), "Store profile {expected_network} should map: {store:?}");
+        let (transport, store) = match (transport, store) {
+            (std::result::Result::Ok(transport), std::result::Result::Ok(store)) => (transport, store),
+            _ => continue,
+        };
+        assert_eq!(store.settings().network().as_str(), expected_network);
+        assert!(transport.http_settings().endpoints().iter().all(|endpoint| return endpoint.cluster().as_str() == expected_network));
+        if let std::option::Option::Some(ws) = transport.ws_settings() {
+            assert!(ws.endpoints().iter().all(|endpoint| return endpoint.cluster().as_str() == expected_network));
+        }
+        if let std::option::Option::Some(grpc) = transport.grpc_settings() {
+            assert!(grpc.endpoints().iter().all(|endpoint| return endpoint.cluster().as_str() == expected_network));
+        }
+    }
+}
+
 fn fixture_example_engine() -> ksp_core_lib::Result<crate::ConfigDocumentEngine> {
     let workspace = workspace_root();
     let fixture_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("unit_tests/fixtures");