@lamentis/naome 1.3.16 → 1.4.0

package/crates/naome-core/tests/architecture_acceptance.rs

@@ -0,0 +1,304 @@
+use naome_core::{
+    scan_architecture, validate_architecture, ArchitectureScanOptions, ArchitectureScanReport,
+    ArchitectureValidation,
+};
+
+mod architecture_support;
+
+use architecture_support::{has_import_edge, FixtureRepo};
+
+const LAYER_POLICY: &str = r#"
+layers:
+  ui:
+    paths:
+      - "src/ui/**"
+      - "Sources/App/**"
+  application:
+    paths:
+      - "src/application/**"
+      - "cmd/**"
+  domain:
+    paths:
+      - "src/domain/**"
+      - "src/billing/domain/**"
+      - "crates/**/src/domain/**"
+      - "Sources/Core/**"
+      - "internal/domain/**"
+  infrastructure:
+    paths:
+      - "src/infrastructure/**"
+      - "src/billing/infrastructure/**"
+      - "crates/**/src/infrastructure/**"
+      - "Sources/Adapters/**"
+      - "internal/infrastructure/**"
+allowed_dependencies:
+  ui:
+    - application
+    - domain
+  application:
+    - domain
+    - infrastructure
+  infrastructure:
+    - domain
+  domain:
+rules:
+  no_forbidden_layer_dependencies:
+    enabled: true
+    severity: error
+  external_dependency_policy:
+    enabled: true
+    severity: error
+external_dependencies:
+  domain:
+    allow: []
+  infrastructure:
+    allow:
+      - "stripe"
+      - "Alamofire"
+ignore:
+  - path: "generated/**"
+    reason: "Generated code is not architecture-owned."
+"#;
+
+#[test]
+fn typescript_rust_go_and_swift_fixture_repos_detect_layer_violations() {
+    let repo = FixtureRepo::new();
+    write_files(
+        &repo,
+        &[
+            ("naome.arch.yaml", LAYER_POLICY),
+            (
+                "src/domain/order.ts",
+                "import { connect } from '../infrastructure/sql';\n",
+            ),
+            ("src/infrastructure/sql.ts", "export const connect = 1;\n"),
+            (
+                "crates/core/src/domain/lib.rs",
+                "use crate::infrastructure::db::Pool;\n",
+            ),
+            ("crates/core/src/infrastructure/db.rs", "pub struct Pool;\n"),
+            ("go.mod", "module example.com/acme\n"),
+            (
+                "internal/domain/event.go",
+                "package domain\nimport \"example.com/acme/internal/infrastructure/db\"\n",
+            ),
+            ("internal/infrastructure/db/db.go", "package db\n"),
+            (
+                "Sources/Core/Event.swift",
+                "import Foundation\nimport Adapters\n",
+            ),
+            (
+                "Sources/Adapters/Adapters.swift",
+                "public struct Adapter {}\n",
+            ),
+        ],
+    );
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let violation_paths = report
+        .violations
+        .iter()
+        .filter(|violation| violation.id == "arch.no_forbidden_layer_dependencies")
+        .filter_map(|violation| violation.path.as_deref())
+        .collect::<Vec<_>>();
+
+    assert!(violation_paths.contains(&"src/domain/order.ts"));
+    assert!(violation_paths.contains(&"crates/core/src/domain/lib.rs"));
+    assert!(violation_paths.contains(&"internal/domain/event.go"));
+    assert!(violation_paths.contains(&"Sources/Core/Event.swift"));
+}
+
+#[test]
+fn python_package_imports_resolve_to_local_files_before_external_policy_runs() {
+    let repo = FixtureRepo::new();
+    write_files(
+        &repo,
+        &[
+            ("naome.arch.yaml", LAYER_POLICY),
+            ("src/billing/__init__.py", ""),
+            ("src/billing/domain/__init__.py", ""),
+            ("src/billing/infrastructure/__init__.py", ""),
+            (
+                "src/billing/domain/event.py",
+                "from billing.infrastructure.db import Session\n",
+            ),
+            (
+                "src/billing/infrastructure/db.py",
+                "class Session:\n    pass\n",
+            ),
+        ],
+    );
+
+    let (report, scan) = validate_and_scan(&repo);
+
+    assert!(has_import_edge(
+        &scan,
+        "file:src/billing/domain/event.py",
+        "file:src/billing/infrastructure/db.py"
+    ));
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.no_forbidden_layer_dependencies"
+            && violation.path.as_deref() == Some("src/billing/domain/event.py")
+    }));
+    assert!(!report.violations.iter().any(|violation| {
+        violation.id == "arch.external_dependency_policy"
+            && violation.to.as_deref() == Some("external:billing")
+    }));
+}
+
+#[test]
+fn python_package_imports_prefer_importing_root_and_keep_missing_modules_unresolved() {
+    let repo = FixtureRepo::new();
+    write_files(
+        &repo,
+        &[
+            ("naome.arch.yaml", LAYER_POLICY),
+            ("services/a/src/billing/__init__.py", ""),
+            ("services/a/src/billing/infrastructure/__init__.py", ""),
+            ("services/a/src/billing/infrastructure/db.py", "A = 1\n"),
+            ("services/b/src/billing/__init__.py", ""),
+            ("services/b/src/billing/domain/__init__.py", ""),
+            ("services/b/src/billing/infrastructure/__init__.py", ""),
+            ("services/b/src/billing/infrastructure/db.py", "B = 1\n"),
+            (
+                "services/b/src/billing/domain/event.py",
+                "from billing.infrastructure.db import B\nfrom billing.infrastructure.missing import Thing\n",
+            ),
+        ],
+    );
+
+    let (report, scan) = validate_and_scan(&repo);
+
+    assert!(has_import_edge(
+        &scan,
+        "file:services/b/src/billing/domain/event.py",
+        "file:services/b/src/billing/infrastructure/db.py"
+    ));
+    assert!(!has_import_edge(
+        &scan,
+        "file:services/b/src/billing/domain/event.py",
+        "file:services/a/src/billing/infrastructure/db.py"
+    ));
+    assert!(report.config_findings.iter().any(|finding| {
+        finding.id == "arch.import.unresolved"
+            && finding.subject == "file:services/b/src/billing/domain/event.py"
+            && finding.message.contains("billing.infrastructure.missing")
+    }));
+}
+
+#[test]
+fn python_from_package_missing_child_does_not_resolve_to_package_init() {
+    assert_missing_child_import_stays_unresolved(
+        "from billing.infrastructure import missing\n",
+        "billing.infrastructure.missing",
+    );
+}
+
+#[test]
+fn python_relative_missing_child_does_not_resolve_to_package_init() {
+    assert_missing_child_import_stays_unresolved(
+        "from ..infrastructure import missing\n",
+        "..infrastructure.missing",
+    );
+}
+
+fn assert_missing_child_import_stays_unresolved(import_line: &str, expected_specifier: &str) {
+    let repo = FixtureRepo::new();
+    write_files(
+        &repo,
+        &[
+            ("naome.arch.yaml", LAYER_POLICY),
+            ("src/billing/__init__.py", ""),
+            ("src/billing/domain/__init__.py", ""),
+            ("src/billing/infrastructure/__init__.py", ""),
+            ("src/billing/domain/event.py", import_line),
+        ],
+    );
+
+    let (report, scan) = validate_and_scan(&repo);
+
+    assert!(!has_import_edge(
+        &scan,
+        "file:src/billing/domain/event.py",
+        "file:src/billing/infrastructure/__init__.py"
+    ));
+    assert!(report.config_findings.iter().any(|finding| {
+        finding.id == "arch.import.unresolved"
+            && finding.subject == "file:src/billing/domain/event.py"
+            && finding.message.contains(expected_specifier)
+    }));
+}
+
+#[test]
+fn python_top_level_package_imports_resolve_to_local_package_files() {
+    let repo = FixtureRepo::new();
+    repo.write("naome.arch.yaml", LAYER_POLICY);
+    repo.write("src/domain/event.py", "import infrastructure\n");
+    repo.write("src/infrastructure/__init__.py", "client = object()\n");
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let scan = scan_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert!(has_import_edge(
+        &scan,
+        "file:src/domain/event.py",
+        "file:src/infrastructure/__init__.py"
+    ));
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.no_forbidden_layer_dependencies"
+            && violation.path.as_deref() == Some("src/domain/event.py")
+    }));
+    assert!(!report.violations.iter().any(|violation| {
+        violation.id == "arch.external_dependency_policy"
+            && violation.to.as_deref() == Some("external:infrastructure")
+    }));
+}
+
+#[test]
+fn mixed_monorepo_acceptance_keeps_local_edges_and_generated_code_out_of_findings() {
+    let repo = FixtureRepo::new();
+    write_files(
+        &repo,
+        &[
+            ("naome.arch.yaml", LAYER_POLICY),
+            (
+                "tsconfig.json",
+                r#"{"compilerOptions":{"baseUrl":".","paths":{"@domain/*":["src/domain/*"]}}}"#,
+            ),
+            (
+                "src/ui/View.tsx",
+                "import { event } from '@domain/event';\n",
+            ),
+            ("src/domain/event.ts", "export const event = 1;\n"),
+            ("generated/client.ts", "import Stripe from 'stripe';\n"),
+            (
+                "Package.swift",
+                "import PackageDescription\nlet package = Package(name: \"App\")\n",
+            ),
+        ],
+    );
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let scan = scan_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert!(has_import_edge(
+        &scan,
+        "file:src/ui/View.tsx",
+        "file:src/domain/event.ts"
+    ));
+    assert!(!scan.file_facts.contains_key("generated/client.ts"));
+    assert_eq!(report.summary.errors, 0, "{:?}", report.violations);
+}
+
+fn write_files(repo: &FixtureRepo, files: &[(&str, &str)]) {
+    for (path, content) in files {
+        repo.write(path, content);
+    }
+}
+
+fn validate_and_scan(repo: &FixtureRepo) -> (ArchitectureValidation, ArchitectureScanReport) {
+    (
+        validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap(),
+        scan_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap(),
+    )
+}

