Files
sorsfonalak/services/backend/src/tests.rs
T
fecoandClaude Opus 5.5 ce3d3804a7 Paid detailed analyses with per-kind units; example analysis page
- Credits become analysis units (migration 0006): a natal analysis uses
  one 'natal' unit, a synastry analysis one 'synastry' unit. No monthly
  free credits, no model tiers: ANALYSIS_MODEL (default Opus 5.5) writes
  every paid analysis. Admins grant units per kind; the worker refunds
  the right unit on failure.
- Chart page: the detailed analysis card (offer with units left and a
  confirmation, progress while writing, the finished six sections).
- Public /pelda page: a full Opus analysis of a made-up chart, with the
  free summary and a login call to action.
- The worker sends the JSON schema with properties in 'required' order.
  serde_json sorted them, so the title came after ~9000 tokens of text
  and Opus sometimes left it empty (3 failed attempts in a live test);
  with the order fixed the same analysis succeeded at the first try.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-16 17:39:15 +00:00

655 lines
31 KiB
Rust

//! 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<Value>) -> (StatusCode, Json<Value>) {
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<Value>) -> (StatusCode, Json<Value>) {
// 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<Value> {
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<Value>) -> 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")));
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}));
}