botrs 0.12.1

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

use super::*;
use crate::token::Token;
use reqwest::StatusCode;
use std::time::Duration;

#[test]
fn test_http_client_creation() {
    let client = HttpClient::new(30, false).unwrap();
    assert!(!client.is_sandbox());
    assert_eq!(client.timeout(), Duration::from_secs(30));
    assert_eq!(client.base_url(), crate::DEFAULT_API_URL);

    let sandbox_client = HttpClient::new(60, true).unwrap();
    assert!(sandbox_client.is_sandbox());
    assert_eq!(sandbox_client.base_url(), crate::SANDBOX_API_URL);
}

#[test]
fn test_api_error_parsing() {
    let client = HttpClient::new(30, false).unwrap();

    let json = serde_json::json!({
        "code": 404,
        "message": "Not found",
        "trace_id": "test-trace"
    });

    let error = client
        .parse_api_error(StatusCode::NOT_FOUND, &json)
        .unwrap();
    assert_eq!(error.code, 404);
    assert_eq!(error.message, "Not found");
    assert_eq!(error.trace_id, Some("test-trace".to_string()));
}

#[test]
fn test_rate_limit_parsing() {
    let client = HttpClient::new(30, false).unwrap();

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-ratelimit-limit", "100".parse().unwrap());
    headers.insert("x-ratelimit-remaining", "50".parse().unwrap());
    headers.insert("x-ratelimit-reset", "1234567890".parse().unwrap());
    headers.insert("x-ratelimit-bucket", "global".parse().unwrap());

    let rate_limit = client.parse_rate_limit(&headers).unwrap();
    assert_eq!(rate_limit.limit, 100);
    assert_eq!(rate_limit.remaining, 50);
    assert_eq!(rate_limit.reset, 1234567890);
    assert_eq!(rate_limit.bucket, Some("global".to_string()));
}

#[test]
fn test_trace_id_storage() {
    let client = HttpClient::new(30, false).unwrap();
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("X-Tps-trace-ID", "trace-123".parse().unwrap());

    client.store_trace_id(&headers);

    assert_eq!(client.trace_id(), "trace-123");
}

#[tokio::test]
async fn authorized_headers_include_union_app_id() {
    let client = HttpClient::new(30, false)
        .unwrap()
        .with_union_app_id("openapi-app");
    let token = Token::new("token-app", "secret");
    token.set_cached_access_token_for_test("cached-token").await;

    let headers = client
        .authorized_headers(&token, reqwest::header::HeaderMap::new())
        .await
        .unwrap();

    assert_eq!(
        headers
            .get("Authorization")
            .and_then(|value| value.to_str().ok()),
        Some("QQBot cached-token")
    );
    assert_eq!(
        headers
            .get("X-Union-Appid")
            .and_then(|value| value.to_str().ok()),
        Some("openapi-app")
    );
}

#[tokio::test]
async fn authorized_headers_fall_back_to_token_app_id() {
    let client = HttpClient::new(30, false).unwrap();
    let token = Token::new("token-app", "secret");
    token.set_cached_access_token_for_test("cached-token").await;

    let headers = client
        .authorized_headers(&token, reqwest::header::HeaderMap::new())
        .await
        .unwrap();

    assert_eq!(
        headers
            .get("X-Union-Appid")
            .and_then(|value| value.to_str().ok()),
        Some("token-app")
    );
}