lib

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

open_lifecycle.rs (4079B)


      1 use std::time::Duration;
      2 
      3 use radroots_storage::{EventStore, event::SourceGeneration, status::EventStoreMode};
      4 use radroots_storage_sqlite::{Error, OpenMode, OpenOptions, Paths, SqliteStorage};
      5 
      6 fn generation(byte: u8) -> SourceGeneration {
      7     SourceGeneration::new([byte; 32]).expect("source generation")
      8 }
      9 
     10 #[tokio::test]
     11 async fn public_open_creates_both_databases_and_reuses_the_durable_generation() {
     12     let directory = tempfile::tempdir().expect("temporary directory");
     13     let paths = Paths::from_directory(directory.path()).expect("owned paths");
     14     let expected = generation(31);
     15     let store = SqliteStorage::open(
     16         OpenOptions::new(paths.clone(), OpenMode::Create)
     17             .with_busy_timeout(Duration::from_millis(250))
     18             .expect("busy timeout")
     19             .with_source_generation(expected, 1_000)
     20             .expect("source generation"),
     21     )
     22     .await
     23     .expect("create storage");
     24     assert!(paths.runtime().is_file());
     25     assert!(paths.private().is_file());
     26     let status = EventStore::status(&store).await.expect("event status");
     27     let token = store.source_token().await.expect("source token");
     28     assert_eq!(token.generation(), expected);
     29     assert_eq!(token.epoch(), 0);
     30     assert_eq!(status.generation(), expected);
     31     assert_eq!(status.mode(), EventStoreMode::ReadWrite);
     32 
     33     let reader = SqliteStorage::open(OpenOptions::new(paths.clone(), OpenMode::ReadOnly))
     34         .await
     35         .expect("concurrent reader");
     36     let reader_status = EventStore::status(&reader).await.expect("reader status");
     37     assert_eq!(
     38         reader.source_token().await.expect("reader source token"),
     39         token
     40     );
     41     assert_eq!(reader_status.generation(), expected);
     42     assert_eq!(reader_status.mode(), EventStoreMode::ReadOnly);
     43     drop(reader);
     44 
     45     assert!(matches!(
     46         SqliteStorage::open(OpenOptions::new(paths.clone(), OpenMode::ReadWriteExisting,)).await,
     47         Err(Error::WriterAlreadyActive { .. })
     48     ));
     49     let cloned = store.clone();
     50     drop(store);
     51     assert!(matches!(
     52         SqliteStorage::open(OpenOptions::new(paths.clone(), OpenMode::ReadWriteExisting,)).await,
     53         Err(Error::WriterAlreadyActive { .. })
     54     ));
     55     drop(cloned);
     56 
     57     let reopened = SqliteStorage::open(OpenOptions::new(paths, OpenMode::ReadWriteExisting))
     58         .await
     59         .expect("reopen after guard release");
     60     assert_eq!(
     61         reopened
     62             .source_token()
     63             .await
     64             .expect("reopened source token"),
     65         token
     66     );
     67     assert_eq!(
     68         EventStore::status(&reopened)
     69             .await
     70             .expect("reopened status")
     71             .generation(),
     72         expected
     73     );
     74 }
     75 
     76 #[tokio::test]
     77 async fn fresh_store_requires_explicit_generation_and_exact_expectations() {
     78     let directory = tempfile::tempdir().expect("temporary directory");
     79     let paths = Paths::from_directory(directory.path()).expect("owned paths");
     80     assert!(matches!(
     81         SqliteStorage::open(OpenOptions::new(paths.clone(), OpenMode::Create)).await,
     82         Err(Error::SourceGenerationRequired)
     83     ));
     84     assert!(!paths.runtime().exists());
     85     assert!(!paths.private().exists());
     86 
     87     let expected = generation(41);
     88     let store = SqliteStorage::open(
     89         OpenOptions::new(paths.clone(), OpenMode::Create)
     90             .with_source_generation(expected, 2_000)
     91             .expect("source generation"),
     92     )
     93     .await
     94     .expect("complete fresh store");
     95     drop(store);
     96 
     97     let exact_reopen = SqliteStorage::open(
     98         OpenOptions::new(paths.clone(), OpenMode::ReadWriteExisting)
     99             .with_source_generation(expected, 2_000)
    100             .expect("exact expectation"),
    101     )
    102     .await
    103     .expect("reopen with exact generation expectation");
    104     drop(exact_reopen);
    105 
    106     assert!(matches!(
    107         SqliteStorage::open(
    108             OpenOptions::new(paths, OpenMode::ReadWriteExisting)
    109                 .with_source_generation(generation(42), 2_000)
    110                 .expect("wrong expectation"),
    111         )
    112         .await,
    113         Err(Error::SourceGenerationMismatch)
    114     ));
    115 }