272 lines
11 KiB
Rust
272 lines
11 KiB
Rust
// file: crates/ksp-store-api/unit_tests/model/raw_inspection.rs
|
|
// version: 3
|
|
|
|
//! Unit tests for backend-neutral RAW inspection contracts.
|
|
|
|
fn network() -> std::option::Option<crate::RawNetworkId> {
|
|
return match crate::RawNetworkId::new("mainnet".to_owned()) {
|
|
std::result::Result::Ok(value) => std::option::Option::Some(value),
|
|
std::result::Result::Err(_) => std::option::Option::None,
|
|
};
|
|
}
|
|
|
|
fn format_id() -> std::option::Option<crate::RawFormatId> {
|
|
return match crate::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
|
|
std::result::Result::Ok(value) => std::option::Option::Some(value),
|
|
std::result::Result::Err(_) => std::option::Option::None,
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn inspection_page_request_preserves_large_offset_and_caller_limit_without_cursor_semantics() {
|
|
let limit = match crate::RawPageLimit::new(100) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let request = crate::RawInspectionPageRequest::new(u64::MAX, limit);
|
|
assert_eq!(request.offset(), u64::MAX);
|
|
assert_eq!(request.limit().get(), 100);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn inspection_page_rejects_inconsistent_exact_counts() {
|
|
assert!(crate::RawInspectionPage::<u64>::try_new(std::vec![1], 0, 0).is_err());
|
|
assert!(crate::RawInspectionPage::<u64>::try_new(std::vec::Vec::new(), 4, 5).is_err());
|
|
let page = crate::RawInspectionPage::<u64>::try_new(std::vec![1, 2], 5, 3);
|
|
assert!(page.is_ok());
|
|
let page = match page {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(page.total_items(), 5);
|
|
assert_eq!(page.filtered_items(), 3);
|
|
assert_eq!(page.items(), &[1, 2]);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn inspection_queries_keep_backend_neutral_filters_and_random_access_page() {
|
|
let network = match network() {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let slots = match crate::RawSlotRange::new(std::option::Option::Some(10), std::option::Option::Some(20)) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let limit = match crate::RawPageLimit::new(25) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let transaction =
|
|
crate::RawTransactionInspectionQuery::new(network.clone(), slots, crate::RawSortDirection::Descending, crate::RawInspectionPageRequest::new(50, limit));
|
|
assert_eq!(transaction.network().as_str(), "mainnet");
|
|
assert_eq!(transaction.page().offset(), 50);
|
|
assert_eq!(transaction.slots().end_inclusive(), std::option::Option::Some(20));
|
|
assert_eq!(transaction.direction(), crate::RawSortDirection::Descending);
|
|
let pubkey = crate::Pubkey::new_from_array([0x21_u8; 32]);
|
|
let account = crate::RawAccountStateInspectionQuery::new(
|
|
network,
|
|
std::option::Option::Some(pubkey),
|
|
slots,
|
|
crate::RawSortDirection::Ascending,
|
|
crate::RawInspectionPageRequest::new(75, limit),
|
|
);
|
|
assert_eq!(account.page().offset(), 75);
|
|
assert_eq!(account.pubkey(), std::option::Option::Some(&pubkey));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn transaction_summary_is_payload_free_and_retention_consistent() {
|
|
let network = match network() {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let format_id = match format_id() {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let reference = crate::RawTransactionReference::new(network, crate::RawTransactionSignature::new([0x31_u8; 64]));
|
|
let full = crate::RawTransactionSummary::try_new(
|
|
reference.clone(),
|
|
42,
|
|
std::option::Option::None,
|
|
format_id.clone(),
|
|
1,
|
|
crate::RawContentHash::new([0x32_u8; 32]),
|
|
std::option::Option::Some(123),
|
|
crate::RawRetentionState::Full,
|
|
);
|
|
assert!(full.is_ok());
|
|
let full = match full {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(full.slot(), 42);
|
|
assert_eq!(full.payload_size_bytes(), std::option::Option::Some(123));
|
|
assert_eq!(full.retention_state(), crate::RawRetentionState::Full);
|
|
assert!(
|
|
crate::RawTransactionSummary::try_new(
|
|
reference.clone(),
|
|
42,
|
|
std::option::Option::None,
|
|
format_id.clone(),
|
|
1,
|
|
crate::RawContentHash::new([0x32_u8; 32]),
|
|
std::option::Option::None,
|
|
crate::RawRetentionState::Full,
|
|
)
|
|
.is_err()
|
|
);
|
|
assert!(
|
|
crate::RawTransactionSummary::try_new(
|
|
reference,
|
|
42,
|
|
std::option::Option::None,
|
|
format_id,
|
|
1,
|
|
crate::RawContentHash::new([0x32_u8; 32]),
|
|
std::option::Option::Some(123),
|
|
crate::RawRetentionState::Purged,
|
|
)
|
|
.is_err()
|
|
);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn account_summary_exposes_length_only_and_enforces_raw_account_bound() {
|
|
let network = match network() {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let reference = crate::RawAccountStateReference::new(network, crate::Pubkey::new_from_array([0x41_u8; 32]), 88, crate::RawContentHash::new([0x42_u8; 32]));
|
|
let summary = crate::RawAccountStateSummary::try_new(reference.clone(), 1000, crate::Pubkey::new_from_array([0x43_u8; 32]), false, 9, 512);
|
|
assert!(summary.is_ok());
|
|
let summary = match summary {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(summary.reference().slot(), 88);
|
|
assert_eq!(summary.data_length_bytes(), 512);
|
|
assert!(crate::RawAccountStateSummary::try_new(reference, 1000, crate::Pubkey::new_from_array([0x43_u8; 32]), false, 9, 16_777_217,).is_err());
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn observation_inspection_queries_require_network_coherence_and_exact_entity_filters() {
|
|
let network = match network() {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let other_network = match crate::RawNetworkId::new("devnet".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let limit = match crate::RawPageLimit::new(25) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let page = crate::RawInspectionPageRequest::new(125, limit);
|
|
let transaction_reference = crate::RawTransactionReference::new(network.clone(), crate::RawTransactionSignature::new([0x51_u8; 64]));
|
|
let transaction = crate::RawTransactionObservationInspectionQuery::try_new(
|
|
network.clone(),
|
|
std::option::Option::Some(transaction_reference.clone()),
|
|
crate::RawSortDirection::Descending,
|
|
page,
|
|
);
|
|
assert!(transaction.is_ok());
|
|
let transaction = match transaction {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(transaction.page().offset(), 125);
|
|
assert_eq!(transaction.transaction(), std::option::Option::Some(&transaction_reference));
|
|
assert!(
|
|
crate::RawTransactionObservationInspectionQuery::try_new(
|
|
other_network.clone(),
|
|
std::option::Option::Some(transaction_reference),
|
|
crate::RawSortDirection::Ascending,
|
|
page,
|
|
)
|
|
.is_err()
|
|
);
|
|
let account_reference =
|
|
crate::RawAccountStateReference::new(network.clone(), crate::Pubkey::new_from_array([0x52_u8; 32]), 99, crate::RawContentHash::new([0x53_u8; 32]));
|
|
let account = crate::RawAccountObservationInspectionQuery::try_new(
|
|
network,
|
|
std::option::Option::Some(account_reference.clone()),
|
|
crate::RawSortDirection::Ascending,
|
|
page,
|
|
);
|
|
assert!(account.is_ok());
|
|
let account = match account {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(account.account(), std::option::Option::Some(&account_reference));
|
|
let mismatched_account = crate::RawAccountStateReference::new(
|
|
other_network.clone(),
|
|
crate::Pubkey::new_from_array([0x54_u8; 32]),
|
|
100,
|
|
crate::RawContentHash::new([0x55_u8; 32]),
|
|
);
|
|
assert!(
|
|
crate::RawAccountObservationInspectionQuery::try_new(
|
|
other_network,
|
|
std::option::Option::Some(account_reference),
|
|
crate::RawSortDirection::Ascending,
|
|
page,
|
|
)
|
|
.is_err()
|
|
);
|
|
let _ = mismatched_account;
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn observation_summaries_expose_safe_provenance_without_raw_entity_bytes() {
|
|
let network = match network() {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
let provider = match crate::RawProvenanceCode::new("publicnode".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let protocol = match crate::RawProvenanceCode::new("solana-json-rpc".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let method = match crate::RawProvenanceCode::new("getTransaction".to_owned()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let received_at = match crate::RawTimestamp::from_unix_millis(1_750_000_000_000) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
let provenance = crate::RawAcquisitionProvenance::new(provider, protocol, method, crate::RawAcquisitionOrigin::Backfill, received_at);
|
|
let transaction_reference = crate::RawTransactionReference::new(network.clone(), crate::RawTransactionSignature::new([0x61_u8; 64]));
|
|
let transaction =
|
|
crate::RawTransactionObservationSummary::new(crate::RawObservationKey::new([0x62_u8; 32]), transaction_reference.clone(), provenance.clone());
|
|
assert_eq!(transaction.transaction(), &transaction_reference);
|
|
assert_eq!(transaction.provenance().received_at(), received_at);
|
|
let account_reference =
|
|
crate::RawAccountStateReference::new(network, crate::Pubkey::new_from_array([0x63_u8; 32]), 700, crate::RawContentHash::new([0x64_u8; 32]));
|
|
let account = crate::RawAccountObservationSummary::new(
|
|
crate::RawObservationKey::new([0x65_u8; 32]),
|
|
account_reference.clone(),
|
|
provenance,
|
|
std::option::Option::Some(true),
|
|
std::option::Option::Some(crate::RawTransactionSignature::new([0x66_u8; 64])),
|
|
std::option::Option::Some(u64::MAX),
|
|
);
|
|
assert_eq!(account.account(), &account_reference);
|
|
assert_eq!(account.is_startup(), std::option::Option::Some(true));
|
|
assert_eq!(account.write_version(), std::option::Option::Some(u64::MAX));
|
|
return;
|
|
}
|