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