217 lines
10 KiB
Rust
217 lines
10 KiB
Rust
// file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/route_inventory.rs
|
|
// version: 5
|
|
|
|
#[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(
|
|
"mainnet",
|
|
false,
|
|
std::option::Option::Some("mainnet"),
|
|
crate::RawIngestRouteUnavailableReason::MissingRequiredSecret,
|
|
);
|
|
assert_eq!(profile.routes.len(), 5);
|
|
assert_eq!(profile.network.as_deref(), std::option::Option::Some("mainnet"));
|
|
for route in profile.routes {
|
|
assert!(!route.selectable);
|
|
assert_eq!(route.reason, std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingRequiredSecret));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_006_fix_003_network_profiles_aggregate_same_network_capabilities_and_omit_undeclared_provider_routes() {
|
|
let management = committed_management();
|
|
assert!(management.is_ok());
|
|
let management = match management {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let environment = ksp_config_lib::ConfigEnvironment::load();
|
|
assert!(environment.is_ok());
|
|
let environment = match environment {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let inventory = crate::build_route_inventory_with_environment(&management, &environment, 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");
|
|
assert_eq!(inventory.profiles.iter().map(|profile| return profile.profile_id.as_str()).collect::<std::vec::Vec<_>>(), vec!["devnet", "mainnet", "testnet"]);
|
|
let devnet = profile(&inventory, "devnet");
|
|
assert!(devnet.is_some());
|
|
if let std::option::Option::Some(devnet) = devnet {
|
|
assert!(devnet.is_default);
|
|
assert_eq!(devnet.network.as_deref(), std::option::Option::Some("devnet"));
|
|
assert_optional_secret_route(devnet, crate::RawIngestRouteId::YellowstoneHydrated);
|
|
assert_route(devnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
|
|
assert_route(devnet, crate::RawIngestRouteId::StandardBlockDirect, true, std::option::Option::None);
|
|
assert_optional_secret_route(devnet, crate::RawIngestRouteId::HeliusTransactionHydrated);
|
|
assert_route(devnet, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
|
|
}
|
|
let mainnet = profile(&inventory, "mainnet");
|
|
assert!(mainnet.is_some());
|
|
if let std::option::Option::Some(mainnet) = mainnet {
|
|
assert_eq!(mainnet.network.as_deref(), std::option::Option::Some("mainnet"));
|
|
assert_optional_secret_route(mainnet, crate::RawIngestRouteId::YellowstoneHydrated);
|
|
assert_route(mainnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
|
|
assert_route(mainnet, crate::RawIngestRouteId::StandardBlockDirect, true, std::option::Option::None);
|
|
assert_optional_secret_route(mainnet, crate::RawIngestRouteId::HeliusTransactionHydrated);
|
|
assert_route(mainnet, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
|
|
}
|
|
let testnet = profile(&inventory, "testnet");
|
|
assert!(testnet.is_some());
|
|
if let std::option::Option::Some(testnet) = testnet {
|
|
assert_eq!(testnet.network.as_deref(), std::option::Option::Some("testnet"));
|
|
assert_optional_secret_route(testnet, crate::RawIngestRouteId::YellowstoneHydrated);
|
|
assert_route(testnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
|
|
assert_route(testnet, crate::RawIngestRouteId::StandardBlockDirect, true, std::option::Option::None);
|
|
assert_route_absent(testnet, crate::RawIngestRouteId::HeliusTransactionHydrated);
|
|
assert_eq!(testnet.routes.len(), 4);
|
|
assert_route(testnet, 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",
|
|
"publicnode_mainnet",
|
|
"helius_mainnet",
|
|
] {
|
|
assert!(!serialized.contains(forbidden), "safe network inventory leaked forbidden source marker {forbidden}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_006_fix_003_base_network_routes_remain_configured_independently_of_optional_sources() {
|
|
let management = committed_management();
|
|
assert!(management.is_ok());
|
|
let management = match management {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let environment = ksp_config_lib::ConfigEnvironment::load();
|
|
assert!(environment.is_ok());
|
|
let environment = match environment {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let inventory = crate::build_route_inventory_with_environment(&management, &environment, 11);
|
|
assert!(inventory.is_ok());
|
|
let inventory = match inventory {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
for profile_id in ["devnet", "mainnet", "testnet"] {
|
|
let selected = profile(&inventory, profile_id);
|
|
assert!(selected.is_some());
|
|
if let std::option::Option::Some(selected) = selected {
|
|
assert_route(selected, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
|
|
assert_route(selected, crate::RawIngestRouteId::StandardBlockDirect, true, std::option::Option::None);
|
|
assert_route(selected, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn committed_management() -> ksp_core_lib::Result<ksp_config_lib::ConfigManagement> {
|
|
let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
|
let crates_root = manifest.parent();
|
|
let crates_root = match crates_root {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => {
|
|
return std::result::Result::Err(ksp_core_lib::Error::new(crate::ERROR_CODE_ROUTE_INVENTORY_INVALID, "test manifest has no crates parent"));
|
|
},
|
|
};
|
|
let workspace = crates_root.parent();
|
|
let workspace = match workspace {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => {
|
|
return std::result::Result::Err(ksp_core_lib::Error::new(crate::ERROR_CODE_ROUTE_INVENTORY_INVALID, "test crates root has no workspace parent"));
|
|
},
|
|
};
|
|
let bootstrap = ksp_config_lib::ConfigBootstrapOptions::from_paths(workspace.join("config"), workspace.join("config/schemas"));
|
|
let bootstrap = match bootstrap {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
let registry = ksp_config_lib::ConfigFileRegistry::defaults();
|
|
let registry = match registry {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
return std::result::Result::Ok(ksp_config_lib::ConfigManagement::new(ksp_config_lib::ConfigDocumentEngine::new(bootstrap, registry)));
|
|
}
|
|
|
|
fn profile<'a>(inventory: &'a crate::RawIngestRouteInventoryDto, profile_id: &str) -> std::option::Option<&'a crate::RawIngestProfileInventoryDto> {
|
|
return inventory.profiles.iter().find(|profile| return profile.profile_id == profile_id);
|
|
}
|
|
|
|
fn assert_optional_secret_route(profile: &crate::RawIngestProfileInventoryDto, route_id: crate::RawIngestRouteId) {
|
|
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 {
|
|
if route.selectable {
|
|
assert_eq!(route.state, crate::RawIngestRouteState::Configured);
|
|
assert_eq!(route.reason, std::option::Option::None);
|
|
} else {
|
|
assert_eq!(route.state, crate::RawIngestRouteState::Unavailable);
|
|
assert_eq!(route.reason, std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingRequiredSecret));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn assert_route_absent(profile: &crate::RawIngestProfileInventoryDto, route_id: crate::RawIngestRouteId) {
|
|
let route = profile.routes.iter().find(|route| return route.route_id == route_id);
|
|
assert!(route.is_none());
|
|
}
|
|
|
|
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 });
|
|
}
|
|
}
|