boundary 0.27.0

A static analysis tool for evaluating DDD and Hexagonal Architecture
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

/// Acceptance tests for FR-28: True Layer Conformance Scoring.
///
/// Each test maps to a scenario in features/layer_conformance.feature.
/// Run `cargo test --test layer_conformance_test` to check the current state.
use std::process::Command;

fn boundary_cmd() -> Command {
    Command::new(env!("CARGO_BIN_EXE_boundary"))
}

fn fixture(name: &str) -> String {
    format!("{}/tests/fixtures/{name}", env!("CARGO_MANIFEST_DIR"))
}

/// Run `boundary analyze <fixture> --score-only --format json` and parse the JSON score object.
fn score_json(fixture_name: &str) -> serde_json::Value {
    let path = fixture(fixture_name);
    let output = boundary_cmd()
        .args(["analyze", &path, "--score-only", "--format", "json"])
        .output()
        .unwrap_or_else(|e| panic!("failed to run boundary on {fixture_name}: {e}"));

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    assert!(
        output.status.success(),
        "boundary failed on {fixture_name}: stdout={stdout}, stderr={stderr}"
    );

    serde_json::from_str(stdout.trim())
        .unwrap_or_else(|e| panic!("invalid JSON from {fixture_name}: {e}\noutput: {stdout}"))
}

/// Run `boundary analyze <fixture>` in text mode and return stdout.
fn analyze_text(fixture_name: &str) -> String {
    let path = fixture(fixture_name);
    let output = boundary_cmd()
        .args(["analyze", &path])
        .output()
        .unwrap_or_else(|e| panic!("failed to run boundary (text) on {fixture_name}: {e}"));

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    assert!(
        output.status.success(),
        "boundary (text) failed on {fixture_name}: stdout={stdout}, stderr={stderr}"
    );

    stdout.to_string()
}

// --------------------------------------------------------------------------
// Scenario: JSON score output uses layer_conformance field
// --------------------------------------------------------------------------

#[test]
fn test_score_json_has_layer_conformance_not_layer_isolation() {
    let score = score_json("sample-go-project");

    assert!(
        score.get("layer_conformance").is_some(),
        "score JSON must contain 'layer_conformance', got: {score}"
    );
    assert!(
        score.get("layer_isolation").is_none(),
        "score JSON must NOT contain old 'layer_isolation', got: {score}"
    );
}

// --------------------------------------------------------------------------
// Scenario: JSON score output uses dependency_compliance field
// --------------------------------------------------------------------------

#[test]
fn test_score_json_has_dependency_compliance_not_dependency_direction() {
    let score = score_json("sample-go-project");

    assert!(
        score.get("dependency_compliance").is_some(),
        "score JSON must contain 'dependency_compliance', got: {score}"
    );
    assert!(
        score.get("dependency_direction").is_none(),
        "score JSON must NOT contain old 'dependency_direction', got: {score}"
    );
}

// --------------------------------------------------------------------------
// Scenario: Layer conformance is a valid percentage
// --------------------------------------------------------------------------

#[test]
fn test_layer_conformance_is_valid_percentage() {
    let score = score_json("sample-go-project");

    let lc = score["layer_conformance"]
        .as_f64()
        .expect("layer_conformance must be a number");

    assert!(
        (0.0..=100.0).contains(&lc),
        "layer_conformance must be in [0, 100], got {lc}"
    );
}

// --------------------------------------------------------------------------
// Scenario: Interface coverage uses min-over-max formula
// --------------------------------------------------------------------------

#[test]
fn test_interface_coverage_uses_min_max_formula() {
    // The interface-coverage-project fixture has 2 ports and 1 adapter.
    // New formula: min(2,1)/max(2,1) = 0.5 → ~50%
    // Old formula: min(2/1, 1.0) * 100 = 100% (the bug this fixes)
    let score = score_json("interface-coverage-project");

    let iface = score["interface_coverage"]
        .as_f64()
        .expect("interface_coverage must be a number");

    assert!(
        (iface - 50.0).abs() <= 5.0,
        "interface_coverage with 2 ports / 1 adapter should be ~50% (±5), got {iface}"
    );
}

// --------------------------------------------------------------------------
// Scenario: Text output uses new label names
// --------------------------------------------------------------------------

#[test]
fn test_text_output_has_layer_conformance_label() {
    let text = analyze_text("sample-go-project");

    assert!(
        text.contains("Layer Conformance"),
        "text output must contain 'Layer Conformance', got:\n{text}"
    );
    assert!(
        !text.contains("Layer Isolation"),
        "text output must NOT contain old 'Layer Isolation', got:\n{text}"
    );
}

#[test]
fn test_text_output_has_dependency_compliance_label() {
    let text = analyze_text("sample-go-project");

    assert!(
        text.contains("Dependency Compliance"),
        "text output must contain 'Dependency Compliance', got:\n{text}"
    );
    assert!(
        !text.contains("Dependency Direction"),
        "text output must NOT contain old 'Dependency Direction', got:\n{text}"
    );
}