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 }