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

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

#[cfg(test)]
mod tests {
  use super::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"));
  }
}