309 lines
16 KiB
Rust
309 lines
16 KiB
Rust
// file: crates/ksp-app-backfill-desk/tests/config_composition.rs
|
|
// version: 7
|
|
|
|
//! Config composite, Transport readiness and Store-network composition contracts for Backfill Desk through pre.006.
|
|
|
|
#![forbid(unsafe_code)]
|
|
#![deny(unreachable_pub)]
|
|
#![warn(missing_docs)]
|
|
|
|
fn workspace_engine() -> ksp_core_lib::Result<ksp_config_lib::ConfigDocumentEngine> {
|
|
let workspace = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
|
|
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();
|
|
return match registry {
|
|
std::result::Result::Ok(value) => std::result::Result::Ok(ksp_config_lib::ConfigDocumentEngine::new(bootstrap, value)),
|
|
std::result::Result::Err(error) => std::result::Result::Err(error),
|
|
};
|
|
}
|
|
|
|
fn assert_component(composite: &ksp_config_lib::ResolvedConfigComposite, component_id: &str, file_id: &str, profile_id: &str) {
|
|
let component = composite.component(component_id);
|
|
assert!(component.is_some(), "missing component {component_id}");
|
|
if let std::option::Option::Some(component) = component {
|
|
assert_eq!(component.resolved().file_id().as_str(), file_id);
|
|
assert_eq!(component.resolved().profile_id(), profile_id);
|
|
assert_eq!(component.resolved().selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_003_devnet_profile_selects_trace_logging_transport_and_store() {
|
|
let engine = workspace_engine();
|
|
assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
|
|
let engine = match engine {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK);
|
|
assert!(file_id.is_ok(), "Backfill Desk composite file_id should be valid: {file_id:?}");
|
|
let file_id = match file_id {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some("devnet"));
|
|
assert!(composite.is_ok(), "committed Backfill Desk devnet profile should resolve: {composite:?}");
|
|
if let std::result::Result::Ok(composite) = composite {
|
|
assert_eq!(composite.profile_id(), "devnet");
|
|
assert_component(&composite, "logging", ksp_config_lib::FILE_ID_STD_LOGGING, "supertrace");
|
|
assert_component(&composite, "transport", ksp_config_lib::FILE_ID_STD_TRANSPORT, "devnet_public");
|
|
assert_component(&composite, "store", ksp_config_lib::FILE_ID_STD_STORE, "devnet");
|
|
let logging = composite.component("logging");
|
|
assert!(logging.is_some(), "Backfill Desk composite should expose Logging");
|
|
if let std::option::Option::Some(logging) = logging {
|
|
assert_eq!(logging.resolved().profile().get("default_filter").and_then(serde_json::Value::as_str), std::option::Option::Some("trace"));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_003_named_profiles_keep_transport_and_store_network_selection_paired() {
|
|
let engine = workspace_engine();
|
|
assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
|
|
let engine = match engine {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK);
|
|
let file_id = match file_id {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
for (profile_id, logging_profile, transport_profile, store_profile) in
|
|
[("mainnet", "supertrace", "mainnet_backfill_pool", "mainnet"), ("testnet", "console_info", "publicnode_testnet", "testnet")]
|
|
{
|
|
let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some(profile_id));
|
|
assert!(composite.is_ok(), "Backfill Desk composite profile {profile_id} should resolve: {composite:?}");
|
|
if let std::result::Result::Ok(composite) = composite {
|
|
assert_eq!(composite.profile_id(), profile_id);
|
|
assert_component(&composite, "logging", ksp_config_lib::FILE_ID_STD_LOGGING, logging_profile);
|
|
assert_component(&composite, "transport", ksp_config_lib::FILE_ID_STD_TRANSPORT, transport_profile);
|
|
assert_component(&composite, "store", ksp_config_lib::FILE_ID_STD_STORE, store_profile);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_default_composite_builds_http_pool_for_both_backfill_rpc_methods() {
|
|
let engine = workspace_engine();
|
|
assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
|
|
let engine = match engine {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK);
|
|
let file_id = match file_id {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some("devnet"));
|
|
assert!(composite.is_ok(), "committed Backfill Desk devnet profile should resolve: {composite:?}");
|
|
let composite = match composite {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let transport = composite.component("transport");
|
|
assert!(transport.is_some(), "Backfill Desk composite should expose Transport");
|
|
let transport = match transport {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let environment = ksp_config_lib::ConfigEnvironment::load();
|
|
assert!(environment.is_ok(), "Config environment should load for committed public devnet profile");
|
|
let environment = match environment {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let resolved = engine.resolve_transport_config_profile(transport.resolved(), &environment);
|
|
assert!(resolved.is_ok(), "composite-selected Transport should map: {resolved:?}");
|
|
let resolved = match resolved {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(resolved.profile_id(), "devnet_public");
|
|
assert_eq!(resolved.selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite);
|
|
let pool = ksp_onchain_transport_lib::HttpTransportPool::new(resolved.into_settings());
|
|
assert!(pool.is_ok(), "composite-selected Transport settings should construct an HTTP pool");
|
|
let pool = match pool {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let snapshot = pool.snapshot();
|
|
let mut clusters = snapshot
|
|
.endpoints()
|
|
.iter()
|
|
.filter_map(|endpoint| {
|
|
if endpoint.enabled() {
|
|
return std::option::Option::Some(endpoint.cluster().to_owned());
|
|
}
|
|
return std::option::Option::None;
|
|
})
|
|
.collect::<std::vec::Vec<_>>();
|
|
clusters.sort();
|
|
clusters.dedup();
|
|
assert_eq!(clusters, vec!["devnet".to_owned()]);
|
|
let role = ksp_onchain_transport_lib::HttpRoleName::new("default");
|
|
for method in ["getSignaturesForAddress", "getTransaction"] {
|
|
let descriptor = ksp_onchain_transport_lib::find_http_rpc_method(method);
|
|
assert!(descriptor.is_some(), "required Transport method {method} should exist");
|
|
if let std::option::Option::Some(descriptor) = descriptor {
|
|
let selection = pool.select_for_method(&role, descriptor);
|
|
assert!(selection.is_ok(), "role default should route {method}: {selection:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn declared_http_networks(profile: &ksp_config_lib::ResolvedConfigProfile) -> std::vec::Vec<String> {
|
|
let endpoints = profile.profile().get("endpoints").and_then(serde_json::Value::as_array);
|
|
let endpoints = match endpoints {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return std::vec::Vec::new(),
|
|
};
|
|
let mut networks = endpoints
|
|
.iter()
|
|
.filter_map(|endpoint| {
|
|
let enabled = endpoint.get("enabled").and_then(serde_json::Value::as_bool);
|
|
if enabled != std::option::Option::Some(true) {
|
|
return std::option::Option::None;
|
|
}
|
|
return endpoint.get("cluster").and_then(serde_json::Value::as_str).map(str::to_owned);
|
|
})
|
|
.collect::<std::vec::Vec<_>>();
|
|
networks.sort();
|
|
networks.dedup();
|
|
return networks;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_005_all_composite_profiles_keep_declared_http_and_store_networks_identical_without_external_secrets() {
|
|
let engine = workspace_engine();
|
|
assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
|
|
let engine = match engine {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK);
|
|
let file_id = match file_id {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
for profile_id in ["devnet", "mainnet", "testnet"] {
|
|
let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some(profile_id));
|
|
assert!(composite.is_ok(), "Backfill Desk composite profile {profile_id} should resolve: {composite:?}");
|
|
let composite = match composite {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => continue,
|
|
};
|
|
let transport = composite.component("transport");
|
|
let store = composite.component("store");
|
|
assert!(transport.is_some(), "profile {profile_id} should expose Transport");
|
|
assert!(store.is_some(), "profile {profile_id} should expose Store");
|
|
let (transport, store) = match (transport, store) {
|
|
(std::option::Option::Some(transport), std::option::Option::Some(store)) => (transport, store),
|
|
_ => continue,
|
|
};
|
|
let networks = declared_http_networks(transport.resolved());
|
|
assert_eq!(networks.len(), 1, "profile {profile_id} must declare exactly one enabled HTTP network");
|
|
let store_network = store.resolved().profile().get("network").and_then(serde_json::Value::as_str);
|
|
assert!(store_network.is_some(), "profile {profile_id} Store should declare one logical network");
|
|
if let (std::option::Option::Some(transport_network), std::option::Option::Some(store_network)) = (networks.first(), store_network) {
|
|
assert_eq!(transport_network.as_str(), store_network, "profile {profile_id} Store/Transport network mismatch");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_006_default_mainnet_profile_exposes_pool_and_targeted_http_routes_without_secret_provider_data() {
|
|
let engine = workspace_engine();
|
|
assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
|
|
let engine = match engine {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK);
|
|
let file_id = match file_id {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let composite = engine.load_resolved_composite(&file_id, std::option::Option::None);
|
|
assert!(composite.is_ok(), "default Backfill Desk composite should resolve: {composite:?}");
|
|
let composite = match composite {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(composite.profile_id(), "mainnet");
|
|
assert_component(&composite, "logging", ksp_config_lib::FILE_ID_STD_LOGGING, "supertrace");
|
|
assert_component(&composite, "transport", ksp_config_lib::FILE_ID_STD_TRANSPORT, "mainnet_backfill_pool");
|
|
assert_component(&composite, "store", ksp_config_lib::FILE_ID_STD_STORE, "mainnet");
|
|
let transport = match composite.component("transport") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let profile = transport.resolved().profile();
|
|
let endpoints = profile.get("endpoints").and_then(serde_json::Value::as_array);
|
|
assert!(endpoints.is_some(), "mainnet Backfill Transport profile should expose HTTP endpoints");
|
|
let endpoints = match endpoints {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let providers = endpoints
|
|
.iter()
|
|
.filter_map(|endpoint| return endpoint.get("provider").and_then(serde_json::Value::as_str))
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
assert_eq!(providers, std::collections::BTreeSet::from(["publicnode", "solana-public"]));
|
|
let roles = endpoints
|
|
.iter()
|
|
.flat_map(|endpoint| return endpoint.get("roles").and_then(serde_json::Value::as_array).into_iter().flatten())
|
|
.filter_map(|role| return role.get("role").and_then(serde_json::Value::as_str))
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
assert!(roles.contains("backfill_pool"));
|
|
assert!(roles.contains("backfill_publicnode"));
|
|
assert!(roles.contains("backfill_solana_public"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_013_composite_profile_and_component_inventory_is_exact() {
|
|
let workspace = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
|
|
let source = std::fs::read_to_string(workspace.join("config/composite.ksp-app-backfill-desk.json"));
|
|
assert!(source.is_ok(), "Backfill Desk composite should be readable");
|
|
let source = match source {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let document = serde_json::from_str::<serde_json::Value>(source.as_str());
|
|
assert!(document.is_ok(), "Backfill Desk composite should remain valid JSON");
|
|
let document = match document {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(document.get("default_profile").and_then(serde_json::Value::as_str), std::option::Option::Some("mainnet"));
|
|
let profiles = document.get("profiles").and_then(serde_json::Value::as_array);
|
|
assert!(profiles.is_some(), "Backfill Desk composite should expose profiles");
|
|
let profiles = match profiles {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let profile_ids = profiles
|
|
.iter()
|
|
.filter_map(|profile| return profile.get("profile_id").and_then(serde_json::Value::as_str))
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
assert_eq!(profile_ids, std::collections::BTreeSet::from(["devnet", "mainnet", "testnet"]));
|
|
for profile in profiles {
|
|
let documents = profile.get("documents").and_then(serde_json::Value::as_array);
|
|
assert!(documents.is_some(), "every Backfill Desk profile should expose component documents");
|
|
let documents = match documents {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => continue,
|
|
};
|
|
let component_ids = documents
|
|
.iter()
|
|
.filter_map(|document| return document.get("component_id").and_then(serde_json::Value::as_str))
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
assert_eq!(component_ids, std::collections::BTreeSet::from(["logging", "store", "transport"]));
|
|
}
|
|
}
|