server-less 0.6.0

Composable derive macros for common Rust patterns
Documentation 
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

//! Integration tests for the AsyncAPI specification generation macro.

#![allow(dead_code)]
#![allow(unused_variables)]

use server_less::asyncapi;

#[derive(Clone)]
struct ChatService;

#[asyncapi(
    title = "Chat API",
    version = "2.0.0",
    server = "ws://chat.example.com"
)]
impl ChatService {
    /// Send a message to a chat room
    pub fn send_message(&self, room: String, content: String) -> bool {
        true
    }

    /// Get message history for a room
    pub fn get_history(&self, room: String, limit: Option<u32>) -> Vec<String> {
        vec![]
    }

    /// Join a chat room
    pub fn join_room(&self, room: String, user: String) -> bool {
        true
    }
}

#[test]
fn test_asyncapi_spec_structure() {
    let spec = ChatService::asyncapi_spec();

    assert_eq!(spec["asyncapi"], "2.6.0");
    assert_eq!(spec["info"]["title"], "Chat API");
    assert_eq!(spec["info"]["version"], "2.0.0");
}

#[test]
fn test_asyncapi_server() {
    let spec = ChatService::asyncapi_spec();

    assert_eq!(spec["servers"]["default"]["url"], "ws://chat.example.com");
    assert_eq!(spec["servers"]["default"]["protocol"], "ws");
}

#[test]
fn test_asyncapi_channels() {
    let spec = ChatService::asyncapi_spec();

    assert!(spec["channels"]["sendMessage"].is_object());
    assert!(spec["channels"]["getHistory"].is_object());
    assert!(spec["channels"]["joinRoom"].is_object());
}

#[test]
fn test_asyncapi_channel_operations() {
    let spec = ChatService::asyncapi_spec();

    // Each channel should have publish and subscribe
    let send_msg = &spec["channels"]["sendMessage"];
    assert!(send_msg["publish"].is_object());
    assert!(send_msg["subscribe"].is_object());
}

#[test]
fn test_asyncapi_messages() {
    let spec = ChatService::asyncapi_spec();

    // Should have request/response messages
    assert!(spec["components"]["messages"]["SendMessageRequest"].is_object());
    assert!(spec["components"]["messages"]["SendMessageResponse"].is_object());
}

#[test]
fn test_asyncapi_message_payload() {
    let spec = ChatService::asyncapi_spec();

    let request = &spec["components"]["messages"]["SendMessageRequest"];
    assert!(request["payload"]["properties"]["room"].is_object());
    assert!(request["payload"]["properties"]["content"].is_object());
}

#[test]
fn test_asyncapi_json_output() {
    let json = ChatService::asyncapi_json();

    assert!(json.contains("asyncapi"));
    assert!(json.contains("Chat API"));
    assert!(json.contains("channels"));
}

// Test default values
#[derive(Clone)]
struct SimpleService;

#[asyncapi]
impl SimpleService {
    pub fn ping(&self) -> String {
        "pong".to_string()
    }
}

#[test]
fn test_asyncapi_defaults() {
    let spec = SimpleService::asyncapi_spec();

    // Default title should be struct name
    assert_eq!(spec["info"]["title"], "SimpleService");
    // Default version
    assert_eq!(spec["info"]["version"], "1.0.0");
    // Default server
    assert_eq!(spec["servers"]["default"]["url"], "ws://localhost:8080");
}

// Combined with ws
#[derive(Clone)]
struct CombinedService;

#[server_less::ws(path = "/ws")]
#[asyncapi(title = "Combined WebSocket API")]
impl CombinedService {
    pub fn echo(&self, message: String) -> String {
        message
    }
}

#[test]
fn test_asyncapi_with_ws() {
    // Both macros work together
    let spec = CombinedService::asyncapi_spec();
    assert_eq!(spec["info"]["title"], "Combined WebSocket API");

    let methods = CombinedService::ws_methods();
    assert!(methods.contains(&"echo".to_string()));
}