Files
sorsfonalak/services/backend/src/tests.rs
T
fecoandClaude Opus 5.5 e004ea696b
CI / test (push) Successful in 47s
CI / build (push) Successful in 4m19s
CI / deploy (push) Skipped
Packages: from one analysis to unlimited, admin can give them
A fixed catalog (packages.rs, reasoning in docs/csomagok.md): Egy elemzés
2 990 Ft, Páros 6 990 Ft, Család 11 990 Ft (featured), Korlátlan 17 990 Ft
for a year, and two top-ups. Every grant is a package_orders row; units are
credit_ledger rows with reason 'package' and never expire. The unlimited
package is a time-limited 'unlimited' entitlement: analyses use no unit and
persons have no limit, with a daily fair-use cap (UNLIMITED_DAILY_LIMIT, 5);
buying it again extends it by a year.

- GET /v1/packages, mock payment by package id, /v1/me unlimited_until
- POST /v1/admin/users/{id}/packages: give a package as a gift
- /csomagok page; the paid step of an analysis offers three packages with
  the bigger one featured; person packs use the catalog; admin user list
  has a package column
- PERSON_PACK_SIZE is replaced by the catalog's +5 személy top-up

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

1071 lines
54 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")));
// (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 r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(corrected.clone())).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<String> =
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);
}