package/crates/naome-core/tests/architecture_aliases.rs

@@ -0,0 +1,101 @@
+use naome_core::{validate_architecture, ArchitectureScanOptions};
+
+mod architecture_support;
+
+use architecture_support::FixtureRepo;
+
+#[test]
+fn typescript_path_aliases_resolve_to_repository_files() {
+    let repo = FixtureRepo::new();
+    repo.write("naome.arch.yaml", &alias_fixture_config());
+    repo.write(
+        "tsconfig.json",
+        r#"{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@infra/*": ["src/infrastructure/*"]
+    }
+  }
+}
+"#,
+    );
+    repo.write("src/domain/event.ts", "import { db } from '@infra/db';\n");
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert_eq!(report.status, "fail");
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.no_forbidden_layer_dependencies"
+            && violation.path.as_deref() == Some("src/domain/event.ts")
+    }));
+}
+
+#[test]
+fn typescript_aliases_read_jsonc_parent_configs_and_report_missing_targets() {
+    let repo = FixtureRepo::new();
+    repo.write("naome.arch.yaml", &alias_fixture_config());
+    repo.write(
+        "tsconfig.base.json",
+        r#"{
+  // workspace aliases are JSONC in normal TypeScript projects
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "*": ["types/*"],
+      "@infra/*": ["src/infrastructure/*"],
+    },
+  },
+}
+"#,
+    );
+    repo.write(
+        "packages/app/tsconfig.json",
+        r#"{
+  "extends": "../../tsconfig.base.json"
+}
+"#,
+    );
+    repo.write(
+        "packages/app/src/domain/event.ts",
+        "import { db } from '@infra/db';\nimport { missing } from '@infra/missing';\n",
+    );
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.no_forbidden_layer_dependencies"
+            && violation.path.as_deref() == Some("packages/app/src/domain/event.ts")
+            && violation.to.as_deref() == Some("file:src/infrastructure/db.ts")
+    }));
+    assert!(report.config_findings.iter().any(|finding| {
+        finding.id == "arch.import.unresolved"
+            && finding.subject == "file:packages/app/src/domain/event.ts"
+            && finding.message.contains("@infra/missing")
+    }));
+}
+
+fn alias_fixture_config() -> String {
+    [
+        "layers:",
+        "  domain:",
+        "    paths:",
+        "      - \"src/domain/**\"",
+        "      - \"packages/app/src/domain/**\"",
+        "  infrastructure:",
+        "    paths:",
+        "      - \"src/infrastructure/**\"",
+        "allowed_dependencies:",
+        "  domain:",
+        "  infrastructure:",
+        "    - domain",
+        "rules:",
+        "  no_forbidden_layer_dependencies:",
+        "    enabled: true",
+        "    severity: error",
+        "",
+    ]
+    .join("\n")
+}

