misskey_api/endpoint/users/
clips.rs

1use crate::model::{clip::Clip, id::Id, user::User};
2
3use serde::Serialize;
4use typed_builder::TypedBuilder;
5
6#[derive(Serialize, Debug, Clone, TypedBuilder)]
7#[serde(rename_all = "camelCase")]
8#[builder(doc)]
9pub struct Request {
10    pub user_id: Id<User>,
11    /// 1 .. 100
12    #[serde(skip_serializing_if = "Option::is_none")]
13    #[builder(default, setter(strip_option))]
14    pub limit: Option<u8>,
15    #[serde(skip_serializing_if = "Option::is_none")]
16    #[builder(default, setter(strip_option))]
17    pub since_id: Option<Id<Clip>>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    #[builder(default, setter(strip_option))]
20    pub until_id: Option<Id<Clip>>,
21}
22
23impl misskey_core::Request for Request {
24    type Response = Vec<Clip>;
25    const ENDPOINT: &'static str = "users/clips";
26}
27
28impl_pagination!(Request, Clip);
29
30#[cfg(test)]
31mod tests {
32    use super::Request;
33    use crate::test::{ClientExt, TestClient};
34
35    #[tokio::test]
36    async fn request_simple() {
37        let client = TestClient::new();
38        let user = client.user.me().await;
39        client
40            .test(Request {
41                user_id: user.id,
42                limit: None,
43                since_id: None,
44                until_id: None,
45            })
46            .await;
47    }
48
49    #[tokio::test]
50    async fn request_with_limit() {
51        let client = TestClient::new();
52        let user = client.user.me().await;
53        client
54            .user
55            .test(crate::endpoint::clips::create::Request {
56                name: "test".to_string(),
57                is_public: None,
58                description: None,
59            })
60            .await;
61
62        client
63            .user
64            .test(Request {
65                user_id: user.id,
66                limit: Some(100),
67                since_id: None,
68                until_id: None,
69            })
70            .await;
71    }
72
73    #[tokio::test]
74    async fn request_paginate() {
75        let client = TestClient::new();
76        let user = client.user.me().await;
77        let clip = client
78            .user
79            .test(crate::endpoint::clips::create::Request {
80                name: "test".to_string(),
81                is_public: None,
82                description: None,
83            })
84            .await;
85
86        client
87            .user
88            .test(Request {
89                user_id: user.id,
90                limit: None,
91                since_id: Some(clip.id),
92                until_id: Some(clip.id),
93            })
94            .await;
95    }
96}