VNOX-Server/hub/tests/profile.rs
loki5512344 c18ccadf99
chore(server): checkpoint deployed services and unfinished forums
User requested a checkpoint and stopped all agents. Deployed artifacts remain the last verified releases; unfinished settings/categories/forums are preserved as WIP. See TODO/roadmap for verification and remaining release/updater work.
2026-11-01 15:31:20 +01:00

412 lines
13 KiB
Rust

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<HubState>,
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<Body> {
Request::builder()
.method("PUT")
.uri("/v1/account/profile")
.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<Body>) -> (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(), 8192).await.unwrap()).unwrap(),
)
}
async fn update(&self, s: &Session, handle: &str, name: &str) -> (StatusCode, Value) {
self.send(self.request(s, json!({"handle":handle,"display_name":name}).to_string()))
.await
}
}
#[tokio::test]
async fn selection_is_normalized_persisted_and_preserved_by_login() {
let f = fixture().await;
let s = f.login("person@example.org").await;
assert!(!s.user.profile_complete);
let (status, body) = f.update(&s, " Alice_123 ", " Алиса ").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["user"]["handle"], "alice_123");
assert_eq!(body["user"]["display_name"], "Алиса");
assert_eq!(body["user"]["profile_complete"], true);
assert_eq!(body["user"]["user_id"], s.user.user_id);
let again = f.login("person@example.org").await;
assert_eq!(again.user.handle, "alice_123");
assert_eq!(again.user.display_name, "Алиса");
assert!(again.user.profile_complete);
let session = f
.send(
Request::builder()
.uri("/v1/auth/session")
.header("cookie", format!("__Host-vnox_session={}", s.token))
.body(Body::empty())
.unwrap(),
)
.await;
assert_eq!(session.1["user"], body["user"]);
assert_eq!(
f.update(&s, "ALICE_123", "New name").await.0,
StatusCode::OK
);
assert_eq!(
f.update(&again, "other_handle", "Changed").await.1["error"],
"handle_locked"
);
}
#[tokio::test]
async fn case_insensitive_claims_are_atomic_and_leave_loser_unchanged() {
let f = fixture().await;
let a = f.login("a@example.org").await;
let b = f.login("b@example.org").await;
let (left, right) = tokio::join!(
f.update(&a, "Same_Name", "A"),
f.update(&b, "same_name", "B")
);
assert_eq!(
[left.0, right.0]
.iter()
.filter(|s| **s == StatusCode::OK)
.count(),
1
);
let (loser, conflict) = if left.0 == StatusCode::OK {
(&b, right)
} else {
(&a, left)
};
assert_eq!(conflict.0, StatusCode::CONFLICT);
assert_eq!(conflict.1["error"], "handle_taken");
let (user, _) = store::get_session(&f.state.database, &loser.token)
.await
.unwrap()
.unwrap();
assert_eq!(user.handle, loser.user.handle);
assert_eq!(user.display_name, loser.user.display_name);
assert!(!user.profile_complete);
}
#[tokio::test]
async fn concurrent_sessions_cannot_choose_two_handles() {
let f = fixture().await;
let a = f.login("a@example.org").await;
let b = f.login("a@example.org").await;
let (left, right) = tokio::join!(
f.update(&a, "first_name", "A"),
f.update(&b, "second_name", "B")
);
assert_eq!(
[left.0, right.0]
.iter()
.filter(|s| **s == StatusCode::OK)
.count(),
1
);
assert_eq!(
if left.0 == StatusCode::OK {
right.1
} else {
left.1
}["error"],
"handle_locked"
);
}
#[tokio::test]
async fn authorization_and_expiry_precede_body_parsing() {
let f = fixture().await;
let s = f.login("a@example.org").await;
for (header, error) in [
("origin", "invalid_origin"),
("cookie", "not_authenticated"),
("x-csrf-token", "invalid_csrf"),
] {
let mut r = f.request(&s, "invalid JSON".into());
r.headers_mut().remove(header);
assert_eq!(f.send(r).await.1["error"], error);
}
let mut r = f.request(&s, "x".repeat(2048));
r.headers_mut()
.insert("origin", "https://wrong.example".parse().unwrap());
assert_eq!(f.send(r).await.1["error"], "invalid_origin");
sqlx::query("UPDATE web_sessions SET expires_at=0")
.execute(&f.state.database)
.await
.unwrap();
assert_eq!(
f.update(&s, "valid_name", "Name").await.0,
StatusCode::UNAUTHORIZED
);
}
#[tokio::test]
async fn validation_and_body_limits_leave_account_unchanged() {
let f = fixture().await;
for handle in [
"ab",
"1alice",
"алиса",
"with-dash",
"with space",
"u_placeholder",
"ADMIN",
"root",
"everyone",
"abcdefghijklmnopqrstuvwxyz",
] {
let s = f
.login(&format!("{}@example.org", uuid::Uuid::new_v4()))
.await;
assert_eq!(
f.update(&s, handle, "Name").await.1["error"],
"invalid_handle"
);
assert!(
!store::get_session(&f.state.database, &s.token)
.await
.unwrap()
.unwrap()
.0
.profile_complete
);
}
let s = f.login("names@example.org").await;
for name in [
"".to_owned(),
" ".into(),
"n\n".into(),
"x\u{202e}y".into(),
"x\u{2066}y".into(),
"я".repeat(65),
] {
assert_eq!(
f.update(&s, "valid_name", &name).await.1["error"],
"invalid_display_name"
);
}
for body in [
"{}",
"{",
r#"{"handle":"valid_name","display_name":"Name","user_id":"other"}"#,
] {
assert_eq!(
f.send(f.request(&s, body.into())).await.0,
StatusCode::BAD_REQUEST
);
}
let s = f.login("large@example.org").await;
assert_eq!(
f.send(f.request(&s, "x".repeat(1025))).await.0,
StatusCode::PAYLOAD_TOO_LARGE
);
assert_eq!(
f.update(&s, "valid_name", &"я".repeat(64)).await.0,
StatusCode::OK
);
}
#[tokio::test]
async fn budgets_limit_accounts_and_sources_independently() {
let f = fixture().await;
let s = f.login("person@example.org").await;
for _ in 0..10 {
assert_eq!(f.update(&s, "person", "Person").await.0, StatusCode::OK);
}
assert_eq!(
f.update(&s, "person", "Person").await.0,
StatusCode::TOO_MANY_REQUESTS
);
for i in 0..2 {
let s = f.login(&format!("p{i}@example.org")).await;
for _ in 0..10 {
assert_eq!(
f.update(&s, &format!("person{i}"), "Name").await.0,
StatusCode::OK
);
}
}
let s = f.login("last@example.org").await;
assert_eq!(
f.update(&s, "last_person", "Name").await.0,
StatusCode::TOO_MANY_REQUESTS
);
let mut r = f.request(
&s,
json!({"handle":"last_person","display_name":"Name"}).to_string(),
);
r.headers_mut()
.insert("x-forwarded-for", "192.0.2.1".parse().unwrap());
assert_eq!(f.send(r).await.0, StatusCode::OK);
}
#[tokio::test]
async fn github_relogin_preserves_selected_profile_and_own_avatar() {
use vnox_hub::auth::provider::GitHubProfile;
let f = fixture().await;
let mut provider = GitHubProfile {
id: 123,
login: "original".into(),
name: Some("Provider name".into()),
avatar_url: Some("https://avatars.githubusercontent.com/u/123".into()),
};
let user = store::upsert_identity(&f.state.database, &provider)
.await
.unwrap();
let (token, csrf) = store::create_session(&f.state.database, &user.user_id)
.await
.unwrap();
let s = Session { user, token, csrf };
let png = image::RgbImage::new(256, 256);
let mut bytes = std::io::Cursor::new(Vec::new());
png.write_to(&mut bytes, image::ImageFormat::Png).unwrap();
let avatar = vnox_hub::avatar::replace(&f.state.database, &s.user.user_id, bytes.get_ref())
.await
.unwrap();
let (status, body) = f.update(&s, "my_handle", "My name").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["user"]["avatar_url"], avatar);
provider.login = "renamed".into();
provider.name = Some("New provider name".into());
let user = store::upsert_identity(&f.state.database, &provider)
.await
.unwrap();
assert_eq!(user.user_id, s.user.user_id);
assert_eq!(user.handle, "my_handle");
assert_eq!(user.display_name, "My name");
assert_eq!(user.avatar_url.as_deref(), Some(avatar.as_str()));
assert!(user.profile_complete);
}
#[tokio::test]
async fn upgrading_legacy_database_preserves_accounts_bindings_sessions_and_avatars() {
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 migrations = tempfile::tempdir().unwrap();
let source = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("migrations");
for name in [
"0001_foundation.sql",
"0002_github_auth.sql",
"0003_email_auth.sql",
"0004_email_resend_chain.sql",
"0005_avatars.sql",
] {
std::fs::copy(source.join(name), migrations.path().join(name)).unwrap();
}
let options = sqlx::sqlite::SqliteConnectOptions::new()
.filename(dir.path().join("hub.sqlite3"))
.create_if_missing(true)
.foreign_keys(true);
let pool = sqlx::sqlite::SqlitePoolOptions::new()
.max_connections(1)
.connect_with(options)
.await
.unwrap();
sqlx::migrate::Migrator::new(migrations.path())
.await
.unwrap()
.run(&pool)
.await
.unwrap();
sqlx::query("INSERT INTO accounts(user_id,handle,created_at,display_name) VALUES('legacy-id','u_legacy',1,'Legacy')").execute(&pool).await.unwrap();
sqlx::query("INSERT INTO external_identities(provider,subject,user_id,linked_at) VALUES('email','legacy@example.org','legacy-id',1)").execute(&pool).await.unwrap();
let (token, csrf) = store::create_session(&pool, "legacy-id").await.unwrap();
let avatar = vnox_hub::avatar::replace(&pool, "legacy-id", b"stored legacy avatar")
.await
.unwrap();
pool.close().await;
let upgraded = database::open(dir.path(), &issuer).await.unwrap();
let (user, stored_csrf) = store::get_session(&upgraded, &token)
.await
.unwrap()
.unwrap();
assert_eq!(stored_csrf, csrf);
assert_eq!(user.user_id, "legacy-id");
assert_eq!(user.handle, "u_legacy");
assert_eq!(user.display_name, "Legacy");
assert!(!user.profile_complete);
assert_eq!(user.avatar_url.as_deref(), Some(avatar.as_str()));
assert_eq!(
store::upsert_email_identity(&upgraded, "legacy@example.org")
.await
.unwrap()
.user_id,
"legacy-id"
);
// The new index also protects writes outside the HTTP handler.
assert!(
sqlx::query("INSERT INTO accounts(user_id,handle,created_at) VALUES('other','U_LEGACY',1)")
.execute(&upgraded)
.await
.is_err()
);
upgraded.close().await;
let reopened = database::open(dir.path(), &issuer).await.unwrap();
assert!(
store::get_session(&reopened, &token)
.await
.unwrap()
.is_some()
);
}