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