receipt_recovery.rs (7500B)
1 use super::*; 2 use radroots_storage::command::EvidenceCaptureOutcome; 3 4 struct Issued { 5 fixture: Fixture, 6 store: Arc<NativeWorkspace>, 7 input: AttachmentInput, 8 proof: AttachmentProof, 9 binding: WorkspaceBinding, 10 attempt: SigningAttempt, 11 evidence: ArtifactEvidence, 12 } 13 impl Issued { 14 async fn new(id: u8, large: bool) -> Self { 15 let fixture = Fixture::new(); 16 let (store, input, proof, binding) = fixture.create().await; 17 let (prepared, digest, recipients) = 18 prepare(&fixture, &store, &binding, &proof, id, large).await; 19 let attempt = claim( 20 store 21 .claim_attempt( 22 selection(&binding, &prepared, digest, recipients[0]), 23 copy(&proof), 24 ) 25 .await 26 .unwrap(), 27 ); 28 let original = obtain(&attempt, true).await; 29 let raw = format!(" \n{}\t", original.raw_json()); 30 let evidence = 31 ArtifactEvidence::verify(&attempt, &raw, original.observed_at_unix_ms()).unwrap(); 32 Self { 33 fixture, 34 store, 35 input, 36 proof, 37 binding, 38 attempt, 39 evidence, 40 } 41 } 42 async fn assert_same_writer(&self) { 43 assert!(matches!( 44 NativeWorkspace::open_existing( 45 &self.fixture.path, 46 self.input.clone(), 47 self.fixture.crypto(), 48 self.fixture.clock.clone() 49 ) 50 .await, 51 Err(WorkspaceError::WriterActive) 52 )); 53 } 54 } 55 fn confirmed(outcome: EvidenceCaptureOutcome) -> radroots_storage::command::EvidenceReceipt { 56 match outcome { 57 EvidenceCaptureOutcome::Committed(receipt) => receipt, 58 _ => panic!("actual original capture must confirm"), 59 } 60 } 61 62 #[tokio::test] 63 async fn original_capture_recovery_retries_known_rollback_without_reissuing_and_preserves_exact_bytes() 64 { 65 let issued = Issued::new(101, false).await; 66 let original = issued.evidence.raw_json().to_owned(); 67 let mut database = issued.fixture.database().await; 68 sqlx::query("CREATE TRIGGER capture_insert_fault BEFORE INSERT ON artifact_evidence BEGIN SELECT RAISE(ABORT,'synthetic capture fault'); END").execute(&mut database).await.unwrap(); 69 assert!( 70 issued 71 .store 72 .capture_evidence(issued.input.clone(), &issued.proof, &issued.evidence) 73 .await 74 .is_err() 75 ); 76 assert!( 77 issued 78 .store 79 .reconcile_unknown(issued.input.clone(), &issued.proof, &issued.evidence) 80 .await 81 .is_err() 82 ); 83 issued.assert_same_writer().await; 84 sqlx::query("DROP TRIGGER capture_insert_fault") 85 .execute(&mut database) 86 .await 87 .unwrap(); 88 let first = confirmed( 89 issued 90 .store 91 .reconcile_unknown(issued.input.clone(), &issued.proof, &issued.evidence) 92 .await 93 .unwrap(), 94 ); 95 assert_eq!(first.observed_at_unix_ms(), None); 96 let replay = confirmed( 97 issued 98 .store 99 .reconcile_unknown(issued.input.clone(), &issued.proof, &issued.evidence) 100 .await 101 .unwrap(), 102 ); 103 assert_eq!(first, replay); 104 let retained = issued 105 .store 106 .obtained_evidence( 107 selection( 108 &issued.binding, 109 issued.attempt.bound_plan().prepared(), 110 *issued.attempt.bound_plan().plan().digest(), 111 issued.attempt.seal().unwrap().recipient(), 112 ), 113 copy(&issued.proof), 114 ) 115 .await 116 .unwrap() 117 .unwrap(); 118 assert_eq!(retained.evidence().raw_json(), original); 119 assert_eq!(retained.evidence().observed_at_unix_ms(), None); 120 database.close().await.unwrap(); 121 issued.store.close().await.unwrap(); 122 } 123 124 #[tokio::test] 125 async fn unknown_capture_recovery_preserves_writer_during_refused_preflight_and_resumes_exact_original() 126 { 127 let issued = Issued::new(102, true).await; 128 let original = issued.evidence.raw_json().to_owned(); 129 let mut database = issued.fixture.database().await; 130 sqlx::raw_sql("CREATE TABLE capture_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER capture_commit_fault_trigger AFTER INSERT ON artifact_evidence BEGIN INSERT INTO capture_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); 131 assert!(matches!( 132 issued 133 .store 134 .capture_evidence(issued.input.clone(), &issued.proof, &issued.evidence) 135 .await, 136 Ok(EvidenceCaptureOutcome::Unknown(_)) 137 )); 138 assert!( 139 issued 140 .store 141 .operation_snapshot( 142 issued.binding.clone(), 143 issued.evidence.operation_id(), 144 None, 145 copy(&issued.proof) 146 ) 147 .await 148 .is_err() 149 ); 150 // The extra fault objects are deliberately outside the exact real schema. 151 // Recovery closes the old connection but must retain namespace authority. 152 assert!( 153 issued 154 .store 155 .reconcile_unknown(issued.input.clone(), &issued.proof, &issued.evidence) 156 .await 157 .is_err() 158 ); 159 issued.assert_same_writer().await; 160 let wrong = AttachmentProof::from_protected_input(&[0; 32]).unwrap(); 161 assert_eq!( 162 issued 163 .store 164 .reconcile_unknown(issued.input.clone(), &wrong, &issued.evidence) 165 .await 166 .unwrap_err() 167 .code(), 168 "unauthorized" 169 ); 170 sqlx::raw_sql("DROP TRIGGER capture_commit_fault_trigger; DROP TABLE capture_commit_fault") 171 .execute(&mut database) 172 .await 173 .unwrap(); 174 issued.fixture.clock.now.store(0, Ordering::SeqCst); 175 let captured = confirmed( 176 issued 177 .store 178 .reconcile_unknown(issued.input.clone(), &issued.proof, &issued.evidence) 179 .await 180 .unwrap(), 181 ); 182 assert_eq!(captured.observed_at_unix_ms(), None); 183 assert_eq!(captured.digest(), issued.evidence.digest()); 184 issued.fixture.clock.now.store(160, Ordering::SeqCst); 185 let snapshot = issued 186 .store 187 .operation_snapshot( 188 issued.binding.clone(), 189 issued.evidence.operation_id(), 190 Some(issued.evidence.command_digest()), 191 copy(&issued.proof), 192 ) 193 .await 194 .unwrap() 195 .unwrap(); 196 assert_eq!( 197 snapshot.prepared().issuance_window(), 198 issued.attempt.bound_plan().prepared().issuance_window() 199 ); 200 assert!(snapshot.installation().is_none()); 201 assert!(snapshot.delivery_attempts().is_empty()); 202 let retained = issued 203 .store 204 .obtained_evidence( 205 selection( 206 &issued.binding, 207 issued.attempt.bound_plan().prepared(), 208 *issued.attempt.bound_plan().plan().digest(), 209 issued.attempt.seal().unwrap().recipient(), 210 ), 211 copy(&issued.proof), 212 ) 213 .await 214 .unwrap() 215 .unwrap(); 216 assert_eq!(retained.evidence().raw_json(), original); 217 assert_eq!(retained.evidence().observed_at_unix_ms(), None); 218 issued.assert_same_writer().await; 219 database.close().await.unwrap(); 220 issued.store.close().await.unwrap(); 221 }