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 }