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 }