misskey_api/endpoint/users/
search.rs

1use crate::model::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    #[builder(setter(into))]
11    pub query: String,
12    #[serde(skip_serializing_if = "Option::is_none")]
13    #[builder(default, setter(strip_option))]
14    pub local_only: Option<bool>,
15    #[serde(skip_serializing_if = "Option::is_none")]
16    #[builder(default, setter(strip_option))]
17    pub detail: Option<bool>,
18    /// 1 .. 100
19    #[serde(skip_serializing_if = "Option::is_none")]
20    #[builder(default, setter(strip_option))]
21    pub limit: Option<u8>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    #[builder(default, setter(strip_option))]
24    pub offset: Option<u64>,
25}
26
27impl misskey_core::Request for Request {
28    type Response = Vec<User>;
29    const ENDPOINT: &'static str = "users/search";
30}
31
32impl_offset_pagination!(Request, User);
33
34#[cfg(test)]
35mod tests {
36    use super::Request;
37    use crate::test::{ClientExt, TestClient};
38
39    #[tokio::test]
40    async fn request() {
41        let client = TestClient::new();
42        client
43            .test(Request {
44                query: "test".to_string(),
45                local_only: None,
46                detail: None,
47                limit: None,
48                offset: None,
49            })
50            .await;
51    }
52
53    #[tokio::test]
54    async fn request_with_options() {
55        let client = TestClient::new();
56        client
57            .test(Request {
58                query: "admin".to_string(),
59                local_only: Some(true),
60                detail: Some(false),
61                limit: None,
62                offset: None,
63            })
64            .await;
65    }
66
67    #[tokio::test]
68    async fn request_with_limit() {
69        let client = TestClient::new();
70        client
71            .test(Request {
72                query: "test".to_string(),
73                local_only: None,
74                detail: None,
75                limit: Some(100),
76                offset: None,
77            })
78            .await;
79    }
80
81    #[tokio::test]
82    async fn request_with_offset() {
83        let client = TestClient::new();
84        client
85            .test(Request {
86                query: "admin".to_string(),
87                local_only: None,
88                detail: None,
89                limit: None,
90                offset: Some(5),
91            })
92            .await;
93    }
94}