this repo has no description
lewis.moe
1mod common;
2use common::*;
3
4use reqwest::StatusCode;
5use serde_json::{Value, json};
6
7#[tokio::test]
8async fn test_create_invite_code_success() {
9 let client = client();
10 let (access_jwt, _did) = create_account_and_login(&client).await;
11
12 let payload = json!({
13 "useCount": 5
14 });
15
16 let res = client
17 .post(format!(
18 "{}/xrpc/com.atproto.server.createInviteCode",
19 base_url().await
20 ))
21 .bearer_auth(&access_jwt)
22 .json(&payload)
23 .send()
24 .await
25 .expect("Failed to send request");
26
27 assert_eq!(res.status(), StatusCode::OK);
28 let body: Value = res.json().await.expect("Response was not valid JSON");
29 assert!(body["code"].is_string());
30 let code = body["code"].as_str().unwrap();
31 assert!(!code.is_empty());
32 assert!(code.contains('-'), "Code should be a UUID format");
33}
34
35#[tokio::test]
36async fn test_create_invite_code_no_auth() {
37 let client = client();
38 let payload = json!({
39 "useCount": 5
40 });
41
42 let res = client
43 .post(format!(
44 "{}/xrpc/com.atproto.server.createInviteCode",
45 base_url().await
46 ))
47 .json(&payload)
48 .send()
49 .await
50 .expect("Failed to send request");
51
52 assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
53 let body: Value = res.json().await.expect("Response was not valid JSON");
54 assert_eq!(body["error"], "AuthenticationRequired");
55}
56
57#[tokio::test]
58async fn test_create_invite_code_invalid_use_count() {
59 let client = client();
60 let (access_jwt, _did) = create_account_and_login(&client).await;
61
62 let payload = json!({
63 "useCount": 0
64 });
65
66 let res = client
67 .post(format!(
68 "{}/xrpc/com.atproto.server.createInviteCode",
69 base_url().await
70 ))
71 .bearer_auth(&access_jwt)
72 .json(&payload)
73 .send()
74 .await
75 .expect("Failed to send request");
76
77 assert_eq!(res.status(), StatusCode::BAD_REQUEST);
78 let body: Value = res.json().await.expect("Response was not valid JSON");
79 assert_eq!(body["error"], "InvalidRequest");
80}
81
82#[tokio::test]
83async fn test_create_invite_code_for_another_account() {
84 let client = client();
85 let (access_jwt1, _did1) = create_account_and_login(&client).await;
86 let (_access_jwt2, did2) = create_account_and_login(&client).await;
87
88 let payload = json!({
89 "useCount": 3,
90 "forAccount": did2
91 });
92
93 let res = client
94 .post(format!(
95 "{}/xrpc/com.atproto.server.createInviteCode",
96 base_url().await
97 ))
98 .bearer_auth(&access_jwt1)
99 .json(&payload)
100 .send()
101 .await
102 .expect("Failed to send request");
103
104 assert_eq!(res.status(), StatusCode::OK);
105 let body: Value = res.json().await.expect("Response was not valid JSON");
106 assert!(body["code"].is_string());
107}
108
109#[tokio::test]
110async fn test_create_invite_codes_success() {
111 let client = client();
112 let (access_jwt, _did) = create_account_and_login(&client).await;
113
114 let payload = json!({
115 "useCount": 2,
116 "codeCount": 3
117 });
118
119 let res = client
120 .post(format!(
121 "{}/xrpc/com.atproto.server.createInviteCodes",
122 base_url().await
123 ))
124 .bearer_auth(&access_jwt)
125 .json(&payload)
126 .send()
127 .await
128 .expect("Failed to send request");
129
130 assert_eq!(res.status(), StatusCode::OK);
131 let body: Value = res.json().await.expect("Response was not valid JSON");
132 assert!(body["codes"].is_array());
133 let codes = body["codes"].as_array().unwrap();
134 assert_eq!(codes.len(), 1);
135 assert_eq!(codes[0]["codes"].as_array().unwrap().len(), 3);
136}
137
138#[tokio::test]
139async fn test_create_invite_codes_for_multiple_accounts() {
140 let client = client();
141 let (access_jwt1, did1) = create_account_and_login(&client).await;
142 let (_access_jwt2, did2) = create_account_and_login(&client).await;
143
144 let payload = json!({
145 "useCount": 1,
146 "codeCount": 2,
147 "forAccounts": [did1, did2]
148 });
149
150 let res = client
151 .post(format!(
152 "{}/xrpc/com.atproto.server.createInviteCodes",
153 base_url().await
154 ))
155 .bearer_auth(&access_jwt1)
156 .json(&payload)
157 .send()
158 .await
159 .expect("Failed to send request");
160
161 assert_eq!(res.status(), StatusCode::OK);
162 let body: Value = res.json().await.expect("Response was not valid JSON");
163 let codes = body["codes"].as_array().unwrap();
164 assert_eq!(codes.len(), 2);
165
166 for code_obj in codes {
167 assert!(code_obj["account"].is_string());
168 assert_eq!(code_obj["codes"].as_array().unwrap().len(), 2);
169 }
170}
171
172#[tokio::test]
173async fn test_create_invite_codes_no_auth() {
174 let client = client();
175 let payload = json!({
176 "useCount": 2
177 });
178
179 let res = client
180 .post(format!(
181 "{}/xrpc/com.atproto.server.createInviteCodes",
182 base_url().await
183 ))
184 .json(&payload)
185 .send()
186 .await
187 .expect("Failed to send request");
188
189 assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
190}
191
192#[tokio::test]
193async fn test_get_account_invite_codes_success() {
194 let client = client();
195 let (access_jwt, _did) = create_account_and_login(&client).await;
196
197 let create_payload = json!({
198 "useCount": 5
199 });
200 let _ = client
201 .post(format!(
202 "{}/xrpc/com.atproto.server.createInviteCode",
203 base_url().await
204 ))
205 .bearer_auth(&access_jwt)
206 .json(&create_payload)
207 .send()
208 .await
209 .expect("Failed to create invite code");
210
211 let res = client
212 .get(format!(
213 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
214 base_url().await
215 ))
216 .bearer_auth(&access_jwt)
217 .send()
218 .await
219 .expect("Failed to send request");
220
221 assert_eq!(res.status(), StatusCode::OK);
222 let body: Value = res.json().await.expect("Response was not valid JSON");
223 assert!(body["codes"].is_array());
224 let codes = body["codes"].as_array().unwrap();
225 assert!(!codes.is_empty());
226
227 let code = &codes[0];
228 assert!(code["code"].is_string());
229 assert!(code["available"].is_number());
230 assert!(code["disabled"].is_boolean());
231 assert!(code["createdAt"].is_string());
232 assert!(code["uses"].is_array());
233}
234
235#[tokio::test]
236async fn test_get_account_invite_codes_no_auth() {
237 let client = client();
238
239 let res = client
240 .get(format!(
241 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
242 base_url().await
243 ))
244 .send()
245 .await
246 .expect("Failed to send request");
247
248 assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
249}
250
251#[tokio::test]
252async fn test_get_account_invite_codes_include_used_filter() {
253 let client = client();
254 let (access_jwt, _did) = create_account_and_login(&client).await;
255
256 let create_payload = json!({
257 "useCount": 5
258 });
259 let _ = client
260 .post(format!(
261 "{}/xrpc/com.atproto.server.createInviteCode",
262 base_url().await
263 ))
264 .bearer_auth(&access_jwt)
265 .json(&create_payload)
266 .send()
267 .await
268 .expect("Failed to create invite code");
269
270 let res = client
271 .get(format!(
272 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
273 base_url().await
274 ))
275 .bearer_auth(&access_jwt)
276 .query(&[("includeUsed", "false")])
277 .send()
278 .await
279 .expect("Failed to send request");
280
281 assert_eq!(res.status(), StatusCode::OK);
282 let body: Value = res.json().await.expect("Response was not valid JSON");
283 assert!(body["codes"].is_array());
284
285 for code in body["codes"].as_array().unwrap() {
286 assert!(code["available"].as_i64().unwrap() > 0);
287 }
288}