package/crates/naome-core/tests/architecture_cache.rs

@@ -165,6 +165,63 @@ fn changed_only_degrades_when_go_module_context_changes() {
     );
 }
 
+#[test]
+fn changed_only_degrades_when_manifest_resolver_context_changes() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("Package.swift", "// swift package\n");
+    repo.write(
+        "src/domain/event.swift",
+        "import Foundation\nlet event = 1\n",
+    );
+    repo.write("src/infrastructure/db.swift", "let db = 1\n");
+    repo.init_git();
+    validate_architecture(repo.path(), changed_only()).unwrap();
+
+    repo.write(
+        "Package.swift",
+        "let package = Package(name: \"Changed\")\n",
+    );
+
+    let report = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(report.changed_only_requested);
+    assert!(report.changed_only_degraded_to_full_scan);
+    assert_eq!(report.changed_only_mode, "degraded_full_scan");
+    assert_eq!(
+        report.changed_only_degradation_reason.as_deref(),
+        Some("resolver_context_changed")
+    );
+}
+
+#[test]
+fn changed_only_degrades_when_cache_extractor_version_is_stale() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("src/domain/event.ts", "export const event = 1;\n");
+    repo.init_git();
+    validate_architecture(repo.path(), changed_only()).unwrap();
+    let cache_path = repo.path().join(".naome/cache/architecture/cache.json");
+    let stale_cache = std::fs::read_to_string(&cache_path)
+        .unwrap()
+        .replace("architecture-cache-v1.4.0", "architecture-cache-v1.3.17");
+    std::fs::write(cache_path, stale_cache).unwrap();
+
+    let report = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(report.changed_only_degraded_to_full_scan);
+    assert_eq!(
+        report.changed_only_degradation_reason.as_deref(),
+        Some("cache_miss")
+    );
+}
+
 fn changed_only() -> ArchitectureScanOptions {
     ArchitectureScanOptions {
         changed_only: true,

package/crates/naome-core/tests/architecture_config.rs

@@ -1,4 +1,7 @@
-use naome_core::{format_architecture_validation, validate_architecture, ArchitectureScanOptions};
+use naome_core::{
+    architecture_validation_sarif_with_root, format_architecture_validation, validate_architecture,
+    ArchitectureScanOptions,
+};
 
 mod architecture_support;
 
@@ -65,3 +68,154 @@ rules:
     }));
     assert!(output.contains("configuration findings: 2"));
 }
