active-core 1.4.0

Core implementation of the Active configuration and data language: lexer, parser, IR, dependency graph, evaluator, type system and diagnostics
Documentation 
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

//! Diagnostic quality tests (C-015).
//!
//! Proves on the real shipped path that every diagnostic class carries a
//! stable code and a precise source span: parse errors (E0xx), evaluation
//! type errors (T0xx), and unresolved-identifier warnings (W0xx).

use active_core::{parse, Engine};

#[test]
fn parse_errors_carry_code_and_span() {
    let src = "[app\nname = 1\n";
    let diags = parse(src, "spans").expect_err("unclosed table header must fail");
    let d = diags
        .iter()
        .find(|d| d.code == "E001")
        .expect("E001 expected");
    assert_eq!(d.severity, active_core::diag::Severity::Error);
    // The span points at the offending token — the Newline at column 5,
    // immediately after `[app` where `]` was expected.
    let span = d.span.as_ref().expect("parse diagnostics must carry spans");
    assert_eq!(
        (span.line, span.column),
        (1, 5),
        "span must point at the unexpected Newline token"
    );
}

#[test]
fn e004_depth_error_carries_code_and_span() {
    let src = format!("x = {}1{}", "(".repeat(200), ")".repeat(200));
    let diags = parse(&src, "spans").expect_err("depth limit must fail");
    let d = diags
        .iter()
        .find(|d| d.code == "E004")
        .expect("E004 expected");
    assert!(d.span.is_some(), "E004 must carry a span");
}

#[test]
fn e003_bad_secret_env_carries_code_and_span() {
    let src = "x = secret.env(42)\n";
    let diags = parse(src, "spans").expect_err("non-literal secret.env arg must fail");
    let d = diags
        .iter()
        .find(|d| d.code == "E003")
        .expect("E003 expected");
    assert!(d.span.is_some(), "E003 must carry a span");
}

#[test]
fn unresolved_identifier_warning_carries_code_and_span() {
    // The identifier sits at line 1, column 8 (`x = missing`).
    let src = "x = missing\n";
    let module = parse(src, "spans").expect("must parse");
    let engine = Engine::new();
    let (value, diags) = engine.evaluate(&module).expect("must evaluate");
    let d = diags
        .iter()
        .find(|d| d.code == "W001")
        .expect("W001 expected");
    assert_eq!(d.severity, active_core::diag::Severity::Warning);
    let span = d
        .span
        .as_ref()
        .expect("W001 must carry a span via node_spans");
    assert_eq!(span.line, 1, "span must point at line 1");
    assert_eq!(span.column, 5, "span must point at the identifier start");
    // The value degrades to null rather than failing.
    let json = active_core::convert::value_to_pretty_json(&value);
    assert!(
        json.contains("null"),
        "unresolved value must be null: {json}"
    );
}

#[test]
fn type_error_carries_code_and_span() {
    // `x = !5` — the unary op starts at line 1, column 5.
    let src = "x = !5\n";
    let module = parse(src, "spans").expect("must parse");
    let engine = Engine::new();
    let err = engine
        .evaluate(&module)
        .expect_err("type error must abort evaluation");
    assert_eq!(err.code(), "T001");
    let span = err.span().expect("T001 must carry a span via node_spans");
    assert_eq!((span.line, span.column), (1, 5));
}

#[test]
fn secret_leak_error_has_stable_code() {
    let src = "let p = secret(\"k\")\nurl = \"http://${p}\"\n";
    let module = parse(src, "spans").expect("must parse");
    let engine = Engine::new();
    let err = engine
        .evaluate(&module)
        .expect_err("secret interpolation must be refused");
    assert_eq!(err.code(), "S004");
}

#[test]
fn eval_errors_have_stable_codes() {
    // Cycle detection before any value is produced.
    let module = parse("let a = b\nlet b = a\n", "spans").expect("must parse");
    let err = Engine::new()
        .evaluate(&module)
        .expect_err("cycle must fail");
    assert_eq!(err.code(), "S001");
}