lib

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

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 }