crank/tests/unit/test_check_rust_boundaries.py

import importlib.util
import sys
import unittest
from pathlib import Path


ROOT = Path(__file__).resolve().parents[2]
CHECKER = ROOT / "scripts" / "check-rust-boundaries.py"


def load_checker_module():
    spec = importlib.util.spec_from_file_location("check_rust_boundaries", CHECKER)
    module = importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    sys.modules[spec.name] = module
    spec.loader.exec_module(module)
    return module


def package(root: Path, name: str, rel_dir: str, dependencies: list[str] | None = None) -> dict:
    dependencies = dependencies or []
    return {
        "id": f"path+file://{root / rel_dir}#{name}",
        "name": name,
        "manifest_path": str(root / rel_dir / "Cargo.toml"),
        "dependencies": [{"name": dependency} for dependency in dependencies],
    }


def metadata(packages: list[dict], root: Path | None = None) -> dict:
    root = root or Path("/tmp/crank")
    return {
        "workspace_root": str(root),
        "workspace_members": [pkg["id"] for pkg in packages],
        "packages": packages,
    }


class RustBoundaryCheckTests(unittest.TestCase):
    def setUp(self) -> None:
        self.checker = load_checker_module()
        self.root = Path("/tmp/crank")

    def test_allows_apps_to_depend_on_workspace_crates(self) -> None:
        packages = [
            package(self.root, "admin-api", "apps/admin-api", ["crank-runtime"]),
            package(self.root, "crank-runtime", "crates/crank-runtime", ["crank-core"]),
            package(self.root, "crank-core", "crates/crank-core"),
        ]

        violations = self.checker.find_violations(metadata(packages, self.root))

        self.assertEqual(violations, [])

    def test_rejects_core_dependency_on_runtime(self) -> None:
        packages = [
            package(self.root, "crank-core", "crates/crank-core", ["crank-runtime"]),
            package(self.root, "crank-runtime", "crates/crank-runtime"),
        ]

        violations = self.checker.find_violations(metadata(packages, self.root))

        self.assertEqual(len(violations), 1)
        self.assertEqual(violations[0].source, "crank-core")
        self.assertEqual(violations[0].dependency, "crank-runtime")

    def test_rejects_workspace_crate_dependency_on_app(self) -> None:
        packages = [
            package(self.root, "crank-runtime", "crates/crank-runtime", ["admin-api"]),
            package(self.root, "admin-api", "apps/admin-api"),
        ]

        violations = self.checker.find_violations(metadata(packages, self.root))

        self.assertEqual(len(violations), 1)
        self.assertIn("must not depend on apps", violations[0].reason)

    def test_rejects_registry_dependency_on_adapter(self) -> None:
        packages = [
            package(self.root, "crank-registry", "crates/crank-registry", ["crank-adapter-rest"]),
            package(self.root, "crank-adapter-rest", "crates/crank-adapter-rest"),
        ]

        violations = self.checker.find_violations(metadata(packages, self.root))

        self.assertEqual(len(violations), 1)
        self.assertEqual(violations[0].source, "crank-registry")
        self.assertEqual(violations[0].dependency, "crank-adapter-rest")

    def test_allows_apps_to_depend_on_observability(self) -> None:
        packages = [
            package(
                self.root,
                "admin-api",
                "apps/admin-api",
                ["crank-observability"],
            ),
            package(
                self.root,
                "crank-observability",
                "crates/crank-observability",
            ),
        ]

        violations = self.checker.find_violations(metadata(packages, self.root))

        self.assertEqual(violations, [])

    def test_rejects_observability_dependency_on_workspace_crates(self) -> None:
        for dependency in ("crank-core", "crank-registry", "crank-runtime"):
            packages = [
                package(
                    self.root,
                    "crank-observability",
                    "crates/crank-observability",
                    [dependency],
                ),
                package(self.root, dependency, f"crates/{dependency}"),
            ]

            violations = self.checker.find_violations(metadata(packages, self.root))

            self.assertEqual(len(violations), 1, dependency)
            self.assertEqual(violations[0].source, "crank-observability")
            self.assertEqual(violations[0].dependency, dependency)

    def test_rejects_domain_and_runtime_dependencies_on_observability(self) -> None:
        for source in ("crank-core", "crank-registry", "crank-runtime"):
            packages = [
                package(
                    self.root,
                    source,
                    f"crates/{source}",
                    ["crank-observability"],
                ),
                package(
                    self.root,
                    "crank-observability",
                    "crates/crank-observability",
                ),
            ]

            violations = self.checker.find_violations(metadata(packages, self.root))

            self.assertEqual(len(violations), 1, source)
            self.assertEqual(violations[0].source, source)
            self.assertEqual(violations[0].dependency, "crank-observability")


if __name__ == "__main__":
    unittest.main()