oas3-gen 0.25.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

use crate::tests::event_stream::event_stream::{
  EventPayload, EventsRequest, StreamEvent, TypedEvent, TypedEventType, TypedEventsRequest, TypedEventsRequestQuery,
};

#[allow(unused)]
#[path = "../../fixtures/event_stream/mod.rs"]
#[allow(clippy::module_inception)]
mod event_stream;

#[test]
fn test_stream_event_struct_compiles() {
  let event = StreamEvent {
    id: "evt-123".to_string(),
    data: r#"{"message":"hello"}"#.to_string(),
    timestamp: None,
  };
  assert_eq!(event.id, "evt-123");
}

#[test]
fn test_stream_event_deserializes() {
  let json = r#"{"id": "evt-456", "data": "test data"}"#;
  let event: StreamEvent = serde_json::from_str(json).unwrap();
  assert_eq!(event.id, "evt-456");
  assert_eq!(event.data, "test data");
  assert!(event.timestamp.is_none());
}

#[test]
fn test_typed_event_with_enum() {
  let payload = EventPayload {
    id: "item-1".to_string(),
    name: Some("Test Item".to_string()),
    value: Some(42),
  };
  let event = TypedEvent {
    r#type: TypedEventType::Created,
    payload,
  };
  assert!(matches!(event.r#type, TypedEventType::Created));
  assert_eq!(event.payload.id, "item-1");
}

#[test]
fn test_typed_event_deserializes() {
  let json = r#"{
      "type": "updated",
      "payload": {
        "id": "item-2",
        "name": "Updated Item",
        "value": 100
      }
    }"#;
  let event: TypedEvent = serde_json::from_str(json).unwrap();
  assert!(matches!(event.r#type, TypedEventType::Updated));
  assert_eq!(event.payload.id, "item-2");
  assert_eq!(event.payload.value, Some(100));
}

#[test]
fn test_typed_event_type_enum_values() {
  let json_created = r#""created""#;
  let json_updated = r#""updated""#;
  let json_deleted = r#""deleted""#;

  let created: TypedEventType = serde_json::from_str(json_created).unwrap();
  let updated: TypedEventType = serde_json::from_str(json_updated).unwrap();
  let deleted: TypedEventType = serde_json::from_str(json_deleted).unwrap();

  assert!(matches!(created, TypedEventType::Created));
  assert!(matches!(updated, TypedEventType::Updated));
  assert!(matches!(deleted, TypedEventType::Deleted));
}

#[test]
fn test_stream_events_request_is_empty() {
  let request = EventsRequest {};
  assert!(std::mem::size_of_val(&request) == 0 || std::mem::size_of_val(&request) == 1);
}

#[test]
fn test_stream_typed_events_request_has_query() {
  let request = TypedEventsRequest {
    query: TypedEventsRequestQuery {
      filter: Some("active".to_string()),
    },
  };
  assert_eq!(request.query.filter, Some("active".to_string()));
}

#[test]
fn test_query_serialization() {
  let query = TypedEventsRequestQuery {
    filter: Some("status:active".to_string()),
  };
  let serialized = serde_json::to_string(&query).unwrap();
  assert!(serialized.contains("filter"));
  assert!(serialized.contains("status:active"));
}

#[test]
fn test_query_with_none_filter() {
  let query = TypedEventsRequestQuery { filter: None };
  let serialized = serde_json::to_string(&query).unwrap();
  assert!(!serialized.contains("filter"));
}