Files
sorsfonalak/services/backend/src/tests.rs
T
fecoandClaude Opus 5.5 d9e71ed349
CI / test (push) Successful in 1m22s
CI / build (push) Successful in 7m0s
CI / deploy (push) Skipped
Purchases for admins only until the opening; brand images for Stripe
PURCHASES_OPEN (default false) keeps Stripe purchases to admins, also with
a live key, so nobody types a real card before the opening.

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

2404 lines
118 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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": {"date": date, "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_forecast(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
let year = body["year"].as_i64().unwrap_or(2026);
let loc = body.get("location").cloned().unwrap_or(json!({"country": "HU", "place": body["birth"]["place"]}));
(
StatusCode::OK,
Json(json!({
"year": year,
"solar_return": {
"location": {"place": {"name": loc["place"]}, "latitude": 47.0, "longitude": 19.0},
"timezone": "Europe/Budapest", "points": [], "input": {"date": format!("{year}-03-15")}
},
"location": loc,
"forecast": {"start": format!("{year}-03-15"), "end": format!("{}-03-15", year + 1), "transits": []},
"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_openrouter_models() -> Json<Value> {
let model = |id: &str, name: &str, structured: bool| {
json!({
"id": id, "name": name, "context_length": 200000,
"pricing": {"prompt": "0.000003", "completion": "0.000015"},
"supported_parameters": if structured { json!(["tools", "structured_outputs"]) } else { json!(["tools"]) },
})
};
Json(json!({"data": [
model("anthropic/claude-test", "Claude Test", true),
model("vendor/plain", "Plain (no JSON)", false),
model("openai/gpt-x", "GPT X", true),
]}))
}
/// Checkout sessions the fake Stripe created: form fields and whether paid.
type FakeSessions = std::sync::Mutex<std::collections::HashMap<String, (Vec<(String, String)>, bool)>>;
static STRIPE_SESSIONS: std::sync::LazyLock<FakeSessions> = std::sync::LazyLock::new(Default::default);
static STRIPE_IDS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
fn stripe_form(id: &str, key: &str) -> Option<String> {
let sessions = STRIPE_SESSIONS.lock().unwrap();
sessions.get(id)?.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
}
fn stripe_pay(id: &str) {
STRIPE_SESSIONS.lock().unwrap().get_mut(id).unwrap().1 = true;
}
async fn fake_stripe_create(
headers: HeaderMap,
axum::Form(form): axum::Form<Vec<(String, String)>>,
) -> (StatusCode, Json<Value>) {
if headers.get("authorization").and_then(|v| v.to_str().ok()) != Some("Bearer sk_live_fake") {
return (StatusCode::UNAUTHORIZED, Json(json!({"error": {"message": "bad key"}})));
}
let id = format!("cs_fake_{}", STRIPE_IDS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
STRIPE_SESSIONS.lock().unwrap().insert(id.clone(), (form, false));
(
StatusCode::OK,
Json(
json!({"id": id, "url": format!("https://checkout.stripe.test/{id}"), "payment_status": "unpaid", "status": "open"}),
),
)
}
async fn fake_stripe_get(axum::extract::Path(id): axum::extract::Path<String>) -> (StatusCode, Json<Value>) {
match STRIPE_SESSIONS.lock().unwrap().get(&id) {
Some((_, paid)) => (
StatusCode::OK,
Json(json!({"id": id, "url": null,
"payment_status": if *paid { "paid" } else { "unpaid" },
"status": if *paid { "complete" } else { "open" }})),
),
None => (StatusCode::NOT_FOUND, Json(json!({"error": {"message": "no such session"}}))),
}
}
async fn fake_services() -> String {
let app = Router::new()
.route("/openrouter/models", get(fake_openrouter_models))
.route("/v1/checkout/sessions", post(fake_stripe_create))
.route("/v1/checkout/sessions/{id}", get(fake_stripe_get))
.route("/v1/natal", post(fake_natal))
.route("/v1/synastry", post(fake_synastry))
.route("/v1/forecast", post(fake_forecast))
.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,
state: Arc<AppState>,
}
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);
let state = Arc::new(AppState::new(pool.clone(), config));
Self { router: routes::router(state.clone()), pool, state }
}
async fn call(&self, method: &str, uri: &str, token: Option<&str>, body: Option<Value>) -> Response {
self.call_with(method, uri, token, body, &[]).await
}
/// A request with extra headers (user agent, forwarded address).
async fn call_with(
&self,
method: &str,
uri: &str,
token: Option<&str>,
body: Option<Value>,
headers: &[(&str, &str)],
) -> Response {
let mut req = Request::builder().method(method).uri(uri);
for (name, value) in headers {
req = req.header(*name, *value);
}
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, "forecast": 0, "question": 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, "forecast": 0, "question": 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, "forecast": 0, "question": 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));
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_person_can_be_invited_by_mail(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
app.chart(&anna, "Saját", true, "1990-03-15").await;
// links are not allowed in the message (it may go out in our e-mail)
let r =
app.post("/v1/invites", Some(&anna), json!({"message": "nézd: www.x.hu", "email": "bela@example.com"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
let r = app.post("/v1/invites", Some(&anna), json!({"email": "anna@example.com"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST, "not herself");
let r = app
.post(
"/v1/invites",
Some(&anna),
json!({"label": "Béla", "email": " Bela@Example.com ", "message": "Nézzük meg, mennyire illünk!"}),
)
.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(&format!("/meghivas/{token}")));
assert_eq!((r.body["emailed"].as_bool(), r.body["email"].as_str()), (Some(true), Some("bela@example.com")));
let (template, payload): (String, Value) =
sqlx::query_as("SELECT template, payload FROM email_outbox WHERE to_email = 'bela@example.com'")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!((template.as_str(), &payload["inviter_name"]), ("synastry_invite", &json!("Anna")));
let invites = app.get("/v1/invites", Some(&anna)).await.body;
assert_eq!(
(&invites["invites"][0]["label"], &invites["invites"][0]["status"]),
(&json!("Béla"), &json!("pending"))
);
// the address can opt out; the next invitation goes by link only
let r = app.post(&format!("/v1/public/invitations/unsubscribe?token={token}"), None, json!({})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
let r = app.post("/v1/invites", Some(&anna), json!({"email": "bela@example.com"})).await;
assert_eq!((r.status, r.body["emailed"].as_bool()), (StatusCode::CREATED, Some(false)));
// at most ten e-mailed a day
for i in 2..10 {
let r = app.post("/v1/invites", Some(&anna), json!({"email": format!("p{i}@example.com")})).await;
assert_eq!(r.status, StatusCode::CREATED);
}
let r = app.post("/v1/invites", Some(&anna), json!({"email": "p10@example.com"})).await;
assert_eq!(r.body["error"]["code"], "invite_mail_limit");
let r = app.post("/v1/invites", Some(&anna), json!({"label": "link only"})).await;
assert_eq!(r.status, StatusCode::CREATED, "a link is still fine");
// accepted: the inviter's mail leads to the comparison page
let bela = app.register("bela@example.com", "Béla").await;
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 url = app.outbox_url("anna@example.com", "invite_accepted").await;
assert!(url.ends_with(&format!("/osszevetesek/{}", r.body["id"].as_str().unwrap())), "{url}");
}
/// 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["credits_charged"]),
(Some("summary"), Some("pending"), &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["credits_charged"]),
(Some("pending"), Some("hu"), &json!(1))
);
let first = r.body["id"].as_str().unwrap().to_string();
// the model is used but never shown to users
assert!(r.body.get("model").is_none() && summary.get("model").is_none());
let (model,): (String,) = sqlx::query_as("SELECT model FROM analyses WHERE id = $1::uuid")
.bind(&first)
.fetch_one(&app.pool)
.await
.unwrap();
assert_eq!(model, "anthropic/claude-test");
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 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, "forecast": 0, "question": 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");
}
assert!(r.body["summary"].is_null(), "no finished summary yet");
// the newest finished summary comes with the chart
sqlx::query(
"INSERT INTO analyses (id, kind, chart_id, requested_by, language, model, prompt_version, cache_key, \
credits_charged, status, content, completed_at) \
VALUES ($1, 'summary', $2::uuid, (SELECT id FROM users WHERE email = 'anna@example.com'), 'hu', 'm', 'v', \
'k', 0, 'done', $3, now())",
)
.bind(uuid::Uuid::now_v7())
.bind(chart_id)
.bind(json!({"title": "Csendes erő", "summary": "Rövid **összefoglaló**."}))
.execute(&app.pool)
.await
.unwrap();
let r = app.get(&format!("/v1/public/shares/{slug}"), None).await;
assert_eq!(r.body["summary"]["title"], "Csendes erő");
assert_eq!(r.body["summary"]["summary"], "Rövid **összefoglaló**.");
// sharing the same again gives the open link
let r = app
.post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart_id, "title": "A radixom"}))
.await;
assert_eq!((r.status, r.body["slug"].as_str()), (StatusCode::OK, Some(slug.as_str())));
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);
}
/// Only these answer without a session: login and sign-up, the public
/// config and catalog, shared links, invitation pages, the waitlist and
/// unsubscribing. Every other route (charts, calculations, analyses) needs a
/// logged-in user, so other apps cannot use them.
const PUBLIC_ROUTES: [&str; 16] = [
"/healthz",
// Stripe calls it; the signature proves it.
"/v1/payments/stripe/webhook",
"/v1/config",
"/v1/packages",
"/v1/auth/register",
"/v1/auth/login",
"/v1/auth/google",
"/v1/auth/verify-email",
"/v1/auth/password-reset",
"/v1/auth/password-reset/confirm",
"/v1/public/shares/{slug}",
"/v1/public/shares/{slug}/visit",
"/v1/public/invites/{token}",
"/v1/public/invitations/unsubscribe",
"/v1/public/invitations/{token}",
"/v1/public/waitlist",
];
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_visit_by_someone_else_earns_one_question_once(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 share = json!({"kind": "chart", "target_id": chart["id"]});
let home = ("x-forwarded-for", "203.0.113.7");
let r = app.call_with("POST", "/v1/shares", Some(&anna), Some(share), &[home]).await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let visit = format!("/v1/public/shares/{}/visit", r.body["slug"].as_str().unwrap());
let browser = ("user-agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) Mobile/15E148");
let me = || async { app.get("/v1/me", Some(&anna)).await.body };
let before = me().await["analyses_left"]["question"].as_i64().unwrap();
// robots, a missing user agent, the sharer's address and the sharer do not count
let elsewhere = ("x-forwarded-for", "198.51.100.1, 172.70.1.1");
for (token, headers) in [
(None, vec![("user-agent", "facebookexternalhit/1.1"), elsewhere]),
(None, vec![elsewhere]),
(None, vec![browser, home]),
(Some(anna.as_str()), vec![browser, elsewhere]),
] {
let r = app.call_with("POST", &visit, token, None, &headers).await;
assert_eq!((r.status, &r.body["counted"]), (StatusCode::OK, &json!(false)), "{headers:?}");
}
let body = me().await;
assert_eq!(
(body["analyses_left"]["question"].as_i64(), &body["share_reward_granted"]),
(Some(before), &json!(false))
);
// reading the share counts nothing either
app.get(&visit.replace("/visit", ""), None).await;
// someone else: counted, and the reward comes once
for _ in 0..2 {
let r = app.call_with("POST", &visit, None, None, &[browser, elsewhere]).await;
assert_eq!(r.body["counted"], true);
}
let body = me().await;
assert_eq!(
(body["analyses_left"]["question"].as_i64(), &body["share_reward_granted"]),
(Some(before + 1), &json!(true))
);
let r = app.get("/v1/shares", Some(&anna)).await;
assert_eq!(r.body["shares"][0]["view_count"], 2);
// a second link earns nothing more
let r =
app.post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart["id"], "title": "Új"})).await;
let other = format!("/v1/public/shares/{}/visit", r.body["slug"].as_str().unwrap());
app.call_with("POST", &other, None, None, &[browser, elsewhere]).await;
assert_eq!(me().await["analyses_left"]["question"].as_i64(), Some(before + 1));
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn everything_else_needs_login(pool: PgPool) {
let app = TestApp::new(pool).await;
let source = include_str!("routes/mod.rs");
let id = uuid::Uuid::now_v7().to_string();
let mut checked = 0;
for line in source.lines().map(str::trim).filter(|l| l.starts_with(".route(\"")) {
let path = line.split('"').nth(1).unwrap();
if PUBLIC_ROUTES.contains(&path) {
continue;
}
let uri = path
.split('/')
.map(|seg| if seg.starts_with('{') { id.as_str() } else { seg })
.collect::<Vec<_>>()
.join("/");
for (name, method) in
[("get(", "GET"), ("post(", "POST"), ("patch(", "PATCH"), ("put(", "PUT"), ("delete(", "DELETE")]
{
if !line.contains(name) {
continue;
}
let body = (method != "GET" && method != "DELETE").then(|| json!({}));
let r = app.call(method, &uri, None, body).await;
assert_eq!(r.status, StatusCode::UNAUTHORIZED, "{method} {uri} answers without login: {}", r.body);
checked += 1;
}
}
assert!(checked > 40, "{checked}");
}
#[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!(r.body.get("analysis_model").is_none() && r.body.get("summary_model").is_none());
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, "forecast": 0, "question": 0})
);
// questions can be asked about the relationship analysis too
let analysis = r.body["id"].as_str().unwrap().to_string();
sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Kettőtök\"}' WHERE kind = 'synastry'")
.execute(&app.pool)
.await
.unwrap();
grant_units(&app, &anna, "question", 1).await;
let r = app
.post(&format!("/v1/analyses/{analysis}/questions"), Some(&anna), json!({"question": "Mire figyeljünk?"}))
.await;
assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::ACCEPTED, Some("pending")), "{}", r.body);
}
#[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, "forecast": 0, "question": 3})),
"{}",
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, "forecast": 0, "question": 3})
);
// 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 family package adds five more
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "family"})).await;
assert_eq!(r.body["persons"], json!({"used": 3, "limit": 11, "left": 8, "unlimited": false}));
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<String> =
prompts.iter().map(|p| format!("{}/{}", p["kind"], p["language"]).replace('"', "")).collect();
let expected =
["summary", "natal", "synastry", "forecast", "question"].map(|k| [format!("{k}/hu"), format!("{k}/en")]);
assert_eq!(keys, expected.concat());
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
);
// a yearly forecast is tried on a forecast of one of the admin's charts
sqlx::query("UPDATE prompt_previews SET status = 'done'").execute(&pool).await.unwrap();
let own_id = own["id"].as_str().unwrap();
let forecast = app.post(&format!("/v1/charts/{own_id}/forecasts"), Some(&admin), json!({})).await;
assert_eq!(forecast.status, StatusCode::CREATED, "{}", forecast.body);
let annas_id = annas["id"].as_str().unwrap();
let annas_forecast = app.post(&format!("/v1/charts/{annas_id}/forecasts"), Some(&anna), json!({})).await;
let uri = "/v1/admin/prompts/forecast/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 body = json!({"system": "Próba.", "forecast_id": annas_forecast.body["id"]});
assert_eq!(app.call("POST", uri, Some(&admin), Some(body)).await.status, StatusCode::NOT_FOUND);
let body = json!({"system": "Próba.", "forecast_id": forecast.body["id"]});
let r = app.call("POST", uri, Some(&admin), Some(body)).await;
assert_eq!(
(r.status, r.body["forecast_id"].as_str()),
(StatusCode::ACCEPTED, forecast.body["id"].as_str()),
"{}",
r.body
);
// and its prompt is listed and can be saved like the others
let prompts = app.get("/v1/admin/prompts", Some(&admin)).await.body;
assert!(prompts["prompts"].as_array().unwrap().iter().any(|p| p["kind"] == "forecast"));
let r = app.call("PUT", "/v1/admin/prompts/forecast/hu", Some(&admin), Some(json!({"system": "Saját."}))).await;
assert_eq!((r.status, &r.body["custom"]), (StatusCode::OK, &json!(true)), "{}", 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(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();
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"], Value::Null);
// 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", "addon_synastry", "addon_forecast", "addon_persons", "addon_questions"]
);
assert_eq!(
(&r.body["packages"][2]["badge"], &r.body["packages"][2]["per_analysis_huf"]),
(&json!("Legnépszerűbb"), &json!(647))
);
// 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, "forecast": 6, "question": 3})),
"{}",
r.body
);
let me = app.get("/v1/me", Some(&anna)).await.body;
assert_eq!(me["persons"]["limit"], 10); // 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, "forecast": 8, "question": 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, 6000);
// the header shows the latest main package; a top-up does not change it
app.post("/v1/payments/mock", Some(&anna), json!({"package": "addon_persons"})).await;
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"]["name"], "Páros");
// the unlimited package is not sold any more; an old order of it is skipped
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "unlimited"})).await;
assert_eq!(r.status, StatusCode::NOT_FOUND);
assert_eq!(grant_package(&app, &admin, &anna_id, "unlimited").await.status, StatusCode::NOT_FOUND);
sqlx::query("INSERT INTO package_orders (id, user_id, package, source) VALUES ($1, $2::uuid, 'unlimited', 'mock')")
.bind(uuid::Uuid::now_v7())
.bind(&anna_id)
.execute(&pool)
.await
.unwrap();
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"]["name"], "Páros");
}
#[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);
}
async fn google_signup(app: &TestApp, sub: &str, email: &str, invite: Option<&str>) -> Response {
app.post(
"/v1/auth/google",
None,
json!({"id_token": google_token(sub, email, GOOGLE_CLIENT), "invite_token": invite}),
)
.await
}
fn invite_token(url: &str) -> String {
url.rsplit('/').next().unwrap().to_string()
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn invitation_only_signup(pool: PgPool) {
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
assert_eq!(app.get("/v1/config", None).await.body["signup_mode"], "invite");
// nobody gets in uninvited, except the bootstrap admin
let r = google_signup(&app, "g-x", "stranger@gmail.com", None).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("not_invited")));
let admin = app.register("admin@example.com", "Admin").await;
// an existing user (from before the invitation-only times) is not an admin
let user = {
let open = TestApp::new(pool.clone()).await;
open.register("anna@example.com", "Anna").await
};
// inviting: duplicates, invalid addresses and existing users are sorted out
let r = app
.post(
"/v1/admin/invitations",
Some(&admin),
json!({"emails": ["Guest@Example.com", "guest@example.com", "nope", "anna@example.com", "kata@example.com"],
"message": "Gyere, nézd meg!"}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let statuses: Vec<&str> =
r.body["results"].as_array().unwrap().iter().map(|x| x["status"].as_str().unwrap()).collect();
assert_eq!(statuses, ["invited", "invalid", "already_user", "invited"]);
let guest_url = r.body["results"][0]["url"].as_str().unwrap().to_string();
let guest_id = r.body["results"][0]["id"].as_str().unwrap().to_string();
let guest_token = invite_token(&guest_url);
let r = app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["guest@example.com"]})).await;
assert_eq!(r.body["results"][0]["status"], "already_invited");
let r = app
.post(
"/v1/admin/invitations",
Some(&admin),
json!({"emails": ["x@example.com"], "message": "nézd: www.spam.hu"}),
)
.await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
assert_eq!(app.get("/v1/admin/invitations", Some(&user)).await.status, StatusCode::FORBIDDEN);
// the e-mail and the landing page
let (payload,): (Value,) = sqlx::query_as(
"SELECT payload FROM email_outbox WHERE to_email = 'guest@example.com' AND template = 'invitation'",
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(payload["url"], guest_url.as_str());
assert_eq!(payload["inviter_name"], "Admin");
assert!(
payload["unsubscribe_post_url"].as_str().unwrap().contains("/api/v1/public/invitations/unsubscribe?token=")
);
let r = app.get(&format!("/v1/public/invitations/{guest_token}"), None).await;
assert_eq!((r.body["inviter_name"].as_str(), r.body["status"].as_str()), (Some("Admin"), Some("pending")));
// a resend: not too soon, then with a new link; the old one keeps working
let r = app.post(&format!("/v1/admin/invitations/{guest_id}/resend"), Some(&admin), json!({})).await;
assert_eq!(r.body["error"]["code"], "resend_too_soon");
sqlx::query("UPDATE invitations SET last_sent_at = now() - interval '25 hours'").execute(&pool).await.unwrap();
let r = app.post(&format!("/v1/admin/invitations/{guest_id}/resend"), Some(&admin), json!({})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_ne!(r.body["url"], guest_url.as_str());
// the link lets in any Google account, once
let r = google_signup(&app, "g-1", "guests.other.account@gmail.com", Some(&guest_token)).await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let r = google_signup(&app, "g-2", "third@gmail.com", Some(&guest_token)).await;
assert_eq!(r.body["error"]["code"], "not_invited");
// the invited address itself gets in without the link
assert_eq!(google_signup(&app, "g-3", "kata@example.com", None).await.status, StatusCode::CREATED);
// revoked: no entry
let r = app
.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["zoli@example.com", "mari@example.com"]}))
.await;
let zoli_id = r.body["results"][0]["id"].as_str().unwrap().to_string();
let mari_token = invite_token(r.body["results"][1]["url"].as_str().unwrap());
assert_eq!(
app.call("DELETE", &format!("/v1/admin/invitations/{zoli_id}"), Some(&admin), None).await.status,
StatusCode::NO_CONTENT
);
assert_eq!(google_signup(&app, "g-4", "zoli@example.com", None).await.status, StatusCode::FORBIDDEN);
// unsubscribing (one-click POST): the invitation closes and no new one can be sent
let r = app.call("POST", &format!("/v1/public/invitations/unsubscribe?token={mari_token}"), None, None).await;
assert_eq!(r.status, StatusCode::OK);
assert_eq!(google_signup(&app, "g-5", "mari@example.com", None).await.status, StatusCode::FORBIDDEN);
let r = app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["MARI@example.com"]})).await;
assert_eq!(r.body["results"][0]["status"], "opted_out");
// the waitlist: joining reveals nothing, an invited and accepted address leaves it
for email in ["wait@example.com", "anna@example.com"] {
let r = app.post("/v1/public/waitlist", None, json!({"email": email})).await;
assert_eq!(r.status, StatusCode::ACCEPTED);
}
let list = app.get("/v1/admin/invitations", Some(&admin)).await.body;
assert_eq!(list["waitlist"].as_array().unwrap().len(), 1);
let statuses: Vec<(&str, &str)> = list["invitations"]
.as_array()
.unwrap()
.iter()
.map(|i| (i["email"].as_str().unwrap(), i["status"].as_str().unwrap()))
.collect();
assert!(
statuses.contains(&("guest@example.com", "accepted")) && statuses.contains(&("zoli@example.com", "revoked"))
);
app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["wait@example.com"]})).await;
assert_eq!(google_signup(&app, "g-6", "wait@example.com", None).await.status, StatusCode::CREATED);
assert!(app.get("/v1/admin/invitations", Some(&admin)).await.body["waitlist"].as_array().unwrap().is_empty());
// preview and a test copy to the admin
let r =
app.post("/v1/admin/invitations/preview", Some(&admin), json!({"message": "Szia!", "send_to_me": true})).await;
assert_eq!(r.body["subject"], "Admin meghívott a Sorsfonalakra");
assert!(r.body["html"].as_str().unwrap().contains("Szia!") && r.body["text"].as_str().unwrap().contains("> Szia!"));
assert_eq!(app.outbox_url("admin@example.com", "invitation").await, "https://sorsfonalak.test/meghivo/minta");
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn forecasts_are_free_their_analysis_uses_a_forecast_unit(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
let bob = app.register("bob@example.com", "Bob").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let uri = format!("/v1/charts/{chart_id}/forecasts");
// the year of life the user is in can be calculated (free, stored once)
let list = app.get(&uri, Some(&anna)).await.body;
let year = list["years"][0].as_i64().expect("an open year");
assert_eq!(list["forecasts"], json!([]));
let r = app.post(&uri, Some(&anna), json!({})).await;
assert_eq!((r.status, &r.body["year"]), (StatusCode::CREATED, &json!(year)), "{}", r.body);
assert_eq!(r.body["start"], format!("{year}-03-15"));
assert!(r.body["result"].get("meta").is_none());
let id = r.body["id"].as_str().unwrap().to_string();
let again = app.post(&uri, Some(&anna), json!({"year": year})).await;
assert_eq!((again.status, again.body["id"].as_str()), (StatusCode::OK, Some(id.as_str())));
// another place on the birthday is another forecast
let away = app
.post(&uri, Some(&anna), json!({"location": {"country": "JP", "geonames_id": 1850147, "place": "Tokió"}}))
.await;
assert_eq!((away.status, &away.body["place"]), (StatusCode::CREATED, &json!("Tokió")));
assert_eq!(app.get(&uri, Some(&anna)).await.body["forecasts"].as_array().unwrap().len(), 2);
// far years are closed to users; others cannot see it
let r = app.post(&uri, Some(&anna), json!({"year": 2000})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("forecast_year_closed")));
assert_eq!(app.post(&uri, Some(&anna), json!({"year": year, "oops": 1})).await.status, StatusCode::BAD_REQUEST);
assert_eq!(app.get(&format!("/v1/forecasts/{id}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(app.get(&uri, Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(app.get(&format!("/v1/forecasts/{id}"), Some(&anna)).await.body["year"], json!(year));
// the detailed text uses a forecast unit, not a natal one
let analyses = format!("/v1/forecasts/{id}/analyses");
grant_units(&app, &anna, "natal", 1).await;
let r = app.call("POST", &analyses, Some(&anna), None).await;
assert_eq!(
(r.status, r.body["error"]["code"].as_str()),
(StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits"))
);
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "forecast"})).await;
assert_eq!(r.body["analyses_left"], json!({"natal": 1, "synastry": 0, "forecast": 1, "question": 0}), "{}", r.body);
let r = app.call("POST", &analyses, Some(&anna), None).await;
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
assert_eq!((r.body["kind"].as_str(), r.body["forecast_id"].as_str()), (Some("forecast"), Some(id.as_str())));
let analysis = r.body["id"].as_str().unwrap().to_string();
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 0})
);
assert_eq!(app.call("POST", &analyses, Some(&anna), None).await.status, StatusCode::OK); // the same one, no charge
assert_eq!(app.get(&analyses, Some(&anna)).await.body["analyses"].as_array().unwrap().len(), 1);
assert_eq!(app.get(&format!("/v1/analyses/{analysis}"), Some(&anna)).await.status, StatusCode::OK);
assert_eq!(app.get(&format!("/v1/analyses/{analysis}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(app.call("POST", &analyses, Some(&bob), None).await.status, StatusCode::NOT_FOUND);
// the natal analyses of the chart do not list it
let natal = app.get(&format!("/v1/charts/{chart_id}/analyses"), Some(&anna)).await.body;
assert!(natal["analyses"].as_array().unwrap().iter().all(|a| a["kind"] != "forecast"));
// deleting the chart deletes its forecasts
assert_eq!(
app.call("DELETE", &format!("/v1/charts/{chart_id}"), Some(&anna), None).await.status,
StatusCode::NO_CONTENT
);
let (n,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts").fetch_one(&pool).await.unwrap();
assert_eq!(n, 0);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn recalculate_refreshes_calculations_and_queues_every_analysis_again(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 syn = app.post("/v1/synastries", Some(&anna), json!({"chart1_id": own["id"], "chart2_id": bela["id"]})).await;
let own_id = own["id"].as_str().unwrap();
let forecast = app.post(&format!("/v1/charts/{own_id}/forecasts"), Some(&anna), json!({})).await;
assert_eq!(forecast.status, StatusCode::CREATED, "{}", forecast.body);
let before = app.get("/v1/me", Some(&anna)).await.body["analyses_left"].clone();
// stored with an older calculation
sqlx::query("UPDATE charts SET result = '{}', chart_hash = 'old'").execute(&pool).await.unwrap();
sqlx::query("UPDATE synastries SET result = '{}', synastry_hash = 'old'").execute(&pool).await.unwrap();
sqlx::query("UPDATE forecasts SET result = '{}', forecast_hash = 'old'").execute(&pool).await.unwrap();
routes::recalculate(&app.state).await.unwrap();
let (old,): (i64,) = sqlx::query_as(
"SELECT (SELECT count(*) FROM charts WHERE chart_hash = 'old' OR result = '{}') \
+ (SELECT count(*) FROM synastries WHERE synastry_hash = 'old' OR result = '{}') \
+ (SELECT count(*) FROM forecasts WHERE forecast_hash = 'old' OR result = '{}')",
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(old, 0);
let rows: Vec<(String, String, i32)> =
sqlx::query_as("SELECT kind, status, credits_charged FROM analyses ORDER BY kind")
.fetch_all(&pool)
.await
.unwrap();
let kinds: Vec<&str> = rows.iter().map(|r| r.0.as_str()).collect();
assert_eq!(kinds, ["forecast", "natal", "natal", "summary", "summary", "synastry"]);
assert!(rows.iter().all(|r| r.1 == "pending" && r.2 == 0), "{rows:?}");
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["analyses_left"], before);
assert_eq!(syn.status, StatusCode::CREATED);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn admins_choose_the_model_of_each_function(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/models", Some(&anna)).await.status, StatusCode::FORBIDDEN);
let r = app.get("/v1/admin/models", Some(&admin)).await;
let models: Vec<(&str, &str, bool)> = r.body["functions"]
.as_array()
.unwrap()
.iter()
.map(|f| (f["kind"].as_str().unwrap(), f["model"].as_str().unwrap(), f["custom"].as_bool().unwrap()))
.collect();
assert_eq!(
models,
[
("summary", "anthropic/claude-summary", false),
("analysis", "anthropic/claude-test", false),
("question", "anthropic/claude-test", false),
]
);
// the list has only models that give structured answers, with prices per million tokens
let r = app.get("/v1/admin/models/catalog", Some(&admin)).await;
let ids: Vec<&str> = r.body["models"].as_array().unwrap().iter().map(|m| m["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["anthropic/claude-test", "openai/gpt-x"]);
assert_eq!(r.body["models"][1]["input_per_million"].as_f64().map(|p| (p * 100.0).round()), Some(300.0));
let put = |kind: &str, model: Value| {
let uri = format!("/v1/admin/models/{kind}");
let (app, admin) = (&app, &admin);
async move { app.call("PUT", &uri, Some(admin), Some(json!({ "model": model }))).await }
};
assert_eq!(put("analysis", json!("vendor/plain")).await.status, StatusCode::BAD_REQUEST);
assert_eq!(put("natal", json!("openai/gpt-x")).await.status, StatusCode::NOT_FOUND);
let r = put("analysis", json!("openai/gpt-x")).await;
assert_eq!((r.status, &r.body["model"], &r.body["custom"]), (StatusCode::OK, &json!("openai/gpt-x"), &json!(true)));
// new analyses use it; regenerating writes it again in place with the current model
let chart = app.chart(&admin, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let r = app.post(&format!("/v1/charts/{chart_id}/analyses"), Some(&admin), json!({})).await;
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
let id = r.body["id"].as_str().unwrap().to_string();
let model = || {
sqlx::query_as::<_, (String, Option<String>)>("SELECT model, fallback_model FROM analyses WHERE id = $1::uuid")
.bind(&id)
.fetch_one(&pool)
};
// the default model is kept as the fallback
assert_eq!(model().await.unwrap(), ("openai/gpt-x".into(), Some("anthropic/claude-test".into())));
let regenerate_uri = format!("/v1/admin/analyses/{id}/regenerate");
let regenerate = || app.post(&regenerate_uri, Some(&admin), json!({}));
assert_eq!(regenerate().await.status, StatusCode::CONFLICT); // still being written
sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Régi\"}', completed_at = now()")
.execute(&pool)
.await
.unwrap();
assert_eq!(put("analysis", Value::Null).await.body["model"], "anthropic/claude-test");
assert_eq!(
app.post(&format!("/v1/admin/analyses/{id}/regenerate"), Some(&anna), json!({})).await.status,
StatusCode::FORBIDDEN
);
let r = regenerate().await;
assert_eq!(
(r.status, r.body["status"].as_str(), &r.body["content"]),
(StatusCode::OK, Some("pending"), &Value::Null)
);
assert_eq!(r.body["id"].as_str(), Some(id.as_str()));
assert_eq!(model().await.unwrap(), ("anthropic/claude-test".into(), None));
let r = app.get(&format!("/v1/charts/{chart_id}/analyses"), Some(&admin)).await;
assert_eq!(r.body["analyses"].as_array().unwrap().iter().filter(|a| a["kind"] == "natal").count(), 1);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn questions_about_an_analysis_use_question_units(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
let bob = app.register("bob@example.com", "Bob").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
// a package comes with three questions
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "single"})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
let left = || async { app.get("/v1/me", Some(&anna)).await.body["analyses_left"]["question"].clone() };
assert_eq!(left().await, json!(3));
let r = app.post(&format!("/v1/charts/{chart_id}/analyses"), Some(&anna), json!({})).await;
let analysis = r.body["id"].as_str().unwrap().to_string();
let uri = format!("/v1/analyses/{analysis}/questions");
let ask = |who: &str, q: &str| {
let (app, uri, who, body) = (&app, &uri, who.to_string(), json!({ "question": q }));
async move { app.post(uri, Some(&who), body).await }
};
let r = ask(&anna, "Mi az erősségem?").await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("analysis_not_ready")));
sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Cím\"}'").execute(&pool).await.unwrap();
assert_eq!(ask(&bob, "Mi az erősségem?").await.status, StatusCode::NOT_FOUND);
assert_eq!(ask(&anna, "?").await.status, StatusCode::BAD_REQUEST);
assert_eq!(ask(&anna, &"x".repeat(601)).await.status, StatusCode::BAD_REQUEST);
let r = ask(&anna, " Mi az erősségem? ").await;
assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::ACCEPTED, Some("pending")), "{}", r.body);
assert_eq!(r.body["question"], "Mi az erősségem?");
assert!(r.body.get("model").is_none(), "the model is a secret");
assert_eq!(left().await, json!(2));
let question = r.body["id"].as_str().unwrap().to_string();
// the question model of the admin page answers (here the default)
let (q_model, fallback): (String, Option<String>) =
sqlx::query_as("SELECT model, fallback_model FROM questions WHERE id = $1::uuid")
.bind(&question)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!((q_model.as_str(), fallback), ("anthropic/claude-test", None));
// one at a time
let r = ask(&anna, "És a munkában?").await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("question_in_progress")));
sqlx::query("UPDATE questions SET status = 'done', answer = 'A kitartásod.'").execute(&pool).await.unwrap();
assert_eq!(app.get(&format!("/v1/questions/{question}"), Some(&anna)).await.body["answer"], "A kitartásod.");
assert_eq!(app.get(&format!("/v1/questions/{question}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(ask(&anna, "És a munkában?").await.status, StatusCode::ACCEPTED);
sqlx::query("UPDATE questions SET status = 'done', answer = 'Válasz.'").execute(&pool).await.unwrap();
assert_eq!(ask(&anna, "És a pénz?").await.status, StatusCode::ACCEPTED);
sqlx::query("UPDATE questions SET status = 'done', answer = 'Válasz.'").execute(&pool).await.unwrap();
let r = ask(&anna, "És a szerelem?").await;
assert_eq!(
(r.status, r.body["error"]["code"].as_str()),
(StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits"))
);
let list = app.get(&uri, Some(&anna)).await.body;
assert_eq!(list["questions"].as_array().unwrap().len(), 3);
assert_eq!(list["questions"][0]["question"], "Mi az erősségem?");
// more can be bought; the summary cannot be asked about
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "question"})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_eq!(left().await, json!(5));
let summary: String =
sqlx::query_scalar("SELECT id::text FROM analyses WHERE kind = 'summary'").fetch_one(&pool).await.unwrap();
sqlx::query("UPDATE analyses SET status = 'done', content = '{}' WHERE kind = 'summary'")
.execute(&pool)
.await
.unwrap();
let r = app.post(&format!("/v1/analyses/{summary}/questions"), Some(&anna), json!({"question": "Miért?"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
// admins regenerate an answer in place
let admin = app.register("admin@example.com", "Admin").await;
let r = app.post(&format!("/v1/admin/questions/{question}/regenerate"), Some(&admin), json!({})).await;
assert_eq!(
(r.status, r.body["status"].as_str(), &r.body["answer"]),
(StatusCode::OK, Some("pending"), &Value::Null)
);
assert_eq!(left().await, json!(5), "regenerating charges nobody");
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn admins_restart_open_generations_with_the_current_models(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/jobs", Some(&anna)).await.status, StatusCode::FORBIDDEN);
let put = |model: &str| {
let (app, admin, body) = (&app, &admin, json!({ "model": model }));
async move { app.call("PUT", "/v1/admin/models/analysis", Some(admin), Some(body)).await }
};
assert_eq!(put("openai/gpt-x").await.status, StatusCode::OK);
let chart = app.chart(&admin, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let r = app.post(&format!("/v1/charts/{chart_id}/analyses"), Some(&admin), json!({})).await;
let id = r.body["id"].as_str().unwrap().to_string();
// the worker is writing it with the chosen model
sqlx::query("UPDATE analyses SET status = 'running', started_at = now(), attempts = 1 WHERE id = $1::uuid")
.bind(&id)
.execute(&pool)
.await
.unwrap();
// after switching back to the default, the list shows what a restart would use
assert_eq!(
app.call("PUT", "/v1/admin/models/analysis", Some(&admin), Some(json!({"model": null}))).await.status,
StatusCode::OK
);
let jobs = app.get("/v1/admin/jobs", Some(&admin)).await.body["jobs"].clone();
let job = jobs.as_array().unwrap().iter().find(|j| j["id"] == json!(id)).expect("the analysis is listed");
assert_eq!(
(&job["status"], &job["model"], &job["next_model"]),
(&json!("running"), &json!("openai/gpt-x"), &json!("anthropic/claude-test"))
);
let r = app.post("/v1/admin/jobs/restart", Some(&admin), json!({ "ids": [id] })).await;
assert_eq!((r.status, &r.body["restarted"]), (StatusCode::OK, &json!(1)), "{}", r.body);
let (status, model, fallback, started, attempts): (
String,
String,
Option<String>,
Option<time::OffsetDateTime>,
i32,
) = sqlx::query_as("SELECT status, model, fallback_model, started_at, attempts FROM analyses WHERE id = $1::uuid")
.bind(&id)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(
(status.as_str(), model.as_str(), fallback, started, attempts),
("pending", "anthropic/claude-test", None, None, 0)
);
// finished ones are left alone
sqlx::query("UPDATE analyses SET status = 'done', content = '{}'").execute(&pool).await.unwrap();
assert_eq!(app.post("/v1/admin/jobs/restart", Some(&admin), json!({})).await.body["restarted"], 0);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn admins_read_the_error_log(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 chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let analysis: uuid::Uuid = sqlx::query_scalar("SELECT id FROM analyses WHERE chart_id = $1::uuid")
.bind(chart_id)
.fetch_one(&pool)
.await
.unwrap();
for (attempt, outcome) in [(1, "retry"), (2, "failed")] {
sqlx::query(
"INSERT INTO generation_errors (source, item_id, kind, model, attempt, outcome, error, seconds) \
VALUES ('analysis', $1, 'summary', 'cheap/model', $2, $3, 'answer cut off at the token limit', 301)",
)
.bind(analysis)
.bind(attempt)
.bind(outcome)
.execute(&pool)
.await
.unwrap();
}
assert_eq!(app.get("/v1/admin/errors", Some(&anna)).await.status, StatusCode::FORBIDDEN);
let r = app.get("/v1/admin/errors", Some(&admin)).await;
assert_eq!((r.status, &r.body["total"], &r.body["last_day"]), (StatusCode::OK, &json!(2), &json!(2)), "{}", r.body);
let first = &r.body["errors"][0];
assert_eq!(
(&first["outcome"], &first["attempt"], &first["user"], &first["seconds"]),
(&json!("failed"), &json!(2), &json!("anna@example.com"), &json!(301))
);
let r = app.get("/v1/admin/errors?outcome=retry", Some(&admin)).await;
assert_eq!(r.body["errors"].as_array().unwrap().len(), 1);
assert_eq!(app.get("/v1/admin/errors?source=question", Some(&admin)).await.body["total"], 0);
// users see the attempts of their analysis (the page says it is tried again)
let r = app.get(&format!("/v1/analyses/{analysis}"), Some(&anna)).await;
assert_eq!(r.body["attempts"], 0);
assert!(r.body["next_attempt_at"].is_string());
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn promo_codes_are_made_by_admins_and_redeemed_once(pool: PgPool) {
let app = TestApp::new(pool).await;
let admin = app.register("admin@example.com", "Admin").await; // BOOTSTRAP_ADMIN_EMAILS
let anna = app.register("anna@example.com", "Anna").await;
let bela = app.register("bela@example.com", "Béla").await;
// only admins make codes
let r = app.post("/v1/admin/promo-codes", Some(&anna), json!({"package": "single", "count": 1})).await;
assert_eq!(r.status, StatusCode::FORBIDDEN);
let r = app.post("/v1/admin/promo-codes", Some(&admin), json!({"package": "nincs", "count": 1})).await;
assert_eq!(r.status, StatusCode::NOT_FOUND);
let r = app
.post("/v1/admin/promo-codes", Some(&admin), json!({"package": "single", "count": 3, "note": "meghívottak"}))
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let codes: Vec<String> = r.body["codes"].as_array().unwrap().iter().map(|c| c.as_str().unwrap().into()).collect();
assert_eq!(codes.len(), 3);
assert!(codes.iter().all(|c| c.len() == 14 && c.matches('-').count() == 2), "{codes:?}");
// redeemed in any spelling: the package arrives
let before = app.get("/v1/me", Some(&anna)).await.body["analyses_left"]["natal"].as_i64().unwrap();
let typed = format!(" {} ", codes[0].replace('-', " ").to_lowercase());
let r = app.post("/v1/promo-codes/redeem", Some(&anna), json!({"code": typed})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_eq!(r.body["package"]["id"], "single");
let me = app.get("/v1/me", Some(&anna)).await.body;
assert_eq!(me["analyses_left"]["natal"].as_i64(), Some(before + 1));
assert_eq!(me["package"]["id"], "single");
// once only, also for someone else
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": codes[0]})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("promo_used")));
// a withdrawn code and an unknown one do not work
let list = app.get("/v1/admin/promo-codes", Some(&admin)).await.body;
assert_eq!(list["total"], 2, "unused is the default filter: {list}");
let withdrawn = list["codes"].as_array().unwrap().iter().find(|c| c["code"] == codes[1].as_str()).unwrap().clone();
let r = app
.post(&format!("/v1/admin/promo-codes/{}/revoke", withdrawn["id"].as_str().unwrap()), Some(&admin), json!({}))
.await;
assert_eq!(r.status, StatusCode::NO_CONTENT);
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": codes[1]})).await;
assert_eq!(r.body["error"]["code"], "promo_revoked");
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": "AAAA-BBBB-CCCC"})).await;
assert_eq!(r.body["error"]["code"], "promo_unknown");
// the filters
let get = |q: &str| {
let uri = format!("/v1/admin/promo-codes?{q}");
let app = &app;
let admin = &admin;
async move { app.get(&uri, Some(admin)).await }
};
let used = get("status=used").await.body;
assert_eq!(
(used["total"].as_i64(), &used["codes"][0]["redeemed_by"]["email"]),
(Some(1), &json!("anna@example.com"))
);
assert_eq!(get("status=revoked").await.body["total"], 1);
assert_eq!(get("status=all").await.body["total"], 3);
assert_eq!(get("status=all&package=addon_questions").await.body["total"], 0);
assert_eq!(get("status=all&q=anna@").await.body["total"], 1);
assert_eq!(get("status=all&q=megh").await.body["total"], 3);
let part = codes[2].split('-').nth(1).unwrap().to_lowercase();
assert_eq!(get(&format!("status=unused&q={part}")).await.body["total"], 1);
// guessing is cut off
for _ in 0..10 {
app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": "ZZZZ-ZZZZ-ZZZZ"})).await;
}
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": codes[2]})).await;
assert_eq!(r.status, StatusCode::TOO_MANY_REQUESTS);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn an_invitation_brings_its_package_and_codes_fill_up(pool: PgPool) {
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
let admin = app.register("admin@example.com", "Admin").await;
let r = app
.post(
"/v1/admin/invitations",
Some(&admin),
json!({"emails": ["guest@example.com", "other@example.com"], "package": "couple"}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let guest = &r.body["results"][0];
let guest_token = invite_token(guest["url"].as_str().unwrap());
let other_id = r.body["results"][1]["id"].as_str().unwrap().to_string();
// the e-mail shows the package and its code
let (payload,): (Value,) = sqlx::query_as(
"SELECT payload FROM email_outbox WHERE to_email = 'guest@example.com' AND template = 'invitation'",
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(payload["package_name"], "Páros");
assert_eq!(payload["promo_code"], guest["promo_code"]);
assert!(
payload["redeem_url"]
.as_str()
.unwrap()
.ends_with(&format!("/bevaltas?kod={}", guest["promo_code"].as_str().unwrap()))
);
let list = app.get("/v1/admin/invitations", Some(&admin)).await.body;
assert_eq!(list["invitations"][0]["package"]["name"], "Páros");
// revoking an invitation withdraws its code
let r = app.call("DELETE", &format!("/v1/admin/invitations/{other_id}"), Some(&admin), None).await;
assert_eq!(r.status, StatusCode::NO_CONTENT);
let codes = app.get("/v1/admin/promo-codes?status=revoked", Some(&admin)).await.body;
assert_eq!((codes["total"].as_i64(), &codes["codes"][0]["note"]), (Some(1), &json!("meghívó: other@example.com")));
// signing up redeems it by itself
let r = google_signup(&app, "g-guest", "guest@example.com", Some(&guest_token)).await;
assert!(r.status.is_success(), "{}", r.body);
let token = r.body["token"].as_str().map(str::to_string).unwrap_or_else(|| {
let cookie = r.headers.get("set-cookie").unwrap().to_str().unwrap();
cookie.split(';').next().unwrap().split('=').nth(1).unwrap().to_string()
});
let me = app.get("/v1/me", Some(&token)).await.body;
let left = &me["analyses_left"];
assert_eq!(
(left["natal"].as_i64(), left["synastry"].as_i64(), left["forecast"].as_i64()),
(Some(2), Some(1), Some(2)),
"{me}"
);
assert_eq!(me["package"]["id"], "couple");
let used = app.get("/v1/admin/promo-codes?status=used", Some(&admin)).await.body;
assert_eq!(used["codes"][0]["redeemed_by"]["email"], "guest@example.com");
// a code fills up: nothing to add while everything is there…
let r = app.post("/v1/admin/promo-codes", Some(&admin), json!({"package": "couple", "count": 1})).await;
let spare = r.body["codes"][0].as_str().unwrap().to_string();
let r = app.post("/v1/promo-codes/redeem", Some(&token), json!({"code": spare})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("promo_nothing_to_add")));
// …used units come back, extra ones stay
sqlx::query(
"INSERT INTO credit_ledger (id, user_id, unit, delta, reason) \
SELECT gen_random_uuid(), id, unit, delta, 'admin_adjust' FROM users, \
(VALUES ('natal', -2), ('forecast', 3)) AS v(unit, delta) WHERE email = 'guest@example.com'",
)
.execute(&pool)
.await
.unwrap();
let r = app.post("/v1/promo-codes/redeem", Some(&token), json!({"code": spare})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_eq!(r.body["added"], json!({"natal": 2}));
let left = &app.get("/v1/me", Some(&token)).await.body["analyses_left"];
assert_eq!(
(left["natal"].as_i64(), left["synastry"].as_i64(), left["forecast"].as_i64()),
(Some(2), Some(1), Some(5))
);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn the_waitlist_confirms_and_can_be_left(pool: PgPool) {
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
let admin = app.register("admin@example.com", "Admin").await;
let from = |ip: &'static str| [("x-forwarded-for", ip)];
// one confirmation per address, even when sent again
for _ in 0..2 {
let r = app
.call_with(
"POST",
"/v1/public/waitlist",
None,
Some(json!({"email": "Wait@Example.com"})),
&from("198.51.100.7"),
)
.await;
assert_eq!(r.status, StatusCode::ACCEPTED);
}
let mails: Vec<(Value,)> = sqlx::query_as(
"SELECT payload FROM email_outbox WHERE to_email = 'wait@example.com' AND template = 'waitlist_joined'",
)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(mails.len(), 1);
let leave = mails[0].0["unsubscribe_post_url"].as_str().unwrap().to_string();
let token = leave.rsplit("token=").next().unwrap().to_string();
// leaving: off the list, and no invitation can be sent there any more
let r = app.call("POST", &format!("/v1/public/invitations/unsubscribe?token={token}"), None, None).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert!(app.get("/v1/admin/invitations", Some(&admin)).await.body["waitlist"].as_array().unwrap().is_empty());
let r = app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["wait@example.com"]})).await;
assert_eq!(r.body["results"][0]["status"], "opted_out");
// and signing up again sends nothing
app.call_with(
"POST",
"/v1/public/waitlist",
None,
Some(json!({"email": "wait@example.com"})),
&from("198.51.100.8"),
)
.await;
let count: i64 = sqlx::query_scalar("SELECT count(*) FROM email_outbox WHERE to_email = 'wait@example.com'")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(count, 1);
// one address cannot flood the form
let mut last = StatusCode::OK;
for i in 0..12 {
let r = app
.call_with(
"POST",
"/v1/public/waitlist",
None,
Some(json!({"email": format!("w{i}@example.com")})),
&from("203.0.113.9"),
)
.await;
last = r.status;
}
assert_eq!(last, StatusCode::TOO_MANY_REQUESTS);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn user_invitations_wait_for_the_launch(pool: PgPool) {
let app = TestApp::with_config(pool, |c| c.user_invites = false).await;
assert_eq!(app.get("/v1/config", None).await.body["user_invites"], false);
let anna = app.register("anna@example.com", "Anna").await;
app.chart(&anna, "Saját", true, "1990-03-15").await;
let r = app.post("/v1/invites", Some(&anna), json!({"label": "Béla"})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("invites_disabled")));
// admins may, to try it
let admin = app.register("admin@example.com", "Admin").await;
app.chart(&admin, "Saját", true, "1980-01-01").await;
assert_eq!(app.post("/v1/invites", Some(&admin), json!({})).await.status, StatusCode::CREATED);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_new_user_from_a_shared_link_earns_an_analysis(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 r = app.post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart["id"]})).await;
let slug = r.body["slug"].as_str().unwrap().to_string();
let natal = |token: String| {
let app = &app;
async move { app.get("/v1/me", Some(&token)).await.body["analyses_left"]["natal"].as_i64().unwrap() }
};
let before = natal(anna.clone()).await;
let join = |email: String| {
let (app, slug) = (&app, slug.clone());
async move {
let r = app
.post(
"/v1/auth/register",
None,
json!({"email": email, "password": "titkos-jelszo-123", "referral": slug}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
r.body["token"].as_str().map(str::to_string).unwrap_or_else(|| {
let cookie = r.headers.get("set-cookie").unwrap().to_str().unwrap();
cookie.split(';').next().unwrap().split('=').nth(1).unwrap().to_string()
})
}
};
// signing up is not enough: the reward comes with their own chart
let bela = join("bela@example.com".into()).await;
assert_eq!(natal(anna.clone()).await, before);
app.chart(&bela, "Saját", true, "1985-08-02").await;
assert_eq!(natal(anna.clone()).await, before + 1);
// a second chart of theirs changes nothing
app.chart(&bela, "Másik", false, "1970-01-01").await;
assert_eq!(natal(anna.clone()).await, before + 1);
// at most three
for i in 0..3 {
let t = join(format!("p{i}@example.com")).await;
app.chart(&t, "Saját", true, "1980-05-05").await;
}
assert_eq!(natal(anna.clone()).await, before + 3);
let me = app.get("/v1/me", Some(&anna)).await.body;
assert_eq!(me["referral_rewards"], json!({"earned": 3, "limit": 3}));
// nothing while the rewards are off
let off = TestApp::with_config(pool, |c| c.referral_rewards = false).await;
let r = off
.post(
"/v1/auth/register",
None,
json!({"email": "late@example.com", "password": "titkos-jelszo-123", "referral": slug}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED);
let count: i64 = sqlx::query_scalar(
"SELECT count(*) FROM referrals r JOIN users u ON u.id = r.user_id WHERE u.email = 'late@example.com'",
)
.fetch_one(&off.pool)
.await
.unwrap();
assert_eq!(count, 0);
}
fn with_stripe(config: &mut Config, key: &str) {
config.stripe = Some(crate::config::StripeConfig {
secret_key: key.into(),
webhook_secret: Some("whsec_fake".into()),
api_url: config.horoscope_api_url.clone(),
});
}
async fn stripe_orders(pool: &PgPool, email: &str) -> Vec<(String, i32)> {
sqlx::query_as(
"SELECT o.package, o.price_huf FROM package_orders o JOIN users u ON u.id = o.user_id \
WHERE u.email = $1 AND o.source = 'stripe' ORDER BY o.created_at",
)
.bind(email)
.fetch_all(pool)
.await
.unwrap()
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
let app = TestApp::with_config(pool, |c| with_stripe(c, "sk_live_fake")).await;
let r = app.get("/v1/config", None).await;
assert_eq!(r.body["payments"], "stripe");
assert_eq!(r.body["payments_test"], false);
// Stripe replaces the stand-in payment.
assert_eq!(r.body["mock_payments"], false);
let anna = app.register("anna@example.com", "Anna").await;
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "couple"})).await;
assert_eq!(r.status, StatusCode::NOT_FOUND);
let r = app.post("/v1/payments/checkout", Some(&anna), json!({"package": "nincs"})).await;
assert_eq!(r.status, StatusCode::NOT_FOUND);
let r = app
.post("/v1/payments/checkout", Some(&anna), json!({"package": "couple", "return_path": "/kepletek/abc?x=1"}))
.await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
let url = r.body["url"].as_str().unwrap();
let id = url.rsplit('/').next().unwrap().to_string();
assert_eq!(stripe_form(&id, "line_items[0][price_data][currency]").as_deref(), Some("huf"));
assert_eq!(stripe_form(&id, "line_items[0][price_data][unit_amount]").as_deref(), Some("600000"));
assert_eq!(
stripe_form(&id, "line_items[0][price_data][product_data][name]").as_deref(),
Some("Sorsfonalak – Páros")
);
assert_eq!(stripe_form(&id, "customer_email").as_deref(), Some("anna@example.com"));
assert_eq!(
stripe_form(&id, "success_url").as_deref(),
Some("https://sorsfonalak.test/kepletek/abc?fizetes={CHECKOUT_SESSION_ID}")
);
// Only paths of this site to come back to.
let r = app
.post("/v1/payments/checkout", Some(&anna), json!({"package": "single", "return_path": "//evil.example/x"}))
.await;
let other = r.body["url"].as_str().unwrap().rsplit('/').next().unwrap().to_string();
assert_eq!(
stripe_form(&other, "cancel_url").as_deref(),
Some("https://sorsfonalak.test/csomagok?fizetes=megszakitva")
);
// Not paid yet: nothing granted.
let r = app.get(&format!("/v1/payments/checkout/{id}"), Some(&anna)).await;
assert_eq!(r.body["status"], "pending", "{}", r.body);
assert!(stripe_orders(&app.pool, "anna@example.com").await.is_empty());
// Someone else's payment is not found.
let bela = app.register("bela@example.com", "Béla").await;
let r = app.get(&format!("/v1/payments/checkout/{id}"), Some(&bela)).await;
assert_eq!(r.status, StatusCode::NOT_FOUND);
// The webhook: a bad signature is refused, a good one grants the package,
// and Stripe's retries do not grant it again.
let event = json!({"id": "evt_1", "type": "checkout.session.completed",
"data": {"object": {"id": id, "payment_status": "paid"}}});
let body = event.to_string();
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let bad = crate::stripe::sign("whsec_other", body.as_bytes(), now);
let r = app
.call_with("POST", "/v1/payments/stripe/webhook", None, Some(event.clone()), &[("stripe-signature", &bad)])
.await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
assert!(stripe_orders(&app.pool, "anna@example.com").await.is_empty());
let good = crate::stripe::sign("whsec_fake", body.as_bytes(), now);
for _ in 0..2 {
let r = app
.call_with("POST", "/v1/payments/stripe/webhook", None, Some(event.clone()), &[("stripe-signature", &good)])
.await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
}
assert_eq!(stripe_orders(&app.pool, "anna@example.com").await, vec![("couple".to_string(), 6000)]);
let r = app.get(&format!("/v1/payments/checkout/{id}"), Some(&anna)).await;
assert_eq!(r.body["status"], "paid");
assert_eq!(r.body["name"], "Páros");
let r = app.get("/v1/me", Some(&anna)).await;
assert_eq!(r.status, StatusCode::OK);
// A session we did not start is ignored.
let stray = json!({"type": "checkout.session.completed", "data": {"object": {"id": "cs_unknown", "payment_status": "paid"}}});
let sig = crate::stripe::sign("whsec_fake", stray.to_string().as_bytes(), now);
let r =
app.call_with("POST", "/v1/payments/stripe/webhook", None, Some(stray), &[("stripe-signature", &sig)]).await;
assert_eq!(r.status, StatusCode::OK);
// Without the webhook (late or not set up) the return page asks Stripe.
stripe_pay(&other);
let r = app.get(&format!("/v1/payments/checkout/{other}"), Some(&anna)).await;
assert_eq!(r.body["status"], "paid", "{}", r.body);
let r = app.get(&format!("/v1/payments/checkout/{other}"), Some(&anna)).await;
assert_eq!(r.body["status"], "paid");
assert_eq!(
stripe_orders(&app.pool, "anna@example.com").await,
vec![("couple".to_string(), 6000), ("single".to_string(), 2000)]
);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn stripe_test_mode_is_for_admins_only(pool: PgPool) {
let app = TestApp::with_config(pool, |c| with_stripe(c, "sk_test_fake")).await;
let r = app.get("/v1/config", None).await;
assert_eq!(r.body["payments"], "stripe");
assert_eq!(r.body["payments_test"], true);
assert_eq!(r.body["payments_admins_only"], true);
let anna = app.register("anna@example.com", "Anna").await;
let r = app.post("/v1/payments/checkout", Some(&anna), json!({"package": "single"})).await;
assert_eq!(r.status, StatusCode::FORBIDDEN);
// The admin gets as far as Stripe (the fake one only knows the live key).
let admin = app.register("admin@example.com", "Admin").await;
let r = app.post("/v1/payments/checkout", Some(&admin), json!({"package": "single"})).await;
assert_eq!(r.body["error"]["code"], "payment_unavailable", "{}", r.body);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn stripe_purchases_wait_for_the_opening(pool: PgPool) {
let app = TestApp::with_config(pool, |c| {
with_stripe(c, "sk_live_fake");
c.purchases_open = false;
})
.await;
let r = app.get("/v1/config", None).await;
assert_eq!((&r.body["payments_test"], &r.body["payments_admins_only"]), (&json!(false), &json!(true)));
let anna = app.register("anna@example.com", "Anna").await;
let r = app.post("/v1/payments/checkout", Some(&anna), json!({"package": "single"})).await;
assert_eq!(r.status, StatusCode::FORBIDDEN);
let admin = app.register("admin@example.com", "Admin").await;
let r = app.post("/v1/payments/checkout", Some(&admin), json!({"package": "single"})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
}