lib

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

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 }