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