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