tests/sync.rs at 4825105b2c69dbb5fa9bcc3d0632b7174b12f4aa · lewis.moe/bspds-sandbox

lewis.moe / bspds-sandbox
this repo has no description
bspds-sandbox / tests / sync.rs
at 4825105b2c69dbb5fa9bcc3d0632b7174b12f4aa 10 kB view raw
  1mod common;
  2use common::*;
  3use reqwest::StatusCode;
  4use reqwest::header;
  5use serde_json::Value;
  6
  7#[tokio::test]
  8async fn test_get_latest_commit_success() {
  9    let client = client();
 10    let (_, did) = create_account_and_login(&client).await;
 11
 12    let params = [("did", did.as_str())];
 13    let res = client
 14        .get(format!(
 15            "{}/xrpc/com.atproto.sync.getLatestCommit",
 16            base_url().await
 17        ))
 18        .query(&params)
 19        .send()
 20        .await
 21        .expect("Failed to send request");
 22
 23    assert_eq!(res.status(), StatusCode::OK);
 24    let body: Value = res.json().await.expect("Response was not valid JSON");
 25    assert!(body["cid"].is_string());
 26    assert!(body["rev"].is_string());
 27}
 28
 29#[tokio::test]
 30async fn test_get_latest_commit_not_found() {
 31    let client = client();
 32    let params = [("did", "did:plc:nonexistent12345")];
 33    let res = client
 34        .get(format!(
 35            "{}/xrpc/com.atproto.sync.getLatestCommit",
 36            base_url().await
 37        ))
 38        .query(&params)
 39        .send()
 40        .await
 41        .expect("Failed to send request");
 42
 43    assert_eq!(res.status(), StatusCode::NOT_FOUND);
 44    let body: Value = res.json().await.expect("Response was not valid JSON");
 45    assert_eq!(body["error"], "RepoNotFound");
 46}
 47
 48#[tokio::test]
 49async fn test_get_latest_commit_missing_param() {
 50    let client = client();
 51    let res = client
 52        .get(format!(
 53            "{}/xrpc/com.atproto.sync.getLatestCommit",
 54            base_url().await
 55        ))
 56        .send()
 57        .await
 58        .expect("Failed to send request");
 59
 60    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
 61}
 62
 63#[tokio::test]
 64async fn test_list_repos() {
 65    let client = client();
 66    let _ = create_account_and_login(&client).await;
 67
 68    let res = client
 69        .get(format!(
 70            "{}/xrpc/com.atproto.sync.listRepos",
 71            base_url().await
 72        ))
 73        .send()
 74        .await
 75        .expect("Failed to send request");
 76
 77    assert_eq!(res.status(), StatusCode::OK);
 78    let body: Value = res.json().await.expect("Response was not valid JSON");
 79    assert!(body["repos"].is_array());
 80    let repos = body["repos"].as_array().unwrap();
 81    assert!(!repos.is_empty());
 82
 83    let repo = &repos[0];
 84    assert!(repo["did"].is_string());
 85    assert!(repo["head"].is_string());
 86    assert!(repo["active"].is_boolean());
 87}
 88
 89#[tokio::test]
 90async fn test_list_repos_with_limit() {
 91    let client = client();
 92    let _ = create_account_and_login(&client).await;
 93    let _ = create_account_and_login(&client).await;
 94    let _ = create_account_and_login(&client).await;
 95
 96    let params = [("limit", "2")];
 97    let res = client
 98        .get(format!(
 99            "{}/xrpc/com.atproto.sync.listRepos",
100            base_url().await
101        ))
102        .query(&params)
103        .send()
104        .await
105        .expect("Failed to send request");
106
107    assert_eq!(res.status(), StatusCode::OK);
108    let body: Value = res.json().await.expect("Response was not valid JSON");
109    let repos = body["repos"].as_array().unwrap();
110    assert!(repos.len() <= 2);
111}
112
113#[tokio::test]
114async fn test_list_repos_pagination() {
115    let client = client();
116    let _ = create_account_and_login(&client).await;
117    let _ = create_account_and_login(&client).await;
118    let _ = create_account_and_login(&client).await;
119
120    let params = [("limit", "1")];
121    let res = client
122        .get(format!(
123            "{}/xrpc/com.atproto.sync.listRepos",
124            base_url().await
125        ))
126        .query(&params)
127        .send()
128        .await
129        .expect("Failed to send request");
130
131    assert_eq!(res.status(), StatusCode::OK);
132    let body: Value = res.json().await.expect("Response was not valid JSON");
133    let repos = body["repos"].as_array().unwrap();
134    assert_eq!(repos.len(), 1);
135
136    if let Some(cursor) = body["cursor"].as_str() {
137        let params = [("limit", "1"), ("cursor", cursor)];
138        let res = client
139            .get(format!(
140                "{}/xrpc/com.atproto.sync.listRepos",
141                base_url().await
142            ))
143            .query(&params)
144            .send()
145            .await
146            .expect("Failed to send request");
147
148        assert_eq!(res.status(), StatusCode::OK);
149        let body: Value = res.json().await.expect("Response was not valid JSON");
150        let repos2 = body["repos"].as_array().unwrap();
151        assert_eq!(repos2.len(), 1);
152        assert_ne!(repos[0]["did"], repos2[0]["did"]);
153    }
154}
155
156#[tokio::test]
157async fn test_get_repo_status_success() {
158    let client = client();
159    let (_, did) = create_account_and_login(&client).await;
160
161    let params = [("did", did.as_str())];
162    let res = client
163        .get(format!(
164            "{}/xrpc/com.atproto.sync.getRepoStatus",
165            base_url().await
166        ))
167        .query(&params)
168        .send()
169        .await
170        .expect("Failed to send request");
171
172    assert_eq!(res.status(), StatusCode::OK);
173    let body: Value = res.json().await.expect("Response was not valid JSON");
174    assert_eq!(body["did"], did);
175    assert_eq!(body["active"], true);
176    assert!(body["rev"].is_string());
177}
178
179#[tokio::test]
180async fn test_get_repo_status_not_found() {
181    let client = client();
182    let params = [("did", "did:plc:nonexistent12345")];
183    let res = client
184        .get(format!(
185            "{}/xrpc/com.atproto.sync.getRepoStatus",
186            base_url().await
187        ))
188        .query(&params)
189        .send()
190        .await
191        .expect("Failed to send request");
192
193    assert_eq!(res.status(), StatusCode::NOT_FOUND);
194    let body: Value = res.json().await.expect("Response was not valid JSON");
195    assert_eq!(body["error"], "RepoNotFound");
196}
197
198#[tokio::test]
199async fn test_list_blobs_success() {
200    let client = client();
201    let (access_jwt, did) = create_account_and_login(&client).await;
202
203    let blob_res = client
204        .post(format!(
205            "{}/xrpc/com.atproto.repo.uploadBlob",
206            base_url().await
207        ))
208        .header(header::CONTENT_TYPE, "text/plain")
209        .bearer_auth(&access_jwt)
210        .body("test blob content")
211        .send()
212        .await
213        .expect("Failed to upload blob");
214
215    assert_eq!(blob_res.status(), StatusCode::OK);
216
217    let params = [("did", did.as_str())];
218    let res = client
219        .get(format!(
220            "{}/xrpc/com.atproto.sync.listBlobs",
221            base_url().await
222        ))
223        .query(&params)
224        .send()
225        .await
226        .expect("Failed to send request");
227
228    assert_eq!(res.status(), StatusCode::OK);
229    let body: Value = res.json().await.expect("Response was not valid JSON");
230    assert!(body["cids"].is_array());
231    let cids = body["cids"].as_array().unwrap();
232    assert!(!cids.is_empty());
233}
234
235#[tokio::test]
236async fn test_list_blobs_not_found() {
237    let client = client();
238    let params = [("did", "did:plc:nonexistent12345")];
239    let res = client
240        .get(format!(
241            "{}/xrpc/com.atproto.sync.listBlobs",
242            base_url().await
243        ))
244        .query(&params)
245        .send()
246        .await
247        .expect("Failed to send request");
248
249    assert_eq!(res.status(), StatusCode::NOT_FOUND);
250    let body: Value = res.json().await.expect("Response was not valid JSON");
251    assert_eq!(body["error"], "RepoNotFound");
252}
253
254#[tokio::test]
255async fn test_get_blob_success() {
256    let client = client();
257    let (access_jwt, did) = create_account_and_login(&client).await;
258
259    let blob_content = "test blob for get_blob";
260    let blob_res = client
261        .post(format!(
262            "{}/xrpc/com.atproto.repo.uploadBlob",
263            base_url().await
264        ))
265        .header(header::CONTENT_TYPE, "text/plain")
266        .bearer_auth(&access_jwt)
267        .body(blob_content)
268        .send()
269        .await
270        .expect("Failed to upload blob");
271
272    assert_eq!(blob_res.status(), StatusCode::OK);
273    let blob_body: Value = blob_res.json().await.expect("Response was not valid JSON");
274    let cid = blob_body["blob"]["ref"]["$link"].as_str().expect("No CID");
275
276    let params = [("did", did.as_str()), ("cid", cid)];
277    let res = client
278        .get(format!(
279            "{}/xrpc/com.atproto.sync.getBlob",
280            base_url().await
281        ))
282        .query(&params)
283        .send()
284        .await
285        .expect("Failed to send request");
286
287    assert_eq!(res.status(), StatusCode::OK);
288    assert_eq!(
289        res.headers()
290            .get("content-type")
291            .and_then(|h| h.to_str().ok()),
292        Some("text/plain")
293    );
294    let body = res.text().await.expect("Failed to get body");
295    assert_eq!(body, blob_content);
296}
297
298#[tokio::test]
299async fn test_get_blob_not_found() {
300    let client = client();
301    let (_, did) = create_account_and_login(&client).await;
302
303    let params = [
304        ("did", did.as_str()),
305        ("cid", "bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku"),
306    ];
307    let res = client
308        .get(format!(
309            "{}/xrpc/com.atproto.sync.getBlob",
310            base_url().await
311        ))
312        .query(&params)
313        .send()
314        .await
315        .expect("Failed to send request");
316
317    assert_eq!(res.status(), StatusCode::NOT_FOUND);
318    let body: Value = res.json().await.expect("Response was not valid JSON");
319    assert_eq!(body["error"], "BlobNotFound");
320}
321
322#[tokio::test]
323async fn test_notify_of_update() {
324    let client = client();
325    let params = [("hostname", "example.com")];
326    let res = client
327        .post(format!(
328            "{}/xrpc/com.atproto.sync.notifyOfUpdate",
329            base_url().await
330        ))
331        .query(&params)
332        .send()
333        .await
334        .expect("Failed to send request");
335
336    assert_eq!(res.status(), StatusCode::OK);
337}
338
339#[tokio::test]
340async fn test_request_crawl() {
341    let client = client();
342    let payload = serde_json::json!({"hostname": "example.com"});
343    let res = client
344        .post(format!(
345            "{}/xrpc/com.atproto.sync.requestCrawl",
346            base_url().await
347        ))
348        .json(&payload)
349        .send()
350        .await
351        .expect("Failed to send request");
352
353    assert_eq!(res.status(), StatusCode::OK);
354}