botrs 0.13.0

A Rust QQ Bot framework based on QQ Guild Bot API
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
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::*;

fn test_user(id: &str, username: &str) -> User {
    User {
        id: id.to_string(),
        username: username.to_string(),
        avatar: String::new(),
        bot: false,
        union_openid: String::new(),
        union_user_account: String::new(),
    }
}

#[test]
fn test_user_creation() {
    let user = test_user("123456789", "TestUser");
    assert_eq!(user.id, "123456789");
    assert_eq!(user.username, "TestUser");
    assert_eq!(user.avatar, "");
    assert_eq!(user.union_openid, "");
    assert_eq!(user.union_user_account, "");
    assert!(!user.bot);
}

#[test]
fn user_uses_required_zero_value_fields() {
    let user: User = serde_json::from_value(serde_json::json!({})).unwrap();

    assert_eq!(user.id, "");
    assert_eq!(user.username, "");
    assert_eq!(user.avatar, "");
    assert!(!user.bot);
    assert_eq!(user.union_openid, "");
    assert_eq!(user.union_user_account, "");
}

#[test]
fn user_keeps_official_json_shape() {
    let user = User {
        id: "user-1".to_string(),
        username: "alice".to_string(),
        avatar: "avatar-key".to_string(),
        bot: true,
        union_openid: "union-openid".to_string(),
        union_user_account: "union-account".to_string(),
    };
    let value = serde_json::to_value(&user).unwrap();

    assert_eq!(value["id"], "user-1");
    assert_eq!(value["username"], "alice");
    assert_eq!(value["avatar"], "avatar-key");
    assert_eq!(value["bot"], true);
    assert_eq!(value["union_openid"], "union-openid");
    assert_eq!(value["union_user_account"], "union-account");
}

#[test]
fn user_from_bot_info_preserves_union_fields() {
    let user = User::from(crate::models::api::BotInfo {
        id: "bot-1".to_string(),
        username: "bot".to_string(),
        avatar: "avatar-key".to_string(),
        bot: true,
        union_openid: "UNION_OPENID_XXXXXX".to_string(),
        union_user_account: "UNION_ACCOUNT_XXXXXX".to_string(),
        share_url: "https://example.com/share".to_string(),
        welcome_msg: "hello".to_string(),
    });

    assert_eq!(user.id, "bot-1");
    assert_eq!(user.username, "bot");
    assert_eq!(user.avatar, "avatar-key");
    assert!(user.bot);
    assert_eq!(user.union_openid, "UNION_OPENID_XXXXXX");
    assert_eq!(user.union_user_account, "UNION_ACCOUNT_XXXXXX");
}

#[test]
fn test_member_name_fallback() {
    let user = test_user("123456789", "TestUser");
    let mut member = Member {
        user,
        nick: None,
        roles: Vec::new(),
        joined_at: "2024-01-01T00:00:00Z".to_string(),
        deaf: false,
        mute: false,
    };

    assert_eq!(
        member.nick.as_deref().unwrap_or(&member.user.username),
        "TestUser"
    );

    member.nick = Some("Nickname".to_string());
    assert_eq!(
        member.nick.as_deref().unwrap_or(&member.user.username),
        "Nickname"
    );
}

#[test]
fn test_member_roles() {
    let user = test_user("123456789", "TestUser");
    let mut member = Member {
        user,
        nick: None,
        roles: Vec::new(),
        joined_at: "2024-01-01T00:00:00Z".to_string(),
        deaf: false,
        mute: false,
    };

    member.roles = vec!["role1".to_string(), "role2".to_string()];

    assert!(member.roles.contains(&"role1".to_string()));
    assert!(!member.roles.contains(&"role3".to_string()));

    assert!(
        ["role1".to_string(), "role3".to_string()]
            .iter()
            .any(|role_id| member.roles.contains(role_id))
    );
    assert!(
        ["role1".to_string(), "role2".to_string()]
            .iter()
            .all(|role_id| member.roles.contains(role_id))
    );
    assert!(
        ["role1".to_string(), "role3".to_string()]
            .iter()
            .any(|role_id| !member.roles.contains(role_id))
    );
}

#[test]
fn test_role_creation() {
    let role = Role {
        id: "123456789".to_string(),
        name: "TestRole".to_string(),
        color: 0,
        hoist: false,
        position: 0,
        permissions: "0".to_string(),
        managed: false,
        mentionable: false,
    };

    assert_eq!(role.id, "123456789");
    assert_eq!(role.name, "TestRole");
    assert_eq!(role.permissions, "0");
}