+
+#[test]
+fn validation_reports_ineffective_layers_contexts_and_unresolved_imports() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        r#"
+layers:
+  domain:
+    paths:
+      - "src/domain/**"
+  missing:
+    paths:
+      - "src/missing/**"
+contexts:
+  billing:
+    paths:
+      - "src/billing/**"
+    public_api:
+      - "src/billing/index.ts"
+  empty:
+    paths:
+      - "src/empty/**"
+rules:
+  no_forbidden_layer_dependencies:
+    enabled: true
+    severity: error
+"#,
+    );
+    repo.write(
+        "src/domain/event.ts",
+        "import missing from './missing';\nexport const event = missing;\n",
+    );
+    repo.write("src/billing/index.ts", "export const billing = 1;\n");
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert_eq!(report.status, "pass");
+    assert!(report.config_findings.iter().any(|finding| {
+        finding.id == "arch.config.layer_matches_no_files" && finding.subject == "layer:missing"
+    }));
+    assert!(report.config_findings.iter().any(|finding| {
+        finding.id == "arch.config.context_matches_no_files" && finding.subject == "context:empty"
+    }));
+    assert!(report.config_findings.iter().any(|finding| {
+        finding.id == "arch.import.unresolved"
+            && finding.subject == "file:src/domain/event.ts"
+            && finding.agent_instruction.contains("./missing")
+    }));
+    assert!(report.agent_feedback.iter().any(|feedback| {
+        feedback.files == vec!["src/domain/event.ts"]
+            && feedback
+                .repair
+                .contains("Resolve or remove import ./missing")
+    }));
+}
+
+#[test]
+fn validation_reports_unresolved_repo_absolute_imports() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "src/domain/event.ts",
+        "import missing from 'src/domain/missing';\nimport app from '@/app/missing';\n",
+    );
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let unresolved = report
+        .config_findings
+        .iter()
+        .filter(|finding| finding.id == "arch.import.unresolved")
+        .map(|finding| finding.message.as_str())
+        .collect::<Vec<_>>();
+
+    assert!(unresolved
+        .iter()
+        .any(|message| message.contains("src/domain/missing")));
+    assert!(unresolved
+        .iter()
+        .any(|message| message.contains("@/app/missing")));
+    assert!(report.agent_feedback.iter().any(|feedback| {
+        feedback.files == vec!["src/domain/event.ts"]
+            && feedback
+                .must_not_do
+                .iter()
+                .any(|item| item.contains("unresolved imports"))
+    }));
+}
+
+#[test]
+fn validation_sarif_includes_violations_and_config_findings() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        r#"
+layers:
+  domain:
+    paths:
+      - "src/domain/**"
+  infrastructure:
+    paths:
+      - "src/infrastructure/**"
+  unused:
+    paths:
+      - "src/unused/**"
+allowed_dependencies:
+  domain:
+  infrastructure:
+rules:
+  no_forbidden_layer_dependencies:
+    enabled: true
+    severity: error
+"#,
+    );
+    repo.write(
+        "src/domain/event.ts",
+        "import { db } from '../infrastructure/db';\nimport missing from './missing';\n",
+    );
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let sarif = architecture_validation_sarif_with_root(&report, repo.path());
+    let results = sarif["runs"][0]["results"].as_array().unwrap();
+
+    assert_eq!(sarif["version"], "2.1.0");
+    assert!(sarif["runs"][0]["originalUriBaseIds"]["REPO_ROOT"]["uri"]
+        .as_str()
+        .is_some_and(|uri| uri.starts_with("file://") && uri.ends_with('/')));
+    assert!(results.iter().any(|result| {
+        result["ruleId"] == "arch.no_forbidden_layer_dependencies"
+            && result["level"] == "error"
+            && result["locations"][0]["physicalLocation"]["artifactLocation"]["uri"]
+                == "src/domain/event.ts"
+            && result["locations"][0]["physicalLocation"]["artifactLocation"]["uriBaseId"]
+                == "REPO_ROOT"
+    }));
+    assert!(results.iter().any(|result| {
+        result["ruleId"] == "arch.import.unresolved"
+            && result["level"] == "warning"
+            && result["properties"]["agentInstruction"]
+                .as_str()
+                .is_some_and(|instruction| instruction.contains("./missing"))
+    }));
+    assert!(results.iter().any(|result| {
+        result["ruleId"] == "arch.config.layer_matches_no_files"
+            && result["level"] == "warning"
+            && result["locations"][0]["physicalLocation"]["artifactLocation"]["uri"]
+                == "naome.arch.yaml"
+            && result["locations"][0]["physicalLocation"]["artifactLocation"]["uriBaseId"]
+                == "REPO_ROOT"
+    }));
+}

