this repo has no description
lewis.moe
1use chrono::Utc;
2use reqwest::StatusCode;
3use serde_json::{Value, json};
4
5pub use crate::common::*;
6
7fn unique_id() -> String {
8 uuid::Uuid::new_v4().simple().to_string()[..12].to_string()
9}
10
11#[allow(dead_code)]
12pub async fn setup_new_user(handle_prefix: &str) -> (String, String) {
13 let client = client();
14 let uid = unique_id();
15 let handle = format!("{}-{}.test", handle_prefix, uid);
16 let email = format!("{}-{}@test.com", handle_prefix, uid);
17 let password = "E2epass123!";
18 let create_account_payload = json!({
19 "handle": handle,
20 "email": email,
21 "password": password
22 });
23 let create_res = client
24 .post(format!(
25 "{}/xrpc/com.atproto.server.createAccount",
26 base_url().await
27 ))
28 .json(&create_account_payload)
29 .send()
30 .await
31 .expect("setup_new_user: Failed to send createAccount");
32 if create_res.status() != reqwest::StatusCode::OK {
33 panic!(
34 "setup_new_user: Failed to create account: {:?}",
35 create_res.text().await
36 );
37 }
38 let create_body: Value = create_res
39 .json()
40 .await
41 .expect("setup_new_user: createAccount response was not JSON");
42 let new_did = create_body["did"]
43 .as_str()
44 .expect("setup_new_user: Response had no DID")
45 .to_string();
46 let new_jwt = verify_new_account(&client, &new_did).await;
47 (new_did, new_jwt)
48}
49
50#[allow(dead_code)]
51pub async fn create_post(
52 client: &reqwest::Client,
53 did: &str,
54 jwt: &str,
55 text: &str,
56) -> (String, String) {
57 let collection = "app.bsky.feed.post";
58 let rkey = format!("e2e_social_{}", unique_id());
59 let now = Utc::now().to_rfc3339();
60 let create_payload = json!({
61 "repo": did,
62 "collection": collection,
63 "rkey": rkey,
64 "record": {
65 "$type": collection,
66 "text": text,
67 "createdAt": now
68 }
69 });
70 let create_res = client
71 .post(format!(
72 "{}/xrpc/com.atproto.repo.putRecord",
73 base_url().await
74 ))
75 .bearer_auth(jwt)
76 .json(&create_payload)
77 .send()
78 .await
79 .expect("Failed to send create post request");
80 assert_eq!(
81 create_res.status(),
82 reqwest::StatusCode::OK,
83 "Failed to create post record"
84 );
85 let create_body: Value = create_res
86 .json()
87 .await
88 .expect("create post response was not JSON");
89 let uri = create_body["uri"].as_str().unwrap().to_string();
90 let cid = create_body["cid"].as_str().unwrap().to_string();
91 (uri, cid)
92}
93
94#[allow(dead_code)]
95pub async fn create_follow(
96 client: &reqwest::Client,
97 follower_did: &str,
98 follower_jwt: &str,
99 followee_did: &str,
100) -> (String, String) {
101 let collection = "app.bsky.graph.follow";
102 let rkey = format!("e2e_follow_{}", unique_id());
103 let now = Utc::now().to_rfc3339();
104 let create_payload = json!({
105 "repo": follower_did,
106 "collection": collection,
107 "rkey": rkey,
108 "record": {
109 "$type": collection,
110 "subject": followee_did,
111 "createdAt": now
112 }
113 });
114 let create_res = client
115 .post(format!(
116 "{}/xrpc/com.atproto.repo.putRecord",
117 base_url().await
118 ))
119 .bearer_auth(follower_jwt)
120 .json(&create_payload)
121 .send()
122 .await
123 .expect("Failed to send create follow request");
124 assert_eq!(
125 create_res.status(),
126 reqwest::StatusCode::OK,
127 "Failed to create follow record"
128 );
129 let create_body: Value = create_res
130 .json()
131 .await
132 .expect("create follow response was not JSON");
133 let uri = create_body["uri"].as_str().unwrap().to_string();
134 let cid = create_body["cid"].as_str().unwrap().to_string();
135 (uri, cid)
136}
137
138#[allow(dead_code)]
139pub async fn create_like(
140 client: &reqwest::Client,
141 liker_did: &str,
142 liker_jwt: &str,
143 subject_uri: &str,
144 subject_cid: &str,
145) -> (String, String) {
146 let collection = "app.bsky.feed.like";
147 let rkey = format!("e2e_like_{}", unique_id());
148 let now = Utc::now().to_rfc3339();
149 let payload = json!({
150 "repo": liker_did,
151 "collection": collection,
152 "rkey": rkey,
153 "record": {
154 "$type": collection,
155 "subject": {
156 "uri": subject_uri,
157 "cid": subject_cid
158 },
159 "createdAt": now
160 }
161 });
162 let res = client
163 .post(format!(
164 "{}/xrpc/com.atproto.repo.putRecord",
165 base_url().await
166 ))
167 .bearer_auth(liker_jwt)
168 .json(&payload)
169 .send()
170 .await
171 .expect("Failed to create like");
172 assert_eq!(res.status(), StatusCode::OK, "Failed to create like");
173 let body: Value = res.json().await.expect("Like response not JSON");
174 (
175 body["uri"].as_str().unwrap().to_string(),
176 body["cid"].as_str().unwrap().to_string(),
177 )
178}
179
180#[allow(dead_code)]
181pub async fn create_repost(
182 client: &reqwest::Client,
183 reposter_did: &str,
184 reposter_jwt: &str,
185 subject_uri: &str,
186 subject_cid: &str,
187) -> (String, String) {
188 let collection = "app.bsky.feed.repost";
189 let rkey = format!("e2e_repost_{}", unique_id());
190 let now = Utc::now().to_rfc3339();
191 let payload = json!({
192 "repo": reposter_did,
193 "collection": collection,
194 "rkey": rkey,
195 "record": {
196 "$type": collection,
197 "subject": {
198 "uri": subject_uri,
199 "cid": subject_cid
200 },
201 "createdAt": now
202 }
203 });
204 let res = client
205 .post(format!(
206 "{}/xrpc/com.atproto.repo.putRecord",
207 base_url().await
208 ))
209 .bearer_auth(reposter_jwt)
210 .json(&payload)
211 .send()
212 .await
213 .expect("Failed to create repost");
214 assert_eq!(res.status(), StatusCode::OK, "Failed to create repost");
215 let body: Value = res.json().await.expect("Repost response not JSON");
216 (
217 body["uri"].as_str().unwrap().to_string(),
218 body["cid"].as_str().unwrap().to_string(),
219 )
220}
221
222#[allow(dead_code)]
223pub async fn set_account_takedown(did: &str, takedown_ref: Option<&str>) {
224 let pool = get_test_db_pool().await;
225 sqlx::query!(
226 "UPDATE users SET takedown_ref = $1 WHERE did = $2",
227 takedown_ref,
228 did
229 )
230 .execute(pool)
231 .await
232 .expect("Failed to update takedown_ref");
233}
234
235#[allow(dead_code)]
236pub async fn set_account_deactivated(did: &str, deactivated: bool) {
237 let pool = get_test_db_pool().await;
238 let deactivated_at: Option<chrono::DateTime<Utc>> =
239 if deactivated { Some(Utc::now()) } else { None };
240 sqlx::query!(
241 "UPDATE users SET deactivated_at = $1 WHERE did = $2",
242 deactivated_at,
243 did
244 )
245 .execute(pool)
246 .await
247 .expect("Failed to update deactivated_at");
248}