//! End-to-end tests against a real PostgreSQL database. //! //! `DATABASE_URL` must point to a server where the user may create databases //! (e.g. the `postgres` service of docker-compose); every test gets a fresh, //! migrated database. The horoscope service and Google's key endpoint are //! replaced by a small fake HTTP server. use std::sync::Arc; use axum::body::Body; use axum::http::{HeaderMap, Request, StatusCode}; use axum::routing::{get, post}; use axum::{Json, Router}; use http_body_util::BodyExt; use serde_json::{Value, json}; use sqlx::PgPool; use tower::ServiceExt; use crate::config::Config; use crate::{AppState, routes}; const GOOGLE_CLIENT: &str = "test-client.apps.googleusercontent.com"; const GOOGLE_KEY_PEM: &[u8] = include_bytes!("../testdata/google-test-key.pem"); const GOOGLE_KEY_N: &str = include_str!("../testdata/google-test-key.n"); // --- fake horoscope service and Google key endpoint -------------------------------------- async fn fake_natal(Json(body): Json) -> (StatusCode, Json) { if body["place"] == "Nincsilyenhely" { return ( StatusCode::NOT_FOUND, Json(json!({"error": {"code": "place_not_found", "message": "place not found", "suggestions": []}})), ); } let date = body["date"].as_str().unwrap_or("2000-01-01"); let time = body["time"].as_str(); ( StatusCode::OK, Json(json!({ "input": body, "location": {"country": {"name": "Hungary"}, "place": {"name": body["place"]}, "latitude": 47.0, "longitude": 19.0}, "time": {"local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()}, "astronomy": {"julian_day_ut": 2451545.0}, "settings": body.get("options").cloned().unwrap_or(json!({"house_system": "placidus"})), "points": [{"id": "sun", "sign": "cancer", "longitude": 90.4}, {"id": "moon", "sign": "pisces", "longitude": 338.2}], "angles": {"ascendant": {"sign": "aries", "longitude": 18.0}}, "warnings": [], "meta": {"data_sources": {"ephemeris": {"version": "test"}}} })), ) } async fn fake_synastry(Json(body): Json) -> (StatusCode, Json) { // Like the real service: options only at the top level. if body["person1"].get("options").is_some() || body["person2"].get("options").is_some() { return ( StatusCode::BAD_REQUEST, Json(json!({"error": {"code": "bad_request", "message": "per-person options"}})), ); } ( StatusCode::OK, Json(json!({ "person1": {"input": body["person1"]}, "person2": {"input": body["person2"]}, "settings": {"aspect_set": "major"}, "aspects": [{"person1": "sun", "person2": "moon", "aspect": "trine"}], "house_overlays": {"person1_in_person2": [], "person2_in_person1": []}, "summary": {"aspect_count": 1}, "composite": {"method": "midpoint", "points": []}, "meta": {} })), ) } async fn fake_jwks() -> Json { Json( json!({"keys": [{"kid": "test-key", "kty": "RSA", "alg": "RS256", "use": "sig", "n": GOOGLE_KEY_N.trim(), "e": "AQAB"}]}), ) } async fn fake_services() -> String { let app = Router::new() .route("/v1/natal", post(fake_natal)) .route("/v1/synastry", post(fake_synastry)) .route("/jwks", get(fake_jwks)); let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let addr = listener.local_addr().unwrap(); tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }); format!("http://{addr}") } fn google_token(sub: &str, email: &str, audience: &str) -> String { let now = time::OffsetDateTime::now_utc().unix_timestamp(); let claims = json!({ "iss": "https://accounts.google.com", "aud": audience, "sub": sub, "email": email, "email_verified": true, "name": "Google Gábor", "iat": now, "exp": now + 3600 }); let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256); header.kid = Some("test-key".into()); jsonwebtoken::encode(&header, &claims, &jsonwebtoken::EncodingKey::from_rsa_pem(GOOGLE_KEY_PEM).unwrap()).unwrap() } // --- test client ------------------------------------------------------------------------------- struct TestApp { router: Router, pool: PgPool, } struct Response { status: StatusCode, body: Value, headers: HeaderMap, } impl TestApp { async fn new(pool: PgPool) -> Self { let fake = fake_services().await; let config = Config::for_tests(String::new(), fake.clone(), format!("{fake}/jwks")); Self { router: routes::router(Arc::new(AppState::new(pool.clone(), config))), pool } } async fn call(&self, method: &str, uri: &str, token: Option<&str>, body: Option) -> Response { let mut req = Request::builder().method(method).uri(uri); if let Some(t) = token { req = req.header("authorization", format!("Bearer {t}")); } let body = match body { Some(v) => { req = req.header("content-type", "application/json"); Body::from(v.to_string()) } None => Body::empty(), }; let resp = self.router.clone().oneshot(req.body(body).unwrap()).await.unwrap(); let status = resp.status(); let headers = resp.headers().clone(); let bytes = resp.into_body().collect().await.unwrap().to_bytes(); Response { status, body: serde_json::from_slice(&bytes).unwrap_or(Value::Null), headers } } async fn get(&self, uri: &str, token: Option<&str>) -> Response { self.call("GET", uri, token, None).await } async fn post(&self, uri: &str, token: Option<&str>, body: Value) -> Response { self.call("POST", uri, token, Some(body)).await } /// Registers a user; returns the session token. async fn register(&self, email: &str, name: &str) -> String { let r = self .post( "/v1/auth/register", None, json!({"email": email, "password": "titkos-jelszo-123", "display_name": name}), ) .await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); r.body["session"]["token"].as_str().unwrap().to_string() } async fn chart(&self, token: &str, label: &str, primary: bool, date: &str) -> Value { let r = self .post( "/v1/charts", Some(token), json!({"label": label, "is_primary": primary, "birth": {"name": "Secret Name", "date": date, "time": "14:30", "country": "HU", "place": "Szeged"}}), ) .await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); r.body } async fn outbox_url(&self, email: &str, template: &str) -> String { let (payload,): (Value,) = sqlx::query_as( "SELECT payload FROM email_outbox WHERE to_email = $1 AND template = $2 ORDER BY created_at DESC LIMIT 1", ) .bind(email) .bind(template) .fetch_one(&self.pool) .await .unwrap(); payload["url"].as_str().unwrap().to_string() } } fn token_param(url: &str) -> &str { url.split("token=").nth(1).unwrap() } // --- tests ------------------------------------------------------------------------------------ #[sqlx::test(migrator = "db::MIGRATOR")] async fn register_login_verify_logout(pool: PgPool) { let app = TestApp::new(pool).await; let r = app .post("/v1/auth/register", None, json!({"email": "Anna@Example.com", "password": "titkos-jelszo-123"})) .await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let cookie = r.headers.get("set-cookie").unwrap().to_str().unwrap(); assert!(cookie.starts_with("sf_session=") && cookie.contains("HttpOnly") && cookie.contains("Secure")); assert_eq!(r.body["user"]["email"], "anna@example.com"); assert_eq!(r.body["user"]["roles"], json!(["user"])); assert_eq!(r.body["user"]["email_verified"], false); let token = r.body["session"]["token"].as_str().unwrap().to_string(); // duplicate, short password let r = app .post("/v1/auth/register", None, json!({"email": "anna@example.com", "password": "titkos-jelszo-123"})) .await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("email_taken"))); let r = app.post("/v1/auth/register", None, json!({"email": "b@example.com", "password": "rovid"})).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); let r = app.get("/v1/me", Some(&token)).await; assert_eq!(r.status, StatusCode::OK); assert_eq!(r.body["providers"], json!(["password"])); assert_eq!(r.body["credits"], 2); // e-mail verification through the queued e-mail's link let url = app.outbox_url("anna@example.com", "verify_email").await; assert!(url.starts_with("https://sorsfonalak.test/verify-email?token=")); let r = app.post("/v1/auth/verify-email", None, json!({"token": token_param(&url)})).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); let r = app.post("/v1/auth/verify-email", None, json!({"token": token_param(&url)})).await; assert_eq!(r.body["error"]["code"], "invalid_token"); assert_eq!(app.get("/v1/me", Some(&token)).await.body["user"]["email_verified"], true); // login let r = app.post("/v1/auth/login", None, json!({"email": "anna@example.com", "password": "rossz-jelszo-123"})).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::UNAUTHORIZED, Some("invalid_credentials"))); let r = app.post("/v1/auth/login", None, json!({"email": "nincs@example.com", "password": "titkos-jelszo-123"})).await; assert_eq!(r.status, StatusCode::UNAUTHORIZED); let r = app.post("/v1/auth/login", None, json!({"email": "ANNA@example.com", "password": "titkos-jelszo-123"})).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); let second = r.body["session"]["token"].as_str().unwrap().to_string(); // logout ends only that session; guards answer 401 without a session assert_eq!(app.post("/v1/auth/logout", Some(&token), json!({})).await.status, StatusCode::NO_CONTENT); assert_eq!(app.get("/v1/me", Some(&token)).await.status, StatusCode::UNAUTHORIZED); assert_eq!(app.get("/v1/me", Some(&second)).await.status, StatusCode::OK); assert_eq!(app.get("/v1/me", None).await.status, StatusCode::UNAUTHORIZED); assert_eq!(app.get("/v1/charts", Some("garbage")).await.status, StatusCode::UNAUTHORIZED); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn password_reset_ends_sessions(pool: PgPool) { let app = TestApp::new(pool).await; let token = app.register("anna@example.com", "Anna").await; // unknown address: same answer assert_eq!( app.post("/v1/auth/password-reset", None, json!({"email": "x@example.com"})).await.status, StatusCode::ACCEPTED ); assert_eq!( app.post("/v1/auth/password-reset", None, json!({"email": "anna@example.com"})).await.status, StatusCode::ACCEPTED ); let url = app.outbox_url("anna@example.com", "reset_password").await; let r = app .post( "/v1/auth/password-reset/confirm", None, json!({"token": token_param(&url), "password": "uj-titkos-jelszo-456"}), ) .await; assert_eq!(r.status, StatusCode::NO_CONTENT, "{}", r.body); assert_eq!(app.get("/v1/me", Some(&token)).await.status, StatusCode::UNAUTHORIZED); let r = app .post("/v1/auth/login", None, json!({"email": "anna@example.com", "password": "uj-titkos-jelszo-456"})) .await; assert_eq!(r.status, StatusCode::OK); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn google_login_creates_links_and_rejects(pool: PgPool) { let app = TestApp::new(pool).await; let r = app .post("/v1/auth/google", None, json!({"id_token": google_token("g-1", "gabor@gmail.com", GOOGLE_CLIENT)})) .await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); assert_eq!(r.body["created"], true); assert_eq!(r.body["user"]["email_verified"], true); assert_eq!(r.body["user"]["display_name"], "Google Gábor"); let r = app .post("/v1/auth/google", None, json!({"id_token": google_token("g-1", "gabor@gmail.com", GOOGLE_CLIENT)})) .await; assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false))); // an existing password account with the same address gets Google linked let token = app.register("anna@example.com", "Anna").await; let r = app .post("/v1/auth/google", None, json!({"id_token": google_token("g-2", "anna@example.com", GOOGLE_CLIENT)})) .await; assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false))); assert_eq!(app.get("/v1/me", Some(&token)).await.body["providers"], json!(["password", "google"])); let r = app .post("/v1/auth/google", None, json!({"id_token": google_token("g-3", "x@gmail.com", "other-client")})) .await; assert_eq!(r.status, StatusCode::UNAUTHORIZED); let r = app.post("/v1/auth/google", None, json!({"id_token": "not-a-jwt"})).await; assert_eq!(r.status, StatusCode::UNAUTHORIZED); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn roles_and_admin_guard(pool: PgPool) { let app = TestApp::new(pool).await; let user = app.register("anna@example.com", "Anna").await; let admin = app.register("admin@example.com", "Admin").await; // BOOTSTRAP_ADMIN_EMAILS assert_eq!(app.get("/v1/me", Some(&admin)).await.body["user"]["roles"], json!(["user", "admin"])); assert_eq!(app.get("/v1/admin/users", None).await.status, StatusCode::UNAUTHORIZED); let r = app.get("/v1/admin/users", Some(&user)).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("forbidden"))); let r = app.get("/v1/admin/users?q=anna", Some(&admin)).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); let users = r.body["users"].as_array().unwrap(); assert_eq!(users.len(), 1); let anna = users[0]["id"].as_str().unwrap().to_string(); let r = app .call("PATCH", &format!("/v1/admin/users/{anna}"), Some(&admin), Some(json!({"roles": ["user", "creator"]}))) .await; assert_eq!(r.body["roles"], json!(["creator", "user"])); let r = app.call("PATCH", &format!("/v1/admin/users/{anna}"), Some(&admin), Some(json!({"roles": ["root"]}))).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); let admin_id = app.get("/v1/me", Some(&admin)).await.body["user"]["id"].as_str().unwrap().to_string(); let r = app.call("PATCH", &format!("/v1/admin/users/{admin_id}"), Some(&admin), Some(json!({"roles": ["user"]}))).await; assert_eq!(r.status, StatusCode::CONFLICT); let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), json!({"delta": 5, "note": "bonus"})).await; assert_eq!(r.status, StatusCode::CREATED); assert_eq!(app.get("/v1/credits", Some(&user)).await.body["balance"], 7); // 2 monthly + 5 } #[sqlx::test(migrator = "db::MIGRATOR")] async fn charts_are_private(pool: PgPool) { let app = TestApp::new(pool).await; let anna = app.register("anna@example.com", "Anna").await; let bela = app.register("bela@example.com", "Béla").await; let own = app.chart(&anna, "Saját", true, "1990-03-15").await; assert_eq!(own["highlights"]["sun"], "cancer"); assert!(own["birth_data"].get("name").is_none(), "names must not be stored or sent"); let id = own["id"].as_str().unwrap(); let other = app.chart(&anna, "Anya", true, "1950-03-01").await; let list = app.get("/v1/charts", Some(&anna)).await.body; assert_eq!(list["charts"].as_array().unwrap().len(), 2); assert_eq!(list["charts"][0]["id"], other["id"]); // the new primary first assert_eq!(list["charts"][1]["is_primary"], false); assert_eq!(app.get(&format!("/v1/charts/{id}"), Some(&bela)).await.status, StatusCode::NOT_FOUND); assert_eq!(app.call("DELETE", &format!("/v1/charts/{id}"), Some(&bela), None).await.status, StatusCode::NOT_FOUND); assert_eq!(app.get("/v1/charts/not-a-uuid", Some(&anna)).await.status, StatusCode::BAD_REQUEST); // birth data errors of the horoscope service are passed through let r = app .post( "/v1/charts", Some(&anna), json!({"label": "X", "birth": {"date": "1990-01-01", "country": "HU", "place": "Nincsilyenhely"}}), ) .await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::NOT_FOUND, Some("place_not_found"))); let r = app .call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(json!({"label": "Én", "is_primary": true}))) .await; assert_eq!((r.body["label"].as_str(), &r.body["is_primary"]), (Some("Én"), &json!(true))); assert_eq!(app.call("DELETE", &format!("/v1/charts/{id}"), Some(&anna), None).await.status, StatusCode::NO_CONTENT); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn invitation_links_two_users(pool: PgPool) { let app = TestApp::new(pool).await; let anna = app.register("anna@example.com", "Anna").await; let bela = app.register("bela@example.com", "Béla").await; let r = app.post("/v1/invites", Some(&anna), json!({"message": "Nézzük meg!"})).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("primary_chart_required"))); app.chart(&anna, "Saját", true, "1990-03-15").await; let r = app.post("/v1/invites", Some(&anna), json!({"message": "Nézzük meg!"})).await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let token = r.body["token"].as_str().unwrap().to_string(); assert!(r.body["url"].as_str().unwrap().ends_with(&token)); // public landing page data, no login let r = app.get(&format!("/v1/public/invites/{token}"), None).await; assert_eq!( r.body, json!({"inviter_name": "Anna", "message": "Nézzük meg!", "status": "pending", "expires_at": r.body["expires_at"]}) ); let r = app.post("/v1/invites/accept", Some(&anna), json!({"token": token})).await; assert_eq!(r.status, StatusCode::CONFLICT); // own invitation let r = app.post("/v1/invites/accept", Some(&bela), json!({"token": token})).await; assert_eq!(r.status, StatusCode::CONFLICT); // Béla has no chart yet app.chart(&bela, "Saját", true, "1976-09-03").await; let r = app.post("/v1/invites/accept", Some(&bela), json!({"token": token})).await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let synastry_id = r.body["id"].as_str().unwrap().to_string(); assert_eq!(r.body["synastry"]["summary"]["aspect_count"], 1); assert!(r.body["synastry"].get("person1").is_none()); assert_eq!(r.body["chart2"]["owned"], true); assert_eq!(r.body["chart1"]["owned"], false); assert_eq!(r.body["chart1"]["label"], "Anna"); // the inviter's name, not her label assert!(r.body["chart1"].get("birth_data").is_none()); assert!(r.body["chart1"]["chart"].get("time").is_none()); // both see it; Anna does not see Béla's birth data let r = app.get(&format!("/v1/synastries/{synastry_id}"), Some(&anna)).await; assert_eq!(r.status, StatusCode::OK); assert_eq!(r.body["owned"], true); assert!(r.body["chart2"].get("birth_data").is_none()); assert!(r.body["chart1"]["birth_data"].is_object()); assert_eq!(app.get("/v1/synastries", Some(&bela)).await.body["synastries"].as_array().unwrap().len(), 1); let outsider = app.register("c@example.com", "C").await; assert_eq!(app.get(&format!("/v1/synastries/{synastry_id}"), Some(&outsider)).await.status, StatusCode::NOT_FOUND); let r = app.post("/v1/invites/accept", Some(&outsider), json!({"token": token})).await; assert_eq!(r.status, StatusCode::GONE); assert_eq!(app.get("/v1/invites", Some(&anna)).await.body["invites"][0]["status"], "accepted"); assert!(app.outbox_url("anna@example.com", "invite_accepted").await.ends_with(&synastry_id)); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn analyses_spend_credits_and_reuse_results(pool: PgPool) { let app = TestApp::new(pool.clone()).await; let anna = app.register("anna@example.com", "Anna").await; let chart = app.chart(&anna, "Saját", true, "1990-03-15").await; let uri = format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()); let r = app.call("POST", &uri, Some(&anna), None).await; assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body); assert_eq!((r.body["status"].as_str(), r.body["language"].as_str()), (Some("pending"), Some("hu"))); let first = r.body["id"].as_str().unwrap().to_string(); assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], 1); // same request again: the same analysis, no charge let r = app.call("POST", &uri, Some(&anna), None).await; assert_eq!((r.status, r.body["id"].as_str()), (StatusCode::OK, Some(first.as_str()))); let r = app.post(&uri, Some(&anna), json!({"language": "en"})).await; assert_eq!(r.status, StatusCode::ACCEPTED); let r = app.post(&uri, Some(&anna), json!({"model": "anthropic/claude-test"})).await; assert_eq!( (r.status, r.body["error"]["code"].as_str()), (StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits")) ); let r = app.post(&uri, Some(&anna), json!({"model": "unknown/model"})).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); // the worker finishes the first one; another user with the same birth data gets it for free sqlx::query("UPDATE analyses SET status = 'done', content = $1, completed_at = now() WHERE id = $2::uuid") .bind(json!({"summary": "Érzékeny mag, harcos külső."})) .bind(&first) .execute(&pool) .await .unwrap(); let bela = app.register("bela@example.com", "Béla").await; let same = app.chart(&bela, "Saját", true, "1990-03-15").await; assert_eq!(same["chart_hash"], chart["chart_hash"]); let r = app.call("POST", &format!("/v1/charts/{}/analyses", same["id"].as_str().unwrap()), Some(&bela), None).await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); assert_eq!((r.body["status"].as_str(), &r.body["credits_charged"]), (Some("done"), &json!(0))); assert_eq!(app.get("/v1/credits", Some(&bela)).await.body["balance"], 2); assert_eq!(app.get(&format!("/v1/analyses/{first}"), Some(&bela)).await.status, StatusCode::NOT_FOUND); assert_eq!(app.get(&uri, Some(&anna)).await.body["analyses"].as_array().unwrap().len(), 2); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn public_shares(pool: PgPool) { let app = TestApp::new(pool).await; let anna = app.register("anna@example.com", "Anna").await; let chart = app.chart(&anna, "Saját", true, "1990-03-15").await; let chart_id = chart["id"].as_str().unwrap(); let r = app .post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart_id, "title": "A radixom"})) .await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let (share_id, slug) = (r.body["id"].as_str().unwrap().to_string(), r.body["slug"].as_str().unwrap().to_string()); assert_eq!(slug.len(), 16); let r = app.get(&format!("/v1/public/shares/{slug}"), None).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); assert_eq!(r.body["title"], "A radixom"); let shown = &r.body["chart"]["chart"]; assert_eq!(shown["points"][0]["sign"], "cancer"); for hidden in ["input", "location", "time", "astronomy", "birth"] { assert!(shown.get(hidden).is_none(), "{hidden} must not be public"); } let r = app .post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart_id, "show_birth_data": true})) .await; let r = app.get(&format!("/v1/public/shares/{}", r.body["slug"].as_str().unwrap()), None).await; assert_eq!(r.body["chart"]["chart"]["birth"]["date"], "1990-03-15"); // others cannot share it; revoked links disappear let bela = app.register("bela@example.com", "Béla").await; let r = app.post("/v1/shares", Some(&bela), json!({"kind": "chart", "target_id": chart_id})).await; assert_eq!(r.status, StatusCode::NOT_FOUND); assert_eq!( app.call("DELETE", &format!("/v1/shares/{share_id}"), Some(&anna), None).await.status, StatusCode::NO_CONTENT ); assert_eq!(app.get(&format!("/v1/public/shares/{slug}"), None).await.status, StatusCode::NOT_FOUND); assert_eq!(app.get("/v1/public/shares/nincs-ilyen", None).await.status, StatusCode::NOT_FOUND); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn export_and_delete_account(pool: PgPool) { let app = TestApp::new(pool).await; let anna = app.register("anna@example.com", "Anna").await; let bela = app.register("bela@example.com", "Béla").await; let a = app.chart(&anna, "Saját", true, "1990-03-15").await; let b = app.chart(&anna, "Béla", false, "1976-09-03").await; let r = app.post("/v1/synastries", Some(&anna), json!({"chart1_id": a["id"], "chart2_id": b["id"]})).await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let r = app.post("/v1/synastries", Some(&anna), json!({"chart1_id": b["id"], "chart2_id": a["id"]})).await; assert_eq!(r.status, StatusCode::OK); // already exists let r = app.get("/v1/me/export", Some(&anna)).await; assert_eq!(r.status, StatusCode::OK); assert_eq!(r.body["charts"].as_array().unwrap().len(), 2); assert_eq!(r.body["synastries"].as_array().unwrap().len(), 1); assert!(r.body["login_methods"][0].get("password_hash").is_none()); let r = app.call("DELETE", "/v1/me", Some(&anna), Some(json!({"confirm": "yes"}))).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); let r = app.call("DELETE", "/v1/me", Some(&anna), Some(json!({"confirm": "DELETE"}))).await; assert_eq!(r.status, StatusCode::NO_CONTENT); assert_eq!(app.get("/v1/me", Some(&anna)).await.status, StatusCode::UNAUTHORIZED); let r = app.post("/v1/auth/login", None, json!({"email": "anna@example.com", "password": "titkos-jelszo-123"})).await; assert_eq!(r.status, StatusCode::UNAUTHORIZED); let (left,): (i64,) = sqlx::query_as("SELECT count(*) FROM charts").fetch_one(&app.pool).await.unwrap(); assert_eq!(left, 0); assert_eq!(app.get("/v1/me", Some(&bela)).await.status, StatusCode::OK); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn public_config_and_health(pool: PgPool) { let app = TestApp::new(pool).await; let r = app.get("/v1/config", None).await; assert_eq!(r.body["google_login"]["enabled"], true); assert_eq!(r.body["google_login"]["client_id"], GOOGLE_CLIENT); assert_eq!(r.body["locales"], json!(["hu", "en"])); assert_eq!(app.get("/healthz", None).await.status, StatusCode::OK); }