bpi-rs 0.2.0

Bilibili API client library for Rust
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

use crate::wallet::{UserWallet, WalletInfoParams};
use crate::{BilibiliRequest, BpiClient, BpiResult};

const INFO_ENDPOINT: &str = "https://pay.bilibili.com/paywallet/wallet/getUserWallet";

/// Wallet API client.
#[derive(Clone, Copy)]
pub struct WalletClient<'a> {
    pub(crate) client: &'a BpiClient,
}

impl<'a> WalletClient<'a> {
    pub(crate) fn new(client: &'a BpiClient) -> Self {
        Self { client }
    }

    #[cfg(test)]
    pub(crate) fn info_endpoint(&self) -> &'static str {
        INFO_ENDPOINT
    }

    /// Gets authenticated wallet information.
    pub async fn info(&self, params: WalletInfoParams) -> BpiResult<UserWallet> {
        let csrf = self.client.csrf()?;
        let body = params.body(&csrf);

        self.client
            .post(INFO_ENDPOINT)
            .json(&body)
            .send_bpi_payload("wallet.info")
            .await
    }
}

#[cfg(test)]
mod tests {
    use std::future::Future;

    use crate::probe::contract::HttpMethod;
    use crate::probe::endpoint_contract::EndpointContract;
    use crate::wallet::{UserWallet, WalletInfoParams};
    use crate::{BpiClient, BpiResult};

    fn assert_info_future<F>(_future: F)
    where
        F: Future<Output = BpiResult<UserWallet>>,
    {
    }

    fn contract() -> BpiResult<EndpointContract> {
        EndpointContract::from_slice(include_bytes!(
            "../../tests/contracts/wallet/read/info/contract.json"
        ))
    }

    #[test]
    fn wallet_client_exposes_promoted_endpoint_url() -> BpiResult<()> {
        let client = BpiClient::new()?;
        let wallet = client.wallet();

        assert_eq!(
            wallet.info_endpoint(),
            "https://pay.bilibili.com/paywallet/wallet/getUserWallet"
        );
        Ok(())
    }

    #[test]
    fn wallet_info_returns_payload_future() -> BpiResult<()> {
        let client = BpiClient::new()?;
        let wallet = client.wallet();

        assert_info_future(wallet.info(WalletInfoParams::at_timestamp(1_700_000_000_000)));
        Ok(())
    }

    #[test]
    fn wallet_contract_matches_module_client_endpoint() -> BpiResult<()> {
        let client = BpiClient::new()?;
        let wallet = client.wallet();
        let contract = contract()?;

        assert_eq!(contract.name, "wallet.info");
        assert_eq!(contract.request.method, HttpMethod::Post);
        assert_eq!(contract.request.url.as_str(), wallet.info_endpoint());
        assert!(contract.request.query.is_empty());
        assert_eq!(contract.cases.len(), 2);

        let body =
            contract.request.body.as_ref().ok_or_else(|| {
                crate::BpiError::unsupported_response("missing wallet contract body")
            })?;
        assert_eq!(body["csrf"], "${csrf}");
        assert_eq!(body["platformType"], 3);
        assert_eq!(body["timestamp"], 1_700_000_000_000_i64);
        assert_eq!(body["traceId"], 1_700_000_000_000_i64);
        assert_eq!(body["version"], "1.0");
        Ok(())
    }
}