this repo has no description
lewis.moe
1mod common;
2use common::*;
3use reqwest::StatusCode;
4use serde_json::{Value, json};
5
6#[tokio::test]
7async fn test_create_invite_code_success() {
8 let client = client();
9 let (access_jwt, _did) = create_admin_account_and_login(&client).await;
10 let payload = json!({
11 "useCount": 5
12 });
13 let res = client
14 .post(format!(
15 "{}/xrpc/com.atproto.server.createInviteCode",
16 base_url().await
17 ))
18 .bearer_auth(&access_jwt)
19 .json(&payload)
20 .send()
21 .await
22 .expect("Failed to send request");
23 assert_eq!(res.status(), StatusCode::OK);
24 let body: Value = res.json().await.expect("Response was not valid JSON");
25 assert!(body["code"].is_string());
26 let code = body["code"].as_str().unwrap();
27 assert!(!code.is_empty());
28 assert!(code.contains('-'), "Code should be in hostname-xxxxx-xxxxx format");
29 let parts: Vec<&str> = code.split('-').collect();
30 assert!(parts.len() >= 3, "Code should have at least 3 parts (hostname + 2 random parts)");
31}
32
33#[tokio::test]
34async fn test_create_invite_code_no_auth() {
35 let client = client();
36 let payload = json!({
37 "useCount": 5
38 });
39 let res = client
40 .post(format!(
41 "{}/xrpc/com.atproto.server.createInviteCode",
42 base_url().await
43 ))
44 .json(&payload)
45 .send()
46 .await
47 .expect("Failed to send request");
48 assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
49 let body: Value = res.json().await.expect("Response was not valid JSON");
50 assert_eq!(body["error"], "AuthenticationRequired");
51}
52
53#[tokio::test]
54async fn test_create_invite_code_non_admin() {
55 let client = client();
56 let _ = create_admin_account_and_login(&client).await;
57 let (access_jwt, _did) = create_account_and_login(&client).await;
58 let payload = json!({
59 "useCount": 5
60 });
61 let res = client
62 .post(format!(
63 "{}/xrpc/com.atproto.server.createInviteCode",
64 base_url().await
65 ))
66 .bearer_auth(&access_jwt)
67 .json(&payload)
68 .send()
69 .await
70 .expect("Failed to send request");
71 assert_eq!(res.status(), StatusCode::FORBIDDEN);
72 let body: Value = res.json().await.expect("Response was not valid JSON");
73 assert_eq!(body["error"], "AdminRequired");
74}
75
76#[tokio::test]
77async fn test_create_invite_code_invalid_use_count() {
78 let client = client();
79 let (access_jwt, _did) = create_admin_account_and_login(&client).await;
80 let payload = json!({
81 "useCount": 0
82 });
83 let res = client
84 .post(format!(
85 "{}/xrpc/com.atproto.server.createInviteCode",
86 base_url().await
87 ))
88 .bearer_auth(&access_jwt)
89 .json(&payload)
90 .send()
91 .await
92 .expect("Failed to send request");
93 assert_eq!(res.status(), StatusCode::BAD_REQUEST);
94 let body: Value = res.json().await.expect("Response was not valid JSON");
95 assert_eq!(body["error"], "InvalidRequest");
96}
97
98#[tokio::test]
99async fn test_create_invite_code_for_another_account() {
100 let client = client();
101 let (access_jwt1, _did1) = create_admin_account_and_login(&client).await;
102 let (_access_jwt2, did2) = create_account_and_login(&client).await;
103 let payload = json!({
104 "useCount": 3,
105 "forAccount": did2
106 });
107 let res = client
108 .post(format!(
109 "{}/xrpc/com.atproto.server.createInviteCode",
110 base_url().await
111 ))
112 .bearer_auth(&access_jwt1)
113 .json(&payload)
114 .send()
115 .await
116 .expect("Failed to send request");
117 assert_eq!(res.status(), StatusCode::OK);
118 let body: Value = res.json().await.expect("Response was not valid JSON");
119 assert!(body["code"].is_string());
120}
121
122#[tokio::test]
123async fn test_create_invite_codes_success() {
124 let client = client();
125 let (access_jwt, did) = create_admin_account_and_login(&client).await;
126 let payload = json!({
127 "useCount": 2,
128 "codeCount": 3
129 });
130 let res = client
131 .post(format!(
132 "{}/xrpc/com.atproto.server.createInviteCodes",
133 base_url().await
134 ))
135 .bearer_auth(&access_jwt)
136 .json(&payload)
137 .send()
138 .await
139 .expect("Failed to send request");
140 assert_eq!(res.status(), StatusCode::OK);
141 let body: Value = res.json().await.expect("Response was not valid JSON");
142 assert!(body["codes"].is_array());
143 let codes = body["codes"].as_array().unwrap();
144 assert_eq!(codes.len(), 1);
145 assert_eq!(codes[0]["account"], did);
146 assert_eq!(codes[0]["codes"].as_array().unwrap().len(), 3);
147}
148
149#[tokio::test]
150async fn test_create_invite_codes_for_multiple_accounts() {
151 let client = client();
152 let (access_jwt1, did1) = create_admin_account_and_login(&client).await;
153 let (_access_jwt2, did2) = create_account_and_login(&client).await;
154 let payload = json!({
155 "useCount": 1,
156 "codeCount": 2,
157 "forAccounts": [did1, did2]
158 });
159 let res = client
160 .post(format!(
161 "{}/xrpc/com.atproto.server.createInviteCodes",
162 base_url().await
163 ))
164 .bearer_auth(&access_jwt1)
165 .json(&payload)
166 .send()
167 .await
168 .expect("Failed to send request");
169 assert_eq!(res.status(), StatusCode::OK);
170 let body: Value = res.json().await.expect("Response was not valid JSON");
171 let codes = body["codes"].as_array().unwrap();
172 assert_eq!(codes.len(), 2);
173 for code_obj in codes {
174 assert!(code_obj["account"].is_string());
175 assert_eq!(code_obj["codes"].as_array().unwrap().len(), 2);
176 }
177}
178
179#[tokio::test]
180async fn test_create_invite_codes_no_auth() {
181 let client = client();
182 let payload = json!({
183 "useCount": 2
184 });
185 let res = client
186 .post(format!(
187 "{}/xrpc/com.atproto.server.createInviteCodes",
188 base_url().await
189 ))
190 .json(&payload)
191 .send()
192 .await
193 .expect("Failed to send request");
194 assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
195}
196
197#[tokio::test]
198async fn test_create_invite_codes_non_admin() {
199 let client = client();
200 let (access_jwt, _did) = create_account_and_login(&client).await;
201 let payload = json!({
202 "useCount": 2
203 });
204 let res = client
205 .post(format!(
206 "{}/xrpc/com.atproto.server.createInviteCodes",
207 base_url().await
208 ))
209 .bearer_auth(&access_jwt)
210 .json(&payload)
211 .send()
212 .await
213 .expect("Failed to send request");
214 assert_eq!(res.status(), StatusCode::FORBIDDEN);
215 let body: Value = res.json().await.expect("Response was not valid JSON");
216 assert_eq!(body["error"], "AdminRequired");
217}
218
219#[tokio::test]
220async fn test_get_account_invite_codes_success() {
221 let client = client();
222 let (admin_jwt, _admin_did) = create_admin_account_and_login(&client).await;
223 let (user_jwt, user_did) = create_account_and_login(&client).await;
224
225 let create_payload = json!({
226 "useCount": 5,
227 "forAccount": user_did
228 });
229 let _ = client
230 .post(format!(
231 "{}/xrpc/com.atproto.server.createInviteCode",
232 base_url().await
233 ))
234 .bearer_auth(&admin_jwt)
235 .json(&create_payload)
236 .send()
237 .await
238 .expect("Failed to create invite code");
239
240 let res = client
241 .get(format!(
242 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
243 base_url().await
244 ))
245 .bearer_auth(&user_jwt)
246 .send()
247 .await
248 .expect("Failed to send request");
249 assert_eq!(res.status(), StatusCode::OK);
250 let body: Value = res.json().await.expect("Response was not valid JSON");
251 assert!(body["codes"].is_array());
252 let codes = body["codes"].as_array().unwrap();
253 assert!(!codes.is_empty());
254 let code = &codes[0];
255 assert!(code["code"].is_string());
256 assert!(code["available"].is_number());
257 assert!(code["disabled"].is_boolean());
258 assert!(code["createdAt"].is_string());
259 assert!(code["uses"].is_array());
260 assert_eq!(code["forAccount"], user_did);
261 assert_eq!(code["createdBy"], "admin");
262}
263
264#[tokio::test]
265async fn test_get_account_invite_codes_no_auth() {
266 let client = client();
267 let res = client
268 .get(format!(
269 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
270 base_url().await
271 ))
272 .send()
273 .await
274 .expect("Failed to send request");
275 assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
276}
277
278#[tokio::test]
279async fn test_get_account_invite_codes_include_used_filter() {
280 let client = client();
281 let (admin_jwt, _admin_did) = create_admin_account_and_login(&client).await;
282 let (user_jwt, user_did) = create_account_and_login(&client).await;
283
284 let create_payload = json!({
285 "useCount": 5,
286 "forAccount": user_did
287 });
288 let _ = client
289 .post(format!(
290 "{}/xrpc/com.atproto.server.createInviteCode",
291 base_url().await
292 ))
293 .bearer_auth(&admin_jwt)
294 .json(&create_payload)
295 .send()
296 .await
297 .expect("Failed to create invite code");
298
299 let res = client
300 .get(format!(
301 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
302 base_url().await
303 ))
304 .bearer_auth(&user_jwt)
305 .query(&[("includeUsed", "false")])
306 .send()
307 .await
308 .expect("Failed to send request");
309 assert_eq!(res.status(), StatusCode::OK);
310 let body: Value = res.json().await.expect("Response was not valid JSON");
311 assert!(body["codes"].is_array());
312 for code in body["codes"].as_array().unwrap() {
313 assert!(code["available"].as_i64().unwrap() > 0);
314 }
315}
316
317#[tokio::test]
318async fn test_get_account_invite_codes_filters_disabled() {
319 let client = client();
320 let (admin_jwt, admin_did) = create_admin_account_and_login(&client).await;
321
322 let create_payload = json!({
323 "useCount": 5,
324 "forAccount": admin_did
325 });
326 let create_res = client
327 .post(format!(
328 "{}/xrpc/com.atproto.server.createInviteCode",
329 base_url().await
330 ))
331 .bearer_auth(&admin_jwt)
332 .json(&create_payload)
333 .send()
334 .await
335 .expect("Failed to create invite code");
336 let create_body: Value = create_res.json().await.unwrap();
337 let code = create_body["code"].as_str().unwrap();
338
339 let disable_payload = json!({
340 "codes": [code]
341 });
342 let _ = client
343 .post(format!(
344 "{}/xrpc/com.atproto.admin.disableInviteCodes",
345 base_url().await
346 ))
347 .bearer_auth(&admin_jwt)
348 .json(&disable_payload)
349 .send()
350 .await
351 .expect("Failed to disable invite code");
352
353 let res = client
354 .get(format!(
355 "{}/xrpc/com.atproto.server.getAccountInviteCodes",
356 base_url().await
357 ))
358 .bearer_auth(&admin_jwt)
359 .send()
360 .await
361 .expect("Failed to send request");
362 assert_eq!(res.status(), StatusCode::OK);
363 let body: Value = res.json().await.expect("Response was not valid JSON");
364 let codes = body["codes"].as_array().unwrap();
365 for c in codes {
366 assert_ne!(c["code"].as_str().unwrap(), code, "Disabled code should be filtered out");
367 }
368}