lib

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

test_provider.rs (6593B)


      1 use super::*;
      2 use radroots_secrets::{
      3     Error,
      4     file::FileProvider,
      5     id::BackendKind,
      6     provider::{SecretCapabilities, SecretProvider},
      7     wrapping::{KeyWrapping, SecretMaterial, UnwrapRequest, WrapRequest, WrappedSecret},
      8 };
      9 use radroots_transport::BoxFuture;
     10 use std::sync::{Condvar, Mutex};
     11 use std::time::Duration;
     12 
     13 struct Gate {
     14     state: Mutex<(bool, bool, bool)>,
     15     changed: Condvar,
     16 }
     17 impl Gate {
     18     fn new() -> Self {
     19         Self {
     20             state: Mutex::new((false, false, false)),
     21             changed: Condvar::new(),
     22         }
     23     }
     24     fn arm(&self) {
     25         *self.state.lock().unwrap() = (true, false, false);
     26     }
     27     fn pause(&self) {
     28         let mut state = self.state.lock().unwrap();
     29         if !state.0 {
     30             return;
     31         }
     32         state.0 = false;
     33         state.1 = true;
     34         self.changed.notify_all();
     35         let (state, timeout) = self
     36             .changed
     37             .wait_timeout_while(state, Duration::from_secs(20), |s| !s.2)
     38             .unwrap();
     39         assert!(
     40             !timeout.timed_out() && state.2,
     41             "test must release provider"
     42         );
     43     }
     44     fn entered(&self) {
     45         let (state, timeout) = self
     46             .changed
     47             .wait_timeout_while(self.state.lock().unwrap(), Duration::from_secs(20), |s| {
     48                 !s.1
     49             })
     50             .unwrap();
     51         assert!(
     52             !timeout.timed_out() && state.1,
     53             "worker must enter actual provider IO"
     54         );
     55     }
     56     fn release(&self) {
     57         self.state.lock().unwrap().2 = true;
     58         self.changed.notify_all();
     59     }
     60 }
     61 struct Provider {
     62     inner: Arc<FileProvider>,
     63     gate: Gate,
     64 }
     65 impl SecretProvider for Provider {
     66     fn backend_kind(&self) -> BackendKind {
     67         self.inner.backend_kind()
     68     }
     69     fn capabilities(&self) -> SecretCapabilities {
     70         self.inner.capabilities()
     71     }
     72 }
     73 impl KeyWrapping for Provider {
     74     fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> {
     75         Box::pin(async move {
     76             let result = self.inner.wrap(request).await;
     77             if request.context().payload_schema().as_str()
     78                 == format!(
     79                     "radroots.seller_stock.authority.v{}",
     80                     crate::workspace::stock::schema::CURRENT
     81                 )
     82             {
     83                 self.gate.pause();
     84             }
     85             result
     86         })
     87     }
     88     fn unwrap<'a>(
     89         &'a self,
     90         request: UnwrapRequest<'a>,
     91     ) -> BoxFuture<'a, Result<SecretMaterial, Error>> {
     92         self.inner.unwrap(request)
     93     }
     94 }
     95 async fn reopen(r: &mut Rig) -> Arc<Provider> {
     96     r.store.close().await.unwrap();
     97     let provider = Arc::new(Provider {
     98         inner: r.fixture.provider.clone(),
     99         gate: Gate::new(),
    100     });
    101     r.store = NativeWorkspace::open_seller_stock(
    102         &r.path,
    103         r.input.clone(),
    104         r.fixture.crypto_with_provider(provider.clone()),
    105         r.clock.clone(),
    106     )
    107     .await
    108     .unwrap();
    109     provider
    110 }
    111 
    112 #[tokio::test]
    113 async fn current_time_and_target_are_rechecked_after_actual_provider_io() {
    114     for changed_target in [false, true] {
    115         let mut r = Rig::new().await;
    116         let provider = reopen(&mut r).await;
    117         let capture = r.capture(&r.binding, 0x31);
    118         let mut raw = SqliteConnection::connect_with(
    119             &sqlx::sqlite::SqliteConnectOptions::new()
    120                 .filename(r.path.join("stock_execution_v1.sqlite")),
    121         )
    122         .await
    123         .unwrap();
    124         provider.gate.arm();
    125         let mut future =
    126             Box::pin(
    127                 r.store
    128                     .issue_stock_consent(r.binding.clone(), r.minimum, &capture, &r.proof),
    129             );
    130         assert!(futures::poll!(future.as_mut()).is_pending());
    131         provider.gate.entered();
    132         if changed_target {
    133             // This write succeeds while the real wrapping provider is paused:
    134             // the worker must not hold a SQL transaction across provider IO.
    135             sqlx::query(
    136                 "UPDATE stock_grants SET protected=randomblob(length(protected)) WHERE grant_id=?",
    137             )
    138             .bind(r.input.grant_id().as_bytes().as_slice())
    139             .execute(&mut raw)
    140             .await
    141             .unwrap();
    142         } else {
    143             r.clock.0.store(151, Ordering::SeqCst);
    144         }
    145         provider.gate.release();
    146         let result = future.await;
    147         if changed_target {
    148             assert!(result.is_err());
    149         } else {
    150             assert_eq!(result, Err(OperationError::DeadlineExceeded));
    151         }
    152         let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_operations")
    153             .fetch_one(&mut raw)
    154             .await
    155             .unwrap();
    156         assert_eq!(count, 0);
    157         raw.close().await.unwrap();
    158         r.store.close().await.unwrap();
    159     }
    160 }
    161 
    162 #[tokio::test]
    163 async fn cancelled_issuance_observer_cannot_release_owner_before_drain_and_original_recovery() {
    164     let mut r = Rig::new().await;
    165     let provider = reopen(&mut r).await;
    166     let capture = r.capture(&r.binding, 0x31);
    167     provider.gate.arm();
    168     let mut future =
    169         Box::pin(
    170             r.store
    171                 .issue_stock_consent(r.binding.clone(), r.minimum, &capture, &r.proof),
    172         );
    173     assert!(futures::poll!(future.as_mut()).is_pending());
    174     provider.gate.entered();
    175     drop(future);
    176     assert!(matches!(
    177         NativeWorkspace::open_seller_stock(
    178             &r.path,
    179             r.input.clone(),
    180             r.fixture.crypto(),
    181             r.clock.clone()
    182         )
    183         .await,
    184         Err(WorkspaceError::WriterActive)
    185     ));
    186     provider.gate.release();
    187     r.store.close().await.unwrap();
    188     let store = NativeWorkspace::open_seller_stock(
    189         &r.path,
    190         r.input.clone(),
    191         r.fixture.crypto(),
    192         r.clock.clone(),
    193     )
    194     .await
    195     .unwrap();
    196     let receipt = store
    197         .stock_consent(
    198             r.binding.clone(),
    199             r.minimum,
    200             capture.command().context().operation_id(),
    201             r.input.grant_id(),
    202             &r.proof,
    203         )
    204         .await
    205         .unwrap()
    206         .unwrap();
    207     assert_eq!(
    208         receipt.control_operation_id(),
    209         capture.control_operation_id()
    210     );
    211     assert_eq!(receipt.transaction_id(), capture.transaction_id());
    212     assert_eq!(
    213         committed(
    214             store
    215                 .issue_stock_consent(r.binding.clone(), receipt.checkpoint(), &capture, &r.proof)
    216                 .await
    217                 .unwrap()
    218         ),
    219         receipt
    220     );
    221     store.close().await.unwrap();
    222 }