misskey_api/endpoint/charts/user/
following.rs

1use crate::model::{
2    chart::{ChartSpan, FollowersChart, FollowingChart},
3    id::Id,
4    user::User,
5};
6
7use serde::{Deserialize, Serialize};
8use typed_builder::TypedBuilder;
9
10#[derive(Serialize, Debug, Clone, TypedBuilder)]
11#[serde(rename_all = "camelCase")]
12#[builder(doc)]
13pub struct Request {
14    pub span: ChartSpan,
15    pub user_id: Id<User>,
16    /// 1 .. 500
17    #[serde(skip_serializing_if = "Option::is_none")]
18    #[builder(default, setter(strip_option))]
19    pub limit: Option<u64>,
20    #[builder(default, setter(strip_option))]
21    pub offset: Option<u64>,
22}
23
24#[derive(Deserialize, Debug, Clone)]
25#[serde(rename_all = "camelCase")]
26pub struct Response {
27    pub local: FollowFollowerChart,
28    pub remote: FollowFollowerChart,
29}
30
31#[derive(Deserialize, Debug, Clone)]
32#[serde(rename_all = "camelCase")]
33pub struct FollowFollowerChart {
34    pub followings: FollowingChart,
35    pub followers: FollowersChart,
36}
37
38impl misskey_core::Request for Request {
39    type Response = Response;
40    const ENDPOINT: &'static str = "charts/user/following";
41}
42
43#[cfg(test)]
44mod tests {
45    use super::Request;
46    use crate::test::{ClientExt, TestClient};
47
48    #[tokio::test]
49    async fn request() {
50        use crate::model::chart::ChartSpan;
51
52        let client = TestClient::new();
53        let user = client.user.me().await;
54
55        client
56            .test(Request {
57                span: ChartSpan::Day,
58                user_id: user.id.clone(),
59                limit: None,
60                offset: None,
61            })
62            .await;
63        client
64            .test(Request {
65                span: ChartSpan::Hour,
66                user_id: user.id.clone(),
67                limit: None,
68                offset: None,
69            })
70            .await;
71    }
72
73    #[tokio::test]
74    async fn request_with_limit() {
75        use crate::model::chart::ChartSpan;
76
77        let client = TestClient::new();
78        let user = client.user.me().await;
79
80        client
81            .test(Request {
82                span: ChartSpan::Day,
83                user_id: user.id,
84                limit: Some(500),
85                offset: None,
86            })
87            .await;
88    }
89
90    #[tokio::test]
91    async fn request_with_offset() {
92        use crate::model::chart::ChartSpan;
93
94        let client = TestClient::new();
95        let user = client.user.me().await;
96
97        client
98            .test(Request {
99                span: ChartSpan::Day,
100                user_id: user.id,
101                limit: None,
102                offset: Some(5),
103            })
104            .await;
105    }
106}