package_boundary.rs (4842B)
1 use std::fs; 2 use std::path::PathBuf; 3 4 const README: &str = include_str!("../README.md"); 5 const JOURNAL: &str = include_str!("../src/journal.rs"); 6 7 #[test] 8 fn manifest_matches_the_release_v1_package_boundary() { 9 let manifest = fs::read_to_string(PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("Cargo.toml")) 10 .expect("storage package manifest must be readable"); 11 12 for required in [ 13 "radroots_event", 14 "radroots_protocol", 15 "radroots_trade", 16 "radroots_transport", 17 ] { 18 assert!( 19 manifest.contains(&format!("{required} = {{ workspace = true")), 20 "missing required Radroots dependency {required}" 21 ); 22 } 23 24 for forbidden in ["sqlx", "rusqlite", "reqwest", "nostr-sdk"] { 25 assert!( 26 !manifest.contains(forbidden), 27 "storage SPI must not depend on {forbidden}" 28 ); 29 } 30 31 for feature in [ 32 "default = [\"memory\", \"serde\"]", 33 "memory = []", 34 "serde = [", 35 ] { 36 assert!(manifest.contains(feature), "missing feature law: {feature}"); 37 } 38 for forbidden_feature in ["sqlite =", "tokio =", "nostr =", "runtime ="] { 39 assert!( 40 !manifest.contains(forbidden_feature), 41 "storage SPI declares forbidden feature {forbidden_feature}" 42 ); 43 } 44 } 45 46 #[test] 47 fn release_v1_public_module_skeleton_is_declared() { 48 let root = include_str!("../src/lib.rs"); 49 for module in [ 50 "atomic", 51 "backup", 52 "event", 53 "journal", 54 "memory", 55 "outbox", 56 "private_artifact", 57 "projection", 58 "status", 59 ] { 60 assert!( 61 root.contains(&format!("pub mod {module};")), 62 "missing public module {module}" 63 ); 64 } 65 } 66 67 #[test] 68 fn root_exports_are_exact_and_implementation_types_do_not_leak() { 69 let root = include_str!("../src/lib.rs"); 70 for required in [ 71 "pub trait Storage:", 72 "pub use backup::StorageReliability as BackupSource;", 73 "pub use error::Error;", 74 "pub use event::EventStore;", 75 "pub use journal::Journal;", 76 "pub use outbox::Outbox;", 77 "pub use projection::ProjectionStore;", 78 "pub use status::StorageStatus;", 79 ] { 80 assert!(root.contains(required), "missing root contract: {required}"); 81 } 82 for forbidden in [ 83 "pub use atomic::AtomicStorage", 84 "pub use backup::StorageReliability;", 85 "pub use private_artifact::PrivateArtifactStore", 86 ] { 87 assert!( 88 !root.contains(forbidden), 89 "forbidden root export: {forbidden}" 90 ); 91 } 92 93 let source_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src"); 94 let mut source = String::new(); 95 fn collect(source_root: &std::path::Path, source: &mut String) { 96 for entry in fs::read_dir(source_root).expect("source directory") { 97 let path = entry.expect("source entry").path(); 98 if path.is_dir() { 99 collect(&path, source); 100 } else if path.extension().and_then(|value| value.to_str()) == Some("rs") { 101 source.push_str(&fs::read_to_string(path).expect("source file")); 102 } 103 } 104 } 105 collect(&source_root, &mut source); 106 for forbidden in [ 107 "sqlx::", 108 "rusqlite::", 109 "nostr_sdk::", 110 "std::path::Path", 111 "tokio::runtime", 112 ] { 113 assert!( 114 !source.contains(forbidden), 115 "public storage source leaks implementation path {forbidden}" 116 ); 117 } 118 } 119 120 #[test] 121 fn idempotency_keys_validate_borrowed_input_before_bounded_allocation() { 122 for required in [ 123 "Idempotency-key construction validates borrowed input before allocating its\nbounded owned representation", 124 "rejected oversized input cannot force a\nsecond attacker-sized allocation", 125 ] { 126 assert!(README.contains(required), "README is missing `{required}`"); 127 } 128 let parser = JOURNAL 129 .split_once("pub fn parse(value: impl AsRef<str>)") 130 .expect("borrowed idempotency parser") 131 .1 132 .split_once("pub fn as_str") 133 .expect("idempotency accessor") 134 .0; 135 assert!(parser.contains("let value = value.as_ref();")); 136 assert_eq!(parser.matches("to_owned()").count(), 1); 137 let validation = parser 138 .find("value.len() > IDEMPOTENCY_KEY_MAX_BYTES") 139 .expect("pre-allocation byte bound"); 140 let allocation = parser 141 .find("Self(value.to_owned())") 142 .expect("bounded owned representation"); 143 assert!(validation < allocation); 144 for forbidden in ["impl Into<String>", "let value = value.into()"] { 145 assert!( 146 !parser.contains(forbidden), 147 "idempotency parser contains pre-validation allocation `{forbidden}`" 148 ); 149 } 150 }