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