lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

work_tests.rs (7554B)


      1 use super::tests::{observed, signed_event_with, store, verified, visible};
      2 use super::work::{Counts, Read};
      3 use super::*;
      4 use std::task::{Context, Poll, Waker};
      5 
      6 async fn retained_source(size: u64) -> (SqliteStorage, u64) {
      7     let generation = SourceGeneration::new([71; 32]).unwrap();
      8     let storage = store(generation).await;
      9     let mut bytes = 0;
     10     for index in 0..size {
     11         let content = if index % 4 == 0 {
     12             format!(r#"{{"display_name":"Farm {index}","bot":false}}"#)
     13         } else {
     14             format!("retained note {index}")
     15         };
     16         let event = signed_event_with(
     17             &content,
     18             false,
     19             1_800_000_100 + index,
     20             if index % 4 == 0 { 0 } else { 1 },
     21             vec![],
     22         );
     23         bytes += event.raw_json().len() as u64;
     24         let provenance = observed(event.clone(), 10 + index, None);
     25         let admission = match index % 4 {
     26             2 => EventAdmission::raw(provenance),
     27             3 => EventAdmission::verified(provenance, verified(&event)).unwrap(),
     28             _ => EventAdmission::visible(provenance, visible(&event)).unwrap(),
     29         };
     30         storage.admit(admission).await.unwrap();
     31     }
     32     storage.work.take();
     33     (storage, bytes)
     34 }
     35 
     36 fn first() -> EventQuery {
     37     EventQuery::all(EventQueryBounds::first(5).unwrap())
     38 }
     39 
     40 fn assert_materialized(counts: Counts, rows: u64, bytes: u64) {
     41     assert_eq!(counts.materialization_requests, 1);
     42     assert_eq!(counts.event_rows_returned, rows);
     43     assert_eq!(counts.event_bytes_returned, bytes);
     44     assert_eq!(counts.codec_inputs, rows);
     45     assert_eq!(counts.codec_input_bytes, bytes);
     46     assert_eq!(counts.codec_successes, rows);
     47     assert_eq!(counts.visibility_inputs, rows);
     48 }
     49 
     50 async fn plan(storage: &SqliteStorage, kind: Read) -> Vec<String> {
     51     let template = storage.work.template(kind);
     52     let mut builder = QueryBuilder::<Sqlite>::new("EXPLAIN QUERY PLAN ");
     53     builder.push(template);
     54     let mut query = builder
     55         .build()
     56         .bind(storage.generation.as_bytes().as_slice());
     57     if matches!(kind, Read::Bounded | Read::Keys) {
     58         query = query.bind(0_i64).bind(6_i64);
     59     }
     60     query
     61         .fetch_all(&storage.pool)
     62         .await
     63         .unwrap()
     64         .into_iter()
     65         .map(|row| row.get::<String, _>("detail"))
     66         .collect()
     67 }
     68 
     69 #[cfg(test)]
     70 #[tokio::test]
     71 async fn actual_returned_and_decoded_work_distinguishes_bounded_and_full_reads() {
     72     for retained in [32, 96] {
     73         let (storage, bytes) = retained_source(retained).await;
     74         let raw = storage.query_raw(first()).await.unwrap();
     75         assert_eq!(raw.items().len(), 5);
     76         let bounded = storage.work.take();
     77         assert_eq!(bounded.bounded_requests, 1);
     78         assert_eq!(bounded.successful_fetches, 1);
     79         assert_eq!(bounded.event_rows_returned, 6);
     80         assert_eq!(bounded.codec_inputs, 6);
     81         assert_eq!(bounded.codec_successes, 6);
     82         assert_eq!(bounded.event_bytes_returned, bounded.codec_input_bytes);
     83         assert!(bounded.event_bytes_returned > 0 && bounded.event_bytes_returned < bytes);
     84         assert_eq!(bounded.visibility_inputs, 0);
     85         let bounded_plan = plan(&storage, Read::Bounded).await;
     86         let page = storage.query_visible(first()).await.unwrap();
     87         assert_eq!(page.items().len(), 5);
     88         let full = storage.work.take();
     89         assert_eq!(full.materialization_requests, 0);
     90         assert_eq!(full.visibility_inputs, 0);
     91         assert_eq!(full.key_requests, 1);
     92         assert_eq!(full.key_rows_returned, 6);
     93         assert_eq!(full.codec_inputs, 5);
     94         assert_eq!(full.event_rows_returned, 5);
     95         assert_eq!(full.aggregate_requests, 1);
     96         let full_plan = plan(&storage, Read::Keys).await;
     97         assert!(!bounded_plan.is_empty() && !full_plan.is_empty());
     98         assert!(
     99             full_plan
    100                 .iter()
    101                 .any(|line| line.contains("visibility_members_page_idx"))
    102         );
    103         println!(
    104             "{}",
    105             serde_json::json!({"scenario":"bounded_vs_materialized", "retained_events":retained,
    106             "returned_page_items":5, "bounded":bounded, "full_visibility":full,
    107             "bounded_query_plan":bounded_plan, "full_query_plan":full_plan,
    108             "sqlite_vm_row_visits_measured":false, "wall_time_qualification":false})
    109         );
    110         storage.close().await.unwrap();
    111     }
    112 }
    113 
    114 #[cfg(test)]
    115 #[tokio::test]
    116 async fn status_and_rebuild_measure_actual_full_source_materialization() {
    117     let (storage, bytes) = retained_source(32).await;
    118     let status = storage.status().await.unwrap();
    119     assert_eq!(status.raw_events(), 32);
    120     assert_eq!(status.verified_events(), 24);
    121     let counts = storage.work.take();
    122     assert_eq!(counts.materialization_requests, 0);
    123     assert_eq!(counts.visibility_inputs, 0);
    124     assert_eq!(counts.codec_inputs, 0);
    125     assert_eq!(counts.event_rows_returned, 0);
    126     assert_eq!(counts.aggregate_requests, 1);
    127     assert_eq!(counts.aggregate_rows_returned, 1);
    128     assert_eq!(counts.successful_fetches, 1);
    129     let aggregate_plan = plan(&storage, Read::Aggregate).await;
    130     let visibility = storage.rebuild_visibility().await.unwrap();
    131     let rebuilt = storage.work.take();
    132     assert_materialized(rebuilt, 32, bytes);
    133     assert_eq!(rebuilt.aggregate_requests, 0);
    134     assert_eq!(rebuilt.successful_fetches, 1);
    135     assert_eq!(
    136         status.visible_events(),
    137         visibility.visible_event_ids().len() as u64
    138     );
    139     println!(
    140         "{}",
    141         serde_json::json!({"scenario":"status_and_rebuild", "status":counts,
    142         "rebuild":rebuilt, "aggregate_query_plan":aggregate_plan, "sqlite_vm_row_visits_measured":false})
    143     );
    144     storage.close().await.unwrap();
    145 }
    146 
    147 #[cfg(test)]
    148 #[tokio::test]
    149 async fn cancelled_pool_wait_materializes_nothing_and_retry_executes_real_read() {
    150     let (storage, _) = retained_source(32).await;
    151     let held = storage.pool.acquire().await.unwrap();
    152     let mut future = storage.query_raw(first());
    153     assert!(matches!(
    154         future
    155             .as_mut()
    156             .poll(&mut Context::from_waker(Waker::noop())),
    157         Poll::Pending
    158     ));
    159     drop(future);
    160     let cancelled = storage.work.take();
    161     assert_eq!(cancelled.bounded_requests, 1);
    162     assert_eq!(cancelled.successful_fetches, 0);
    163     assert_eq!(cancelled.event_rows_returned, 0);
    164     assert_eq!(cancelled.codec_inputs, 0);
    165     assert_eq!(cancelled.codec_input_bytes, 0);
    166     drop(held);
    167     assert_eq!(storage.query_raw(first()).await.unwrap().items().len(), 5);
    168     let retry = storage.work.take();
    169     assert_eq!(retry.bounded_requests, 1);
    170     assert_eq!(retry.successful_fetches, 1);
    171     assert_eq!(retry.event_rows_returned, 6);
    172     assert_eq!(retry.codec_successes, 6);
    173     println!(
    174         "{}",
    175         serde_json::json!({"scenario":"cancelled_pool_wait", "cancelled":cancelled, "retry":retry,
    176         "cancellation_boundary":"pending pool acquisition", "running_sqlite_worker_cancellation_qualified":false})
    177     );
    178     storage.close().await.unwrap();
    179 }
    180 
    181 #[cfg(test)]
    182 #[tokio::test]
    183 async fn observations_are_instance_scoped_and_shared_only_by_clones() {
    184     let (storage, _) = retained_source(32).await;
    185     let (other, _) = retained_source(32).await;
    186     let cloned = storage.clone();
    187     cloned.query_raw(first()).await.unwrap();
    188     assert_eq!(storage.work.take().event_rows_returned, 6);
    189     assert_eq!(cloned.work.take(), Counts::default());
    190     assert_eq!(other.work.take(), Counts::default());
    191     storage.close().await.unwrap();
    192     other.close().await.unwrap();
    193 }