use super::helpers::*;
pub(super) fn confine(governed: &str, crate_name: &str) -> ModuleBoundary {
ModuleBoundary::in_crate("x")
.module(governed)
.confine_external_crate(crate_name)
.because("the platform vocabulary stays behind the ffi module")
}
#[test]
pub(super) fn confine_observes_an_import_inside_a_path_remapped_module() {
let (result, violations) = run_module_check(
"confine-remapped",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "#[path = \"far.rs\"]\npub mod inner;\n"),
("far.rs", "use libc::c_int;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(violations.len(), 1, "{violations:?}");
assert_eq!(violations[0].target(), "libc");
assert!(
violations[0].finding.contains("crate::service::inner"),
"the finding must name the remapped module: {:?}",
violations[0].finding
);
}
#[test]
pub(super) fn confine_flags_an_external_import_outside_the_subtree() {
let (result, violations) = run_module_check(
"confine-outside",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use libc::c_int;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(violations.len(), 1, "{violations:?}");
assert_eq!(violations[0].target(), "libc");
assert_eq!(violations[0].finding, "crate::service");
let file = violations[0].file.as_deref().expect("carries its file");
assert!(file.ends_with("service.rs"), "names the offender: {file}");
}
#[test]
pub(super) fn confine_is_clean_within_the_subtree() {
let (result, violations) = run_module_check(
"confine-within",
&[
("lib.rs", "pub mod ffi;\n"),
("ffi.rs", "use libc::c_int;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert!(
violations.is_empty(),
"within the subtree is clean: {violations:?}"
);
}
#[test]
pub(super) fn confine_allows_beneath_the_subtree() {
let (result, violations) = run_module_check(
"confine-beneath",
&[
("lib.rs", "pub mod ffi;\n"),
("ffi.rs", "pub mod raw;\n"),
("ffi/raw.rs", "use libc::c_int;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert!(
violations.is_empty(),
"a module beneath the permitted subtree is clean: {violations:?}"
);
}
#[test]
pub(super) fn confine_flags_a_prefix_colliding_sibling_of_the_subtree() {
let (result, violations) = run_module_check(
"confine-sibling",
&[
("lib.rs", "pub mod ffi;\npub mod ffi_utils;\n"),
("ffi.rs", "\n"),
("ffi_utils.rs", "use libc::c_int;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(violations.len(), 1, "{violations:?}");
assert_eq!(violations[0].finding, "crate::ffi_utils");
}
#[test]
pub(super) fn confine_observes_a_glob_and_a_bare_import() {
let (result, violations) = run_module_check(
"confine-glob",
&[
("lib.rs", "pub mod ffi;\npub mod a;\npub mod b;\n"),
("ffi.rs", "\n"),
("a.rs", "use libc::*;\n"),
("b.rs", "use libc;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
let findings: Vec<&str> = violations.iter().map(|v| v.finding.as_str()).collect();
assert_eq!(violations.len(), 2, "{violations:?}");
assert!(
findings.contains(&"crate::a") && findings.contains(&"crate::b"),
"{findings:?}"
);
}
#[test]
pub(super) fn confine_ignores_a_different_external_crate() {
let (result, violations) = run_module_check(
"confine-other-crate",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use serde::Deserialize;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert!(
violations.is_empty(),
"the rule observes only the confined crate: {violations:?}"
);
}
#[test]
pub(super) fn confine_of_an_unimported_crate_is_clean_with_no_error() {
let (result, violations) = run_module_check(
"confine-unimported",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use serde::Deserialize;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(
result.is_ok(),
"no error for an unimported confined crate: {result:?}"
);
assert!(violations.is_empty(), "{violations:?}");
}
#[test]
pub(super) fn confine_resolves_a_shadowing_root_module_as_internal_no_false_positive() {
let (result, violations) = run_module_check(
"confine-shadow",
&[
("lib.rs", "pub mod libc;\npub mod ffi;\nuse libc::helper;\n"),
("libc.rs", "pub fn helper() {}\n"),
("ffi.rs", "\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert!(
violations.is_empty(),
"a shadowing root module resolves internal, not as the confined external crate: {violations:?}"
);
}
#[test]
pub(super) fn confine_observes_submodule_bare_and_leading_colon_forms() {
let (result, violations) = run_module_check(
"confine-forms",
&[
("lib.rs", "pub mod ffi;\npub mod service;\npub mod other;\n"),
("ffi.rs", "\n"),
("service.rs", "use libc::c_int;\n"),
("other.rs", "use ::libc::c_void;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
let findings: Vec<&str> = violations.iter().map(|v| v.finding.as_str()).collect();
assert_eq!(violations.len(), 2, "{violations:?}");
assert!(
findings.contains(&"crate::service") && findings.contains(&"crate::other"),
"both a submodule-bare and a leading-`::` external import are observed: {findings:?}"
);
}
#[test]
pub(super) fn confine_observes_a_use_aliased_to_underscore() {
let (result, violations) = run_module_check(
"confine-as-underscore",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "#[allow(unused_imports)]\nuse libc as _;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
let findings: Vec<&str> = violations.iter().map(|v| v.finding.as_str()).collect();
assert_eq!(findings, ["crate::service"], "{violations:?}");
}
#[test]
pub(super) fn confine_ignores_a_use_inside_a_string_literal_or_macro_body() {
for (name, service) in [
(
"confine-string",
"pub fn f() { let _s = \"use libc::c_int;\"; }\n",
),
(
"confine-macro-rules",
"macro_rules! m { () => { use libc::c_int; }; }\n",
),
("confine-macro-call", "some_macro! { use libc::c_int; }\n"),
] {
let (result, violations) = run_module_check(
name,
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", service),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{name}: {result:?}");
assert!(violations.is_empty(), "{name}: no use: {violations:?}");
}
}
#[test]
pub(super) fn confine_dedups_multiple_imports_from_one_importer() {
let (result, violations) = run_module_check(
"confine-dedup",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use libc::c_int;\nuse libc::c_void;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(
violations.len(),
1,
"one importer importing the confined crate twice yields one violation: {violations:?}"
);
}
#[test]
pub(super) fn confine_identity_is_injective_across_confined_crates() {
let files = [
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use libc::c_int;\nuse winapi::HANDLE;\n"),
];
let (r1, libc_v) = run_module_check("confine-inj-libc", &files, confine("crate::ffi", "libc"));
let (r2, winapi_v) = run_module_check(
"confine-inj-winapi",
&files,
confine("crate::ffi", "winapi"),
);
assert!(r1.is_ok() && r2.is_ok(), "{r1:?} {r2:?}");
assert_eq!(libc_v.len(), 1, "{libc_v:?}");
assert_eq!(winapi_v.len(), 1, "{winapi_v:?}");
assert_eq!(libc_v[0].target(), "libc");
assert_eq!(winapi_v[0].target(), "winapi");
assert_eq!(
libc_v[0].finding, winapi_v[0].finding,
"same offending importer — only the target (confined crate) differs"
);
let baseline = Baseline::of(&Report::new(libc_v.clone()));
let mut both = Report::new(vec![libc_v[0].clone(), winapi_v[0].clone()]);
apply_baseline(&mut both, &baseline);
assert!(both.violations[0].baselined, "libc is baselined");
assert!(
!both.violations[1].baselined,
"winapi is NOT masked by libc's baseline — distinct target keeps identity injective"
);
assert_eq!(
Outcome::Violations(both).exit_code(),
1,
"the new winapi violation still fails"
);
}
#[test]
pub(super) fn confine_canonicalizes_a_raw_identifier_crate_name() {
let (result, violations) = run_module_check(
"confine-raw-id",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use r#async::spawn;\n"),
],
confine("crate::ffi", "async"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(
violations.len(),
1,
"raw and plain crate-name forms are one identity: {violations:?}"
);
assert_eq!(violations[0].target(), "async");
}
#[test]
pub(super) fn confine_on_the_crate_root_is_a_constitution_error() {
let (result, _violations) = run_module_check(
"confine-on-crate",
&[("lib.rs", "use libc::c_int;\n")],
confine("crate", "libc"),
);
let err = result.expect_err("confining to the crate root is a constitution error");
assert_eq!(err, confine_external_crate_on_crate_error("x"));
}
#[test]
pub(super) fn confine_unknown_subtree_is_a_constitution_error() {
let (result, _violations) = run_module_check(
"confine-unknown",
&[("lib.rs", "pub mod ffi;\n"), ("ffi.rs", "\n")],
confine("crate::nope", "libc"),
);
let err = result.expect_err("an unreachable permitted subtree is a constitution error");
assert_eq!(err, unknown_module_error("crate::nope", "x"));
}
#[test]
pub(super) fn confine_honors_warn_severity() {
let boundary = ModuleBoundary::in_crate("x")
.module("crate::ffi")
.confine_external_crate("libc")
.warn()
.because("advisory during adoption");
let (result, violations) = run_module_check(
"confine-warn",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use libc::c_int;\n"),
],
boundary,
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(violations.len(), 1, "{violations:?}");
assert_eq!(violations[0].severity, Severity::Warn);
assert_eq!(
Outcome::Violations(Report::new(violations)).exit_code(),
0,
"a warn-only confinement does not fail CI"
);
}
#[test]
pub(super) fn confine_external_crate_rule_text_and_json_params() {
let rule = ModuleRule::ConfineExternalCrate {
crate_name: "libc".to_string(),
};
assert_eq!(rule.label(), "external crate confined to module");
assert_eq!(rule.polarity(), Polarity::AllowlistGap);
assert_eq!(
rule.text(),
"confines external crate libc to this module's subtree"
);
assert_eq!(
rule.json_params(),
vec![("external_crate", serde_json::json!("libc"))]
);
}
#[test]
pub(super) fn confine_external_crate_projects_its_crate_and_subtree() {
let constitution = Constitution::new("p").boundary(
ModuleBoundary::in_crate("app")
.module("crate::ffi")
.confine_external_crate("libc")
.because("the raw libc surface stays behind the ffi module"),
);
let text = constitution_text(&constitution);
assert!(
text.contains("crate::ffi"),
"the declared subtree is named: {text}"
);
assert!(
text.contains("confines external crate libc"),
"the confined crate is named: {text}"
);
let doc: serde_json::Value = serde_json::from_str(&constitution_json(&constitution)).unwrap();
assert_eq!(
doc["boundaries"][0]["rule"],
"external crate confined to module"
);
assert_eq!(doc["boundaries"][0]["target"], "crate::ffi");
assert_eq!(doc["boundaries"][0]["external_crate"], "libc");
assert!(doc["boundaries"][0]["forbidden"].is_null());
assert!(doc["boundaries"][0]["only"].is_null());
}
#[test]
pub(super) fn confine_matches_a_hyphenated_package_name_against_its_underscore_identifier() {
let (result, violations) = run_module_check(
"confine-hyphen",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
(
"service.rs",
"use windows_sys::Win32::Foundation::HANDLE;\n",
),
],
confine("crate::ffi", "windows-sys"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(
violations.len(),
1,
"a hyphenated package name matches its underscore import identifier: {violations:?}"
);
assert_eq!(violations[0].target(), "windows_sys");
assert_eq!(violations[0].finding, "crate::service");
}
#[test]
pub(super) fn confine_observes_an_aliased_import_of_the_confined_crate() {
let (result, violations) = run_module_check(
"confine-alias",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "use libc as c;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(
violations.len(),
1,
"an aliased import is still observed: {violations:?}"
);
assert_eq!(violations[0].target(), "libc");
assert_eq!(violations[0].finding, "crate::service");
}
#[test]
pub(super) fn confine_ignores_an_extern_crate_declaration() {
let (result, violations) = run_module_check(
"confine-extern-crate",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
("service.rs", "extern crate libc;\n"),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert!(
violations.is_empty(),
"the rule is use-only: an `extern crate` declaration is not observed: {violations:?}"
);
}
#[test]
pub(super) fn confine_external_crate_is_cfg_blind_to_unenabled_cfg_arms() {
let (result, violations) = run_module_check(
"confine-cfg-blind",
&[
("lib.rs", "pub mod ffi;\npub mod service;\n"),
("ffi.rs", "\n"),
(
"service.rs",
"#[cfg(impossible_predicate)]\nuse libc::c_int;\n",
),
],
confine("crate::ffi", "libc"),
);
assert!(result.is_ok(), "{result:?}");
assert_eq!(violations.len(), 1, "{violations:?}");
assert_eq!(violations[0].target(), "libc");
assert_eq!(violations[0].finding, "crate::service");
}
#[test]
pub(super) fn confine_external_crate_evaluates_each_unit_at_a_coincident_conventional_path() {
let ws = TempWorkspace::new("confine-lib-bin-coincident");
ws.write("lib.rs", "pub mod ffi;\npub mod bad;\n");
ws.write("main.rs", "pub mod ffi;\npub mod bad;\nfn main() {}\n");
ws.write("ffi.rs", "\n");
ws.write("bad.rs", "use libc::c_int;\n");
let metadata = serde_json::json!({
"packages": [{
"name": "x",
"targets": [
{ "kind": ["lib"], "src_path": ws.src().join("lib.rs").to_string_lossy() },
{ "kind": ["bin"], "src_path": ws.src().join("main.rs").to_string_lossy() },
],
}],
});
let mut violations = Vec::new();
let result = check_module_boundary(&metadata, &confine("crate::ffi", "libc"), &mut violations);
assert!(result.is_ok(), "{result:?}");
assert_eq!(
violations.len(),
2,
"the coincident-path leak exists once per compilation unit and must be reported for each, \
not merged into one and not dropped for either: {violations:?}"
);
let units: std::collections::BTreeSet<String> = violations
.iter()
.map(|v| {
v.fact().to_json()["fields"]["unit"]
.as_str()
.expect("unit is a string")
.to_string()
})
.collect();
assert_eq!(
units,
std::collections::BTreeSet::from(["lib.rs".to_string(), "main.rs".to_string()]),
"each unit's own copy of the leak must carry that unit's own label: {violations:?}"
);
}