251 lines
11 KiB
Rust
251 lines
11 KiB
Rust
// file: crates/ksp-store-api/tests/external_backend.rs
|
|
// version: 4
|
|
|
|
//! External-implementation canary for object-safe Store API capabilities.
|
|
|
|
struct ExternalMemoryBackend;
|
|
|
|
impl ksp_store_api::RawTransactionRead for ExternalMemoryBackend {
|
|
fn get_raw_transaction<'a>(
|
|
&'a self,
|
|
reference: &'a ksp_store_api::RawTransactionReference,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransaction>>> {
|
|
let _ = reference;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(std::option::Option::None);
|
|
});
|
|
}
|
|
|
|
fn list_raw_transactions<'a>(
|
|
&'a self,
|
|
query: &'a ksp_store_api::RawTransactionQuery,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawTransactionReference>>> {
|
|
let _ = query;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawPage::new(std::vec::Vec::new(), std::option::Option::None));
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionInspectionRead for ExternalMemoryBackend {
|
|
fn inspect_raw_transactions<'a>(
|
|
&'a self,
|
|
query: &'a ksp_store_api::RawTransactionInspectionQuery,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawInspectionPage<ksp_store_api::RawTransactionSummary>>> {
|
|
let _ = query;
|
|
return std::boxed::Box::pin(async {
|
|
return ksp_store_api::RawInspectionPage::try_new(std::vec::Vec::new(), 0, 0);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionWrite for ExternalMemoryBackend {
|
|
fn persist_raw_transaction_acquisition<'a>(
|
|
&'a self,
|
|
transaction: ksp_store_api::RawTransaction,
|
|
observation: ksp_store_api::RawTransactionObservation,
|
|
mode: ksp_store_api::RawTransactionAcquisitionMode,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
|
|
let _ = transaction;
|
|
let _ = observation;
|
|
let _ = mode;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawAcquisitionWriteOutcome::new(
|
|
ksp_store_api::RawEntityWriteOutcome::Inserted,
|
|
ksp_store_api::RawObservationWriteOutcome::Inserted,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionObservationInspectionRead for ExternalMemoryBackend {
|
|
fn inspect_raw_transaction_observations<'a>(
|
|
&'a self,
|
|
query: &'a ksp_store_api::RawTransactionObservationInspectionQuery,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawInspectionPage<ksp_store_api::RawTransactionObservationSummary>>> {
|
|
let _ = query;
|
|
return std::boxed::Box::pin(async {
|
|
return ksp_store_api::RawInspectionPage::try_new(std::vec::Vec::new(), 0, 0);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionObservationRead for ExternalMemoryBackend {
|
|
fn get_raw_transaction_observation<'a>(
|
|
&'a self,
|
|
observation_key: &'a ksp_store_api::RawObservationKey,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransactionObservation>>> {
|
|
let _ = observation_key;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(std::option::Option::None);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionObservationWrite for ExternalMemoryBackend {
|
|
fn record_raw_transaction_observation<'a>(
|
|
&'a self,
|
|
observation: ksp_store_api::RawTransactionObservation,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
|
|
let _ = observation;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawObservationWriteOutcome::Inserted);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawAccountStateRead for ExternalMemoryBackend {
|
|
fn get_raw_account_state<'a>(
|
|
&'a self,
|
|
reference: &'a ksp_store_api::RawAccountStateReference,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountState>>> {
|
|
let _ = reference;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(std::option::Option::None);
|
|
});
|
|
}
|
|
|
|
fn list_raw_account_states<'a>(
|
|
&'a self,
|
|
query: &'a ksp_store_api::RawAccountStateQuery,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawAccountStateReference>>> {
|
|
let _ = query;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawPage::new(std::vec::Vec::new(), std::option::Option::None));
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawAccountStateInspectionRead for ExternalMemoryBackend {
|
|
fn inspect_raw_account_states<'a>(
|
|
&'a self,
|
|
query: &'a ksp_store_api::RawAccountStateInspectionQuery,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawInspectionPage<ksp_store_api::RawAccountStateSummary>>> {
|
|
let _ = query;
|
|
return std::boxed::Box::pin(async {
|
|
return ksp_store_api::RawInspectionPage::try_new(std::vec::Vec::new(), 0, 0);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawAccountStateWrite for ExternalMemoryBackend {
|
|
fn persist_raw_account_acquisition<'a>(
|
|
&'a self,
|
|
state: ksp_store_api::RawAccountState,
|
|
observation: ksp_store_api::RawAccountObservation,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
|
|
let _ = state;
|
|
let _ = observation;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawAcquisitionWriteOutcome::new(
|
|
ksp_store_api::RawEntityWriteOutcome::Inserted,
|
|
ksp_store_api::RawObservationWriteOutcome::Inserted,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawAccountObservationInspectionRead for ExternalMemoryBackend {
|
|
fn inspect_raw_account_observations<'a>(
|
|
&'a self,
|
|
query: &'a ksp_store_api::RawAccountObservationInspectionQuery,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawInspectionPage<ksp_store_api::RawAccountObservationSummary>>> {
|
|
let _ = query;
|
|
return std::boxed::Box::pin(async {
|
|
return ksp_store_api::RawInspectionPage::try_new(std::vec::Vec::new(), 0, 0);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawAccountObservationRead for ExternalMemoryBackend {
|
|
fn get_raw_account_observation<'a>(
|
|
&'a self,
|
|
observation_key: &'a ksp_store_api::RawObservationKey,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountObservation>>> {
|
|
let _ = observation_key;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(std::option::Option::None);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawAccountObservationWrite for ExternalMemoryBackend {
|
|
fn record_raw_account_observation<'a>(
|
|
&'a self,
|
|
observation: ksp_store_api::RawAccountObservation,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
|
|
let _ = observation;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawObservationWriteOutcome::Inserted);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionRetentionRead for ExternalMemoryBackend {
|
|
fn get_raw_transaction_retention_state<'a>(
|
|
&'a self,
|
|
reference: &'a ksp_store_api::RawTransactionReference,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawRetentionState>>> {
|
|
let _ = reference;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(std::option::Option::None);
|
|
});
|
|
}
|
|
|
|
fn get_raw_transaction_tombstone<'a>(
|
|
&'a self,
|
|
reference: &'a ksp_store_api::RawTransactionReference,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransactionTombstone>>> {
|
|
let _ = reference;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(std::option::Option::None);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl ksp_store_api::RawTransactionRetentionWrite for ExternalMemoryBackend {
|
|
fn transition_raw_transaction_retention<'a>(
|
|
&'a self,
|
|
transition: ksp_store_api::RawTransactionRetentionTransition,
|
|
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawRetentionWriteOutcome>> {
|
|
let _ = transition;
|
|
return std::boxed::Box::pin(async {
|
|
return std::result::Result::Ok(ksp_store_api::RawRetentionWriteOutcome::Applied);
|
|
});
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_8_pre_003_external_backend_implements_canonical_and_inspection_capabilities_without_runtime_crate() {
|
|
let backend = ExternalMemoryBackend;
|
|
let transaction_read: &dyn ksp_store_api::RawTransactionRead = &backend;
|
|
let transaction_write: &dyn ksp_store_api::RawTransactionWrite = &backend;
|
|
let transaction_inspection: &dyn ksp_store_api::RawTransactionInspectionRead = &backend;
|
|
let transaction_observation_inspection: &dyn ksp_store_api::RawTransactionObservationInspectionRead = &backend;
|
|
let transaction_observation_read: &dyn ksp_store_api::RawTransactionObservationRead = &backend;
|
|
let transaction_observation_write: &dyn ksp_store_api::RawTransactionObservationWrite = &backend;
|
|
let account_read: &dyn ksp_store_api::RawAccountStateRead = &backend;
|
|
let account_write: &dyn ksp_store_api::RawAccountStateWrite = &backend;
|
|
let account_inspection: &dyn ksp_store_api::RawAccountStateInspectionRead = &backend;
|
|
let account_observation_inspection: &dyn ksp_store_api::RawAccountObservationInspectionRead = &backend;
|
|
let account_observation_read: &dyn ksp_store_api::RawAccountObservationRead = &backend;
|
|
let account_observation_write: &dyn ksp_store_api::RawAccountObservationWrite = &backend;
|
|
let retention_read: &dyn ksp_store_api::RawTransactionRetentionRead = &backend;
|
|
let retention_write: &dyn ksp_store_api::RawTransactionRetentionWrite = &backend;
|
|
let _ = transaction_read;
|
|
let _ = transaction_write;
|
|
let _ = transaction_inspection;
|
|
let _ = transaction_observation_inspection;
|
|
let _ = transaction_observation_read;
|
|
let _ = transaction_observation_write;
|
|
let _ = account_read;
|
|
let _ = account_write;
|
|
let _ = account_inspection;
|
|
let _ = account_observation_inspection;
|
|
let _ = account_observation_read;
|
|
let _ = account_observation_write;
|
|
let _ = retention_read;
|
|
let _ = retention_write;
|
|
return;
|
|
}
|