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


//! Builder模式兼容性测试
//! 
//! 测试Builder模式的向后兼容性和新功能

use open_lark::prelude::*;
use open_lark::service::workplace::models::*;

/// 测试Builder模式基本功能
#[tokio::test]
async fn test_builder_basic_functionality() {
    // 测试Builder基本链式调用
    let request = AccessDataSearchRequest::builder()
        .page_size(50)
        .start_time(1609459200)
        .end_time(1640995200)
        .build();
        
    assert_eq!(request.page_size, Some(50));
    assert_eq!(request.start_time, Some(1609459200));
    assert_eq!(request.end_time, Some(1640995200));
}

/// 测试Builder复合方法
#[tokio::test]
async fn test_builder_compound_methods() {
    // 测试复合设置方法
    let request = AccessDataSearchRequest::builder()
        .time_range(1609459200, 1640995200)  // 复合方法
        .pagination(Some("token".to_string()), Some(20))  // 复合方法
        .build();
        
    assert_eq!(request.start_time, Some(1609459200));
    assert_eq!(request.end_time, Some(1640995200));
    assert_eq!(request.page_token, Some("token".to_string()));
    assert_eq!(request.page_size, Some(20));
}

/// 测试Builder便捷方法
#[tokio::test]
async fn test_builder_convenience_methods() {
    // 测试语义化的便捷方法
    let request = AccessDataSearchRequest::builder()
        .user_filter("user123")  // 便捷方法
        .department_filter("dept456")  // 便捷方法
        .access_type_filter("view")  // 便捷方法
        .build();
        
    assert_eq!(request.user_id, Some("user123".to_string()));
    assert_eq!(request.department_id, Some("dept456".to_string()));
    assert_eq!(request.access_type, Some("view".to_string()));
}

/// 测试Builder与传统方式等价性
#[tokio::test]
async fn test_builder_equivalence_with_traditional() {
    // 传统构造方式
    let traditional = AccessDataSearchRequest {
        page_token: Some("token".to_string()),
        page_size: Some(25),
        start_time: Some(1609459200),
        end_time: Some(1640995200),
        user_id: Some("user789".to_string()),
        department_id: None,
        access_type: Some("edit".to_string()),
    };
    
    // Builder构造方式  
    let builder_made = AccessDataSearchRequest::builder()
        .page_token("token")
        .page_size(25)
        .time_range(1609459200, 1640995200)
        .user_filter("user789")
        .access_type_filter("edit")
        .build();
        
    // 应该完全等价
    assert_eq!(traditional.page_token, builder_made.page_token);
    assert_eq!(traditional.page_size, builder_made.page_size);
    assert_eq!(traditional.start_time, builder_made.start_time);
    assert_eq!(traditional.end_time, builder_made.end_time);
    assert_eq!(traditional.user_id, builder_made.user_id);
    assert_eq!(traditional.department_id, builder_made.department_id);
    assert_eq!(traditional.access_type, builder_made.access_type);
}

/// 测试Builder类型转换
#[tokio::test]
async fn test_builder_type_conversions() {
    // 测试Into<String>转换
    let request1 = AccessDataSearchRequest::builder()
        .user_filter("string_literal")  // &str
        .build();
        
    let request2 = AccessDataSearchRequest::builder()
        .user_filter("owned_string".to_string())  // String
        .build();
        
    assert_eq!(request1.user_id, Some("string_literal".to_string()));
    assert_eq!(request2.user_id, Some("owned_string".to_string()));
}