oas3-gen 0.22.0

A rust type generator for OpenAPI v3.1.x specification.
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

use oas3::spec::Response;

use crate::generator::ast::{StatusCodeToken, status_codes::status_code_to_variant_name};

#[test]
fn test_from_openapi_specific_codes() {
  let cases = [
    ("200", StatusCodeToken::Ok200),
    ("201", StatusCodeToken::Created201),
    ("204", StatusCodeToken::NoContent204),
    ("400", StatusCodeToken::BadRequest400),
    ("404", StatusCodeToken::NotFound404),
    ("500", StatusCodeToken::InternalServerError500),
  ];
  for (input, expected) in cases {
    assert_eq!(StatusCodeToken::from_openapi(input), expected, "failed for {input}");
  }
}

#[test]
fn test_from_openapi_wildcards() {
  let cases = [
    ("1XX", StatusCodeToken::Informational1XX),
    ("1xx", StatusCodeToken::Informational1XX),
    ("2XX", StatusCodeToken::Success2XX),
    ("2xx", StatusCodeToken::Success2XX),
    ("4XX", StatusCodeToken::ClientError4XX),
    ("5XX", StatusCodeToken::ServerError5XX),
  ];
  for (input, expected) in cases {
    assert_eq!(StatusCodeToken::from_openapi(input), expected, "failed for {input}");
  }
}

#[test]
fn test_from_openapi_default_and_unknown() {
  assert_eq!(StatusCodeToken::from_openapi("default"), StatusCodeToken::Default);
  assert_eq!(StatusCodeToken::from_openapi("418"), StatusCodeToken::Unknown(418));
  assert_eq!(StatusCodeToken::from_openapi("invalid"), StatusCodeToken::Default);
}

#[test]
fn test_code() {
  assert_eq!(StatusCodeToken::Ok200.code(), Some(200));
  assert_eq!(StatusCodeToken::NotFound404.code(), Some(404));
  assert_eq!(StatusCodeToken::Unknown(418).code(), Some(418));
  assert_eq!(StatusCodeToken::Success2XX.code(), None);
  assert_eq!(StatusCodeToken::Default.code(), None);
}

#[test]
fn test_variant_name() {
  assert_eq!(StatusCodeToken::Ok200.variant_name(), "Ok");
  assert_eq!(StatusCodeToken::NotFound404.variant_name(), "NotFound");
  assert_eq!(StatusCodeToken::Success2XX.variant_name(), "Success");
  assert_eq!(StatusCodeToken::Default.variant_name(), "Unknown");
}

#[test]
fn test_display() {
  assert_eq!(StatusCodeToken::Ok200.to_string(), "200");
  assert_eq!(StatusCodeToken::Success2XX.to_string(), "2XX");
  assert_eq!(StatusCodeToken::Unknown(418).to_string(), "418");
  assert_eq!(StatusCodeToken::Default.to_string(), "default");
}

#[test]
fn test_is_success() {
  assert!(StatusCodeToken::Ok200.is_success());
  assert!(StatusCodeToken::Created201.is_success());
  assert!(StatusCodeToken::Success2XX.is_success());
  assert!(!StatusCodeToken::NotFound404.is_success());
  assert!(!StatusCodeToken::Default.is_success());
}

fn make_response(description: Option<&str>) -> Response {
  Response {
    description: description.map(ToString::to_string),
    ..Default::default()
  }
}

#[test]
fn test_known_status_codes() {
  let cases = [
    (StatusCodeToken::Ok200, "Ok"),
    (StatusCodeToken::Created201, "Created"),
    (StatusCodeToken::NotFound404, "NotFound"),
    (StatusCodeToken::InternalServerError500, "InternalServerError"),
  ];
  for (token, expected) in cases {
    let result = status_code_to_variant_name(token, &make_response(None));
    assert_eq!(result.to_string(), expected, "failed for {token:?}");
  }
}

#[test]
fn test_wildcard_status_codes() {
  let cases = [
    (StatusCodeToken::Informational1XX, "Informational"),
    (StatusCodeToken::Success2XX, "Success"),
    (StatusCodeToken::Redirection3XX, "Redirection"),
    (StatusCodeToken::ClientError4XX, "ClientError"),
    (StatusCodeToken::ServerError5XX, "ServerError"),
  ];
  for (token, expected) in cases {
    let result = status_code_to_variant_name(token, &make_response(None));
    assert_eq!(result.to_string(), expected, "failed for {token:?}");
  }
}

#[test]
fn test_default_status_code() {
  let result = status_code_to_variant_name(StatusCodeToken::Default, &make_response(None));
  assert_eq!(result.to_string(), "Unknown");
}

#[test]
fn test_unknown_with_description() {
  let response = make_response(Some("I'm a teapot"));
  let result = status_code_to_variant_name(StatusCodeToken::Unknown(418), &response);
  assert_eq!(result.to_string(), "ImATeapot");
}

#[test]
fn test_unknown_without_description() {
  let result = status_code_to_variant_name(StatusCodeToken::Unknown(418), &make_response(None));
  assert_eq!(result.to_string(), "Status418");
}