oas3-gen 0.23.2

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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::collections::BTreeMap;

use oas3::spec::{ObjectOrReference, ObjectSchema, SchemaType, SchemaTypeSet};

use crate::{
  generator::{ast::RustType, converter::SchemaConverter},
  tests::common::{create_test_graph, default_config},
};

#[test]
fn test_inline_object_generation() -> anyhow::Result<()> {
  let mut parent_schema = ObjectSchema {
    schema_type: Some(SchemaTypeSet::Single(SchemaType::Object)),
    ..Default::default()
  };

  // Define an inline object for the "config" field
  let mut config_schema = ObjectSchema {
    schema_type: Some(SchemaTypeSet::Single(SchemaType::Object)),
    ..Default::default()
  };
  config_schema.properties.insert(
    "timeout".to_string(),
    ObjectOrReference::Object(ObjectSchema {
      schema_type: Some(SchemaTypeSet::Single(SchemaType::Integer)),
      ..Default::default()
    }),
  );
  config_schema.properties.insert(
    "enabled".to_string(),
    ObjectOrReference::Object(ObjectSchema {
      schema_type: Some(SchemaTypeSet::Single(SchemaType::Boolean)),
      ..Default::default()
    }),
  );

  parent_schema
    .properties
    .insert("config".to_string(), ObjectOrReference::Object(config_schema));

  let graph = create_test_graph(BTreeMap::from([("Parent".to_string(), parent_schema)]));
  let converter = SchemaConverter::new(&graph, default_config());
  let result = converter.convert_schema("Parent", graph.get_schema("Parent").unwrap(), None)?;

  // Check for Parent struct
  let parent_struct = result
    .iter()
    .find_map(|ty| match ty {
      RustType::Struct(def) if def.name == "Parent" => Some(def),
      _ => None,
    })
    .expect("Parent struct should be present");

  // Check "config" field type
  let config_field = parent_struct
    .fields
    .iter()
    .find(|f| f.name == "config")
    .expect("config field should exist");

  assert_eq!(
    config_field.rust_type.to_rust_type(),
    "Option<ParentConfig>",
    "Config field should reference generated inline struct"
  );

  // Check for ParentConfig struct
  let config_struct = result
    .iter()
    .find_map(|ty| match ty {
      RustType::Struct(def) if def.name == "ParentConfig" => Some(def),
      _ => None,
    })
    .expect("ParentConfig struct should be present");

  assert!(config_struct.fields.iter().any(|f| f.name == "timeout"));
  assert!(config_struct.fields.iter().any(|f| f.name == "enabled"));

  Ok(())
}

#[test]
fn test_inline_object_without_type_field() -> anyhow::Result<()> {
  // Some specs omit "type": "object" but implied by properties
  let mut parent_schema = ObjectSchema {
    schema_type: Some(SchemaTypeSet::Single(SchemaType::Object)),
    ..Default::default()
  };

  // Define an inline object for the "metadata" field WITHOUT type: object
  let mut meta_schema = ObjectSchema {
    schema_type: None, // Intentionally missing
    ..Default::default()
  };
  meta_schema.properties.insert(
    "key".to_string(),
    ObjectOrReference::Object(ObjectSchema {
      schema_type: Some(SchemaTypeSet::Single(SchemaType::String)),
      ..Default::default()
    }),
  );

  parent_schema
    .properties
    .insert("metadata".to_string(), ObjectOrReference::Object(meta_schema));

  let graph = create_test_graph(BTreeMap::from([("Resource".to_string(), parent_schema)]));
  let converter = SchemaConverter::new(&graph, default_config());
  let result = converter.convert_schema("Resource", graph.get_schema("Resource").unwrap(), None)?;

  // Check for Resource struct
  let resource_struct = result
    .iter()
    .find_map(|ty| match ty {
      RustType::Struct(def) if def.name == "Resource" => Some(def),
      _ => None,
    })
    .expect("Resource struct should be present");

  // Check "metadata" field type
  let meta_field = resource_struct
    .fields
    .iter()
    .find(|f| f.name == "metadata")
    .expect("metadata field should exist");

  assert_eq!(
    meta_field.rust_type.to_rust_type(),
    "Option<ResourceMetadata>",
    "Metadata field should reference generated inline struct even if type is missing"
  );

  // Check for ResourceMetadata struct
  let meta_struct = result
    .iter()
    .find_map(|ty| match ty {
      RustType::Struct(def) if def.name == "ResourceMetadata" => Some(def),
      _ => None,
    })
    .expect("ResourceMetadata struct should be present");

  assert!(meta_struct.fields.iter().any(|f| f.name == "key"));

  Ok(())
}