v0.3.6-pre.007
This commit is contained in:
348
crates/ksp-job-backfill-lib/unit_tests/persistence.rs
Normal file
348
crates/ksp-job-backfill-lib/unit_tests/persistence.rs
Normal file
@@ -0,0 +1,348 @@
|
||||
// file: crates/ksp-job-backfill-lib/unit_tests/persistence.rs
|
||||
// version: 1
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum FakeResponse {
|
||||
Outcome(ksp_store_lib::RawAcquisitionWriteOutcome),
|
||||
Conflict,
|
||||
Failure,
|
||||
}
|
||||
|
||||
struct FakePersistencePort {
|
||||
network: ksp_store_lib::RawNetworkId,
|
||||
responses: std::sync::Mutex<std::collections::VecDeque<FakeResponse>>,
|
||||
calls: std::sync::atomic::AtomicUsize,
|
||||
normal_mode_only: std::sync::atomic::AtomicBool,
|
||||
}
|
||||
|
||||
impl FakePersistencePort {
|
||||
fn new(network: ksp_store_lib::RawNetworkId, responses: &[FakeResponse]) -> Self {
|
||||
return Self {
|
||||
network,
|
||||
responses: std::sync::Mutex::new(responses.iter().copied().collect()),
|
||||
calls: std::sync::atomic::AtomicUsize::new(0),
|
||||
normal_mode_only: std::sync::atomic::AtomicBool::new(true),
|
||||
};
|
||||
}
|
||||
|
||||
fn calls(&self) -> usize {
|
||||
return self.calls.load(std::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
|
||||
fn used_only_normal_mode(&self) -> bool {
|
||||
return self.normal_mode_only.load(std::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
impl super::RawTransactionPersistencePort for FakePersistencePort {
|
||||
fn network_matches(&self, network: &ksp_store_lib::RawNetworkId) -> bool {
|
||||
return &self.network == network;
|
||||
}
|
||||
|
||||
fn persist_acquisition<'a>(
|
||||
&'a self,
|
||||
transaction: ksp_store_lib::RawTransaction,
|
||||
observation: ksp_store_lib::RawTransactionObservation,
|
||||
mode: ksp_store_lib::RawTransactionAcquisitionMode,
|
||||
) -> ksp_store_lib::StoreApiFuture<'a, ksp_store_lib::Result<ksp_store_lib::RawAcquisitionWriteOutcome>> {
|
||||
self.calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
if mode != ksp_store_lib::RawTransactionAcquisitionMode::Normal {
|
||||
self.normal_mode_only.store(false, std::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
let result = if transaction.reference() != observation.transaction() {
|
||||
std::result::Result::Err(ksp_core_lib::Error::new(
|
||||
ksp_core_lib::ErrorCode::new("test", "reference_mismatch"),
|
||||
"fake persistence reference mismatch",
|
||||
))
|
||||
} else {
|
||||
let response = match self.responses.lock() {
|
||||
std::result::Result::Ok(mut responses) => responses.pop_front(),
|
||||
std::result::Result::Err(_) => std::option::Option::None,
|
||||
};
|
||||
match response {
|
||||
std::option::Option::Some(FakeResponse::Outcome(outcome)) => std::result::Result::Ok(outcome),
|
||||
std::option::Option::Some(FakeResponse::Conflict) => {
|
||||
std::result::Result::Err(ksp_core_lib::Error::new(ksp_store_lib::ERROR_CODE_RAW_CONFLICT, "fake canonical content conflict"))
|
||||
},
|
||||
std::option::Option::Some(FakeResponse::Failure) | std::option::Option::None => {
|
||||
std::result::Result::Err(ksp_core_lib::Error::new(ksp_core_lib::ErrorCode::new("test", "store_failure"), "fake Store failure"))
|
||||
},
|
||||
}
|
||||
};
|
||||
return std::boxed::Box::pin(async move {
|
||||
return result;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn raw_network(value: &str) -> std::option::Option<ksp_store_lib::RawNetworkId> {
|
||||
return match ksp_store_lib::RawNetworkId::new(value) {
|
||||
std::result::Result::Ok(network) => std::option::Option::Some(network),
|
||||
std::result::Result::Err(_) => std::option::Option::None,
|
||||
};
|
||||
}
|
||||
|
||||
fn raw_reference(network: &str, signature_byte: u8) -> std::option::Option<ksp_store_lib::RawTransactionReference> {
|
||||
let network = match raw_network(network) {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return std::option::Option::None,
|
||||
};
|
||||
return std::option::Option::Some(ksp_store_lib::RawTransactionReference::new(network, ksp_store_lib::RawTransactionSignature::new([signature_byte; 64])));
|
||||
}
|
||||
|
||||
fn raw_acquisition_parts(
|
||||
network: &str,
|
||||
signature_byte: u8,
|
||||
observation_byte: u8,
|
||||
) -> std::option::Option<(ksp_store_lib::RawTransactionReference, ksp_store_lib::RawTransaction, ksp_store_lib::RawTransactionObservation)> {
|
||||
let reference = match raw_reference(network, signature_byte) {
|
||||
std::option::Option::Some(reference) => reference,
|
||||
std::option::Option::None => return std::option::Option::None,
|
||||
};
|
||||
let format_id = match ksp_store_lib::RawFormatId::new(crate::RAW_TRANSACTION_FORMAT_ID) {
|
||||
std::result::Result::Ok(format_id) => format_id,
|
||||
std::result::Result::Err(_) => return std::option::Option::None,
|
||||
};
|
||||
let payload = ksp_store_lib::RawPayload::try_new(
|
||||
format_id,
|
||||
crate::RAW_TRANSACTION_FORMAT_VERSION,
|
||||
std::vec![signature_byte].into_boxed_slice(),
|
||||
ksp_store_lib::RawContentHash::new([signature_byte; 32]),
|
||||
);
|
||||
let payload = match payload {
|
||||
std::result::Result::Ok(payload) => payload,
|
||||
std::result::Result::Err(_) => return std::option::Option::None,
|
||||
};
|
||||
let received_at = match ksp_store_lib::RawTimestamp::from_unix_millis(1_700_000_000_000) {
|
||||
std::result::Result::Ok(received_at) => received_at,
|
||||
std::result::Result::Err(_) => return std::option::Option::None,
|
||||
};
|
||||
let provider = match ksp_store_lib::RawProvenanceCode::new("provider") {
|
||||
std::result::Result::Ok(provider) => provider,
|
||||
std::result::Result::Err(_) => return std::option::Option::None,
|
||||
};
|
||||
let protocol = match ksp_store_lib::RawProvenanceCode::new("solana.http.json_rpc") {
|
||||
std::result::Result::Ok(protocol) => protocol,
|
||||
std::result::Result::Err(_) => return std::option::Option::None,
|
||||
};
|
||||
let method = match ksp_store_lib::RawProvenanceCode::new("getTransaction") {
|
||||
std::result::Result::Ok(method) => method,
|
||||
std::result::Result::Err(_) => return std::option::Option::None,
|
||||
};
|
||||
let provenance = ksp_store_lib::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_lib::RawAcquisitionOrigin::Backfill, received_at);
|
||||
let transaction = ksp_store_lib::RawTransaction::new(reference.clone(), 42, std::option::Option::None, payload);
|
||||
let observation =
|
||||
ksp_store_lib::RawTransactionObservation::new(ksp_store_lib::RawObservationKey::new([observation_byte; 32]), reference.clone(), provenance);
|
||||
return std::option::Option::Some((reference, transaction, observation));
|
||||
}
|
||||
|
||||
fn store_outcome(
|
||||
entity: ksp_store_lib::RawEntityWriteOutcome,
|
||||
observation: ksp_store_lib::RawObservationWriteOutcome,
|
||||
) -> ksp_store_lib::RawAcquisitionWriteOutcome {
|
||||
return ksp_store_lib::RawAcquisitionWriteOutcome::new(entity, observation);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_missing_skips_store_and_preserves_network_scoped_identity() {
|
||||
let reference = match raw_reference("devnet", 1) {
|
||||
std::option::Option::Some(reference) => reference,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let port = FakePersistencePort::new(network, &[]);
|
||||
let result = super::persist_hydration_with_port(&port, crate::BackfillHydrationOutcome::Missing(reference.clone())).await;
|
||||
assert!(result.is_ok());
|
||||
if let std::result::Result::Ok(result) = result {
|
||||
assert_eq!(result.reference(), &reference);
|
||||
assert_eq!(result.entity(), crate::BackfillEntityPersistence::Missing);
|
||||
assert_eq!(result.observation(), crate::BackfillObservationPersistence::NotApplicable);
|
||||
}
|
||||
assert_eq!(port.calls(), 0);
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_store_network_mismatch_is_rejected_before_any_write() {
|
||||
let reference = match raw_reference("devnet", 2) {
|
||||
std::option::Option::Some(reference) => reference,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("mainnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let port = FakePersistencePort::new(network, &[]);
|
||||
let result = super::persist_hydration_with_port(&port, crate::BackfillHydrationOutcome::Missing(reference)).await;
|
||||
assert!(result.is_err());
|
||||
if let std::result::Result::Err(error) = result {
|
||||
assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID);
|
||||
}
|
||||
assert_eq!(port.calls(), 0);
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_atomic_insert_maps_entity_and_observation_without_second_write() {
|
||||
let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 3, 13) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let response = store_outcome(ksp_store_lib::RawEntityWriteOutcome::Inserted, ksp_store_lib::RawObservationWriteOutcome::Inserted);
|
||||
let port = FakePersistencePort::new(network, &[FakeResponse::Outcome(response)]);
|
||||
let result = super::persist_available_with_port(&port, reference.clone(), transaction, observation).await;
|
||||
assert!(result.is_ok());
|
||||
if let std::result::Result::Ok(result) = result {
|
||||
assert_eq!(result.reference(), &reference);
|
||||
assert_eq!(result.entity(), crate::BackfillEntityPersistence::Inserted);
|
||||
assert_eq!(result.observation(), crate::BackfillObservationPersistence::Inserted);
|
||||
}
|
||||
assert_eq!(port.calls(), 1);
|
||||
assert!(port.used_only_normal_mode());
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_existing_entity_distinguishes_new_from_idempotent_observation() {
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let first = store_outcome(ksp_store_lib::RawEntityWriteOutcome::AlreadyPresent, ksp_store_lib::RawObservationWriteOutcome::Inserted);
|
||||
let second = store_outcome(ksp_store_lib::RawEntityWriteOutcome::AlreadyPresent, ksp_store_lib::RawObservationWriteOutcome::AlreadyPresent);
|
||||
let port = FakePersistencePort::new(network, &[FakeResponse::Outcome(first), FakeResponse::Outcome(second)]);
|
||||
let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 4, 14) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
|
||||
assert!(result.is_ok());
|
||||
if let std::result::Result::Ok(result) = result {
|
||||
assert_eq!(result.entity(), crate::BackfillEntityPersistence::AlreadyPresent);
|
||||
assert_eq!(result.observation(), crate::BackfillObservationPersistence::Inserted);
|
||||
}
|
||||
let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 4, 14) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let rerun = super::persist_available_with_port(&port, reference, transaction, observation).await;
|
||||
assert!(rerun.is_ok());
|
||||
if let std::result::Result::Ok(rerun) = rerun {
|
||||
assert_eq!(rerun.entity(), crate::BackfillEntityPersistence::AlreadyPresent);
|
||||
assert_eq!(rerun.observation(), crate::BackfillObservationPersistence::AlreadyPresent);
|
||||
}
|
||||
assert_eq!(port.calls(), 2);
|
||||
assert!(port.used_only_normal_mode());
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_normal_backfill_respects_purged_tombstone_without_observation() {
|
||||
let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 5, 15) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let response = store_outcome(ksp_store_lib::RawEntityWriteOutcome::SkippedPurged, ksp_store_lib::RawObservationWriteOutcome::NotRecorded);
|
||||
let port = FakePersistencePort::new(network, &[FakeResponse::Outcome(response)]);
|
||||
let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
|
||||
assert!(result.is_ok());
|
||||
if let std::result::Result::Ok(result) = result {
|
||||
assert_eq!(result.entity(), crate::BackfillEntityPersistence::SkippedPurged);
|
||||
assert_eq!(result.observation(), crate::BackfillObservationPersistence::NotRecorded);
|
||||
}
|
||||
assert!(port.used_only_normal_mode());
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_store_content_conflict_is_explicit_and_not_idempotent_success() {
|
||||
let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 6, 16) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let port = FakePersistencePort::new(network, &[FakeResponse::Conflict]);
|
||||
let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
|
||||
assert!(result.is_ok());
|
||||
if let std::result::Result::Ok(result) = result {
|
||||
assert_eq!(result.entity(), crate::BackfillEntityPersistence::Conflict);
|
||||
assert_eq!(result.observation(), crate::BackfillObservationPersistence::NotRecorded);
|
||||
assert_ne!(result.entity(), crate::BackfillEntityPersistence::AlreadyPresent);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_non_conflict_store_failure_propagates_unchanged() {
|
||||
let (reference, transaction, observation) = match raw_acquisition_parts("devnet", 7, 17) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let port = FakePersistencePort::new(network, &[FakeResponse::Failure]);
|
||||
let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
|
||||
assert!(result.is_err());
|
||||
if let std::result::Result::Err(error) = result {
|
||||
assert_eq!(error.code(), ksp_core_lib::ErrorCode::new("test", "store_failure"));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pre_007_normal_mode_rejects_impossible_store_outcome_combinations() {
|
||||
let reference = match raw_reference("devnet", 8) {
|
||||
std::option::Option::Some(reference) => reference,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let impossible = [
|
||||
store_outcome(ksp_store_lib::RawEntityWriteOutcome::Rehydrated, ksp_store_lib::RawObservationWriteOutcome::Inserted),
|
||||
store_outcome(ksp_store_lib::RawEntityWriteOutcome::Inserted, ksp_store_lib::RawObservationWriteOutcome::AlreadyPresent),
|
||||
store_outcome(ksp_store_lib::RawEntityWriteOutcome::SkippedPurged, ksp_store_lib::RawObservationWriteOutcome::Inserted),
|
||||
];
|
||||
for outcome in impossible {
|
||||
let result = super::map_store_outcome(reference.clone(), outcome);
|
||||
assert!(result.is_err());
|
||||
if let std::result::Result::Err(error) = result {
|
||||
assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pre_007_mismatched_transaction_observation_reference_is_rejected_before_store() {
|
||||
let (reference, transaction, _) = match raw_acquisition_parts("devnet", 9, 19) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let (_, _, observation) = match raw_acquisition_parts("devnet", 10, 20) {
|
||||
std::option::Option::Some(parts) => parts,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let network = match raw_network("devnet") {
|
||||
std::option::Option::Some(network) => network,
|
||||
std::option::Option::None => return,
|
||||
};
|
||||
let port = FakePersistencePort::new(network, &[]);
|
||||
let result = super::persist_available_with_port(&port, reference, transaction, observation).await;
|
||||
assert!(result.is_err());
|
||||
assert_eq!(port.calls(), 0);
|
||||
return;
|
||||
}
|
||||
Reference in New Issue
Block a user