package/crates/naome-core/tests/architecture_rules.rs

@@ -20,6 +20,7 @@ const TRANSITIVE_LAYER_POLICY_CONFIG: &str = "layers:\n  domain:\n    paths:\n
 const GO_EXTERNAL_POLICY_CONFIG: &str = "layers:\n  domain:\n    paths:\n      - \"domain/**\"\nexternal_dependencies:\n  domain:\n    allow:\n      - \"github.com/acme/payments\"\nrules:\n  external_dependency_policy:\n    enabled: true\n    severity: error\n";
 const PYTHON_RUST_EXTERNAL_POLICY_CONFIG: &str = "layers:\n  domain:\n    paths:\n      - \"src/domain/**\"\nexternal_dependencies:\n  domain:\n    allow:\n      - \"requests\"\n      - \"serde\"\nrules:\n  external_dependency_policy:\n    enabled: true\n    severity: error\n";
 const STDLIB_EXTERNAL_POLICY_CONFIG: &str = "layers:\n  domain:\n    paths:\n      - \"src/domain/**\"\n      - \"domain/**\"\nexternal_dependencies:\n  domain:\n    allow: []\nrules:\n  external_dependency_policy:\n    enabled: true\n    severity: error\n";
+const FORBIDDEN_LAYER_CONFIG: &str = "layers:\n  domain:\n    paths:\n      - \"src/domain/**\"\n  infrastructure:\n    paths:\n      - \"src/infrastructure/**\"\nallowed_dependencies:\n  domain:\n  infrastructure:\n    - domain\nrules:\n  no_forbidden_layer_dependencies:\n    enabled: true\n    severity: error\n";
 
 #[test]
 fn context_public_api_cycles_and_budgets_report_deterministic_violations() {
@@ -176,6 +177,37 @@ fn transitive_layer_and_external_dependency_policies_are_enforced() {
     }));
 }
 
+#[test]
+fn agent_feedback_includes_source_and_target_files_for_dependency_repairs() {
+    let repo = fixture_root();
+    fixture_write(&repo, "naome.arch.yaml", FORBIDDEN_LAYER_CONFIG);
+    fixture_write(
+        &repo,
+        "src/domain/event.ts",
+        "import { db } from '../infrastructure/db';\n",
+    );
+    fixture_write(&repo, "src/infrastructure/db.ts", "export const db = 1;\n");
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    let feedback = report
+        .agent_feedback
+        .iter()
+        .find(|feedback| feedback.problem.contains("forbidden layer"))
+        .expect("expected forbidden dependency feedback");
+    assert_eq!(
+        feedback.files,
+        vec![
+            "src/domain/event.ts".to_string(),
+            "src/infrastructure/db.ts".to_string()
+        ]
+    );
+    assert!(feedback
+        .must_not_do
+        .iter()
+        .any(|item| item.contains("Do not import infrastructure from domain")));
+}
+
 #[test]
 fn go_external_dependency_policy_matches_full_module_paths() {
     let repo = fixture_root();