//! 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 { Self::with_config(pool, |_| {}).await } async fn with_config(pool: PgPool, change: impl FnOnce(&mut Config)) -> Self { let fake = fake_services().await; let mut config = Config::for_tests(String::new(), fake.clone(), format!("{fake}/jwks")); change(&mut config); 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["analyses_left"], json!({"natal": 0, "synastry": 0})); // 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 grant = |unit: &str, delta: i32| json!({"unit": unit, "delta": delta, "note": "bonus"}); let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("natal", 5)).await; assert_eq!((r.status, &r.body["analyses_left"]), (StatusCode::CREATED, &json!({"natal": 5, "synastry": 0}))); let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("chat", 5)).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); let credits = app.get("/v1/credits", Some(&user)).await.body; assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0})); assert_eq!((credits["ledger"][0]["unit"].as_str(), &credits["ledger"][0]["delta"]), (Some("natal"), &json!(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); // the same birth data again: the saved chart is reused, not calculated again let r = app .post( "/v1/charts", Some(&anna), json!({"label": "Újra", "is_primary": true, "birth": {"date": "1990-03-15", "time": "14:30", "country": "HU", "place": "Szeged"}}), ) .await; assert_eq!((r.status, r.body["id"].as_str(), &r.body["is_primary"]), (StatusCode::OK, Some(id), &json!(true))); assert_eq!(app.get("/v1/charts", Some(&anna)).await.body["charts"].as_array().unwrap().len(), 2); app.call( "PATCH", &format!("/v1/charts/{}", other["id"].as_str().unwrap()), Some(&anna), Some(json!({"is_primary": true})), ) .await; 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"))); // (the fourth change of the own chart; the limit is tested in birth_data_changes_are_limited) sqlx::query("DELETE FROM birth_data_changes").execute(&app.pool).await.unwrap(); 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)); } /// Gives `token`'s user analysis units (the admin endpoint is tested in `roles_and_admin_guard`). async fn grant_units(app: &TestApp, token: &str, unit: &str, delta: i32) { let id = app.get("/v1/me", Some(token)).await.body["user"]["id"].as_str().unwrap().to_string(); sqlx::query( "INSERT INTO credit_ledger (id, user_id, unit, delta, reason) VALUES (gen_random_uuid(), $1::uuid, $2, $3, 'purchase')", ) .bind(id) .bind(unit) .bind(delta) .execute(&app.pool) .await .unwrap(); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn analyses_spend_units_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()); // saving the chart queued the free short summary let list = app.get(&uri, Some(&anna)).await.body; let summary = &list["analyses"][0]; assert_eq!( (summary["kind"].as_str(), summary["status"].as_str(), summary["model"].as_str(), &summary["credits_charged"]), (Some("summary"), Some("pending"), Some("anthropic/claude-summary"), &json!(0)) ); let r = app.call("POST", &format!("/v1/charts/{}/summary", chart["id"].as_str().unwrap()), Some(&anna), None).await; assert_eq!((r.status, &r.body["id"]), (StatusCode::OK, &summary["id"])); // the detailed analysis is paid: no unit, no analysis let r = app.call("POST", &uri, Some(&anna), None).await; assert_eq!( (r.status, r.body["error"]["code"].as_str()), (StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits")) ); grant_units(&app, &anna, "natal", 2).await; 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(), r.body["model"].as_str(), &r.body["credits_charged"]), (Some("pending"), Some("hu"), Some("anthropic/claude-test"), &json!(1)) ); let first = r.body["id"].as_str().unwrap().to_string(); assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0})); // 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); assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 0, "synastry": 0})); let r = app.post(&uri, Some(&anna), json!({"model": "anthropic/claude-other"})).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); // no model choice // 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(&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(), 3); // 2 + summary } #[sqlx::test(migrator = "db::MIGRATOR")] async fn password_login_can_be_disabled(pool: PgPool) { let app = TestApp::with_config(pool, |c| c.password_login = false).await; assert_eq!(app.get("/v1/config", None).await.body["password_login"], false); let r = app .post("/v1/auth/register", None, json!({"email": "anna@example.com", "password": "titkos-jelszo-123"})) .await; assert_eq!(r.status, StatusCode::FORBIDDEN); let r = app.post("/v1/auth/login", None, json!({"email": "anna@example.com", "password": "titkos-jelszo-123"})).await; assert_eq!(r.status, StatusCode::FORBIDDEN); let r = app.post("/v1/auth/password-reset", None, json!({"email": "anna@example.com"})).await; assert_eq!(r.status, StatusCode::FORBIDDEN); } #[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!(r.body["analysis_model"], "anthropic/claude-test"); assert_eq!(r.body["summary_model"], "anthropic/claude-summary"); assert_eq!(app.get("/healthz", None).await.status, StatusCode::OK); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn synastry_analyses_use_synastry_units(pool: PgPool) { let app = TestApp::new(pool).await; let anna = app.register("anna@example.com", "Anna").await; let own = app.chart(&anna, "Saját", true, "1990-03-15").await; let other = app.chart(&anna, "Anya", false, "1950-03-01").await; let r = app.post("/v1/synastries", Some(&anna), json!({"chart1_id": own["id"], "chart2_id": other["id"]})).await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let uri = format!("/v1/synastries/{}/analyses", r.body["id"].as_str().unwrap()); grant_units(&app, &anna, "natal", 1).await; let r = app.call("POST", &uri, Some(&anna), None).await; assert_eq!(r.status, StatusCode::PAYMENT_REQUIRED); // a natal unit does not pay for a synastry grant_units(&app, &anna, "synastry", 1).await; let r = app.call("POST", &uri, Some(&anna), None).await; assert_eq!((r.status, r.body["kind"].as_str()), (StatusCode::ACCEPTED, Some("synastry"))); assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0})); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn birth_data_changes_are_limited(pool: PgPool) { let app = TestApp::new(pool.clone()).await; let anna = app.register("anna@example.com", "Anna").await; assert_eq!(app.get("/v1/me", Some(&anna)).await.body["birth_change"]["limited"], json!(false)); // the first save and three corrections within the hour are free let first = app.chart(&anna, "Saját", true, "1990-03-15").await; for date in ["1990-03-16", "1990-03-17", "1990-03-18"] { app.chart(&anna, "Saját", true, date).await; } // saving the current data again is not a change let r = app .post( "/v1/charts", Some(&anna), json!({"label": "Saját", "is_primary": true, "birth": {"date": "1990-03-18", "time": "14:30", "country": "HU", "place": "Szeged"}}), ) .await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); // the fourth correction: once a day from now on let r = app .post( "/v1/charts", Some(&anna), json!({"label": "Saját", "is_primary": true, "birth": {"date": "1990-03-19", "time": "14:30", "country": "HU", "place": "Szeged"}}), ) .await; assert_eq!(r.status, StatusCode::TOO_MANY_REQUESTS, "{}", r.body); assert_eq!(r.body["error"]["code"], json!("birth_data_change_limit")); let message = r.body["error"]["message"].as_str().unwrap(); assert!(message.starts_with("A rendszer csak napi egy módosítást engedélyez."), "{message}"); assert!(message.ends_with("óra múlva módosíthatod."), "{message}"); // switching back to an older chart is a change too let r = app .call( "PATCH", &format!("/v1/charts/{}", first["id"].as_str().unwrap()), Some(&anna), Some(json!({"is_primary": true})), ) .await; assert_eq!(r.status, StatusCode::TOO_MANY_REQUESTS); // other people's charts are not limited app.chart(&anna, "Béla", false, "1985-08-02").await; let me = app.get("/v1/me", Some(&anna)).await.body; assert_eq!(me["birth_change"]["limited"], json!(true)); assert!(me["birth_change"]["notice"].as_str().unwrap().contains("napi egy")); // a day later it works again sqlx::query("UPDATE birth_data_changes SET created_at = created_at - interval '25 hours'") .execute(&pool) .await .unwrap(); app.chart(&anna, "Saját", true, "1990-03-19").await; // admins are not limited let admin = app.register("admin@example.com", "Admin").await; for day in 10..16 { app.chart(&admin, "Saját", true, &format!("1980-01-{day}")).await; } assert_eq!(app.get("/v1/me", Some(&admin)).await.body["birth_change"]["notice"], Value::Null); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn admins_get_free_analyses_and_mock_payments_add_units(pool: PgPool) { let app = TestApp::new(pool).await; let admin = app.register("admin@example.com", "Admin").await; let chart = app.chart(&admin, "Saját", true, "1990-03-15").await; let r = app.call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&admin), None).await; assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(0)), "{}", r.body); // a user "pays", which adds a unit, then requests the analysis let anna = app.register("anna@example.com", "Anna").await; let chart = app.chart(&anna, "Saját", true, "1991-05-01").await; let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "natal"})).await; assert_eq!( (r.status, &r.body["analyses_left"]), (StatusCode::OK, &json!({"natal": 1, "synastry": 0})), "{}", r.body ); let r = app.call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&anna), None).await; assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(1)), "{}", r.body); assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 0, "synastry": 0})); // without MOCK_PAYMENTS there is no such payment let app = TestApp::with_config(app.pool.clone(), |c| c.mock_payments = false).await; let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "natal"})).await; assert_eq!(r.status, StatusCode::NOT_FOUND); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn persons_use_package_slots(pool: PgPool) { let app = TestApp::with_config(pool, |c| c.free_person_slots = 1).await; let anna = app.register("anna@example.com", "Anna").await; let own = app.chart(&anna, "Saját", true, "1990-03-15").await; assert_eq!(own["kind"], "own"); let persons = |me: Value| me["persons"].clone(); assert_eq!( persons(app.get("/v1/me", Some(&anna)).await.body), json!({"used": 0, "limit": 1, "left": 1, "unlimited": false}) ); // the free slot, then the limit; deleting does not give the slot back let first = app.chart(&anna, "Béla", false, "1985-08-02").await; assert_eq!((&first["kind"], first["editable_until"].is_string()), (&json!("person"), true)); let new_person = |date: &str| json!({"label": "Cili", "birth": {"date": date, "time": "14:30", "country": "HU", "place": "Szeged"}}); let r = app.post("/v1/charts", Some(&anna), new_person("1986-01-01")).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("person_limit_reached"))); assert_eq!(r.body["error"]["message"], crate::persons::LIMIT_MESSAGE); let r = app.call("DELETE", &format!("/v1/charts/{}", first["id"].as_str().unwrap()), Some(&anna), None).await; assert_eq!(r.status, StatusCode::NO_CONTENT); assert_eq!(persons(app.get("/v1/me", Some(&anna)).await.body)["left"], 0); // a person package adds five slots let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "addon_persons"})).await; assert_eq!(r.body["persons"], json!({"used": 1, "limit": 6, "left": 5, "unlimited": false}), "{}", r.body); let second = app.chart(&anna, "Cili", false, "1986-01-01").await; app.chart(&anna, "Dani", false, "1987-01-01").await; assert_eq!(persons(app.get("/v1/me", Some(&anna)).await.body)["left"], 3); // the unlimited package let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "unlimited"})).await; assert_eq!(r.body["persons"], json!({"used": 3, "limit": null, "left": null, "unlimited": true})); app.chart(&anna, "Emma", false, "1988-01-01").await; let list = app.get("/v1/charts", Some(&anna)).await.body; let kinds: Vec<&str> = list["charts"].as_array().unwrap().iter().map(|c| c["kind"].as_str().unwrap()).collect(); assert_eq!(kinds, ["own", "person", "person", "person"]); assert_eq!(list["charts"][1]["birth"]["date"], "1988-01-01"); // a person's birth data can be corrected within an hour, then it is locked let id = second["id"].as_str().unwrap(); let corrected = json!({"birth": {"date": "1986-01-02", "time": "10:00", "country": "HU", "place": "Szeged"}}); let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(corrected.clone())).await; assert_eq!((r.status, &r.body["birth_data"]["date"]), (StatusCode::OK, &json!("1986-01-02")), "{}", r.body); sqlx::query("UPDATE charts SET created_at = now() - interval '2 hours' WHERE id = $1::uuid") .bind(id) .execute(&app.pool) .await .unwrap(); let again = json!({"birth": {"date": "1986-01-03", "time": "10:00", "country": "HU", "place": "Szeged"}}); let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(again)).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("person_locked"))); let r = app.call("PATCH", &format!("/v1/charts/{}", own["id"].as_str().unwrap()), Some(&anna), Some(corrected)).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); // admins: no limit, corrections any time let admin = app.register("admin@example.com", "Admin").await; assert_eq!(persons(app.get("/v1/me", Some(&admin)).await.body)["unlimited"], true); let p = app.chart(&admin, "Feri", false, "1970-01-01").await; let pid = p["id"].as_str().unwrap(); sqlx::query("UPDATE charts SET created_at = now() - interval '2 days' WHERE id = $1::uuid") .bind(pid) .execute(&app.pool) .await .unwrap(); let corrected = json!({"birth": {"date": "1970-01-02", "time": "10:00", "country": "HU", "place": "Szeged"}}); let r = app.call("PATCH", &format!("/v1/charts/{pid}"), Some(&admin), Some(corrected)).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn admins_edit_analysis_prompts(pool: PgPool) { let app = TestApp::new(pool.clone()).await; let admin = app.register("admin@example.com", "Admin").await; let anna = app.register("anna@example.com", "Anna").await; assert_eq!(app.get("/v1/admin/prompts", Some(&anna)).await.status, StatusCode::FORBIDDEN); let r = app.get("/v1/admin/prompts", Some(&admin)).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); let prompts = r.body["prompts"].as_array().unwrap(); let keys: Vec = prompts.iter().map(|p| format!("{}/{}", p["kind"], p["language"]).replace('"', "")).collect(); assert_eq!(keys, ["summary/hu", "summary/en", "natal/hu", "natal/en", "synastry/hu", "synastry/en"]); let natal = &prompts[2]; assert_eq!((&natal["custom"], &natal["system"]), (&json!(false), &natal["default"])); assert!(natal["user_template"].as_str().unwrap().contains("{chart data}")); let default = natal["default"].as_str().unwrap().to_string(); let put = |body: Value, uri: &'static str| app.call("PUT", uri, Some(&admin), Some(body)); assert_eq!(put(json!({"system": " "}), "/v1/admin/prompts/natal/hu").await.status, StatusCode::BAD_REQUEST); assert_eq!(put(json!({"system": "x"}), "/v1/admin/prompts/composite/hu").await.status, StatusCode::NOT_FOUND); assert_eq!(put(json!({"system": "x"}), "/v1/admin/prompts/natal/de").await.status, StatusCode::NOT_FOUND); // saving the built-in text keeps the built-in prompt let r = put(json!({"system": default}), "/v1/admin/prompts/natal/hu").await; assert_eq!( (r.status, &r.body["custom"], r.body["history"].as_array().unwrap().len()), (StatusCode::OK, &json!(false), 0) ); // an analysis written with the built-in prompt let chart = app.chart(&anna, "Saját", true, "1990-03-15").await; let uri = format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()); grant_units(&app, &anna, "natal", 1).await; let r = app.call("POST", &uri, Some(&anna), None).await; assert_eq!((r.status, r.body["prompt_version"].as_str()), (StatusCode::ACCEPTED, Some("v1"))); let first = r.body["id"].as_str().unwrap().to_string(); sqlx::query("UPDATE analyses SET status = 'done', content = '{}', completed_at = now() WHERE id = $1::uuid") .bind(&first) .execute(&pool) .await .unwrap(); let r = put(json!({"system": "Saját szabályok.\r\n"}), "/v1/admin/prompts/natal/hu").await; assert_eq!( (&r.body["custom"], r.body["system"].as_str(), r.body["updated_by"].as_str()), (&json!(true), Some("Saját szabályok."), Some("admin@example.com")) ); let revision = r.body["history"][0]["id"].as_i64().unwrap(); let r = put(json!({"system": "Saját szabályok."}), "/v1/admin/prompts/natal/hu").await; assert_eq!(r.body["history"].as_array().unwrap().len(), 1); // unchanged: no new revision // the chart keeps its analysis; the same birth data elsewhere is written anew with the edited prompt 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 bela = app.register("bela@example.com", "Béla").await; let same = app.chart(&bela, "Saját", true, "1990-03-15").await; grant_units(&app, &bela, "natal", 1).await; let r = app.call("POST", &format!("/v1/charts/{}/analyses", same["id"].as_str().unwrap()), Some(&bela), None).await; let expected = format!("v1-r{revision}"); assert_eq!((r.status, r.body["prompt_version"].as_str()), (StatusCode::ACCEPTED, Some(expected.as_str()))); // back to the built-in prompt let r = put(json!({"system": null}), "/v1/admin/prompts/natal/hu").await; assert_eq!((&r.body["custom"], r.body["system"].as_str()), (&json!(false), Some(default.as_str()))); assert_eq!(r.body["history"].as_array().unwrap().len(), 2); } /// Starts a summary prompt test run on `chart`. async fn start_preview(app: &TestApp, chart: &Value, token: &str) -> Response { let body = json!({"system": " Próba szabályok. ", "chart_id": chart["id"]}); app.call("POST", "/v1/admin/prompts/summary/hu/preview", Some(token), Some(body)).await } #[sqlx::test(migrator = "db::MIGRATOR")] async fn admins_try_prompt_drafts_on_own_charts(pool: PgPool) { let app = TestApp::new(pool.clone()).await; let admin = app.register("admin@example.com", "Admin").await; let anna = app.register("anna@example.com", "Anna").await; let own = app.chart(&admin, "Saját", true, "1990-03-15").await; let annas = app.chart(&anna, "Saját", true, "1991-05-01").await; assert_eq!(start_preview(&app, &own, &anna).await.status, StatusCode::FORBIDDEN); assert_eq!(start_preview(&app, &annas, &admin).await.status, StatusCode::NOT_FOUND); // only own charts let r = start_preview(&app, &own, &admin).await; assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body); assert_eq!( (r.body["status"].as_str(), r.body["kind"].as_str(), r.body["model"].as_str()), (Some("pending"), Some("summary"), Some("anthropic/claude-summary")) ); let id = r.body["id"].as_str().unwrap().to_string(); let (system,): (String,) = sqlx::query_as("SELECT system FROM prompt_previews WHERE id = $1::uuid") .bind(&id) .fetch_one(&pool) .await .unwrap(); assert_eq!(system, "Próba szabályok."); // nothing reaches the chart's analyses, and the saved prompt is unchanged let r = app.get(&format!("/v1/charts/{}/analyses", own["id"].as_str().unwrap()), Some(&admin)).await; assert!( r.body["analyses"].as_array().unwrap().iter().all(|a| a["kind"] == "summary" && a["prompt_version"] == "v1") ); assert_eq!(app.get("/v1/admin/prompts", Some(&admin)).await.body["prompts"][0]["custom"], json!(false)); let r = app.get(&format!("/v1/admin/previews/{id}"), Some(&admin)).await; assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::OK, Some("pending"))); assert_eq!(app.get(&format!("/v1/admin/previews/{id}"), Some(&anna)).await.status, StatusCode::FORBIDDEN); // at most three at a time start_preview(&app, &own, &admin).await; start_preview(&app, &own, &admin).await; let r = start_preview(&app, &own, &admin).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("too_many_previews"))); let body = json!({"system": "Részletes próba.", "chart_id": own["id"]}); sqlx::query("UPDATE prompt_previews SET status = 'done'").execute(&pool).await.unwrap(); let r = app.call("POST", "/v1/admin/prompts/natal/hu/preview", Some(&admin), Some(body)).await; assert_eq!((r.status, r.body["model"].as_str()), (StatusCode::ACCEPTED, Some("anthropic/claude-test"))); // a relationship analysis is tried on one of the admin's comparisons let other = app.chart(&admin, "Béla", false, "1985-08-02").await; let syn = app.post("/v1/synastries", Some(&admin), json!({"chart1_id": own["id"], "chart2_id": other["id"]})).await; let uri = "/v1/admin/prompts/synastry/hu/preview"; let r = app.call("POST", uri, Some(&admin), Some(json!({"system": "Próba.", "chart_id": own["id"]}))).await; assert_eq!(r.status, StatusCode::BAD_REQUEST); let r = app.call("POST", uri, Some(&admin), Some(json!({"system": "Próba.", "synastry_id": syn.body["id"]}))).await; assert_eq!( (r.status, r.body["synastry_id"].as_str()), (StatusCode::ACCEPTED, syn.body["id"].as_str()), "{}", r.body ); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn comparisons_with_persons(pool: PgPool) { let app = TestApp::new(pool).await; let anna = app.register("anna@example.com", "Anna").await; let own = app.chart(&anna, "Saját", true, "1990-03-15").await; let bela = app.chart(&anna, "Béla", false, "1985-08-02").await; let compare = || app.post("/v1/synastries", Some(&anna), json!({"chart1_id": own["id"], "chart2_id": bela["id"]})); let r = compare().await; assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); let first = r.body["id"].as_str().unwrap().to_string(); assert_eq!((&r.body["chart1"]["is_primary"], &r.body["chart2"]["label"]), (&json!(true), &json!("Béla"))); // correcting the person removes the comparison that no longer matches let uri = format!("/v1/charts/{}", bela["id"].as_str().unwrap()); let corrected = |date: &str| json!({"birth": {"date": date, "time": "10:00", "country": "HU", "place": "Szeged"}}); let r = app.call("PATCH", &uri, Some(&anna), Some(corrected("1985-08-03"))).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); assert_eq!(app.get(&format!("/v1/synastries/{first}"), Some(&anna)).await.status, StatusCode::NOT_FOUND); // after a paid relationship analysis the person is fixed let r = compare().await; assert_eq!(r.status, StatusCode::CREATED); let id = r.body["id"].as_str().unwrap(); grant_units(&app, &anna, "synastry", 1).await; let r = app.call("POST", &format!("/v1/synastries/{id}/analyses"), Some(&anna), None).await; assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body); let r = app.call("PATCH", &uri, Some(&anna), Some(corrected("1985-08-04"))).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("person_analysed"))); assert_eq!(app.get("/v1/synastries", Some(&anna)).await.body["synastries"].as_array().unwrap().len(), 1); } /// An admin (or not) gives `user` a package. async fn grant_package(app: &TestApp, token: &str, user: &str, package: &str) -> Response { let body = json!({"package": package, "note": "ajándék"}); app.call("POST", &format!("/v1/admin/users/{user}/packages"), Some(token), Some(body)).await } #[sqlx::test(migrator = "db::MIGRATOR")] async fn packages_grant_units_and_unlimited(pool: PgPool) { let app = TestApp::new(pool.clone()).await; let admin = app.register("admin@example.com", "Admin").await; let anna = app.register("anna@example.com", "Anna").await; let anna_id = app.get("/v1/me", Some(&anna)).await.body["user"]["id"].as_str().unwrap().to_string(); // the catalog is public let r = app.get("/v1/packages", None).await; let ids: Vec<&str> = r.body["packages"].as_array().unwrap().iter().map(|p| p["id"].as_str().unwrap()).collect(); assert_eq!(ids, ["single", "couple", "family", "unlimited", "addon_synastry", "addon_persons"]); assert_eq!( (&r.body["packages"][2]["badge"], &r.body["packages"][2]["per_analysis_huf"]), (&json!("Legnépszerűbb"), &json!(1090)) ); // an admin gives a package as a gift assert_eq!(grant_package(&app, &anna, &anna_id, "family").await.status, StatusCode::FORBIDDEN); assert_eq!(grant_package(&app, &admin, &anna_id, "gold").await.status, StatusCode::NOT_FOUND); let r = grant_package(&app, &admin, &anna_id, "family").await; assert_eq!( (r.status, &r.body["analyses_left"]), (StatusCode::CREATED, &json!({"natal": 6, "synastry": 5})), "{}", r.body ); let me = app.get("/v1/me", Some(&anna)).await.body; assert_eq!((&me["persons"]["limit"], &me["unlimited_until"]), (&json!(10), &Value::Null)); // 5 free + 5 let (source, price): (String, i32) = sqlx::query_as("SELECT source, price_huf FROM package_orders WHERE package = 'family'") .fetch_one(&pool) .await .unwrap(); assert_eq!((source.as_str(), price), ("admin", 0)); // a (mock) purchase adds to it and records the price let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "couple"})).await; assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6}), "{}", r.body); let (price,): (i32,) = sqlx::query_as("SELECT price_huf FROM package_orders WHERE package = 'couple'").fetch_one(&pool).await.unwrap(); assert_eq!(price, 6990); // unlimited: a year, and a second one extends it let bela = app.register("bela@example.com", "Béla").await; let bela_id = app.get("/v1/me", Some(&bela)).await.body["user"]["id"].as_str().unwrap().to_string(); grant_package(&app, &admin, &bela_id, "unlimited").await; let r = grant_package(&app, &admin, &bela_id, "unlimited").await; let until = time::OffsetDateTime::parse( r.body["unlimited_until"].as_str().unwrap(), &time::format_description::well_known::Rfc3339, ) .unwrap(); let days = (until - time::OffsetDateTime::now_utc()).whole_days(); assert!((725..=733).contains(&days), "{days}"); assert_eq!(app.get("/v1/me", Some(&bela)).await.body["persons"]["unlimited"], true); // analyses use no unit, up to the daily cap (3 in tests) for (i, date) in ["1980-01-01", "1981-01-01", "1982-01-01"].into_iter().enumerate() { let chart = app.chart(&bela, &format!("P{i}"), i == 0, date).await; let r = app .call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&bela), None) .await; assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(0)), "{}", r.body); } let fourth = app.chart(&bela, "P3", false, "1983-01-01").await; let uri = format!("/v1/charts/{}/analyses", fourth["id"].as_str().unwrap()); let r = app.call("POST", &uri, Some(&bela), None).await; assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::TOO_MANY_REQUESTS, Some("fair_use_limit"))); // after it ends, units are needed again sqlx::query("UPDATE entitlements SET expires_at = now() - interval '1 day'").execute(&pool).await.unwrap(); let r = app.call("POST", &uri, Some(&bela), None).await; assert_eq!(r.status, StatusCode::PAYMENT_REQUIRED); assert_eq!(app.get("/v1/me", Some(&bela)).await.body["unlimited_until"], Value::Null); } #[sqlx::test(migrator = "db::MIGRATOR")] async fn renaming_a_person_keeps_chart_and_analyses(pool: PgPool) { let app = TestApp::new(pool.clone()).await; let anna = app.register("anna@example.com", "Anna").await; let own = app.chart(&anna, "Saját", true, "1990-03-15").await; let bela = app.chart(&anna, "Béla", false, "1985-08-02").await; let id = bela["id"].as_str().unwrap(); let syn = app.post("/v1/synastries", Some(&anna), json!({"chart1_id": own["id"], "chart2_id": id})).await; assert_eq!(syn.status, StatusCode::CREATED); let summaries = || async { let (n,): (i64,) = sqlx::query_as("SELECT count(*) FROM analyses WHERE chart_id = $1::uuid") .bind(id) .fetch_one(&pool) .await .unwrap(); n }; assert_eq!(summaries().await, 1); // the edit form sends the unchanged birth data with the new name let same = json!({"label": "Béla bácsi", "birth": {"date": "1985-08-02", "time": "14:30", "country": "HU", "place": "Szeged"}}); let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(same.clone())).await; assert_eq!( (r.status, &r.body["label"], &r.body["chart_hash"]), (StatusCode::OK, &json!("Béla bácsi"), &bela["chart_hash"]) ); assert_eq!(summaries().await, 1); let r = app.get(&format!("/v1/synastries/{}", syn.body["id"].as_str().unwrap()), Some(&anna)).await; assert_eq!(r.status, StatusCode::OK); // after the correction window the name can still change sqlx::query("UPDATE charts SET created_at = now() - interval '2 hours' WHERE id = $1::uuid") .bind(id) .execute(&pool) .await .unwrap(); let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(json!({"label": "Béla"}))).await; assert_eq!((r.status, &r.body["label"]), (StatusCode::OK, &json!("Béla"))); let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(same)).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); }