mutation_tests.rs (12441B)
1 use super::tests::{observed, signed_event_with, store, verified, visible}; 2 use super::*; 3 use radroots_storage::atomic::{ 4 AtomicCommit, AtomicCommitDigest, AtomicCommitDisposition, AtomicCommitId, AtomicStorage, 5 AtomicWorkflow, CommitIngested, 6 }; 7 8 fn event(content: &str) -> SignedEvent { 9 signed_event_with(content, false, 1_800_000_100, 0, vec![]) 10 } 11 12 fn generation() -> SourceGeneration { 13 SourceGeneration::new([77; 32]).unwrap() 14 } 15 16 fn atomic_request(event: SignedEvent, id: u8) -> AtomicCommit { 17 AtomicCommit::new( 18 AtomicCommitId::new([id; 16]).unwrap(), 19 AtomicCommitDigest::new([id; 32]), 20 100, 21 AtomicWorkflow::Ingested(Box::new(CommitIngested::new( 22 EventAdmission::raw(observed(event, 100, None)), 23 None, 24 ))), 25 ) 26 .unwrap() 27 } 28 29 #[tokio::test] 30 async fn epoch_tracks_semantic_changes_without_duplicate_or_provenance_churn() { 31 let storage = store(generation()).await; 32 assert_eq!( 33 storage.source_token().await.unwrap(), 34 EventSourceToken::new(generation(), 0) 35 ); 36 let event = event(r#"{"name":"Farm"}"#); 37 let receipt = storage 38 .admit(EventAdmission::raw(observed(event.clone(), 10, None))) 39 .await 40 .unwrap(); 41 assert_eq!(storage.source_token().await.unwrap().epoch(), 1); 42 for at in [10, 20] { 43 assert_eq!( 44 storage 45 .admit(EventAdmission::raw(observed(event.clone(), at, None))) 46 .await 47 .unwrap() 48 .disposition(), 49 AdmissionDisposition::Duplicate 50 ); 51 assert_eq!(storage.source_token().await.unwrap().epoch(), 1); 52 } 53 let advanced = storage 54 .admit( 55 EventAdmission::verified(observed(event.clone(), 30, None), verified(&event)).unwrap(), 56 ) 57 .await 58 .unwrap(); 59 assert_eq!(advanced.position(), receipt.position()); 60 assert_eq!(storage.source_token().await.unwrap().epoch(), 2); 61 storage 62 .admit(EventAdmission::visible(observed(event.clone(), 40, None), visible(&event)).unwrap()) 63 .await 64 .unwrap(); 65 assert_eq!(storage.source_token().await.unwrap().epoch(), 3); 66 storage 67 .admit(EventAdmission::visible(observed(event.clone(), 50, None), visible(&event)).unwrap()) 68 .await 69 .unwrap(); 70 assert_eq!(storage.source_token().await.unwrap().epoch(), 3); 71 assert_eq!(storage.status().await.unwrap().raw_events(), 1); 72 assert_eq!( 73 storage 74 .admit(EventAdmission::raw(observed(event, 60, None))) 75 .await, 76 Err(Error::AdmissionRegression) 77 ); 78 assert_eq!(storage.source_token().await.unwrap().epoch(), 3); 79 } 80 81 #[tokio::test] 82 async fn sqlite_epoch_maximum_allows_replay_but_rolls_back_insert_and_promotion() { 83 let storage = store(generation()).await; 84 sqlx::query("UPDATE radroots_runtime_source_generations SET mutation_epoch = ?") 85 .bind(i64::MAX - 1) 86 .execute(&storage.pool) 87 .await 88 .unwrap(); 89 let original = event(r#"{"name":"Original"}"#); 90 storage 91 .admit(EventAdmission::raw(observed(original.clone(), 10, None))) 92 .await 93 .unwrap(); 94 let maximum = EventSourceToken::new(generation(), i64::MAX as u64); 95 assert_eq!(storage.source_token().await.unwrap(), maximum); 96 storage 97 .admit(EventAdmission::raw(observed(original.clone(), 20, None))) 98 .await 99 .unwrap(); 100 let before_provenance = storage 101 .query_provenance(*original.id(), EventQueryBounds::first(10).unwrap()) 102 .await 103 .unwrap(); 104 assert_eq!( 105 storage 106 .admit( 107 EventAdmission::visible(observed(original.clone(), 30, None), visible(&original)) 108 .unwrap() 109 ) 110 .await, 111 Err(Error::EventMutationOverflow) 112 ); 113 assert_eq!( 114 storage 115 .admit(EventAdmission::raw(observed( 116 event(r#"{"name":"New"}"#), 117 40, 118 None 119 ))) 120 .await, 121 Err(Error::EventMutationOverflow) 122 ); 123 assert_eq!(storage.source_token().await.unwrap(), maximum); 124 let sequence: i64 = 125 sqlx::query_scalar("SELECT sequence_head FROM radroots_runtime_source_generations") 126 .fetch_one(&storage.pool) 127 .await 128 .unwrap(); 129 assert_eq!(sequence, 1); 130 assert_eq!( 131 storage 132 .query_provenance(*original.id(), EventQueryBounds::first(10).unwrap()) 133 .await 134 .unwrap(), 135 before_provenance 136 ); 137 let status = storage.status().await.unwrap(); 138 assert_eq!(status.raw_events(), 1); 139 assert_eq!(status.verified_events(), 0); 140 let error = Error::EventMutationOverflow; 141 assert_eq!(error.to_string(), "storage event mutation epoch overflowed"); 142 } 143 144 #[tokio::test] 145 async fn actual_sql_writer_and_same_value_updates_obey_the_epoch_trigger() { 146 let storage = store(generation()).await; 147 let event = event(r#"{"name":"Farm"}"#); 148 storage 149 .admit(EventAdmission::raw(observed(event, 10, None))) 150 .await 151 .unwrap(); 152 sqlx::query("UPDATE radroots_runtime_events SET admission_stage = 'verified'") 153 .execute(&storage.pool) 154 .await 155 .unwrap(); 156 assert_eq!(storage.source_token().await.unwrap().epoch(), 2); 157 sqlx::query("UPDATE radroots_runtime_events SET admission_stage = 'visible', admitted_contract_id = 'radroots.profile.metadata.v1', admitted_registry_version = 7").execute(&storage.pool).await.unwrap(); 158 assert_eq!(storage.source_token().await.unwrap().epoch(), 3); 159 sqlx::query("UPDATE radroots_runtime_events SET admission_stage = admission_stage, admitted_contract_id = admitted_contract_id, admitted_registry_version = admitted_registry_version, updated_at_unix_ms = 20").execute(&storage.pool).await.unwrap(); 160 assert_eq!(storage.source_token().await.unwrap().epoch(), 3); 161 assert!( 162 sqlx::query("UPDATE radroots_runtime_source_generations SET mutation_epoch = 1") 163 .execute(&storage.pool) 164 .await 165 .is_err() 166 ); 167 assert!( 168 sqlx::query("DELETE FROM radroots_runtime_events") 169 .execute(&storage.pool) 170 .await 171 .is_err() 172 ); 173 assert_eq!(storage.source_token().await.unwrap().epoch(), 3); 174 } 175 176 #[tokio::test] 177 async fn dropped_transaction_rolls_back_event_sequence_and_epoch_together() { 178 let storage = store(generation()).await; 179 let mut transaction = storage.pool.begin_with("BEGIN IMMEDIATE").await.unwrap(); 180 storage 181 .admit_transaction( 182 &mut transaction, 183 EventAdmission::raw(observed(event("{}"), 10, None)), 184 ) 185 .await 186 .unwrap(); 187 let epoch: i64 = 188 sqlx::query_scalar("SELECT mutation_epoch FROM radroots_runtime_source_generations") 189 .fetch_one(&mut *transaction) 190 .await 191 .unwrap(); 192 assert_eq!(epoch, 1); 193 drop(transaction); 194 assert_eq!(storage.source_token().await.unwrap().epoch(), 0); 195 assert_eq!(storage.status().await.unwrap().raw_events(), 0); 196 let sequence: i64 = 197 sqlx::query_scalar("SELECT sequence_head FROM radroots_runtime_source_generations") 198 .fetch_one(&storage.pool) 199 .await 200 .unwrap(); 201 assert_eq!(sequence, 0); 202 } 203 204 #[tokio::test] 205 async fn lost_atomic_receipt_replay_does_not_advance_the_committed_epoch() { 206 let storage = store(generation()).await; 207 let request = atomic_request(event("{}"), 1); 208 let commit_id = request.commit_id(); 209 drop(storage.commit(request.clone()).await.unwrap()); 210 let token = storage.source_token().await.unwrap(); 211 assert_eq!(token.epoch(), 1); 212 assert!(storage.receipt(commit_id).await.unwrap().is_some()); 213 assert_eq!( 214 storage.commit(request).await.unwrap().disposition(), 215 AtomicCommitDisposition::Replay 216 ); 217 assert_eq!(storage.source_token().await.unwrap(), token); 218 } 219 220 #[tokio::test] 221 async fn failure_after_event_write_rolls_back_epoch_and_atomic_receipt() { 222 let storage = store(generation()).await; 223 sqlx::raw_sql("CREATE TEMP TRIGGER test_receipt_fault BEFORE INSERT ON radroots_runtime_atomic_commits BEGIN SELECT RAISE(ABORT, 'injected receipt failure'); END;") 224 .execute(&storage.pool).await.unwrap(); 225 let request = atomic_request(event("{}"), 2); 226 let id = request.commit_id(); 227 assert!(storage.commit(request.clone()).await.is_err()); 228 assert_eq!(storage.source_token().await.unwrap().epoch(), 0); 229 assert_eq!(storage.status().await.unwrap().raw_events(), 0); 230 assert_eq!(storage.receipt(id).await.unwrap(), None); 231 sqlx::query("DROP TRIGGER test_receipt_fault") 232 .execute(&storage.pool) 233 .await 234 .unwrap(); 235 storage.commit(request).await.unwrap(); 236 assert_eq!(storage.source_token().await.unwrap().epoch(), 1); 237 } 238 239 #[tokio::test] 240 async fn token_read_never_decodes_event_history_and_refuses_retired_sources() { 241 let storage = store(generation()).await; 242 storage 243 .admit(EventAdmission::raw(observed(event("{}"), 10, None))) 244 .await 245 .unwrap(); 246 storage.work.take(); 247 sqlx::query("DROP TRIGGER radroots_runtime_events_raw_update_guard") 248 .execute(&storage.pool) 249 .await 250 .unwrap(); 251 sqlx::query("UPDATE radroots_runtime_events SET signed_event = X'7b'") 252 .execute(&storage.pool) 253 .await 254 .unwrap(); 255 assert_eq!(storage.source_token().await.unwrap().epoch(), 1); 256 let counts = storage.work.take(); 257 assert_eq!(counts.event_rows_returned, 0); 258 assert_eq!(counts.codec_inputs, 0); 259 assert!( 260 storage 261 .query_raw(EventQuery::all(EventQueryBounds::first(1).unwrap())) 262 .await 263 .is_err() 264 ); 265 sqlx::query( 266 "UPDATE radroots_runtime_source_generations SET state = 'retired', retired_at_unix_ms = 20", 267 ) 268 .execute(&storage.pool) 269 .await 270 .unwrap(); 271 assert_eq!( 272 storage.source_token().await, 273 Err(Error::SourceGenerationChanged) 274 ); 275 } 276 277 #[tokio::test] 278 async fn forward_migration_bootstraps_retained_and_empty_sources_without_decoding_history() { 279 use crate::migration::runtime::{MIGRATIONS, migration_sql}; 280 use sqlx::sqlite::SqlitePoolOptions; 281 for retained in [false, true] { 282 let pool = SqlitePoolOptions::new() 283 .max_connections(1) 284 .connect("sqlite::memory:") 285 .await 286 .unwrap(); 287 for migration in &MIGRATIONS[..17] { 288 sqlx::raw_sql(migration_sql(migration.version()).unwrap()) 289 .execute(&pool) 290 .await 291 .unwrap(); 292 } 293 sqlx::query("INSERT INTO radroots_runtime_source_generations (generation, sequence_head, state, created_at_unix_ms) VALUES (?, 0, 'active', 1)").bind(generation().as_bytes().as_slice()).execute(&pool).await.unwrap(); 294 if retained { 295 let event = event("{}"); 296 sqlx::query("UPDATE radroots_runtime_source_generations SET sequence_head = 1") 297 .execute(&pool) 298 .await 299 .unwrap(); 300 sqlx::query("INSERT INTO radroots_runtime_events (source_generation, source_sequence, event_id, admission_stage, signed_event, admitted_at_unix_ms, updated_at_unix_ms) VALUES (?, 1, ?, 'raw', X'7b', 10, 10)") 301 .bind(generation().as_bytes().as_slice()).bind(event.id().as_bytes().as_slice()).execute(&pool).await.unwrap(); 302 } 303 let adapter = SqliteStorage::new(pool.clone(), generation(), EventStoreMode::ReadWrite); 304 assert_eq!(adapter.source_token().await, Err(Error::BackendUnavailable)); 305 sqlx::raw_sql(migration_sql(18).unwrap()) 306 .execute(&pool) 307 .await 308 .unwrap(); 309 assert_eq!( 310 adapter.source_token().await.unwrap().epoch(), 311 u64::from(retained) 312 ); 313 let reopened = SqliteStorage::new(pool, generation(), EventStoreMode::ReadOnly); 314 assert_eq!( 315 reopened.source_token().await.unwrap(), 316 adapter.source_token().await.unwrap() 317 ); 318 if retained { 319 assert!( 320 reopened 321 .query_raw(EventQuery::all(EventQueryBounds::first(1).unwrap())) 322 .await 323 .is_err() 324 ); 325 } 326 } 327 }