371 lines
22 KiB
Rust
371 lines
22 KiB
Rust
// file: crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs
|
|
// version: 19
|
|
|
|
//! External public-surface proofs for the RAW transaction ingest Worker foundation.
|
|
|
|
#[test]
|
|
fn pre_003_kind_code_and_settings_are_consumable_from_crate_root() {
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE, "raw_transaction_ingest");
|
|
let kind_result = ksp_worker_api::WorkerKindCode::new(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE);
|
|
assert!(kind_result.is_ok());
|
|
let kind = match kind_result {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(kind.as_str(), "raw_transaction_ingest");
|
|
let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let settings = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::with_defaults(network, worker_id);
|
|
assert_eq!(settings.network().as_str(), "mainnet");
|
|
assert_eq!(settings.worker_id().as_str(), "raw-ingest-mainnet-001");
|
|
assert_eq!(settings.admission_queue_capacity(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY);
|
|
assert_eq!(settings.persistence_concurrency(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY);
|
|
assert_eq!(settings.shutdown_drain_timeout(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_003_invalid_network_and_worker_identity_remain_owned_by_lower_contracts() {
|
|
let network = ksp_store_lib::RawNetworkId::new("");
|
|
let worker_id = ksp_worker_api::WorkerId::new("invalid worker id");
|
|
assert!(network.is_err());
|
|
assert!(worker_id.is_err());
|
|
let network_error = match network {
|
|
std::result::Result::Ok(_) => return,
|
|
std::result::Result::Err(value) => value,
|
|
};
|
|
assert_eq!(network_error.code(), ksp_store_lib::ERROR_CODE_RAW_MODEL_INVALID);
|
|
let worker_error = match worker_id {
|
|
std::result::Result::Ok(_) => return,
|
|
std::result::Result::Err(value) => value,
|
|
};
|
|
assert_eq!(worker_error.code(), ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_003_runtime_bound_errors_are_stable_and_do_not_echo_values() {
|
|
let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let result = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::new(network, worker_id, 0, 8, std::time::Duration::from_secs(5));
|
|
assert!(result.is_err());
|
|
let error = match result {
|
|
std::result::Result::Ok(_) => return,
|
|
std::result::Result::Err(value) => value,
|
|
};
|
|
assert_eq!(error.code(), ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID);
|
|
assert_eq!(error.message(), "invalid RAW transaction ingest Worker settings");
|
|
assert_eq!(error.context().len(), 1);
|
|
assert_eq!(error.context()[0].value(), "admission_queue_capacity");
|
|
assert!(!std::format!("{error:?}").contains("raw-ingest-mainnet-001"));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_start_handle_and_terminal_future_are_consumable_without_public_join_handle() {
|
|
let _start: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings,
|
|
std::sync::Arc<ksp_store_lib::Store>,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestWorker::start;
|
|
let _request_stop: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle) -> bool =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::request_stop;
|
|
let _wait_terminal: for<'a> fn(
|
|
&'a ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestTerminalFuture<'a> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::wait_terminal;
|
|
let root = include_str!("../src/lib.rs");
|
|
assert!(!root.contains("JoinHandle"));
|
|
assert!(!root.contains("JoinSet"));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_007_store_and_content_conflict_error_codes_are_public_and_stable() {
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT.domain(), "worker_raw_transaction_ingest");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT.code(), "content_conflict");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED.domain(), "worker_raw_transaction_ingest");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED.code(), "store_failed");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_008_snapshot_surface_and_common_projection_are_public_and_stable() {
|
|
let _snapshot_source: fn(
|
|
&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::snapshot_source;
|
|
let _worker_snapshot_source: fn(
|
|
&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::worker_snapshot_source;
|
|
let _current: fn(
|
|
&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource::current;
|
|
let _wait: for<'a> fn(
|
|
&'a ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource,
|
|
ksp_worker_api::WorkerSnapshotSequence,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotFuture<'a> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource::wait_for_change;
|
|
fn require_worker_source<T: ksp_worker_api::WorkerSnapshotSource + std::marker::Send + std::marker::Sync>() {}
|
|
require_worker_source::<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource>();
|
|
let _state_type = std::any::type_name::<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState>();
|
|
let _states = [
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Active,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Reconnecting,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Closing,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Closed,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Failed,
|
|
];
|
|
let _source_state = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_state;
|
|
let _reconnect = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_reconnect_total;
|
|
let _replay = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_replay_attempt_total;
|
|
let _gap = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_continuity_gap_total;
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED.domain(), "worker_raw_transaction_ingest");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED.code(), "counter_exhausted");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_009_source_and_drain_timeout_error_codes_are_public_and_stable() {
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT.domain(), "worker_raw_transaction_ingest");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT.code(), "drain_timeout");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED.domain(), "worker_raw_transaction_ingest");
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED.code(), "source_failed");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_002_runtime_resource_types_are_consumable_without_client_escape_hatch() {
|
|
let _source_new: fn(
|
|
ksp_onchain_transport_lib::YellowstoneGrpcChannel,
|
|
ksp_onchain_transport_lib::YellowstoneSubscribeRequest,
|
|
ksp_onchain_transport_lib::HttpTransportPool,
|
|
ksp_onchain_transport_lib::HttpRoleName,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource::new;
|
|
let _resources_new: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::new;
|
|
let _start_with_resources: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings,
|
|
std::sync::Arc<ksp_store_lib::Store>,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestWorker::start_with_runtime_resources;
|
|
let source = include_str!("../src/runtime_resources.rs");
|
|
for forbidden in [
|
|
"pub fn channel(",
|
|
"pub fn http_pool(",
|
|
"pub fn subscribe_request(",
|
|
"pub fn hydration_role(",
|
|
"pub fn enqueue(",
|
|
"pub fn send(",
|
|
"pub fn inner(",
|
|
] {
|
|
assert!(!source.contains(forbidden), "runtime-resource implementation escape hatch present: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_002_multi_source_runtime_resource_surface_is_bounded_and_source_neutral() {
|
|
let _source_count: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources) -> usize =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::source_count;
|
|
let _push_yellowstone: fn(
|
|
&mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource,
|
|
) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_yellowstone_source;
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES, 32);
|
|
let root = include_str!("../src/lib.rs");
|
|
assert!(!root.contains("RawTransactionIngestLiveSource"));
|
|
assert!(!root.contains("source_key"));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_003_standard_logs_runtime_resource_surface_is_typed_and_transport_owned() {
|
|
let _source_new: fn(
|
|
ksp_onchain_transport_lib::WsEndpointSettings,
|
|
ksp_onchain_transport_lib::SolanaLogsSubscribeFilter,
|
|
ksp_onchain_transport_lib::SolanaCommitment,
|
|
ksp_onchain_transport_lib::HttpTransportPool,
|
|
ksp_onchain_transport_lib::HttpRoleName,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource::new;
|
|
let _resources_from_logs: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_standard_logs_source;
|
|
let _push_logs: fn(
|
|
&mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource,
|
|
) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_standard_logs_source;
|
|
let root = include_str!("../src/lib.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
assert!(root.contains("RawTransactionIngestStandardLogsSource"));
|
|
for forbidden in ["pub fn ws_endpoint(", "pub fn filter(", "pub fn http_pool(", "pub fn source_key("] {
|
|
assert!(!resources.contains(forbidden), "standard logs source implementation escape hatch present: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_005_helius_transaction_runtime_resource_surface_is_typed_and_transport_owned() {
|
|
let _source_new: fn(
|
|
ksp_onchain_transport_lib::WsEndpointSettings,
|
|
ksp_onchain_transport_lib::HeliusTransactionSubscribeFilter,
|
|
ksp_onchain_transport_lib::SolanaCommitment,
|
|
ksp_onchain_transport_lib::HttpTransportPool,
|
|
ksp_onchain_transport_lib::HttpRoleName,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource::new;
|
|
let _resources_from_helius: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_helius_transaction_source;
|
|
let _push_helius: fn(
|
|
&mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource,
|
|
) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_helius_transaction_source;
|
|
let root = include_str!("../src/lib.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
assert!(root.contains("RawTransactionIngestHeliusTransactionSource"));
|
|
for forbidden in ["pub fn ws_endpoint(", "pub fn filter(", "pub fn http_pool(", "pub fn source_key("] {
|
|
assert!(!resources.contains(forbidden), "Helius transaction source implementation escape hatch present: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_004_standard_block_runtime_resource_surface_is_typed_and_transport_owned() {
|
|
let _source_new: fn(
|
|
ksp_onchain_transport_lib::WsEndpointSettings,
|
|
ksp_onchain_transport_lib::SolanaBlockSubscribeFilter,
|
|
ksp_onchain_transport_lib::SolanaCommitment,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource::new;
|
|
let _resources_from_block: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_standard_block_source;
|
|
let _push_block: fn(
|
|
&mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource,
|
|
) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_standard_block_source;
|
|
let root = include_str!("../src/lib.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
assert!(root.contains("RawTransactionIngestStandardBlockSource"));
|
|
for forbidden in ["pub fn ws_endpoint(", "pub fn filter(", "pub fn source_key("] {
|
|
assert!(!resources.contains(forbidden), "standard block source implementation escape hatch present: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_006_http_block_polling_runtime_resource_surface_is_bounded_and_transport_owned() {
|
|
let _source_new: fn(
|
|
ksp_onchain_transport_lib::HttpTransportPool,
|
|
ksp_onchain_transport_lib::HttpRoleName,
|
|
ksp_onchain_transport_lib::SolanaCommitment,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource::new;
|
|
let _source_new_with_limits: fn(
|
|
ksp_onchain_transport_lib::HttpTransportPool,
|
|
ksp_onchain_transport_lib::HttpRoleName,
|
|
ksp_onchain_transport_lib::SolanaCommitment,
|
|
std::time::Duration,
|
|
u16,
|
|
) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource::new_with_limits;
|
|
let _resources_from_polling: fn(
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource,
|
|
) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_http_block_polling_source;
|
|
let _push_polling: fn(
|
|
&mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource,
|
|
) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_http_block_polling_source;
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_HTTP_POLL_INTERVAL, std::time::Duration::from_secs(1));
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_HTTP_POLL_MAX_BLOCKS_PER_CYCLE, 128);
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::MIN_RAW_TRANSACTION_INGEST_HTTP_POLL_INTERVAL, std::time::Duration::from_millis(100));
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::MAX_RAW_TRANSACTION_INGEST_HTTP_POLL_INTERVAL, std::time::Duration::from_secs(30));
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::MIN_RAW_TRANSACTION_INGEST_HTTP_POLL_MAX_BLOCKS_PER_CYCLE, 1);
|
|
assert_eq!(ksp_worker_raw_transaction_ingest_lib::MAX_RAW_TRANSACTION_INGEST_HTTP_POLL_MAX_BLOCKS_PER_CYCLE, 1024);
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
for forbidden in ["pub fn http_pool(", "pub fn polling_role(", "pub fn source_key(", "pub fn profile_fingerprint("] {
|
|
assert!(!resources.contains(forbidden), "HTTP polling source implementation escape hatch present: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_007_processing_frontier_snapshot_getters_are_public_and_processing_only() {
|
|
let _hydration_pending: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> usize =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::hydration_pending;
|
|
let _processing_frontier_slot: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> std::option::Option<u64> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::processing_frontier_slot;
|
|
let _oldest_pending_slot: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> std::option::Option<u64> =
|
|
ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::oldest_pending_slot;
|
|
let root = include_str!("../src/lib.rs");
|
|
for forbidden in ["ReplayInfo", "from_slot", "repair", "backfill"] {
|
|
assert!(!root.contains(forbidden), "pre.007 public root overclaims continuity/replay: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_007_source_inventory_and_logical_keys_remain_private() {
|
|
let root = include_str!("../src/lib.rs");
|
|
for forbidden in ["RawTransactionIngestSourceInventory", "RawTransactionIngestSourceInventoryPublisher", "RawTransactionIngestLiveSource", "source_key"] {
|
|
assert!(!root.contains(forbidden), "pre.007 private multi-source implementation leaked through crate root: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_008_convergence_cache_registry_and_source_keys_remain_private() {
|
|
let root = include_str!("../src/lib.rs");
|
|
for forbidden in [
|
|
"pub use self::persistence::RawTransactionIngestPersistenceConvergence",
|
|
"pub use self::persistence::persist_raw_transaction_ingest_converged_acquisition",
|
|
"RawTransactionIngestGlobalHydrationRegistry",
|
|
"RawTransactionIngestHydrationKey",
|
|
"source_key",
|
|
] {
|
|
assert!(!root.contains(forbidden), "pre.008 convergence implementation leaked through public crate root: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_13_pre_009_fairness_budgets_semaphore_and_canonical_state_remain_private() {
|
|
let root = include_str!("../src/lib.rs");
|
|
for private_name in [
|
|
"RawTransactionIngestCanonicalState",
|
|
"RawTransactionIngestGlobalHydrationRegistry",
|
|
"RawTransactionIngestHydrationLeaderGuard",
|
|
"validate_hydration_fairness_capacity",
|
|
"hydration_pending_limit",
|
|
"hydration_in_flight_limit",
|
|
] {
|
|
assert!(!root.contains(&std::format!("pub use self::runtime_resources::{private_name}")));
|
|
assert!(!root.contains(&std::format!("pub use self::persistence::{private_name}")));
|
|
}
|
|
return;
|
|
}
|