cratestack-cli 0.18.0

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
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

#![cfg(test)]
//! `cratestack diff` on enums (`enums.rs`, `response_reach.rs`).

use super::Severity;
use super::test_support::{categories, diff};

/// `Role` is read back on `User`; `Channel` only ever arrives as an argument.
fn schema(role: &str, channel: &str) -> String {
    format!(
        "enum Role {{\n{role}\n}}\n\nenum Channel {{\n{channel}\n}}\n\n\
         model User {{\n  id Int @id\n  role Role\n}}\n\n\
         mutation procedure notify(channel: Channel): Boolean\n"
    )
}

const ROLE: &str = "  admin\n  member";
const CHANNEL: &str = "  email\n  sms";

#[test]
fn an_unchanged_enum_reports_nothing() {
    let base = schema(ROLE, CHANNEL);
    assert!(diff(&base, &base).changes.is_empty());
}

#[test]
fn removing_a_variant_is_breaking() {
    let result = diff(&schema(ROLE, CHANNEL), &schema("  admin", CHANNEL));
    assert_eq!(
        categories(&result, Severity::Breaking),
        ["enum_variant_removed"]
    );
    assert!(
        result.changes[0].message.contains("`member`"),
        "{:?}",
        result.changes
    );
}

#[test]
fn a_variant_added_to_an_enum_responses_carry_is_breaking() {
    let result = diff(
        &schema(ROLE, CHANNEL),
        &schema("  admin\n  member\n  guest", CHANNEL),
    );
    assert_eq!(
        categories(&result, Severity::Breaking),
        ["enum_variant_added"]
    );
    assert!(result.changes[0].message.contains("refuses the new value"));
}

#[test]
fn a_variant_added_to_a_request_only_enum_is_additive() {
    let result = diff(
        &schema(ROLE, CHANNEL),
        &schema(ROLE, "  email\n  sms\n  push"),
    );
    assert!(!result.has_breaking(), "{:?}", result.changes);
    assert_eq!(
        categories(&result, Severity::Additive),
        ["enum_variant_added"]
    );
}

#[test]
fn an_enum_reached_through_a_returned_type_counts_as_a_response() {
    let with = |variants: &str| {
        format!(
            "enum Tier {{\n{variants}\n}}\n\ntype Plan {{\n  tier Tier\n}}\n\n\
             procedure plans(): Plan[]\n"
        )
    };
    let result = diff(&with("  free\n  pro"), &with("  free\n  pro\n  team"));
    assert_eq!(
        categories(&result, Severity::Breaking),
        ["enum_variant_added"]
    );
}

#[test]
fn reordering_a_string_enum_is_internal() {
    let result = diff(
        &schema(ROLE, CHANNEL),
        &schema("  member\n  admin", CHANNEL),
    );
    assert_eq!(
        categories(&result, Severity::Internal),
        ["enum_variants_reordered"]
    );
    assert!(!result.has_breaking());
}

#[test]
fn removing_and_adding_an_enum() {
    let without = "model User {\n  id Int @id\n}\n";
    let with = format!("{without}\nenum Mood {{\n  calm\n}}\n");
    assert_eq!(
        categories(&diff(&with, without), Severity::Breaking),
        ["enum_removed"]
    );
    assert_eq!(
        categories(&diff(without, &with), Severity::Additive),
        ["enum_added"]
    );
}

#[test]
fn an_ordinal_enum_is_matched_by_number() {
    let before = schema("  admin = 1\n  member = 2", CHANNEL);
    // A rename keeps ordinal 2 on the wire but changes client identifiers.
    let renamed = diff(&before, &schema("  admin = 1\n  user = 2", CHANNEL));
    assert_eq!(
        categories(&renamed, Severity::Breaking),
        ["enum_variant_renamed"]
    );
    // Reordering lines is nothing at all: each value names itself.
    let reordered = diff(&before, &schema("  member = 2\n  admin = 1", CHANNEL));
    assert!(reordered.changes.is_empty(), "{:?}", reordered.changes);
    // A renumbering drops the old value and adds a new one.
    let renumbered = diff(&before, &schema("  admin = 1\n  member = 3", CHANNEL));
    assert_eq!(
        categories(&renumbered, Severity::Breaking),
        ["enum_variant_removed", "enum_variant_added"]
    );
}

#[test]
fn switching_between_names_and_ordinals_is_breaking() {
    let names = schema(ROLE, CHANNEL);
    let ordinals = schema("  admin = 1\n  member = 2", CHANNEL);
    for (from, to) in [(&names, &ordinals), (&ordinals, &names)] {
        let result = diff(from, to);
        assert_eq!(
            categories(&result, Severity::Breaking),
            ["enum_encoding_changed"]
        );
    }
}