211 lines
11 KiB
Rust
211 lines
11 KiB
Rust
// file: crates/ksp-store-api/tests/public_api.rs
|
|
// version: 9
|
|
|
|
//! Integration canaries for the public `ksp-store-api` surface.
|
|
|
|
fn consume_result(value: ksp_store_api::Result<ksp_store_api::Pubkey>) -> ksp_store_api::Result<ksp_store_api::Pubkey> {
|
|
return value;
|
|
}
|
|
|
|
fn code(value: &str) -> std::option::Option<ksp_store_api::RawProvenanceCode> {
|
|
return match ksp_store_api::RawProvenanceCode::new(value.to_owned()) {
|
|
std::result::Result::Ok(value) => std::option::Option::Some(value),
|
|
std::result::Result::Err(_) => std::option::Option::None,
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_002_core_facade_remains_available_from_crate_root() {
|
|
let pubkey = ksp_store_api::Pubkey::new_from_array([0x31_u8; 32]);
|
|
let forwarded = consume_result(std::result::Result::Ok(pubkey));
|
|
assert!(forwarded.is_ok());
|
|
let error_code_type: std::option::Option<ksp_store_api::ErrorCode> = std::option::Option::None;
|
|
let error_context_type: std::option::Option<ksp_store_api::ErrorContext> = std::option::Option::None;
|
|
let error_type: std::option::Option<ksp_store_api::Error> = std::option::Option::None;
|
|
assert!(error_code_type.is_none());
|
|
assert!(error_context_type.is_none());
|
|
assert!(error_type.is_none());
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_root() {
|
|
let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let reference = ksp_store_api::RawTransactionReference::new(network, ksp_store_api::RawTransactionSignature::new([1_u8; 64]));
|
|
let format = match ksp_store_api::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let payload = match ksp_store_api::RawPayload::try_new(format, 1, vec![1_u8, 2_u8, 3_u8].into_boxed_slice(), ksp_store_api::RawContentHash::new([2_u8; 32]))
|
|
{
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let transaction = ksp_store_api::RawTransaction::new(reference.clone(), 123, std::option::Option::None, payload);
|
|
let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_000) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let provider = match code("provider") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let protocol = match code("solana_http") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let method = match code("getTransaction") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
|
|
let observation = ksp_store_api::RawTransactionObservation::new(ksp_store_api::RawObservationKey::new([3_u8; 32]), reference, provenance);
|
|
assert_eq!(transaction.slot(), 123);
|
|
assert_eq!(transaction.payload().bytes(), &[1_u8, 2_u8, 3_u8]);
|
|
assert_eq!(observation.transaction().network().as_str(), "mainnet");
|
|
assert_eq!(observation.provenance().acquisition_method().as_str(), "getTransaction");
|
|
assert_eq!(ksp_store_api::ERROR_CODE_RAW_PAYLOAD_INVALID.domain(), "store_api");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_003_surface_keeps_backend_and_structural_types_out() {
|
|
let source = include_str!("../src/lib.rs");
|
|
assert!(!source.contains("pub mod "));
|
|
for forbidden in ["Postgres", "Sql", "Migration", "StructuralTransaction", "RawLog", "ProgramInstruction"] {
|
|
assert!(!source.contains(forbidden), "forbidden pre.003 Store API public concept detected: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_004_raw_account_state_and_observation_are_constructible_from_crate_root() {
|
|
let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let reference = ksp_store_api::RawAccountStateReference::new(
|
|
network,
|
|
ksp_store_api::Pubkey::new_from_array([21_u8; 32]),
|
|
55,
|
|
ksp_store_api::RawContentHash::new([22_u8; 32]),
|
|
);
|
|
let state = ksp_store_api::RawAccountState::try_new(
|
|
reference.clone(),
|
|
123,
|
|
ksp_store_api::Pubkey::new_from_array([23_u8; 32]),
|
|
false,
|
|
9,
|
|
vec![1_u8, 2_u8].into_boxed_slice(),
|
|
);
|
|
assert!(state.is_ok());
|
|
let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(2_000) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let provider = match code("provider") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let protocol = match code("solana_http") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let method = match code("getAccountInfo") {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
|
|
let observation = ksp_store_api::RawAccountObservation::new(ksp_store_api::RawObservationKey::new([24_u8; 32]), reference, provenance);
|
|
assert_eq!(observation.account().slot(), 55);
|
|
assert!(observation.write_version().is_none());
|
|
assert_eq!(ksp_store_api::MAX_RAW_ACCOUNT_DATA_BYTES, 16 * 1024 * 1024);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_005_capabilities_are_available_from_crate_root_and_dyn_compatible() {
|
|
let transaction_read: std::option::Option<&dyn ksp_store_api::RawTransactionRead> = std::option::Option::None;
|
|
let transaction_write: std::option::Option<&dyn ksp_store_api::RawTransactionWrite> = std::option::Option::None;
|
|
let transaction_observation_read: std::option::Option<&dyn ksp_store_api::RawTransactionObservationRead> = std::option::Option::None;
|
|
let transaction_observation_write: std::option::Option<&dyn ksp_store_api::RawTransactionObservationWrite> = std::option::Option::None;
|
|
let account_read: std::option::Option<&dyn ksp_store_api::RawAccountStateRead> = std::option::Option::None;
|
|
let account_write: std::option::Option<&dyn ksp_store_api::RawAccountStateWrite> = std::option::Option::None;
|
|
let account_observation_read: std::option::Option<&dyn ksp_store_api::RawAccountObservationRead> = std::option::Option::None;
|
|
let account_observation_write: std::option::Option<&dyn ksp_store_api::RawAccountObservationWrite> = std::option::Option::None;
|
|
assert!(transaction_read.is_none());
|
|
assert!(transaction_write.is_none());
|
|
assert!(transaction_observation_read.is_none());
|
|
assert!(transaction_observation_write.is_none());
|
|
assert!(account_read.is_none());
|
|
assert!(account_write.is_none());
|
|
assert!(account_observation_read.is_none());
|
|
assert!(account_observation_write.is_none());
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_006_query_outcome_and_retention_contracts_are_available_from_crate_root() {
|
|
let limit = match ksp_store_api::RawPageLimit::new(5_000_000) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(limit.get(), 5_000_000);
|
|
assert!(ksp_store_api::RawPageLimit::new(u64::MAX).is_ok());
|
|
let slots = match ksp_store_api::RawSlotRange::new(std::option::Option::Some(1), std::option::Option::Some(2)) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let query =
|
|
ksp_store_api::RawTransactionQuery::new(network, slots, ksp_store_api::RawSortDirection::Ascending, ksp_store_api::RawPageRequest::first(limit));
|
|
assert_eq!(query.page().limit().get(), 5_000_000);
|
|
let outcome =
|
|
ksp_store_api::RawAcquisitionWriteOutcome::new(ksp_store_api::RawEntityWriteOutcome::Inserted, ksp_store_api::RawObservationWriteOutcome::Inserted);
|
|
assert_eq!(outcome.entity(), ksp_store_api::RawEntityWriteOutcome::Inserted);
|
|
assert_eq!(outcome.observation(), ksp_store_api::RawObservationWriteOutcome::Inserted);
|
|
let retention_read: std::option::Option<&dyn ksp_store_api::RawTransactionRetentionRead> = std::option::Option::None;
|
|
let retention_write: std::option::Option<&dyn ksp_store_api::RawTransactionRetentionWrite> = std::option::Option::None;
|
|
assert!(retention_read.is_none());
|
|
assert!(retention_write.is_none());
|
|
assert_eq!(ksp_store_api::ERROR_CODE_RAW_CONFLICT.domain(), "store_api");
|
|
assert_eq!(ksp_store_api::ERROR_CODE_RAW_QUERY_INVALID.domain(), "store_api");
|
|
assert_eq!(ksp_store_api::ERROR_CODE_RAW_RETENTION_INVALID.domain(), "store_api");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_pre_007_retention_race_outcome_is_available_from_crate_root() {
|
|
assert_ne!(ksp_store_api::RawRetentionWriteOutcome::Applied, ksp_store_api::RawRetentionWriteOutcome::ExpectedStateMismatch);
|
|
assert_ne!(ksp_store_api::RawRetentionWriteOutcome::AlreadyAtTarget, ksp_store_api::RawRetentionWriteOutcome::ExpectedStateMismatch);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_3_8_pre_003_inspection_contracts_are_backend_neutral_and_dyn_compatible() {
|
|
let limit = match ksp_store_api::RawPageLimit::new(25) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let request = ksp_store_api::RawInspectionPageRequest::new(50, limit);
|
|
assert_eq!(request.offset(), 50);
|
|
assert_eq!(request.limit().get(), 25);
|
|
let page = ksp_store_api::RawInspectionPage::<u64>::try_new(std::vec![1, 2], 10, 5);
|
|
assert!(page.is_ok());
|
|
let transaction_inspection: std::option::Option<&dyn ksp_store_api::RawTransactionInspectionRead> = std::option::Option::None;
|
|
let transaction_observation_inspection: std::option::Option<&dyn ksp_store_api::RawTransactionObservationInspectionRead> = std::option::Option::None;
|
|
let account_inspection: std::option::Option<&dyn ksp_store_api::RawAccountStateInspectionRead> = std::option::Option::None;
|
|
let account_observation_inspection: std::option::Option<&dyn ksp_store_api::RawAccountObservationInspectionRead> = std::option::Option::None;
|
|
assert!(transaction_inspection.is_none());
|
|
assert!(transaction_observation_inspection.is_none());
|
|
assert!(account_inspection.is_none());
|
|
assert!(account_observation_inspection.is_none());
|
|
return;
|
|
}
|