lib

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

mutation_tests.rs (12441B)


      1 use super::tests::{observed, signed_event_with, store, verified, visible};
      2 use super::*;
      3 use radroots_storage::atomic::{
      4     AtomicCommit, AtomicCommitDigest, AtomicCommitDisposition, AtomicCommitId, AtomicStorage,
      5     AtomicWorkflow, CommitIngested,
      6 };
      7 
      8 fn event(content: &str) -> SignedEvent {
      9     signed_event_with(content, false, 1_800_000_100, 0, vec![])
     10 }
     11 
     12 fn generation() -> SourceGeneration {
     13     SourceGeneration::new([77; 32]).unwrap()
     14 }
     15 
     16 fn atomic_request(event: SignedEvent, id: u8) -> AtomicCommit {
     17     AtomicCommit::new(
     18         AtomicCommitId::new([id; 16]).unwrap(),
     19         AtomicCommitDigest::new([id; 32]),
     20         100,
     21         AtomicWorkflow::Ingested(Box::new(CommitIngested::new(
     22             EventAdmission::raw(observed(event, 100, None)),
     23             None,
     24         ))),
     25     )
     26     .unwrap()
     27 }
     28 
     29 #[tokio::test]
     30 async fn epoch_tracks_semantic_changes_without_duplicate_or_provenance_churn() {
     31     let storage = store(generation()).await;
     32     assert_eq!(
     33         storage.source_token().await.unwrap(),
     34         EventSourceToken::new(generation(), 0)
     35     );
     36     let event = event(r#"{"name":"Farm"}"#);
     37     let receipt = storage
     38         .admit(EventAdmission::raw(observed(event.clone(), 10, None)))
     39         .await
     40         .unwrap();
     41     assert_eq!(storage.source_token().await.unwrap().epoch(), 1);
     42     for at in [10, 20] {
     43         assert_eq!(
     44             storage
     45                 .admit(EventAdmission::raw(observed(event.clone(), at, None)))
     46                 .await
     47                 .unwrap()
     48                 .disposition(),
     49             AdmissionDisposition::Duplicate
     50         );
     51         assert_eq!(storage.source_token().await.unwrap().epoch(), 1);
     52     }
     53     let advanced = storage
     54         .admit(
     55             EventAdmission::verified(observed(event.clone(), 30, None), verified(&event)).unwrap(),
     56         )
     57         .await
     58         .unwrap();
     59     assert_eq!(advanced.position(), receipt.position());
     60     assert_eq!(storage.source_token().await.unwrap().epoch(), 2);
     61     storage
     62         .admit(EventAdmission::visible(observed(event.clone(), 40, None), visible(&event)).unwrap())
     63         .await
     64         .unwrap();
     65     assert_eq!(storage.source_token().await.unwrap().epoch(), 3);
     66     storage
     67         .admit(EventAdmission::visible(observed(event.clone(), 50, None), visible(&event)).unwrap())
     68         .await
     69         .unwrap();
     70     assert_eq!(storage.source_token().await.unwrap().epoch(), 3);
     71     assert_eq!(storage.status().await.unwrap().raw_events(), 1);
     72     assert_eq!(
     73         storage
     74             .admit(EventAdmission::raw(observed(event, 60, None)))
     75             .await,
     76         Err(Error::AdmissionRegression)
     77     );
     78     assert_eq!(storage.source_token().await.unwrap().epoch(), 3);
     79 }
     80 
     81 #[tokio::test]
     82 async fn sqlite_epoch_maximum_allows_replay_but_rolls_back_insert_and_promotion() {
     83     let storage = store(generation()).await;
     84     sqlx::query("UPDATE radroots_runtime_source_generations SET mutation_epoch = ?")
     85         .bind(i64::MAX - 1)
     86         .execute(&storage.pool)
     87         .await
     88         .unwrap();
     89     let original = event(r#"{"name":"Original"}"#);
     90     storage
     91         .admit(EventAdmission::raw(observed(original.clone(), 10, None)))
     92         .await
     93         .unwrap();
     94     let maximum = EventSourceToken::new(generation(), i64::MAX as u64);
     95     assert_eq!(storage.source_token().await.unwrap(), maximum);
     96     storage
     97         .admit(EventAdmission::raw(observed(original.clone(), 20, None)))
     98         .await
     99         .unwrap();
    100     let before_provenance = storage
    101         .query_provenance(*original.id(), EventQueryBounds::first(10).unwrap())
    102         .await
    103         .unwrap();
    104     assert_eq!(
    105         storage
    106             .admit(
    107                 EventAdmission::visible(observed(original.clone(), 30, None), visible(&original))
    108                     .unwrap()
    109             )
    110             .await,
    111         Err(Error::EventMutationOverflow)
    112     );
    113     assert_eq!(
    114         storage
    115             .admit(EventAdmission::raw(observed(
    116                 event(r#"{"name":"New"}"#),
    117                 40,
    118                 None
    119             )))
    120             .await,
    121         Err(Error::EventMutationOverflow)
    122     );
    123     assert_eq!(storage.source_token().await.unwrap(), maximum);
    124     let sequence: i64 =
    125         sqlx::query_scalar("SELECT sequence_head FROM radroots_runtime_source_generations")
    126             .fetch_one(&storage.pool)
    127             .await
    128             .unwrap();
    129     assert_eq!(sequence, 1);
    130     assert_eq!(
    131         storage
    132             .query_provenance(*original.id(), EventQueryBounds::first(10).unwrap())
    133             .await
    134             .unwrap(),
    135         before_provenance
    136     );
    137     let status = storage.status().await.unwrap();
    138     assert_eq!(status.raw_events(), 1);
    139     assert_eq!(status.verified_events(), 0);
    140     let error = Error::EventMutationOverflow;
    141     assert_eq!(error.to_string(), "storage event mutation epoch overflowed");
    142 }
    143 
    144 #[tokio::test]
    145 async fn actual_sql_writer_and_same_value_updates_obey_the_epoch_trigger() {
    146     let storage = store(generation()).await;
    147     let event = event(r#"{"name":"Farm"}"#);
    148     storage
    149         .admit(EventAdmission::raw(observed(event, 10, None)))
    150         .await
    151         .unwrap();
    152     sqlx::query("UPDATE radroots_runtime_events SET admission_stage = 'verified'")
    153         .execute(&storage.pool)
    154         .await
    155         .unwrap();
    156     assert_eq!(storage.source_token().await.unwrap().epoch(), 2);
    157     sqlx::query("UPDATE radroots_runtime_events SET admission_stage = 'visible', admitted_contract_id = 'radroots.profile.metadata.v1', admitted_registry_version = 7").execute(&storage.pool).await.unwrap();
    158     assert_eq!(storage.source_token().await.unwrap().epoch(), 3);
    159     sqlx::query("UPDATE radroots_runtime_events SET admission_stage = admission_stage, admitted_contract_id = admitted_contract_id, admitted_registry_version = admitted_registry_version, updated_at_unix_ms = 20").execute(&storage.pool).await.unwrap();
    160     assert_eq!(storage.source_token().await.unwrap().epoch(), 3);
    161     assert!(
    162         sqlx::query("UPDATE radroots_runtime_source_generations SET mutation_epoch = 1")
    163             .execute(&storage.pool)
    164             .await
    165             .is_err()
    166     );
    167     assert!(
    168         sqlx::query("DELETE FROM radroots_runtime_events")
    169             .execute(&storage.pool)
    170             .await
    171             .is_err()
    172     );
    173     assert_eq!(storage.source_token().await.unwrap().epoch(), 3);
    174 }
    175 
    176 #[tokio::test]
    177 async fn dropped_transaction_rolls_back_event_sequence_and_epoch_together() {
    178     let storage = store(generation()).await;
    179     let mut transaction = storage.pool.begin_with("BEGIN IMMEDIATE").await.unwrap();
    180     storage
    181         .admit_transaction(
    182             &mut transaction,
    183             EventAdmission::raw(observed(event("{}"), 10, None)),
    184         )
    185         .await
    186         .unwrap();
    187     let epoch: i64 =
    188         sqlx::query_scalar("SELECT mutation_epoch FROM radroots_runtime_source_generations")
    189             .fetch_one(&mut *transaction)
    190             .await
    191             .unwrap();
    192     assert_eq!(epoch, 1);
    193     drop(transaction);
    194     assert_eq!(storage.source_token().await.unwrap().epoch(), 0);
    195     assert_eq!(storage.status().await.unwrap().raw_events(), 0);
    196     let sequence: i64 =
    197         sqlx::query_scalar("SELECT sequence_head FROM radroots_runtime_source_generations")
    198             .fetch_one(&storage.pool)
    199             .await
    200             .unwrap();
    201     assert_eq!(sequence, 0);
    202 }
    203 
    204 #[tokio::test]
    205 async fn lost_atomic_receipt_replay_does_not_advance_the_committed_epoch() {
    206     let storage = store(generation()).await;
    207     let request = atomic_request(event("{}"), 1);
    208     let commit_id = request.commit_id();
    209     drop(storage.commit(request.clone()).await.unwrap());
    210     let token = storage.source_token().await.unwrap();
    211     assert_eq!(token.epoch(), 1);
    212     assert!(storage.receipt(commit_id).await.unwrap().is_some());
    213     assert_eq!(
    214         storage.commit(request).await.unwrap().disposition(),
    215         AtomicCommitDisposition::Replay
    216     );
    217     assert_eq!(storage.source_token().await.unwrap(), token);
    218 }
    219 
    220 #[tokio::test]
    221 async fn failure_after_event_write_rolls_back_epoch_and_atomic_receipt() {
    222     let storage = store(generation()).await;
    223     sqlx::raw_sql("CREATE TEMP TRIGGER test_receipt_fault BEFORE INSERT ON radroots_runtime_atomic_commits BEGIN SELECT RAISE(ABORT, 'injected receipt failure'); END;")
    224         .execute(&storage.pool).await.unwrap();
    225     let request = atomic_request(event("{}"), 2);
    226     let id = request.commit_id();
    227     assert!(storage.commit(request.clone()).await.is_err());
    228     assert_eq!(storage.source_token().await.unwrap().epoch(), 0);
    229     assert_eq!(storage.status().await.unwrap().raw_events(), 0);
    230     assert_eq!(storage.receipt(id).await.unwrap(), None);
    231     sqlx::query("DROP TRIGGER test_receipt_fault")
    232         .execute(&storage.pool)
    233         .await
    234         .unwrap();
    235     storage.commit(request).await.unwrap();
    236     assert_eq!(storage.source_token().await.unwrap().epoch(), 1);
    237 }
    238 
    239 #[tokio::test]
    240 async fn token_read_never_decodes_event_history_and_refuses_retired_sources() {
    241     let storage = store(generation()).await;
    242     storage
    243         .admit(EventAdmission::raw(observed(event("{}"), 10, None)))
    244         .await
    245         .unwrap();
    246     storage.work.take();
    247     sqlx::query("DROP TRIGGER radroots_runtime_events_raw_update_guard")
    248         .execute(&storage.pool)
    249         .await
    250         .unwrap();
    251     sqlx::query("UPDATE radroots_runtime_events SET signed_event = X'7b'")
    252         .execute(&storage.pool)
    253         .await
    254         .unwrap();
    255     assert_eq!(storage.source_token().await.unwrap().epoch(), 1);
    256     let counts = storage.work.take();
    257     assert_eq!(counts.event_rows_returned, 0);
    258     assert_eq!(counts.codec_inputs, 0);
    259     assert!(
    260         storage
    261             .query_raw(EventQuery::all(EventQueryBounds::first(1).unwrap()))
    262             .await
    263             .is_err()
    264     );
    265     sqlx::query(
    266         "UPDATE radroots_runtime_source_generations SET state = 'retired', retired_at_unix_ms = 20",
    267     )
    268     .execute(&storage.pool)
    269     .await
    270     .unwrap();
    271     assert_eq!(
    272         storage.source_token().await,
    273         Err(Error::SourceGenerationChanged)
    274     );
    275 }
    276 
    277 #[tokio::test]
    278 async fn forward_migration_bootstraps_retained_and_empty_sources_without_decoding_history() {
    279     use crate::migration::runtime::{MIGRATIONS, migration_sql};
    280     use sqlx::sqlite::SqlitePoolOptions;
    281     for retained in [false, true] {
    282         let pool = SqlitePoolOptions::new()
    283             .max_connections(1)
    284             .connect("sqlite::memory:")
    285             .await
    286             .unwrap();
    287         for migration in &MIGRATIONS[..17] {
    288             sqlx::raw_sql(migration_sql(migration.version()).unwrap())
    289                 .execute(&pool)
    290                 .await
    291                 .unwrap();
    292         }
    293         sqlx::query("INSERT INTO radroots_runtime_source_generations (generation, sequence_head, state, created_at_unix_ms) VALUES (?, 0, 'active', 1)").bind(generation().as_bytes().as_slice()).execute(&pool).await.unwrap();
    294         if retained {
    295             let event = event("{}");
    296             sqlx::query("UPDATE radroots_runtime_source_generations SET sequence_head = 1")
    297                 .execute(&pool)
    298                 .await
    299                 .unwrap();
    300             sqlx::query("INSERT INTO radroots_runtime_events (source_generation, source_sequence, event_id, admission_stage, signed_event, admitted_at_unix_ms, updated_at_unix_ms) VALUES (?, 1, ?, 'raw', X'7b', 10, 10)")
    301                 .bind(generation().as_bytes().as_slice()).bind(event.id().as_bytes().as_slice()).execute(&pool).await.unwrap();
    302         }
    303         let adapter = SqliteStorage::new(pool.clone(), generation(), EventStoreMode::ReadWrite);
    304         assert_eq!(adapter.source_token().await, Err(Error::BackendUnavailable));
    305         sqlx::raw_sql(migration_sql(18).unwrap())
    306             .execute(&pool)
    307             .await
    308             .unwrap();
    309         assert_eq!(
    310             adapter.source_token().await.unwrap().epoch(),
    311             u64::from(retained)
    312         );
    313         let reopened = SqliteStorage::new(pool, generation(), EventStoreMode::ReadOnly);
    314         assert_eq!(
    315             reopened.source_token().await.unwrap(),
    316             adapter.source_token().await.unwrap()
    317         );
    318         if retained {
    319             assert!(
    320                 reopened
    321                     .query_raw(EventQuery::all(EventQueryBounds::first(1).unwrap()))
    322                     .await
    323                     .is_err()
    324             );
    325         }
    326     }
    327 }