@lamentis/naome 1.3.11 → 1.3.13

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

@@ -0,0 +1,498 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{validate_architecture, ArchitectureScanOptions};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+const BILLING_INTERNAL_DB_IMPORT: &str = "import { db } from '../src/billing/internal/db';\n";
+const BILLING_INTERNAL_DB_EXPORT: &str = "export const db = 1;\n";
+const RUST_PARENT_MODULE_ENTRY: &str = "mod parent;\nuse parent::run;\npub fn main() { run(); }\n";
+const RUST_PARENT_MODULE_SOURCE: &str =
+    "mod child;\nuse self::child::call;\npub fn helper() {}\npub fn run() { call(); }\n";
+const RUST_CHILD_MODULE_SOURCE: &str = "use super::helper;\npub fn call() { helper(); }\n";
+const RUST_CRATE_PARENT_MODULE_SOURCE: &str =
+    "mod child;\nuse crate::parent::child::call;\npub fn helper() {}\npub fn run() { call(); }\n";
+const RUST_CRATE_CHILD_MODULE_SOURCE: &str =
+    "use crate::parent::helper;\npub fn call() { helper(); }\n";
+const TRANSITIVE_LAYER_POLICY_CONFIG: &str = "layers:\n  domain:\n    paths:\n      - \"src/domain/**\"\n  shared:\n    paths:\n      - \"src/shared/**\"\n  infrastructure:\n    paths:\n      - \"src/infrastructure/**\"\nallowed_dependencies:\n  domain:\n    - shared\n  shared:\n  infrastructure:\n    - domain\n    - shared\nexternal_dependencies:\n  domain:\n    allow: []\n  infrastructure:\n    allow:\n      - \"stripe\"\n      - \"@supabase/*\"\nrules:\n  no_transitive_forbidden_layer_dependencies:\n    enabled: true\n    severity: error\n  external_dependency_policy:\n    enabled: true\n    severity: error\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";
+
+#[test]
+fn context_public_api_cycles_and_budgets_report_deterministic_violations() {
+    let repo = fixture_root();
+    write_context_boundary_config(
+        &repo,
+        false,
+        "  no_cycles:\n    enabled: true\n    severity: error\n  max_imports_per_file:\n    enabled: true\n    value: 1\n    severity: warning\n  max_fan_out:\n    enabled: true\n    value: 1\n    severity: warning\n",
+    );
+    fixture_write(
+        &repo,
+        "src/billing/use_ticket.ts",
+        "import { internal } from '../ticketing/internal/service';\nimport { helper } from './helper';\n",
+    );
+    fixture_write(&repo, "src/billing/helper.ts", "export const helper = 1;\n");
+    fixture_write(
+        &repo,
+        "src/ticketing/internal/service.ts",
+        "export const internal = 1;\n",
+    );
+    fixture_write(
+        &repo,
+        "src/billing/a.ts",
+        "import { b } from './b';\nexport const a = b;\n",
+    );
+    fixture_write(
+        &repo,
+        "src/billing/b.ts",
+        "import { a } from './a';\nexport const b = a;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+    let ids = report
+        .violations
+        .iter()
+        .map(|violation| violation.id.as_str())
+        .collect::<Vec<_>>();
+
+    assert!(ids.contains(&"arch.no_cross_context_internal_imports"));
+    assert!(ids.contains(&"arch.public_api_boundary"));
+    assert!(ids.contains(&"arch.no_cycles"));
+    assert!(ids.contains(&"arch.max_imports_per_file"));
+    assert!(ids.contains(&"arch.max_fan_out"));
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.agent_instruction.contains("public API")));
+}
+
+#[test]
+fn catch_all_contexts_do_not_hide_specific_context_boundaries() {
+    let repo = fixture_root();
+    write_context_boundary_config(&repo, true, "");
+    fixture_write(
+        &repo,
+        "src/billing/use_ticket.ts",
+        "import { internal } from '../ticketing/internal/service';\n",
+    );
+    fixture_write(
+        &repo,
+        "src/ticketing/internal/service.ts",
+        "export const internal = 1;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.id == "arch.no_cross_context_internal_imports"));
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.id == "arch.public_api_boundary"));
+}
+
+#[test]
+fn catch_all_contexts_do_not_turn_shared_helpers_into_context_targets() {
+    let repo = fixture_root();
+    write_context_boundary_config(&repo, true, "");
+    fixture_write(
+        &repo,
+        "src/billing/use_logger.ts",
+        "import { logger } from '../shared/logger';\n",
+    );
+    fixture_write(
+        &repo,
+        "src/shared/logger.ts",
+        "export const logger = console;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report.violations.iter().all(|violation| !matches!(
+            violation.id.as_str(),
+            "arch.no_cross_context_internal_imports" | "arch.public_api_boundary"
+        )),
+        "{:?}",
+        report.violations
+    );
+}
+
+fn write_context_boundary_config(repo: &Path, include_default: bool, extra_rules: &str) {
+    let default_context = if include_default {
+        "  default:\n    paths:\n      - \"src/**\"\n    public_api:\n      - \"src/index.ts\"\n"
+    } else {
+        ""
+    };
+    fixture_write(
+        repo,
+        "naome.arch.yaml",
+        &format!(
+            "contexts:\n{default_context}  billing:\n    paths:\n      - \"src/billing/**\"\n    public_api:\n      - \"src/billing/index.ts\"\n  ticketing:\n    paths:\n      - \"src/ticketing/**\"\n    public_api:\n      - \"src/ticketing/index.ts\"\nrules:\n  no_cross_context_internal_imports:\n    enabled: true\n    severity: error\n  public_api_boundary:\n    enabled: true\n    severity: error\n{extra_rules}"
+        ),
+    );
+}
+
+#[test]
+fn transitive_layer_and_external_dependency_policies_are_enforced() {
+    let repo = fixture_root();
+    fixture_write(&repo, "naome.arch.yaml", TRANSITIVE_LAYER_POLICY_CONFIG);
+    fixture_write(
+        &repo,
+        "src/domain/event.ts",
+        "import { shared } from '../shared/shared';\nimport Stripe from 'stripe';\n",
+    );
+    fixture_write(
+        &repo,
+        "src/shared/shared.ts",
+        "import { db } from '../infrastructure/db';\nexport const shared = db;\n",
+    );
+    fixture_write(&repo, "src/infrastructure/db.ts", "export const db = 1;\n");
+    fixture_write(
+        &repo,
+        "src/infrastructure/payments.ts",
+        "import Stripe from 'stripe';\nexport const payments = Stripe;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.no_transitive_forbidden_layer_dependencies"
+            && violation.path.as_deref() == Some("src/domain/event.ts")
+    }));
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.external_dependency_policy"
+            && violation.path.as_deref() == Some("src/domain/event.ts")
+            && violation.to.as_deref() == Some("external:stripe")
+    }));
+    assert!(!report.violations.iter().any(|violation| {
+        violation.id == "arch.external_dependency_policy"
+            && violation.path.as_deref() == Some("src/infrastructure/payments.ts")
+    }));
+}
+
+#[test]
+fn go_external_dependency_policy_matches_full_module_paths() {
+    let repo = fixture_root();
+    fixture_write(&repo, "naome.arch.yaml", GO_EXTERNAL_POLICY_CONFIG);
+    fixture_write(
+        &repo,
+        "domain/payments.go",
+        "package domain\nimport \"github.com/acme/payments\"\n",
+    );
+    fixture_write(
+        &repo,
+        "domain/storage.go",
+        "package domain\nimport \"github.com/acme/storage\"\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(!report.violations.iter().any(|violation| {
+        violation.id == "arch.external_dependency_policy"
+            && violation.path.as_deref() == Some("domain/payments.go")
+    }));
+    assert!(report.violations.iter().any(|violation| {
+        violation.id == "arch.external_dependency_policy"
+            && violation.path.as_deref() == Some("domain/storage.go")
+            && violation.to.as_deref() == Some("external:github.com/acme/storage")
+    }));
+}
+
+#[test]
+fn external_dependency_policy_normalizes_python_members_and_rust_aliases() {
+    let repo = fixture_root();
+    fixture_write(&repo, "naome.arch.yaml", PYTHON_RUST_EXTERNAL_POLICY_CONFIG);
+    fixture_write(
+        &repo,
+        "src/domain/http.py",
+        "from requests import Session\n",
+    );
+    fixture_write(
+        &repo,
+        "src/domain/lib.rs",
+        "extern crate serde as serde_json;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report
+            .violations
+            .iter()
+            .all(|violation| violation.id != "arch.external_dependency_policy"),
+        "{:?}",
+        report.violations
+    );
+}
+
+#[test]
+fn external_dependency_policy_ignores_language_standard_libraries() {
+    let repo = fixture_root();
+    fixture_write(&repo, "naome.arch.yaml", STDLIB_EXTERNAL_POLICY_CONFIG);
+    fixture_write(
+        &repo,
+        "src/domain/node.js",
+        "import fs from 'node:fs';\nimport express from 'express';\n",
+    );
+    fixture_write(
+        &repo,
+        "src/domain/service.py",
+        "from os import path\nimport requests\n",
+    );
+    fixture_write(
+        &repo,
+        "src/domain/lib.rs",
+        "use std::fs;\nextern crate serde;\n",
+    );
+    fixture_write(
+        &repo,
+        "domain/main.go",
+        "package domain\nimport (\n  \"fmt\"\n  \"github.com/acme/storage\"\n)\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+    let external_targets = report
+        .violations
+        .iter()
+        .filter(|violation| violation.id == "arch.external_dependency_policy")
+        .filter_map(|violation| violation.to.as_deref())
+        .collect::<Vec<_>>();
+
+    assert_eq!(
+        external_targets,
+        vec![
+            "external:github.com/acme/storage",
+            "external:serde",
+            "external:express",
+            "external:requests"
+        ]
+    );
+}
+
+#[test]
+fn uncontexted_callers_must_use_context_public_apis() {
+    let repo = fixture_root();
+    fixture_write(
+        &repo,
+        "naome.arch.yaml",
+        r#"
+contexts:
+  billing:
+    paths:
+      - "src/billing/**"
+    public_api:
+      - "src/billing/index.ts"
+rules:
+  no_cross_context_internal_imports:
+    enabled: true
+    severity: error
+  public_api_boundary:
+    enabled: true
+    severity: error
+"#,
+    );
+    fixture_write(&repo, "tests/billing_test.ts", BILLING_INTERNAL_DB_IMPORT);
+    fixture_write(
+        &repo,
+        "src/billing/internal/db.ts",
+        BILLING_INTERNAL_DB_EXPORT,
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.id == "arch.no_cross_context_internal_imports"));
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.id == "arch.public_api_boundary"));
+}
+
+#[test]
+fn non_public_cross_context_imports_do_not_count_as_internal_imports() {
+    let repo = fixture_root();
+    write_context_boundary_config(&repo, false, "");
+    fixture_write(
+        &repo,
+        "src/billing/use_ticket.ts",
+        "import { helper } from '../ticketing/helpers';\n",
+    );
+    fixture_write(
+        &repo,
+        "src/ticketing/helpers.ts",
+        "export const helper = 1;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(!report
+        .violations
+        .iter()
+        .any(|violation| violation.id == "arch.no_cross_context_internal_imports"));
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.id == "arch.public_api_boundary"));
+}
+
+#[test]
+fn rust_module_declarations_do_not_create_import_cycles() {
+    let repo = fixture_root();
+    write_cycle_config(&repo);
+    fixture_write(&repo, "src/lib.rs", RUST_PARENT_MODULE_ENTRY);
+    fixture_write(&repo, "src/parent.rs", RUST_PARENT_MODULE_SOURCE);
+    fixture_write(&repo, "src/parent/child.rs", RUST_CHILD_MODULE_SOURCE);
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report
+            .violations
+            .iter()
+            .all(|violation| violation.id != "arch.no_cycles"),
+        "{:?}",
+        report.violations
+    );
+}
+
+#[test]
+fn rust_crate_qualified_parent_child_modules_do_not_create_import_cycles() {
+    let repo = fixture_root();
+    write_cycle_config(&repo);
+    fixture_write(&repo, "src/lib.rs", "mod parent;\n");
+    fixture_write(&repo, "src/parent.rs", RUST_CRATE_PARENT_MODULE_SOURCE);
+    fixture_write(&repo, "src/parent/child.rs", RUST_CRATE_CHILD_MODULE_SOURCE);
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report
+            .violations
+            .iter()
+            .all(|violation| violation.id != "arch.no_cycles"),
+        "{:?}",
+        report.violations
+    );
+}
+
+#[test]
+fn self_imports_are_reported_as_cycles() {
+    let repo = fixture_root();
+    write_cycle_config(&repo);
+    fixture_write(
+        &repo,
+        "src/a.ts",
+        "import { a } from './a';\nexport const a = 1;\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report
+            .violations
+            .iter()
+            .any(|violation| violation.id == "arch.no_cycles"),
+        "{:?}",
+        report.violations
+    );
+}
+
+#[test]
+fn rust_sibling_module_import_cycles_are_still_reported() {
+    let repo = rust_sibling_cycle_repo(
+        "use crate::parent::right::right;\npub fn left() { right(); }\n",
+        "use crate::parent::left::left;\npub fn right() { left(); }\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report
+            .violations
+            .iter()
+            .any(|violation| violation.id == "arch.no_cycles"),
+        "{:?}",
+        report.violations
+    );
+}
+
+#[test]
+fn rust_relative_sibling_module_references_are_module_internal() {
+    let repo = rust_sibling_cycle_repo(
+        "use super::right::right;\npub fn left() { right(); }\n",
+        "use super::left::left;\npub fn right() { left(); }\n",
+    );
+
+    let report = validate_architecture(&repo, ArchitectureScanOptions::default()).unwrap();
+
+    assert!(
+        report
+            .violations
+            .iter()
+            .any(|violation| violation.id == "arch.no_cycles"),
+        "{:?}",
+        report.violations
+    );
+}
+
+fn rust_sibling_cycle_repo(left_source: &str, right_source: &str) -> PathBuf {
+    let repo = fixture_root();
+    write_cycle_config(&repo);
+    fixture_write(&repo, "src/lib.rs", "mod parent;\n");
+    fixture_write(&repo, "src/parent.rs", "pub mod left;\npub mod right;\n");
+    fixture_write(&repo, "src/parent/left.rs", left_source);
+    fixture_write(&repo, "src/parent/right.rs", right_source);
+    repo
+}
+
+fn write_cycle_config(repo: &Path) {
+    fixture_write(
+        repo,
+        "naome.arch.yaml",
+        r#"
+rules:
+  no_cycles:
+    enabled: true
+    severity: error
+"#,
+    );
+}
+
+fn fixture_root() -> PathBuf {
+    let nonce = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let counter = FIXTURE_COUNTER.fetch_add(1, Ordering::Relaxed);
+    let mut root = std::env::temp_dir();
+    root.push(format!(
+        "naome-arch-rules-fixture-{}-{nonce}-{counter}",
+        std::process::id()
+    ));
+    fs::create_dir_all(&root).unwrap();
+    fs::write(
+        root.join(".naomeignore"),
+        [".naome/archive/", ".naome/tasks/", ""].join("\n"),
+    )
+    .unwrap();
+    root
+}
+
+fn fixture_write(root: &Path, relative_path: &str, content: &str) {
+    let path = relative_path
+        .split('/')
+        .fold(root.to_path_buf(), |mut path, segment| {
+            path.push(segment);
+            path
+        });
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, content).unwrap();
+}

