open-lark 0.14.0

Enterprise-grade Lark/Feishu Open API SDK with comprehensive Chinese documentation and advanced error handling
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

use crate::client::ws_client::LarkWsClient;
use lark_websocket_protobuf::pbbp2::{Frame, Header};

#[tokio::test]
async fn test_single_package_payload_preservation() {
    let mut client = LarkWsClient::new_for_test();

    // 创建单包消息的 frame
    let test_payload = b"test payload data".to_vec();
    let frame = Frame {
        seq_id: 1,
        log_id: 1,
        service: 1,
        method: 1,
        headers: vec![
            Header {
                key: "type".to_string(),
                value: "event".to_string(),
            },
            Header {
                key: "message_id".to_string(),
                value: "test_msg_001".to_string(),
            },
            // 没有 sum 和 seq 头部，应该默认为单包
        ],
        payload_encoding: None,
        payload_type: None,
        payload: Some(test_payload.clone()),
        log_id_new: None,
    };

    // 处理单包消息
    let result = client.process_frame_packages(frame).await;

    // 验证结果
    assert!(result.is_some());
    let processed_frame = result.unwrap();
    assert!(processed_frame.payload.is_some());
    assert_eq!(processed_frame.payload.unwrap(), test_payload);
}

#[tokio::test]
async fn test_multi_package_payload_combination() {
    let mut client = LarkWsClient::new_for_test();

    let part1 = b"Hello ".to_vec();
    let part2 = b"World!".to_vec();
    let combined = b"Hello World!".to_vec();

    // 创建第一个包
    let frame1 = Frame {
        seq_id: 1,
        log_id: 1,
        service: 1,
        method: 1,
        headers: vec![
            Header {
                key: "type".to_string(),
                value: "event".to_string(),
            },
            Header {
                key: "message_id".to_string(),
                value: "test_msg_002".to_string(),
            },
            Header {
                key: "sum".to_string(),
                value: "2".to_string(),
            },
            Header {
                key: "seq".to_string(),
                value: "0".to_string(),
            },
        ],
        payload_encoding: None,
        payload_type: None,
        payload: Some(part1),
        log_id_new: None,
    };

    // 处理第一个包 - 应该返回 None 因为还没收齐
    let result1 = client.process_frame_packages(frame1).await;
    assert!(result1.is_none());

    // 创建第二个包
    let frame2 = Frame {
        seq_id: 2,
        log_id: 1,
        service: 1,
        method: 1,
        headers: vec![
            Header {
                key: "type".to_string(),
                value: "event".to_string(),
            },
            Header {
                key: "message_id".to_string(),
                value: "test_msg_002".to_string(),
            },
            Header {
                key: "sum".to_string(),
                value: "2".to_string(),
            },
            Header {
                key: "seq".to_string(),
                value: "1".to_string(),
            },
        ],
        payload_encoding: None,
        payload_type: None,
        payload: Some(part2),
        log_id_new: None,
    };

    // 处理第二个包 - 应该返回组合后的完整消息
    let result2 = client.process_frame_packages(frame2).await;
    assert!(result2.is_some());
    let processed_frame = result2.unwrap();
    assert!(processed_frame.payload.is_some());
    assert_eq!(processed_frame.payload.unwrap(), combined);
}