this repo has no description
lewis.moe
1use aws_config::BehaviorVersion;
2use aws_sdk_s3::Client as S3Client;
3use aws_sdk_s3::config::Credentials;
4use bspds::state::AppState;
5use chrono::Utc;
6use reqwest::{Client, StatusCode, header};
7use serde_json::{Value, json};
8use sqlx::postgres::PgPoolOptions;
9#[allow(unused_imports)]
10use std::collections::HashMap;
11use std::sync::OnceLock;
12#[allow(unused_imports)]
13use std::time::Duration;
14use testcontainers::core::ContainerPort;
15use testcontainers::{ContainerAsync, GenericImage, ImageExt, runners::AsyncRunner};
16use testcontainers_modules::postgres::Postgres;
17use tokio::net::TcpListener;
18use wiremock::matchers::{method, path};
19use wiremock::{Mock, MockServer, ResponseTemplate};
20
21static SERVER_URL: OnceLock<String> = OnceLock::new();
22static DB_CONTAINER: OnceLock<ContainerAsync<Postgres>> = OnceLock::new();
23static S3_CONTAINER: OnceLock<ContainerAsync<GenericImage>> = OnceLock::new();
24static MOCK_APPVIEW: OnceLock<MockServer> = OnceLock::new();
25
26#[allow(dead_code)]
27pub const AUTH_TOKEN: &str = "test-token";
28#[allow(dead_code)]
29pub const BAD_AUTH_TOKEN: &str = "bad-token";
30#[allow(dead_code)]
31pub const AUTH_DID: &str = "did:plc:fake";
32#[allow(dead_code)]
33pub const TARGET_DID: &str = "did:plc:target";
34
35#[allow(dead_code)]
36pub fn client() -> Client {
37 Client::new()
38}
39
40pub async fn base_url() -> &'static str {
41 SERVER_URL.get_or_init(|| {
42 let (tx, rx) = std::sync::mpsc::channel();
43
44 std::thread::spawn(move || {
45 if std::env::var("DOCKER_HOST").is_err() {
46 if let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") {
47 let podman_sock = std::path::Path::new(&runtime_dir).join("podman/podman.sock");
48 if podman_sock.exists() {
49 unsafe {
50 std::env::set_var(
51 "DOCKER_HOST",
52 format!("unix://{}", podman_sock.display()),
53 );
54 }
55 }
56 }
57 }
58
59 let rt = tokio::runtime::Runtime::new().unwrap();
60 rt.block_on(async move {
61 let s3_container = GenericImage::new("minio/minio", "latest")
62 .with_exposed_port(ContainerPort::Tcp(9000))
63 .with_env_var("MINIO_ROOT_USER", "minioadmin")
64 .with_env_var("MINIO_ROOT_PASSWORD", "minioadmin")
65 .with_cmd(vec!["server".to_string(), "/data".to_string()])
66 .start()
67 .await
68 .expect("Failed to start MinIO");
69
70 let s3_port = s3_container
71 .get_host_port_ipv4(9000)
72 .await
73 .expect("Failed to get S3 port");
74 let s3_endpoint = format!("http://127.0.0.1:{}", s3_port);
75
76 unsafe {
77 std::env::set_var("S3_BUCKET", "test-bucket");
78 std::env::set_var("AWS_ACCESS_KEY_ID", "minioadmin");
79 std::env::set_var("AWS_SECRET_ACCESS_KEY", "minioadmin");
80 std::env::set_var("AWS_REGION", "us-east-1");
81 std::env::set_var("S3_ENDPOINT", &s3_endpoint);
82 }
83
84 let sdk_config = aws_config::defaults(BehaviorVersion::latest())
85 .region("us-east-1")
86 .endpoint_url(&s3_endpoint)
87 .credentials_provider(Credentials::new(
88 "minioadmin",
89 "minioadmin",
90 None,
91 None,
92 "test",
93 ))
94 .load()
95 .await;
96
97 let s3_config = aws_sdk_s3::config::Builder::from(&sdk_config)
98 .force_path_style(true)
99 .build();
100 let s3_client = S3Client::from_conf(s3_config);
101
102 let _ = s3_client.create_bucket().bucket("test-bucket").send().await;
103
104 let mock_server = MockServer::start().await;
105
106 Mock::given(method("GET"))
107 .and(path("/xrpc/app.bsky.actor.getProfile"))
108 .respond_with(ResponseTemplate::new(200).set_body_json(json!({
109 "handle": "mock.handle",
110 "did": "did:plc:mock",
111 "displayName": "Mock User"
112 })))
113 .mount(&mock_server)
114 .await;
115
116 Mock::given(method("GET"))
117 .and(path("/xrpc/app.bsky.actor.searchActors"))
118 .respond_with(ResponseTemplate::new(200).set_body_json(json!({
119 "actors": [],
120 "cursor": null
121 })))
122 .mount(&mock_server)
123 .await;
124
125 unsafe {
126 std::env::set_var("APPVIEW_URL", mock_server.uri());
127 }
128 MOCK_APPVIEW.set(mock_server).ok();
129
130 S3_CONTAINER.set(s3_container).ok();
131
132 let container = Postgres::default()
133 .with_tag("18-alpine")
134 .start()
135 .await
136 .expect("Failed to start Postgres");
137 let connection_string = format!(
138 "postgres://postgres:postgres@127.0.0.1:{}/postgres",
139 container
140 .get_host_port_ipv4(5432)
141 .await
142 .expect("Failed to get port")
143 );
144
145 DB_CONTAINER.set(container).ok();
146
147 let url = spawn_app(connection_string).await;
148 tx.send(url).unwrap();
149 std::future::pending::<()>().await;
150 });
151 });
152
153 rx.recv().expect("Failed to start test server")
154 })
155}
156
157async fn spawn_app(database_url: String) -> String {
158 let pool = PgPoolOptions::new()
159 .connect(&database_url)
160 .await
161 .expect("Failed to connect to Postgres. Make sure the database is running.");
162
163 sqlx::migrate!("./migrations")
164 .run(&pool)
165 .await
166 .expect("Failed to run migrations");
167
168 let state = AppState::new(pool).await;
169 let app = bspds::app(state);
170
171 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
172 let addr = listener.local_addr().unwrap();
173
174 tokio::spawn(async move {
175 axum::serve(listener, app).await.unwrap();
176 });
177
178 format!("http://{}", addr)
179}
180
181#[allow(dead_code)]
182pub async fn upload_test_blob(client: &Client, data: &'static str, mime: &'static str) -> Value {
183 let res = client
184 .post(format!(
185 "{}/xrpc/com.atproto.repo.uploadBlob",
186 base_url().await
187 ))
188 .header(header::CONTENT_TYPE, mime)
189 .bearer_auth(AUTH_TOKEN)
190 .body(data)
191 .send()
192 .await
193 .expect("Failed to send uploadBlob request");
194
195 assert_eq!(res.status(), StatusCode::OK, "Failed to upload blob");
196 let body: Value = res.json().await.expect("Blob upload response was not JSON");
197 body["blob"].clone()
198}
199
200#[allow(dead_code)]
201pub async fn create_test_post(
202 client: &Client,
203 text: &str,
204 reply_to: Option<Value>,
205) -> (String, String, String) {
206 let collection = "app.bsky.feed.post";
207 let mut record = json!({
208 "$type": collection,
209 "text": text,
210 "createdAt": Utc::now().to_rfc3339()
211 });
212
213 if let Some(reply_obj) = reply_to {
214 record["reply"] = reply_obj;
215 }
216
217 let payload = json!({
218 "repo": AUTH_DID,
219 "collection": collection,
220 "record": record
221 });
222
223 let res = client
224 .post(format!(
225 "{}/xrpc/com.atproto.repo.createRecord",
226 base_url().await
227 ))
228 .bearer_auth(AUTH_TOKEN)
229 .json(&payload)
230 .send()
231 .await
232 .expect("Failed to send createRecord");
233
234 assert_eq!(res.status(), StatusCode::OK, "Failed to create post record");
235 let body: Value = res
236 .json()
237 .await
238 .expect("createRecord response was not JSON");
239
240 let uri = body["uri"]
241 .as_str()
242 .expect("Response had no URI")
243 .to_string();
244 let cid = body["cid"]
245 .as_str()
246 .expect("Response had no CID")
247 .to_string();
248 let rkey = uri
249 .split('/')
250 .last()
251 .expect("URI was malformed")
252 .to_string();
253
254 (uri, cid, rkey)
255}
256
257#[allow(dead_code)]
258pub async fn create_account_and_login(client: &Client) -> (String, String) {
259 let handle = format!("user_{}", uuid::Uuid::new_v4());
260 let payload = json!({
261 "handle": handle,
262 "email": format!("{}@example.com", handle),
263 "password": "password"
264 });
265
266 let res = client
267 .post(format!(
268 "{}/xrpc/com.atproto.server.createAccount",
269 base_url().await
270 ))
271 .json(&payload)
272 .send()
273 .await
274 .expect("Failed to create account");
275
276 if res.status() != StatusCode::OK {
277 panic!("Failed to create account: {:?}", res.text().await);
278 }
279
280 let body: Value = res.json().await.expect("Invalid JSON");
281 let access_jwt = body["accessJwt"]
282 .as_str()
283 .expect("No accessJwt")
284 .to_string();
285 let did = body["did"].as_str().expect("No did").to_string();
286 (access_jwt, did)
287}