package_boundary.rs (14628B)
1 use std::collections::BTreeSet; 2 3 const MANIFEST: &str = include_str!("../Cargo.toml"); 4 const WORKSPACE: &str = include_str!("../../../Cargo.toml"); 5 const ROOT: &str = include_str!("../src/lib.rs"); 6 const README: &str = include_str!("../README.md"); 7 8 #[test] 9 fn package_has_final_identity_and_exact_dependencies() { 10 assert!(MANIFEST.contains("name = \"radroots\"")); 11 assert!(MANIFEST.contains("publish = [\"crates-io\"]")); 12 assert_eq!( 13 dependency_names(MANIFEST), 14 BTreeSet::from([ 15 "futures", 16 "radroots_core", 17 "radroots_domain", 18 "radroots_event", 19 "radroots_execution", 20 "radroots_identity", 21 "radroots_nostr", 22 "radroots_protocol", 23 "radroots_sdk", 24 "radroots_signing", 25 "radroots_storage", 26 "radroots_storage_sqlite", 27 "radroots_trade", 28 "radroots_transport", 29 "radroots_transport_nostr", 30 "radroots_transport_nostr_native", 31 "tokio", 32 ]) 33 ); 34 assert!(WORKSPACE.contains( 35 "radroots_sdk = { path = \"crates/sdk\", version = \"=0.1.0-alpha\", default-features = false }" 36 )); 37 } 38 39 #[test] 40 fn features_forward_the_exact_user_oriented_graph() { 41 for forwarding in [ 42 "default = [\"client\"]", 43 "client = [\"radroots_sdk/default\", \"radroots_storage/memory\"]", 44 "native = [\"client\", \"radroots_sdk/native\", \"dep:radroots_storage_sqlite\", \"dep:futures\", \"dep:tokio\", \"dep:radroots_nostr\", \"dep:radroots_transport_nostr\", \"dep:radroots_transport_nostr_native\"]", 45 "nostr = [\"client\", \"radroots_sdk/nostr\"]", 46 "nip46 = [\"nostr\", \"radroots_sdk/nip46\"]", 47 "radrootsd = [\"client\", \"radroots_sdk/radrootsd\"]", 48 "geonames = [\"client\", \"radroots_sdk/geonames\"]", 49 "knowledge = [\"client\", \"radroots_sdk/knowledge\"]", 50 "full = [\"native\", \"radroots_sdk/full\"]", 51 ] { 52 assert!(MANIFEST.contains(forwarding), "missing `{forwarding}`"); 53 } 54 assert!(feature_guard(MANIFEST).is_ok()); 55 } 56 57 #[test] 58 fn root_has_exact_exports_and_no_sdk_namespace() { 59 assert!(ROOT.contains("pub use client::{Client, CloseReceipt, SessionStatus, StartMode};")); 60 assert!(ROOT.contains("pub use radroots_execution::{Error, Result};")); 61 assert!(!ROOT.contains("ClientBuilder")); 62 assert!(!ROOT.contains("pub use radroots_sdk::{Client")); 63 assert!(!ROOT.contains("pub mod sdk")); 64 assert!(!ROOT.contains("pub use radroots_sdk::*")); 65 assert!(ROOT.contains("pub use radroots_domain::OperationId;")); 66 assert!( 67 ROOT.contains("pub use radroots_execution::workspace::{CommandContext, WorkspaceSession};") 68 ); 69 assert!( 70 ROOT.contains("pub use radroots_storage::workspace::{AttachmentInput, AttachmentProof};") 71 ); 72 assert!(ROOT.contains( 73 "pub use radroots_execution::{\n ArtifactObservation, BusinessInstallation, Delivery, DeliveryObservation, Issuance,\n OperationKind, OperationReceipt, OperationStatus, OperationValue, RecoveryRequirement,\n TargetObservation, WaitTermination,\n};" 74 )); 75 assert!(ROOT.contains("pub mod listings;")); 76 assert!(ROOT.contains("pub use radroots_execution::session::SessionState;")); 77 assert!( 78 ROOT.contains( 79 "pub use radroots_execution::{Admission, Code, OperationContext, RetryClass};" 80 ) 81 ); 82 assert!(ROOT.contains("pub use radroots_protocol::command::CommandError;")); 83 assert!(ROOT.contains("pub use radroots_execution::{ExecutionFailure, ExecutionResult};")); 84 assert_eq!(ROOT.matches("pub use ").count(), 11); 85 assert!(README.contains("```compile_fail\nuse radroots::sdk;\n```")); 86 } 87 88 #[test] 89 fn modules_use_deliberate_reexports_without_wildcards() { 90 let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src"); 91 for entry in std::fs::read_dir(source_root).expect("read facade source") { 92 let path = entry.expect("read facade source entry").path(); 93 if path.extension().and_then(|value| value.to_str()) != Some("rs") { 94 continue; 95 } 96 let source = std::fs::read_to_string(&path).expect("read facade module"); 97 assert!( 98 !source.contains("::*"), 99 "{} contains a wildcard reexport", 100 path.display() 101 ); 102 assert!( 103 !source.contains("pub mod sdk"), 104 "{} exposes the forbidden SDK namespace", 105 path.display() 106 ); 107 } 108 } 109 110 fn dependency_names(manifest: &str) -> BTreeSet<&str> { 111 manifest 112 .split_once("[dependencies]") 113 .expect("dependency section") 114 .1 115 .split_once("\n[") 116 .expect("section after dependencies") 117 .0 118 .lines() 119 .filter_map(|line| line.split_once(" = ").map(|(name, _)| name.trim())) 120 .collect() 121 } 122 123 fn feature_guard(manifest: &str) -> Result<(), &'static str> { 124 if manifest.len() > 65_536 { 125 return Err("manifest byte limit exceeded"); 126 } 127 let value: toml::Value = toml::from_str(manifest).map_err(|_| "invalid manifest")?; 128 let dependencies = value 129 .get("dependencies") 130 .and_then(toml::Value::as_table) 131 .ok_or("missing dependency table")?; 132 let features = value 133 .get("features") 134 .and_then(toml::Value::as_table) 135 .ok_or("missing feature table")?; 136 let features = features 137 .iter() 138 .map(|(name, values)| { 139 let values = values.as_array().ok_or("feature must be an array")?; 140 let tokens = values 141 .iter() 142 .map(toml::Value::as_str) 143 .collect::<Option<Vec<_>>>() 144 .ok_or("feature values must be strings")?; 145 Ok((name.as_str(), tokens)) 146 }) 147 .collect::<Result<std::collections::BTreeMap<_, _>, &'static str>>()?; 148 if features.contains_key("sp1") { 149 return Err("SP1 remains a separate capability"); 150 } 151 152 let policy: serde_json::Value = serde_json::from_str(include_str!( 153 "../../../contracts/architecture/decisions/shared_sdk_refactor.v1.json" 154 )) 155 .map_err(|_| "invalid approved target contract")?; 156 let mut approved = policy 157 .get("packages") 158 .and_then(serde_json::Value::as_array) 159 .ok_or("missing approved package graph")? 160 .iter() 161 .map(|p| p.get("package").and_then(serde_json::Value::as_str)) 162 .collect::<Option<BTreeSet<_>>>() 163 .ok_or("invalid approved package identity")?; 164 let advanced = BTreeSet::from([ 165 "radroots_transport_reticulum", 166 "radroots_mesh", 167 "radroots_simplex_chat_proto", 168 "radroots_nostrdb", 169 "radroots_replica_sync", 170 ]); 171 if !advanced.is_subset(&approved) { 172 return Err("advanced owners must exist in approved graph"); 173 } 174 // The original exact-dependency test still governs the current base. New 175 // optional owners must come from the prospective target, not arbitrary text. 176 let base: toml::Value = toml::from_str(MANIFEST).map_err(|_| "invalid base manifest")?; 177 approved.extend( 178 base.get("dependencies") 179 .and_then(toml::Value::as_table) 180 .ok_or("missing base dependencies")? 181 .keys() 182 .map(String::as_str), 183 ); 184 let mut advanced_aliases = BTreeSet::new(); 185 for (alias, declaration) in dependencies { 186 let table = declaration.as_table(); 187 if table.is_none() && declaration.as_str().is_none() { 188 return Err("invalid dependency shape"); 189 } 190 let package = match table.and_then(|t| t.get("package")) { 191 Some(p) => p.as_str().ok_or("invalid package alias")?, 192 None => alias.as_str(), 193 }; 194 if !approved.contains(package) || ["xtask", "radroots_test_fixtures"].contains(&package) { 195 return Err("unapproved runtime dependency owner"); 196 } 197 for name in [alias.as_str(), package] { 198 if ["radroots_ee_", "radroots_ops_", "radroots_platform_"] 199 .iter() 200 .any(|prefix| name.starts_with(prefix)) 201 || (name.starts_with("radroots_") && !approved.contains(name)) 202 { 203 return Err("unapproved package owner"); 204 } 205 if name.starts_with("sp1") { 206 return Err("SP1 remains a separate capability"); 207 } 208 } 209 if advanced.contains(package) { 210 if table 211 .and_then(|t| t.get("optional")) 212 .and_then(toml::Value::as_bool) 213 != Some(true) 214 { 215 return Err("advanced dependency must be optional"); 216 } 217 let explicit = format!("dep:{alias}"); 218 if !features 219 .values() 220 .any(|tokens| tokens.iter().any(|token| *token == explicit)) 221 { 222 return Err("advanced dependency needs explicit activation"); 223 } 224 advanced_aliases.insert(alias.as_str()); 225 } 226 } 227 for tokens in features.values() { 228 for token in tokens { 229 if let Some(alias) = token.strip_prefix("dep:") 230 && !dependencies.contains_key(alias) 231 { 232 return Err("feature activates an undeclared dependency"); 233 } 234 } 235 } 236 let mut pending = features.get("default").cloned().unwrap_or_default(); 237 let mut visited = BTreeSet::new(); 238 while let Some(token) = pending.pop() { 239 let (dependency, activates) = if let Some(alias) = token.strip_prefix("dep:") { 240 (alias, true) 241 } else if let Some((alias, _)) = token.split_once('/') { 242 (alias.trim_end_matches('?'), !alias.ends_with('?')) 243 } else { 244 (token, true) 245 }; 246 if activates && advanced_aliases.contains(dependency) { 247 return Err("advanced dependency cannot be enabled by default"); 248 } 249 if visited.insert(token) 250 && let Some(tokens) = features.get(token) 251 { 252 pending.extend(tokens); 253 } 254 } 255 Ok(()) 256 } 257 258 fn advanced_fixture(feature: &str, package: &str, optional: bool) -> String { 259 let mut value: toml::Value = toml::from_str(MANIFEST).unwrap(); 260 let dependency = toml::Table::from_iter([ 261 ("workspace".to_owned(), toml::Value::Boolean(true)), 262 ("optional".to_owned(), toml::Value::Boolean(optional)), 263 ]); 264 value["dependencies"] 265 .as_table_mut() 266 .unwrap() 267 .insert(package.to_owned(), toml::Value::Table(dependency)); 268 value["features"].as_table_mut().unwrap().insert( 269 feature.to_owned(), 270 toml::Value::Array(vec![toml::Value::String(format!("dep:{package}"))]), 271 ); 272 let text = toml::to_string(&value).unwrap(); 273 assert!(text.len() < 65_536); 274 text 275 } 276 277 #[test] 278 fn approved_optional_reticulum_is_not_rejected_by_vocabulary() { 279 assert!( 280 feature_guard(&advanced_fixture( 281 "reticulum", 282 "radroots_transport_reticulum", 283 true 284 )) 285 .is_ok() 286 ); 287 } 288 289 #[test] 290 fn approved_optional_mesh_is_not_rejected_by_vocabulary() { 291 assert!(feature_guard(&advanced_fixture("mesh", "radroots_mesh", true)).is_ok()); 292 } 293 294 #[test] 295 fn approved_optional_simplex_is_not_rejected_by_vocabulary() { 296 assert!( 297 feature_guard(&advanced_fixture( 298 "simplex", 299 "radroots_simplex_chat_proto", 300 true 301 )) 302 .is_ok() 303 ); 304 } 305 306 #[test] 307 fn approved_optional_nostrdb_is_not_rejected_by_vocabulary() { 308 assert!(feature_guard(&advanced_fixture("nostrdb", "radroots_nostrdb", true)).is_ok()); 309 } 310 311 #[test] 312 fn approved_optional_replica_is_not_rejected_by_vocabulary() { 313 assert!(feature_guard(&advanced_fixture("replica", "radroots_replica_sync", true)).is_ok()); 314 } 315 316 #[test] 317 fn advanced_dependency_must_be_optional() { 318 assert!(feature_guard(&advanced_fixture("mesh", "radroots_mesh", false)).is_err()); 319 } 320 321 #[test] 322 fn advanced_dependency_needs_explicit_activation() { 323 let mut value: toml::Value = 324 toml::from_str(&advanced_fixture("mesh", "radroots_mesh", true)).unwrap(); 325 value["features"].as_table_mut().unwrap().remove("mesh"); 326 assert!(feature_guard(&toml::to_string(&value).unwrap()).is_err()); 327 } 328 329 #[test] 330 fn advanced_dependency_cannot_be_enabled_by_default() { 331 for route in ["direct", "feature", "transitive_feature"] { 332 let mut value: toml::Value = 333 toml::from_str(&advanced_fixture("mesh", "radroots_mesh", true)).unwrap(); 334 let token = match route { 335 "direct" => "dep:radroots_mesh", 336 "feature" => "mesh", 337 _ => { 338 value["features"].as_table_mut().unwrap().insert( 339 "feature_hop".to_owned(), 340 toml::Value::Array(vec![toml::Value::String("mesh".to_owned())]), 341 ); 342 "feature_hop" 343 } 344 }; 345 value["features"]["default"] 346 .as_array_mut() 347 .unwrap() 348 .push(toml::Value::String(token.to_owned())); 349 assert!(feature_guard(&toml::to_string(&value).unwrap()).is_err()); 350 } 351 } 352 353 #[test] 354 fn private_package_cannot_hide_behind_a_feature_alias() { 355 assert!( 356 feature_guard(&advanced_fixture( 357 "innocent_feature", 358 "radroots_ee_hidden", 359 true 360 )) 361 .is_err() 362 ); 363 let mut value: toml::Value = toml::from_str(&advanced_fixture( 364 "innocent_feature", 365 "ordinary_alias", 366 true, 367 )) 368 .unwrap(); 369 value["dependencies"]["ordinary_alias"] 370 .as_table_mut() 371 .unwrap() 372 .insert( 373 "package".to_owned(), 374 toml::Value::String("radroots_ee_hidden".to_owned()), 375 ); 376 assert!(feature_guard(&toml::to_string(&value).unwrap()).is_err()); 377 } 378 379 #[test] 380 fn malformed_or_wrong_shape_manifest_cannot_pass_as_harmless_text() { 381 for value in ["not TOML input", "a = 1", "[features]\ndefault = 7\n"] { 382 assert!(feature_guard(value).is_err()); 383 } 384 } 385 386 #[test] 387 fn oversized_manifest_is_rejected_before_parsing() { 388 assert!(feature_guard(&" ".repeat(65_537)).is_err()); 389 } 390 391 #[test] 392 fn sp1_remains_separate_from_the_ordinary_facade() { 393 assert!(feature_guard(&advanced_fixture("sp1", "sp1_sdk", true)).is_err()); 394 } 395 396 #[test] 397 fn only_approved_dependency_owners_are_admitted() { 398 for package in ["unapproved_owner", "xtask", "radroots_test_fixtures"] { 399 assert!(feature_guard(&advanced_fixture("innocent_feature", package, true)).is_err()); 400 } 401 }