chartlet 0.22.0

Compile structured data into deterministic, accessible static charts
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
110
111
112
113

use crate::{ChartSpec, RenderFormat, RenderOptions, advise_json, render_json};

const BASE: &str = r#"{ "schemaVersion": 1, "type": "bar", "title": "x", "data": [ { "label": "a", "value": 1 } ] }"#;

#[test]
fn a_payload_beyond_the_cap_is_refused_before_it_is_parsed() {
    let padded = format!("{}{}", BASE, " ".repeat(5 * 1024 * 1024));
    let error = ChartSpec::from_json(&padded).expect_err("too large");
    assert_eq!((error.code, error.path.as_str()), ("spec_too_large", "/"));
    assert!(error.message.contains("4 MiB"));
    let error =
        render_json(&padded, RenderFormat::Svg, &RenderOptions::default()).expect_err("too large");
    assert_eq!(error.code, "spec_too_large");
}

#[test]
fn a_payload_within_the_cap_is_read() {
    let padded = format!("{}{}", BASE, " ".repeat(1024 * 1024));
    assert!(ChartSpec::from_json(&padded).is_ok());
}

#[test]
fn deep_nesting_and_a_failed_render_leave_the_next_render_unharmed() {
    let nested = format!("{}{}", "[".repeat(50_000), "]".repeat(50_000));
    assert!(ChartSpec::from_json(&nested).is_err());
    let first = render_json(BASE, RenderFormat::Svg, &RenderOptions::default()).expect("renders");
    let second = render_json(BASE, RenderFormat::Svg, &RenderOptions::default()).expect("renders");
    assert_eq!(first.content, second.content);
}

#[test]
fn escaped_text_never_reaches_the_output_unescaped() {
    let spec = r#"{ "schemaVersion": 1, "type": "bar", "title": "<script>alert(1)</script> & \"q\"",
        "data": [ { "label": "</text><g onload=x>", "value": 1 } ] }"#;
    let output = render_json(spec, RenderFormat::Html, &RenderOptions::default()).expect("renders");
    assert!(!output.content.contains("<script>alert"));
    assert!(!output.content.contains("<g onload"));
    assert!(output.content.contains("&lt;script&gt;"));
}

/// The size the render asks for with `canvas_too_small`, as a number.
fn needed(spec: &str, path: &str) -> Option<u32> {
    let output = render_json(spec, RenderFormat::Svg, &RenderOptions::default()).expect("renders");
    let warning = output
        .warnings
        .iter()
        .find(|warning| warning.code == "canvas_too_small" && warning.path == path)?;
    warning
        .message
        .split("needs ")
        .nth(1)?
        .split_whitespace()
        .next()?
        .parse()
        .ok()
}

/// Issue 6: groups and boundaries add a frame around their members. The size a diagram asks for
/// stays plausible, and rendering again at that size resolves the warning.
#[test]
fn groups_and_boundaries_ask_for_a_plausible_canvas_that_resolves_the_warning() {
    let nodes: Vec<String> = (0..12)
        .map(|index| format!(r#"{{ "id": "n{index}", "label": "Step {index}" }}"#))
        .collect();
    let edges: Vec<String> = (0..11)
        .map(|index| format!(r#"{{ "from": "n{index}", "to": "n{}" }}"#, index + 1))
        .collect();
    let flow = format!(
        r#"{{ "schemaVersion": 1, "type": "flow", "title": "Grouped", "width": 320, "height": 300,
            "flow": {{ "nodes": [{}], "edges": [{}],
              "groups": [ {{ "label": "A", "nodes": ["n0","n1","n2"] }}, {{ "label": "B", "nodes": ["n3","n4","n5"] }} ] }} }}"#,
        nodes.join(","),
        edges.join(",")
    );
    let components: Vec<String> = (0..9)
        .map(|index| {
            format!(
                r#"{{ "id": "c{index}", "label": "Component {index}", "in": "b{}" }}"#,
                index % 3
            )
        })
        .collect();
    let connections: Vec<String> = (0..8)
        .map(|index| format!(r#"{{ "from": "c{index}", "to": "c{}" }}"#, index + 1))
        .collect();
    let architecture = format!(
        r#"{{ "schemaVersion": 1, "type": "architecture", "title": "Nested", "width": 400, "height": 400,
            "architecture": {{ "boundaries": [ {{ "id": "b0", "label": "Zone" }},
              {{ "id": "b1", "label": "Inner", "in": "b0" }}, {{ "id": "b2", "label": "Core", "in": "b1" }} ],
              "components": [{}], "connections": [{}] }} }}"#,
        components.join(","),
        connections.join(",")
    );
    for (name, spec) in [("flow", flow), ("architecture", architecture)] {
        for path in ["/width", "/height"] {
            if let Some(size) = needed(&spec, path) {
                assert!(
                    (200..=6_000).contains(&size),
                    "{name} asks for {size} pixels at {path}"
                );
            }
        }
        for help in advise_json(&spec, &RenderOptions::default()).expect("renders") {
            if help.code == "canvas_too_small" {
                assert!(
                    help.remedies.iter().all(|remedy| remedy.resolves),
                    "{name}: the recommended size at {} resolves the warning",
                    help.path
                );
            }
        }
    }
}