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

use super::*;

#[test]
fn test_manage_event_type_from_str() {
    assert_eq!(
        "group_add_robot".parse::<ManageEventType>(),
        Ok(ManageEventType::GroupAddRobot)
    );
    assert_eq!(
        "friend_add".parse::<ManageEventType>(),
        Ok(ManageEventType::FriendAdd)
    );
    assert_eq!("invalid".parse::<ManageEventType>(), Err(()));
}

#[test]
fn manage_event_type_serializes_as_event_name() {
    assert_eq!(
        serde_json::to_value(ManageEventType::GroupMsgReceive).unwrap(),
        serde_json::json!("group_msg_receive")
    );
    assert_eq!(
        serde_json::from_value::<ManageEventType>(serde_json::json!("c2c_msg_reject")).unwrap(),
        ManageEventType::C2CMsgReject
    );
}

#[test]
fn enter_aio_uses_zero_value_omitempty_shape() {
    let event = EnterAioEvent::new(
        Some("event-1".to_string()),
        &serde_json::json!({
            "user_openid": "user-1",
            "from_source": "profile"
        }),
    );

    assert_eq!(event.user_openid, "user-1");
    assert_eq!(event.from_source, "profile");
    assert_eq!(event.event_id.as_deref(), Some("event-1"));

    let value = serde_json::to_value(&event).unwrap();
    assert_eq!(
        value,
        serde_json::json!({
            "user_openid": "user-1",
            "from_source": "profile"
        })
    );

    let empty = serde_json::to_value(EnterAioEvent::default()).unwrap();
    assert_eq!(empty, serde_json::json!({}));
}

#[test]
fn subscribe_message_status_uses_required_zero_value_fields() {
    let event = SubscribeMessageStatusData::new(
        Some("event-1".to_string()),
        &serde_json::json!({
            "group_openid": "group-1",
            "openid": "user-1",
            "result": [{
                "template_id": 1,
                "custom_template_id": "custom-1",
                "op": 2,
                "subscribe_id": "sub-1",
                "update_ts": 1710000000
            }]
        }),
    );

    assert_eq!(event.group_openid, "group-1");
    assert_eq!(event.openid, "user-1");
    assert_eq!(event.event_id.as_deref(), Some("event-1"));
    assert_eq!(event.result[0].template_id, 1);
    assert_eq!(event.result[0].custom_template_id, "custom-1");
    assert_eq!(event.result[0].op, 2);
    assert_eq!(event.result[0].subscribe_id, "sub-1");
    assert_eq!(event.result[0].update_ts, 1_710_000_000);

    let value = serde_json::to_value(&event).unwrap();
    assert_eq!(value["group_openid"], "group-1");
    assert_eq!(value["openid"], "user-1");
    assert_eq!(value["result"][0]["template_id"], 1);
    assert_eq!(value["result"][0]["custom_template_id"], "custom-1");
    assert_eq!(value["result"][0]["op"], 2);
    assert_eq!(value["result"][0]["subscribe_id"], "sub-1");
    assert_eq!(value["result"][0]["update_ts"], 1_710_000_000_u64);
    assert!(value.get("event_id").is_none());

    let empty = serde_json::to_value(SubscribeMessageStatusData::default()).unwrap();
    assert_eq!(empty["group_openid"], "");
    assert_eq!(empty["openid"], "");
    assert_eq!(empty["result"], serde_json::json!([]));
}

#[test]
fn c2c_friend_data_uses_required_zero_value_fields() {
    let friend: C2CFriendData = serde_json::from_value(serde_json::json!({})).unwrap();

    assert_eq!(friend.openid, "");
    assert_eq!(friend.timestamp, 0);
    assert_eq!(friend.nick, "");
    assert_eq!(friend.avatar, "");

    let value = serde_json::to_value(&friend).unwrap();
    assert_eq!(value["openid"], "");
    assert_eq!(value["timestamp"], 0);
    assert_eq!(value["nick"], "");
    assert_eq!(value["avatar"], "");
}

#[test]
fn manage_event_ids_are_internal_only() {
    let group = GroupManageEvent::new(
        Some("event-1".to_string()),
        &serde_json::json!({
            "timestamp": 1710000000_u64,
            "group_openid": "group-1",
            "op_member_openid": "member-1"
        }),
    );
    let c2c = C2CManageEvent::new(
        Some("event-2".to_string()),
        &serde_json::json!({
            "timestamp": 1710000001_u64,
            "openid": "user-1"
        }),
    );

    assert_eq!(group.event_id.as_deref(), Some("event-1"));
    assert_eq!(c2c.event_id.as_deref(), Some("event-2"));

    let group_value = serde_json::to_value(&group).unwrap();
    let c2c_value = serde_json::to_value(&c2c).unwrap();
    assert!(group_value.get("event_id").is_none());
    assert!(c2c_value.get("event_id").is_none());
}