use axum::{ Router, body::{Body, to_bytes}, http::{Request, StatusCode}, }; use serde_json::{Value, json}; use std::sync::Arc; use tower::ServiceExt; use vnox_hub::{ auth::{self, store}, database, identity::Issuer, web::{self, HubState}, }; const ORIGIN: &str = "https://central.loki-code.dev"; struct Fixture { _dir: tempfile::TempDir, state: Arc, app: Router, } struct Session { user: store::User, token: String, csrf: String, } async fn fixture() -> Fixture { let dir = tempfile::tempdir().unwrap(); #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(dir.path(), std::fs::Permissions::from_mode(0o700)).unwrap(); } let issuer = Issuer::load_or_create(dir.path()).unwrap(); let pool = database::open(dir.path(), &issuer).await.unwrap(); let auth = auth::AuthService::with_provider(pool.clone(), ORIGIN.parse().unwrap(), None); let state = Arc::new(HubState { database: pool, auth: Arc::new(auth), issuer, smtp_configured: false, started: std::time::Instant::now(), }); Fixture { _dir: dir, app: web::router(state.clone()), state, } } impl Fixture { async fn login(&self, email: &str) -> Session { let user = store::upsert_email_identity(&self.state.database, email) .await .unwrap(); let (token, csrf) = store::create_session(&self.state.database, &user.user_id) .await .unwrap(); Session { user, token, csrf } } fn request(&self, s: &Session, body: String) -> Request { Request::builder() .method("POST") .uri("/v1/servers") .header("origin", ORIGIN) .header("content-type", "application/json") .header("cookie", format!("__Host-vnox_session={}", s.token)) .header("x-csrf-token", &s.csrf) .body(Body::from(body)) .unwrap() } async fn send(&self, r: Request) -> (StatusCode, Value) { let r = self.app.clone().oneshot(r).await.unwrap(); assert_eq!(r.headers()["cache-control"], "no-store"); let status = r.status(); ( status, serde_json::from_slice(&to_bytes(r.into_body(), 1048576).await.unwrap()).unwrap(), ) } } #[tokio::test] async fn directory_auth_ownership_normalization_and_persistence() { let f = fixture().await; let owner = f.login("owner@example.org").await; let other = f.login("other@example.org").await; let body = json!({"name":" Voice ","address":"Voice.Example.COM.:07600","description":" public "}) .to_string(); let mut unauth = f.request(&owner, body.clone()); unauth.headers_mut().remove("cookie"); assert_eq!(f.send(unauth).await.0, StatusCode::UNAUTHORIZED); for header in ["origin", "x-csrf-token"] { let mut req = f.request(&owner, body.clone()); req.headers_mut().remove(header); assert_eq!(f.send(req).await.0, StatusCode::FORBIDDEN); } let (status, result) = f.send(f.request(&owner, body.clone())).await; assert_eq!(status, StatusCode::CREATED); assert_eq!(result["server"]["address"], "voice.example.com:7600"); assert_eq!(result["server"]["owner_id"], owner.user.user_id); assert_eq!( f.send(f.request(&owner, body)).await.0, StatusCode::CONFLICT ); let id = result["server"]["id"].as_str().unwrap(); let mut remove = f.request(&other, String::new()); *remove.method_mut() = axum::http::Method::DELETE; *remove.uri_mut() = format!("/v1/servers/{id}").parse().unwrap(); assert_eq!(f.send(remove).await.0, StatusCode::NOT_FOUND); let pool = database::open(f._dir.path(), &f.state.issuer) .await .unwrap(); let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM community_servers") .fetch_one(&pool) .await .unwrap(); assert_eq!(count, 1); let (_, page) = f .send( Request::builder() .uri("/v1/servers") .body(Body::empty()) .unwrap(), ) .await; assert_eq!(page["servers"].as_array().unwrap().len(), 1); sqlx::query("DELETE FROM accounts WHERE user_id=?") .bind(owner.user.user_id) .execute(&pool) .await .unwrap(); let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM community_servers") .fetch_one(&pool) .await .unwrap(); assert_eq!(count, 0); } #[tokio::test] async fn directory_rejects_bad_json_oversize_and_bounds() { let f = fixture().await; let s = f.login("bounds@example.org").await; assert_eq!( f.send(f.request(&s, "{".into())).await.0, StatusCode::BAD_REQUEST ); assert_eq!( f.send(f.request(&s, "x".repeat(4097))).await.0, StatusCode::PAYLOAD_TOO_LARGE ); for body in [ json!({"name":"","address":"voice.example.com:7600","description":""}), json!({"name":"voice","address":"127.0.0.1:7600","description":""}), json!({"name":"voice","address":"voice.example.com:7600","description":"x".repeat(501)}), ] { assert_eq!( f.send(f.request(&s, body.to_string())).await.0, StatusCode::UNPROCESSABLE_ENTITY ); } } #[tokio::test] async fn directory_owner_can_remove_and_rate_budget_is_independent() { let f = fixture().await; let s = f.login("delete@example.org").await; let (_, result) = f .send(f.request( &s, json!({"name":"Voice","address":"voice.example.org:7600","description":""}).to_string(), )) .await; let mut req = f.request(&s, String::new()); *req.method_mut() = axum::http::Method::DELETE; *req.uri_mut() = format!("/v1/servers/{}", result["server"]["id"].as_str().unwrap()) .parse() .unwrap(); let response = f.app.clone().oneshot(req).await.unwrap(); assert_eq!(response.status(), StatusCode::NO_CONTENT); for _ in 0..8 { assert!(f.state.auth.allow_directory(&s.user.user_id, "local")); } assert!(!f.state.auth.allow_directory(&s.user.user_id, "local")); assert!(f.state.auth.allow_avatar(&s.user.user_id, "local")); } #[tokio::test] async fn directory_account_cap_and_pagination_are_bounded() { let f = fixture().await; let s = f.login("cap@example.org").await; for i in 0..105 { sqlx::query("INSERT INTO community_servers(id,name,address,description,owner_id,created_at) VALUES (?,?,?,?,?,?)") .bind(format!("00000000-0000-4000-8000-{i:012}" )).bind("voice").bind(format!("voice{i}.example.org:7600")).bind("").bind(&s.user.user_id).bind(1_i64).execute(&f.state.database).await.unwrap(); } let (status, page) = f .send( Request::builder() .uri("/v1/servers") .body(Body::empty()) .unwrap(), ) .await; assert_eq!(status, StatusCode::OK); assert_eq!(page["servers"].as_array().unwrap().len(), 100); let last = page["servers"][99]["id"].as_str().unwrap(); let (_, next) = f .send( Request::builder() .uri(format!("/v1/servers?after={last}")) .body(Body::empty()) .unwrap(), ) .await; assert_eq!(next["servers"].as_array().unwrap().len(), 5); assert_eq!( f.send(f.request( &s, json!({"name":"voice","address":"new.example.org:7600","description":""}).to_string() )) .await .1["error"], "listing_limit" ); } #[tokio::test] async fn directory_reads_do_not_consume_login_budget() { let f = fixture().await; for _ in 0..20 { assert!(f.state.auth.allow_directory_read("source")); } assert!(!f.state.auth.allow_directory_read("source")); assert!(f.state.auth.allow("source")); }