v0.3.8-pre.005

crates/ksp-store-postgres-lib/tests/postgres_raw_account_live.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/tests/postgres_raw_account_live.rs
-// version: 1
+// version: 2
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -68,7 +68,10 @@ enum LiveAccountPersistResult {
 #[test]
 #[ignore = "opt-in real PostgreSQL RawAccountState proof; reads one dedicated URI from stdin"]
 fn pre_009_real_postgres_raw_account_vertical_slice_is_atomic_concurrent_and_recoverable() {
-    eprintln!("KSP Store RawAccountState live proof: reading one dedicated URI from stdin without echoing it from the test.");
+    eprintln!(
+        "KSP Store RawAccountState live proof: waiting for one dedicated PostgreSQL URI line on stdin; the scenario does not start until Enter is pressed."
+    );
+    eprintln!("KSP Store RawAccountState live proof: the test itself never echoes the URI.");
     let uri_result = read_uri_from_stdin();
     let uri = match uri_result {
         std::result::Result::Ok(value) => value,
@@ -179,6 +182,7 @@ async fn run_raw_account_scenario(admin: &mut tokio_postgres::Client, uri: &str,
         prove_atomic_idempotence_and_conflicts(&backend).await,
         prove_additional_observations(&backend).await,
         prove_pagination_and_cursors(&backend).await,
+        prove_account_inspection(&backend).await,
         prove_cross_family_coexistence(&backend, admin).await,
     ] {
         if let std::result::Result::Err(error) = proof {
@@ -561,6 +565,80 @@ async fn prove_pagination_and_cursors(backend: &ksp_store_postgres_lib::Postgres
     return std::result::Result::Ok(());
 }
 
+async fn prove_account_inspection(backend: &ksp_store_postgres_lib::PostgresBackend) -> std::result::Result<(), LiveFailure> {
+    let filtered_query = match account_inspection_query(
+        std::option::Option::Some(ksp_store_api::Pubkey::new_from_array([50; 32])),
+        200,
+        202,
+        ksp_store_api::RawSortDirection::Ascending,
+        1,
+        2,
+    ) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let filtered = match backend.inspect_raw_account_states(&filtered_query).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(LiveFailure::new("inspection_filtered_query")),
+    };
+    if filtered.filtered_items() != 3 || filtered.total_items() < 5 || filtered.items().len() != 2 {
+        return std::result::Result::Err(LiveFailure::new("inspection_filtered_counts"));
+    }
+    let first = &filtered.items()[0];
+    let second = &filtered.items()[1];
+    if first.reference().slot() != 200
+        || first.reference().pubkey() != &ksp_store_api::Pubkey::new_from_array([50; 32])
+        || first.reference().state_hash() != ksp_store_api::RawContentHash::new([51; 32])
+        || first.data_length_bytes() != 2
+        || second.reference().slot() != 201
+        || second.reference().state_hash() != ksp_store_api::RawContentHash::new([52; 32])
+        || second.data_length_bytes() != 2
+    {
+        return std::result::Result::Err(LiveFailure::new("inspection_filtered_order"));
+    }
+    let descending_query = match account_inspection_query(std::option::Option::None, 200, 202, ksp_store_api::RawSortDirection::Descending, 1, 2) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let descending = match backend.inspect_raw_account_states(&descending_query).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(LiveFailure::new("inspection_descending_query")),
+    };
+    if descending.filtered_items() != 5 || descending.items().len() != 2 {
+        return std::result::Result::Err(LiveFailure::new("inspection_descending_counts"));
+    }
+    let descending_first = &descending.items()[0];
+    let descending_second = &descending.items()[1];
+    if descending_first.reference().slot() != 201
+        || descending_first.reference().pubkey() != &ksp_store_api::Pubkey::new_from_array([51; 32])
+        || descending_first.reference().state_hash() != ksp_store_api::RawContentHash::new([53; 32])
+        || descending_second.reference().slot() != 201
+        || descending_second.reference().pubkey() != &ksp_store_api::Pubkey::new_from_array([50; 32])
+        || descending_second.reference().state_hash() != ksp_store_api::RawContentHash::new([52; 32])
+    {
+        return std::result::Result::Err(LiveFailure::new("inspection_descending_order"));
+    }
+    let deep_query = match account_inspection_query(
+        std::option::Option::Some(ksp_store_api::Pubkey::new_from_array([50; 32])),
+        200,
+        202,
+        ksp_store_api::RawSortDirection::Ascending,
+        10_000,
+        2,
+    ) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let deep = match backend.inspect_raw_account_states(&deep_query).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(LiveFailure::new("inspection_deep_query")),
+    };
+    if deep.filtered_items() != 3 || deep.total_items() != filtered.total_items() || !deep.items().is_empty() {
+        return std::result::Result::Err(LiveFailure::new("inspection_deep_page"));
+    }
+    return std::result::Result::Ok(());
+}
+
 async fn prove_cross_family_coexistence(
     backend: &ksp_store_postgres_lib::PostgresBackend,
     admin: &tokio_postgres::Client,
@@ -850,6 +928,30 @@ fn account_query(
     return std::result::Result::Ok(ksp_store_api::RawAccountStateQuery::new(network, pubkey, slots, direction, page));
 }
 
+fn account_inspection_query(
+    pubkey: std::option::Option<ksp_store_api::Pubkey>,
+    start: u64,
+    end: u64,
+    direction: ksp_store_api::RawSortDirection,
+    offset: u64,
+    limit: u64,
+) -> std::result::Result<ksp_store_api::RawAccountStateInspectionQuery, LiveFailure> {
+    let network = match network("devnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let slots = match ksp_store_api::RawSlotRange::new(std::option::Option::Some(start), std::option::Option::Some(end)) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(LiveFailure::new("inspection_model_slot_range")),
+    };
+    let limit = match ksp_store_api::RawPageLimit::new(limit) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(LiveFailure::new("inspection_model_page_limit")),
+    };
+    let page = ksp_store_api::RawInspectionPageRequest::new(offset, limit);
+    return std::result::Result::Ok(ksp_store_api::RawAccountStateInspectionQuery::new(network, pubkey, slots, direction, page));
+}
+
 fn account_reference(pubkey_seed: u8, slot: u64, hash_seed: u8) -> std::result::Result<ksp_store_api::RawAccountStateReference, LiveFailure> {
     let network = match network("devnet") {
         std::result::Result::Ok(value) => value,