fusible 0.20.2

Electronic linter: a fuse that blows to block firmware code generation
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

//! Exit-code contract tests: the promise the whole product is built on.
//!
//! A violation must exit 1 (fuse blown), a clean circuit 0, and a tool
//! failure 2 — otherwise a phase-2 `fusible && generate-pins` chain cannot
//! tell "the circuit is bad" from "fusible could not read its input".

mod common;

use common::{fusible, TestDir};

#[test]
fn intact_circuit_exits_zero_and_says_so_on_stdout() {
    let out = fusible()
        .args(["--input", "examples/circuit.json", "--mcu", "stm32g431"])
        .output()
        .expect("the binary must run");

    assert_eq!(out.status.code(), Some(0));
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(stdout.contains("fuse intact"), "got: {stdout}");
    assert!(stdout.contains("stm32g431"), "got: {stdout}");
}

#[test]
fn violations_exit_one_with_the_fuse_blown_report() {
    let out = fusible()
        .args(["--input", "examples/circuit-flottant.json"])
        .output()
        .expect("the binary must run");

    assert_eq!(out.status.code(), Some(1));
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(stderr.contains("the fuse blew"), "got: {stderr}");
    assert!(stderr.contains("unconnected_net"), "got: {stderr}");
}

#[test]
fn malformed_json_exits_two_as_a_tool_error() {
    let out = fusible()
        .args(["--input", "examples/circuit-broken.json"])
        .output()
        .expect("the binary must run");

    assert_eq!(out.status.code(), Some(2));
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(stderr.contains("invalid Circuit JSON"), "got: {stderr}");
}

#[test]
fn missing_file_exits_two() {
    let out = fusible()
        .args(["--input", "does-not-exist.json"])
        .output()
        .expect("the binary must run");

    assert_eq!(out.status.code(), Some(2));
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(
        stderr.contains("cannot read the Circuit JSON"),
        "got: {stderr}"
    );
}

fn oversized_schematic_component() -> serde_json::Value {
    serde_json::json!({
        "type": "schematic_component",
        "schematic_component_id": "schematic_component_0",
        "source_component_id": "source_component_0",
        "refdes": "U1",
        "center": { "x": 700.0, "y": -1000.0 }
    })
}

#[test]
fn schematic_scale_alone_warns_and_exits_zero() {
    let dir = TestDir::new("scale_warning");
    let path = dir.path.join("circuit.json");
    let circuit = serde_json::json!([oversized_schematic_component()]);
    std::fs::write(&path, circuit.to_string()).expect("write circuit");

    let out = fusible()
        .arg("--input")
        .arg(&path)
        .output()
        .expect("the binary must run");

    assert_eq!(out.status.code(), Some(0));
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(
        stderr.contains("E_SCHEMATIC_SCALE_EXCESSIVE"),
        "got: {stderr}"
    );
    assert!(!stderr.contains("the fuse blew"), "got: {stderr}");
}

#[test]
fn schematic_scale_next_to_a_real_violation_still_blows_the_fuse() {
    let dir = TestDir::new("scale_with_violation");
    let path = dir.path.join("circuit.json");
    let floating = std::fs::read_to_string("examples/circuit-flottant.json").expect("fixture");
    let mut elements: Vec<serde_json::Value> = serde_json::from_str(&floating).expect("json");
    elements.push(oversized_schematic_component());
    std::fs::write(&path, serde_json::Value::Array(elements).to_string()).expect("write circuit");

    let out = fusible()
        .arg("--input")
        .arg(&path)
        .output()
        .expect("the binary must run");

    assert_eq!(out.status.code(), Some(1));
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(stderr.contains("unconnected_net"), "got: {stderr}");
    assert!(
        stderr.contains("E_SCHEMATIC_SCALE_EXCESSIVE"),
        "got: {stderr}"
    );
}