package/crates/naome-core/tests/architecture_support/mod.rs

@@ -0,0 +1,80 @@
+#![allow(dead_code)]
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{ArchitectureEdgeKind, ArchitectureScanReport};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+pub struct FixtureRepo {
+    root: PathBuf,
+}
+
+impl FixtureRepo {
+    pub fn new() -> Self {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let counter = FIXTURE_COUNTER.fetch_add(1, Ordering::Relaxed);
+        let root = std::env::temp_dir().join(format!(
+            "naome-arch-fixture-{}-{nonce}-{counter}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        fs::write(
+            root.join(".naomeignore"),
+            ".naome/archive/\n.naome/tasks/\n",
+        )
+        .unwrap();
+        Self { root }
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn write(&self, relative_path: &str, content: &str) {
+        let fixture_path = self.root.join(relative_path);
+        if let Some(parent) = fixture_path.parent() {
+            if !parent.exists() {
+                fs::create_dir_all(parent).unwrap();
+            }
+        }
+        fs::write(&fixture_path, content.as_bytes()).unwrap();
+    }
+
+    pub fn init_git(&self) {
+        run_git(&self.root, &["init"]);
+        run_git(&self.root, &["config", "user.email", "naome@example.com"]);
+        run_git(&self.root, &["config", "user.name", "NAOME Test"]);
+        self.write("README.md", "# Fixture\n");
+        run_git(&self.root, &["add", "."]);
+        run_git(&self.root, &["commit", "-m", "baseline"]);
+    }
+}
+
+pub fn has_import_edge(scan: &ArchitectureScanReport, from: &str, to: &str) -> bool {
+    scan.graph.edges.iter().any(|edge| {
+        edge.kind == ArchitectureEdgeKind::Imports && edge.from == from && edge.to == to
+    })
+}
+
+fn run_git(root: &Path, args: &[&str]) {
+    let result = Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "git {:?} failed: {}{}",
+        args,
+        String::from_utf8_lossy(&result.stdout),
+        String::from_utf8_lossy(&result.stderr)
+    );
+}

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

@@ -0,0 +1,111 @@
+use naome_core::{scan_architecture, validate_architecture, ArchitectureScanOptions};
+
+mod architecture_support;
+
+use architecture_support::FixtureRepo;
+
+#[test]
+fn swift_imports_emit_external_dependency_edges_for_ios_apps() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "Sources/Tickets/AppView.swift",
+        "import SwiftUI\nimport UIKit\n@testable import TicketsCore\n@preconcurrency import Alamofire\n@_implementationOnly import Firebase\n",
+    );
+
+    let scan = scan_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let fact = scan
+        .file_facts
+        .get("Sources/Tickets/AppView.swift")
+        .unwrap();
+
+    assert_eq!(fact.language.as_deref(), Some("swift"));
+    for package in ["SwiftUI", "UIKit", "TicketsCore", "Alamofire", "Firebase"] {
+        assert!(
+            scan.graph
+                .nodes
+                .iter()
+                .any(|node| { node.id == format!("external:{package}") && node.label == package }),
+            "missing external node for {package}"
+        );
+    }
+}
+
+#[test]
+fn swift_apple_frameworks_do_not_violate_external_dependency_policy() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        r#"
+layers:
+  domain:
+    paths:
+      - "Sources/Domain/**"
+rules:
+  external_dependency_policy:
+    enabled: true
+    severity: error
+external_dependencies:
+  domain:
+    allow: []
+"#,
+    );
+    repo.write(
+        "Sources/Domain/EventView.swift",
+        "import Foundation\nimport SwiftUI\nimport UIKit\nimport CoreBluetooth\nimport CoreImage\nimport CoreML\nimport Network\nimport Vision\nimport Alamofire\n",
+    );
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert_eq!(report.summary.errors, 1);
+    assert_eq!(
+        report.violations[0].to.as_deref(),
+        Some("external:Alamofire")
+    );
+}
+
+#[test]
+fn swiftpm_target_imports_resolve_to_local_target_files() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        r#"
+layers:
+  ui:
+    paths:
+      - "Sources/App/**"
+      - "Tests/**"
+rules:
+  external_dependency_policy:
+    enabled: true
+    severity: error
+external_dependencies:
+  ui:
+    allow: []
+"#,
+    );
+    repo.write(
+        "Sources/App/AppView.swift",
+        "import SwiftUI\nimport Core\nimport Alamofire\n",
+    );
+    repo.write("Sources/Core/Model.swift", "public struct Model {}\n");
+    repo.write(
+        "Tests/CoreTests/CoreTests.swift",
+        "import XCTest\n@testable import Core\n",
+    );
+
+    let report = validate_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+    let scan = scan_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert!(scan.graph.edges.iter().any(|edge| {
+        edge.from == "file:Sources/App/AppView.swift" && edge.to == "file:Sources/Core/Model.swift"
+    }));
+    assert!(scan.graph.edges.iter().any(|edge| {
+        edge.from == "file:Tests/CoreTests/CoreTests.swift"
+            && edge.to == "file:Sources/Core/Model.swift"
+    }));
+    assert_eq!(report.summary.errors, 1);
+    assert_eq!(
+        report.violations[0].to.as_deref(),
+        Some("external:Alamofire")
+    );
+}