receipt_installation_refusal.rs (10673B)
1 use super::*; 2 use sqlx::Row; 3 4 async fn message_row(database: &mut SqliteConnection) -> Vec<Vec<u8>> { 5 let row = sqlx::query( 6 "SELECT message_id,thread_id,plan_digest,transaction_id,protected FROM chat_messages", 7 ) 8 .fetch_one(database) 9 .await 10 .unwrap(); 11 (0..5).map(|index| row.try_get(index).unwrap()).collect() 12 } 13 async fn work_row(database: &mut SqliteConnection) -> Vec<Vec<u8>> { 14 let row=sqlx::query("SELECT recipient,installation_transaction,capture_transaction,event_id,evidence_digest,transaction_id,protected FROM chat_publication_work").fetch_one(database).await.unwrap(); 15 (0..7).map(|index| row.try_get(index).unwrap()).collect() 16 } 17 18 #[tokio::test] 19 async fn protected_message_and_work_projection_corruption_is_refused_without_repair() { 20 let fixture = Fixture::new(); 21 let (store, input, proof, binding) = fixture.create().await; 22 let (prepared, digest, recipients) = 23 prepare(&fixture, &store, &binding, &proof, 225, false).await; 24 let attempt = claim( 25 store 26 .claim_attempt( 27 selection(&binding, &prepared, digest, recipients[0]), 28 copy(&proof), 29 ) 30 .await 31 .unwrap(), 32 ); 33 capture(&store, &input, &proof, &attempt).await; 34 installed( 35 store 36 .install_transition_and_outbox( 37 request_install(&binding, &prepared, digest), 38 copy(&proof), 39 ) 40 .await 41 .unwrap(), 42 ); 43 let mut database = fixture.database().await; 44 sqlx::query("PRAGMA foreign_keys=OFF") 45 .execute(&mut database) 46 .await 47 .unwrap(); 48 sqlx::query("PRAGMA ignore_check_constraints=ON") 49 .execute(&mut database) 50 .await 51 .unwrap(); 52 let original = message_row(&mut database).await; 53 for statement in [ 54 "UPDATE chat_messages SET message_id=zeroblob(32)", 55 "UPDATE chat_messages SET thread_id=zeroblob(32)", 56 "UPDATE chat_messages SET plan_digest=zeroblob(32)", 57 "UPDATE chat_messages SET transaction_id=zeroblob(32)", 58 "UPDATE chat_messages SET protected=zeroblob(0)", 59 "UPDATE chat_messages SET protected=zeroblob(262145)", 60 "UPDATE chat_messages SET protected=zeroblob(262144)", 61 "UPDATE chat_messages SET message_id=zeroblob(31)", 62 "UPDATE chat_messages SET thread_id=zeroblob(31)", 63 "UPDATE chat_messages SET plan_digest=zeroblob(31)", 64 "UPDATE chat_messages SET transaction_id=zeroblob(31)", 65 ] { 66 sqlx::query(statement).execute(&mut database).await.unwrap(); 67 let corrupt = message_row(&mut database).await; 68 assert!( 69 store 70 .operation_snapshot( 71 binding.clone(), 72 prepared.identity().operation_id(), 73 None, 74 copy(&proof) 75 ) 76 .await 77 .is_err(), 78 "{statement}" 79 ); 80 assert_eq!(message_row(&mut database).await, corrupt); 81 sqlx::query("UPDATE chat_messages SET message_id=?,thread_id=?,plan_digest=?,transaction_id=?,protected=?") 82 .bind(&original[0]).bind(&original[1]).bind(&original[2]).bind(&original[3]).bind(&original[4]).execute(&mut database).await.unwrap(); 83 } 84 let original = work_row(&mut database).await; 85 for statement in [ 86 "UPDATE chat_publication_work SET recipient=zeroblob(32)", 87 "UPDATE chat_publication_work SET installation_transaction=zeroblob(32)", 88 "UPDATE chat_publication_work SET capture_transaction=zeroblob(32)", 89 "UPDATE chat_publication_work SET event_id=zeroblob(32)", 90 "UPDATE chat_publication_work SET evidence_digest=zeroblob(32)", 91 "UPDATE chat_publication_work SET transaction_id=zeroblob(32)", 92 "UPDATE chat_publication_work SET protected=zeroblob(0)", 93 "UPDATE chat_publication_work SET protected=zeroblob(262145)", 94 "UPDATE chat_publication_work SET protected=zeroblob(262144)", 95 "UPDATE chat_publication_work SET installation_transaction=zeroblob(31)", 96 "UPDATE chat_publication_work SET capture_transaction=zeroblob(31)", 97 "UPDATE chat_publication_work SET event_id=zeroblob(31)", 98 "UPDATE chat_publication_work SET evidence_digest=zeroblob(31)", 99 "UPDATE chat_publication_work SET transaction_id=zeroblob(31)", 100 ] { 101 sqlx::query(statement).execute(&mut database).await.unwrap(); 102 let corrupt = work_row(&mut database).await; 103 assert!( 104 store 105 .operation_snapshot( 106 binding.clone(), 107 prepared.identity().operation_id(), 108 None, 109 copy(&proof) 110 ) 111 .await 112 .is_err(), 113 "{statement}" 114 ); 115 assert_eq!(work_row(&mut database).await, corrupt); 116 sqlx::query("UPDATE chat_publication_work SET recipient=?,installation_transaction=?,capture_transaction=?,event_id=?,evidence_digest=?,transaction_id=?,protected=?") 117 .bind(&original[0]).bind(&original[1]).bind(&original[2]).bind(&original[3]).bind(&original[4]).bind(&original[5]).bind(&original[6]).execute(&mut database).await.unwrap(); 118 } 119 // A retained installation cannot silently recreate its missing atomic basis. 120 sqlx::query("DELETE FROM chat_publication_work") 121 .execute(&mut database) 122 .await 123 .unwrap(); 124 assert!(matches!( 125 store 126 .install_transition_and_outbox( 127 request_install(&binding, &prepared, digest), 128 copy(&proof) 129 ) 130 .await, 131 Err(OperationError::RecoveryRequired) 132 )); 133 let count: i64 = sqlx::query_scalar("SELECT count(*) FROM chat_publication_work") 134 .fetch_one(&mut database) 135 .await 136 .unwrap(); 137 assert_eq!(count, 0); 138 sqlx::query("INSERT INTO chat_publication_work(workspace,operation_id,recipient,installation_transaction,capture_transaction,event_id,evidence_digest,transaction_id,protected) VALUES(?,?,?,?,?,?,?,?,?)") 139 .bind(binding.input().workspace_id().as_bytes().as_slice()).bind(prepared.identity().operation_id().as_bytes().as_slice()).bind(&original[0]).bind(&original[1]).bind(&original[2]).bind(&original[3]).bind(&original[4]).bind(&original[5]).bind(&original[6]).execute(&mut database).await.unwrap(); 140 for number in 0..10u8 { 141 sqlx::query("INSERT INTO chat_publication_work SELECT workspace,operation_id,?1,installation_transaction,capture_transaction,event_id,evidence_digest,transaction_id,protected FROM chat_publication_work WHERE recipient=?2") 142 .bind([0x80+number;32].as_slice()).bind(&original[0]).execute(&mut database).await.unwrap(); 143 } 144 assert!( 145 store 146 .operation_snapshot( 147 binding.clone(), 148 prepared.identity().operation_id(), 149 None, 150 copy(&proof) 151 ) 152 .await 153 .is_err() 154 ); 155 assert!( 156 store 157 .install_transition_and_outbox( 158 request_install(&binding, &prepared, digest), 159 copy(&proof) 160 ) 161 .await 162 .is_err() 163 ); 164 let count: i64 = sqlx::query_scalar("SELECT count(*) FROM chat_publication_work") 165 .fetch_one(&mut database) 166 .await 167 .unwrap(); 168 assert_eq!(count, 11); 169 sqlx::query("DELETE FROM chat_publication_work WHERE recipient!=?") 170 .bind(&original[0]) 171 .execute(&mut database) 172 .await 173 .unwrap(); 174 database.close().await.unwrap(); 175 assert!( 176 snapshot(&store, &binding, &prepared, &proof) 177 .await 178 .installed_message() 179 .is_some() 180 ); 181 store.close().await.unwrap(); 182 } 183 184 #[tokio::test] 185 async fn installation_checks_original_scope_current_grant_and_transaction_clock_without_releasing_evidence() 186 { 187 let fixture = Fixture::new(); 188 let (store, input, proof, binding) = fixture.create().await; 189 let (prepared, digest, recipients) = 190 prepare(&fixture, &store, &binding, &proof, 226, false).await; 191 let attempt = claim( 192 store 193 .claim_attempt( 194 selection(&binding, &prepared, digest, recipients[0]), 195 copy(&proof), 196 ) 197 .await 198 .unwrap(), 199 ); 200 let original = capture(&store, &input, &proof, &attempt).await; 201 let wrong = InstallationRequest::new( 202 binding.clone(), 203 prepared.identity().operation_id(), 204 CommandDigest::from_bytes([0x91; 32]), 205 digest, 206 ); 207 assert!(matches!( 208 store 209 .install_transition_and_outbox(wrong, copy(&proof)) 210 .await, 211 Err(OperationError::IdempotencyConflict) 212 )); 213 assert!(matches!( 214 store 215 .install_transition_and_outbox( 216 request_install(&binding, &prepared, [0x92; 32]), 217 copy(&proof) 218 ) 219 .await, 220 Err(OperationError::IdempotencyConflict) 221 )); 222 fixture.clock.now.store(110, Ordering::SeqCst); 223 let (arrived, resume) = fixture.clock.arm(1); 224 let owner = store.clone(); 225 let selected = request_install(&binding, &prepared, digest); 226 let secret = copy(&proof); 227 let observer = 228 tokio::spawn(async move { owner.install_transition_and_outbox(selected, secret).await }); 229 reached(arrived).await; 230 fixture.clock.now.store(105, Ordering::SeqCst); 231 resume.send(()).unwrap(); 232 assert!(matches!( 233 observer.await.unwrap(), 234 Err(OperationError::Workspace(WorkspaceError::Unavailable)) 235 )); 236 let state = snapshot(&store, &binding, &prepared, &proof).await; 237 assert!(state.installation().is_none()); 238 assert_eq!( 239 state 240 .artifacts() 241 .iter() 242 .filter_map(|value| value.obtained()) 243 .collect::<Vec<_>>(), 244 vec![original] 245 ); 246 store.revoke(input, &proof).await.unwrap(); 247 assert!( 248 store 249 .install_transition_and_outbox( 250 request_install(&binding, &prepared, digest), 251 copy(&proof) 252 ) 253 .await 254 .is_err() 255 ); 256 let mut database = fixture.database().await; 257 let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM chat_messages),(SELECT count(*) FROM chat_publication_work),(SELECT count(*) FROM artifact_evidence)").fetch_one(&mut database).await.unwrap(); 258 assert_eq!(counts, (0, 0, 1)); 259 database.close().await.unwrap(); 260 store.close().await.unwrap(); 261 }