lib

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

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 }