A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(admin): let voice restriction lists be cleared (#2701)
Hampuscfa20b7093d8
diff --git a/fluxer_admin/src/api/voice.rs b/fluxer_admin/src/api/voice.rsindex d994fb2cf..154a35207 100644--- a/fluxer_admin/src/api/voice.rs+++ b/fluxer_admin/src/api/voice.rs@@ -55,15 +55,13 @@ impl AdminApiClient {params: &serde_json::Value,) -> ApiResult<UpdateVoiceRegionResponse> {let region_id = required_field(params, "id")?;- let body =- serde_json::from_value::<generated_types::UpdateVoiceRegionRequest>(params.clone())- .map_err(|e| ApiError::Parse(e.to_string()))?;- let response = self- .generated()- .update_admin_voice_region(®ion_id, &body)- .await- .map_err(|e| self.generated_error(e))?;- self.generated_value(response.into_inner())+ validate_against::<generated_types::UpdateVoiceRegionRequest>(params)?;+ self.patch_with_reason(+ &format!("/admin/voice/regions/{}", urlencoding::encode(®ion_id)),+ Some(params),+ None,+ )+ .await}pub async fn delete_voice_region(&self, id: &str) -> ApiResult<DeleteVoiceResponse> {@@ -121,15 +119,17 @@ impl AdminApiClient {let region_id = required_field(params, "region_id")?;let server_id = required_field(params, "server_id")?;paired_coordinates(params)?;- let body =- serde_json::from_value::<generated_types::UpdateVoiceServerRequest>(params.clone())- .map_err(|e| ApiError::Parse(e.to_string()))?;- let response = self- .generated()- .update_admin_voice_server(®ion_id, &server_id, &body)- .await- .map_err(|e| self.generated_error(e))?;- self.generated_value(response.into_inner())+ validate_against::<generated_types::UpdateVoiceServerRequest>(params)?;+ self.patch_with_reason(+ &format!(+ "/admin/voice/regions/{}/servers/{}",+ urlencoding::encode(®ion_id),+ urlencoding::encode(&server_id)+ ),+ Some(params),+ None,+ )+ .await}pub async fn delete_voice_server(@@ -150,6 +150,12 @@ fn bool_param(value: bool) -> &'static str {if value { "true" } else { "false" }}+fn validate_against<T: serde::de::DeserializeOwned>(params: &serde_json::Value) -> ApiResult<()> {+ serde_json::from_value::<T>(params.clone())+ .map(drop)+ .map_err(|e| ApiError::Parse(e.to_string()))+}+fn paired_coordinates(params: &serde_json::Value) -> ApiResult<()> {let has_coordinate = |field: &str| params.get(field).is_some_and(|value| !value.is_null());if has_coordinate("latitude") == has_coordinate("longitude") {diff --git a/fluxer_admin/src/routes/voice_actions.rs b/fluxer_admin/src/routes/voice_actions.rsindex 93d5f4c76..55c639e04 100644--- a/fluxer_admin/src/routes/voice_actions.rs+++ b/fluxer_admin/src/routes/voice_actions.rs@@ -49,17 +49,24 @@ pub(crate) fn build_region_body(form: &MultiValueForm) -> serde_json::Value {}body.insert("is_default".into(), form.bool_value("is_default").into());body.insert("vip_only".into(), form.bool_value("vip_only").into());+ insert_submitted_list(&mut body, form, "required_guild_features");+ insert_submitted_list(&mut body, form, "allowed_guild_ids");+ serde_json::Value::Object(body)+}++fn insert_submitted_list(+ body: &mut serde_json::Map<String, serde_json::Value>,+ form: &MultiValueForm,+ field: &str,+) {+ let repeated = format!("{field}[]");+ if !form.contains_key(&repeated) && !form.contains_key(field) {+ return;+ }body.insert(- "required_guild_features".into(),- form.list_values_any(&["required_guild_features[]", "required_guild_features"])- .into(),- );- body.insert(- "allowed_guild_ids".into(),- form.list_values_any(&["allowed_guild_ids[]", "allowed_guild_ids"])- .into(),+ field.to_owned(),+ form.list_values_any(&[repeated.as_str(), field]).into(),);- serde_json::Value::Object(body)}pub(crate) fn build_server_body(form: &MultiValueForm) -> serde_json::Value {@@ -103,16 +110,8 @@ pub(crate) fn build_server_body(form: &MultiValueForm) -> serde_json::Value {}}body.insert("vip_only".into(), form.bool_value("vip_only").into());- body.insert(- "required_guild_features".into(),- form.list_values_any(&["required_guild_features[]", "required_guild_features"])- .into(),- );- body.insert(- "allowed_guild_ids".into(),- form.list_values_any(&["allowed_guild_ids[]", "allowed_guild_ids"])- .into(),- );+ insert_submitted_list(&mut body, form, "required_guild_features");+ insert_submitted_list(&mut body, form, "allowed_guild_ids");serde_json::Value::Object(body)}@@ -265,6 +264,45 @@ mod tests {assert_eq!(body["allowed_guild_ids"], serde_json::json!(["1", "2"]));}+ #[test]+ fn build_server_body_clears_restriction_lists_the_form_submitted_empty() {+ let form = MultiValueForm::parse(+ b"region_id=us-east&server_id=s1&required_guild_features=&allowed_guild_ids=",+ );+ let body = build_server_body(&form);+ assert_eq!(body["required_guild_features"], serde_json::json!([]));+ assert_eq!(body["allowed_guild_ids"], serde_json::json!([]));+ }++ #[test]+ fn build_server_body_leaves_restriction_lists_alone_when_the_form_omits_them() {+ let form = MultiValueForm::parse(+ b"region_id=us-east&server_id=s1&endpoint=wss%3A%2F%2Fvoice.example&is_active=false&vip_only=true",+ );+ let body = build_server_body(&form);+ let object = body.as_object().unwrap();+ assert!(!object.contains_key("required_guild_features"));+ assert!(!object.contains_key("allowed_guild_ids"));+ assert_eq!(body["is_active"], serde_json::json!(false));+ }++ #[test]+ fn build_region_body_clears_restriction_lists_the_form_submitted_empty() {+ let form = MultiValueForm::parse(b"id=us-east&required_guild_features=&allowed_guild_ids=");+ let body = build_region_body(&form);+ assert_eq!(body["required_guild_features"], serde_json::json!([]));+ assert_eq!(body["allowed_guild_ids"], serde_json::json!([]));+ }++ #[test]+ fn build_region_body_leaves_restriction_lists_alone_when_the_form_omits_them() {+ let form = MultiValueForm::parse(b"id=us-east&name=US%20East");+ let body = build_region_body(&form);+ let object = body.as_object().unwrap();+ assert!(!object.contains_key("required_guild_features"));+ assert!(!object.contains_key("allowed_guild_ids"));+ }+#[test]fn build_server_body_sets_soft_connection_limit_from_a_positive_value() {let form =diff --git a/fluxer_admin/tests/voice_restriction_writes.rs b/fluxer_admin/tests/voice_restriction_writes.rsnew file mode 100644index 000000000..6280db981--- /dev/null+++ b/fluxer_admin/tests/voice_restriction_writes.rs@@ -0,0 +1,336 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++use axum::{+ Json, Router,+ body::{Body, to_bytes},+ extract::State,+ http::{Method, Request, StatusCode, Uri, header},+ response::{IntoResponse, Response},+};+use fluxer_admin::{+ build_router,+ config::{AdminConfig, ProxyConfig, RuntimeEnv},+ session,+};+use serde_json::{Value, json};+use std::sync::{Arc, Mutex};+use tokio::net::TcpListener;+use tower::ServiceExt;++const SECRET_KEY: &str = "voice-restriction-writes-test-secret";+const REGION_ID: &str = "europe-north";+const SERVER_ID: &str = "europe-north-server-1";++type CapturedBodies = Arc<Mutex<Vec<(String, Value)>>>;++#[tokio::test]+async fn clearing_the_restriction_fields_reaches_the_api_as_empty_lists() {+ let app = setup().await;+ let csrf_token = csrf_token(&app).await;+ let status = post_form(+ &app,+ "/voice-servers?action=update",+ &format!(+ "_csrf={csrf_token}®ion_id={REGION_ID}&server_id={SERVER_ID}\+ &endpoint=wss%3A%2F%2Fvoice.example.com&is_active=true\+ &required_guild_features=&allowed_guild_ids=&soft_connection_limit="+ ),+ )+ .await;+ assert_eq!(status, StatusCode::SEE_OTHER);++ let body = captured_body(+ &app,+ "PATCH /admin/voice/regions/europe-north/servers/europe-north-server-1",+ );+ assert_eq!(body["required_guild_features"], json!([]));+ assert_eq!(body["allowed_guild_ids"], json!([]));+ assert_eq!(body["soft_connection_limit"], Value::Null);+ assert_eq!(body["vip_only"], json!(false));+}++#[tokio::test]+async fn activating_a_server_leaves_the_restriction_fields_untouched() {+ let app = setup().await;+ let csrf_token = csrf_token(&app).await;+ let status = post_form(+ &app,+ "/voice-servers?action=update",+ &format!(+ "_csrf={csrf_token}®ion_id={REGION_ID}&server_id={SERVER_ID}\+ &endpoint=wss%3A%2F%2Fvoice.example.com&is_active=false&vip_only=true"+ ),+ )+ .await;+ assert_eq!(status, StatusCode::SEE_OTHER);++ let body = captured_body(+ &app,+ "PATCH /admin/voice/regions/europe-north/servers/europe-north-server-1",+ );+ let object = body.as_object().expect("object body");+ assert!(!object.contains_key("required_guild_features"));+ assert!(!object.contains_key("allowed_guild_ids"));+ assert_eq!(body["is_active"], json!(false));+ assert_eq!(body["vip_only"], json!(true));+}++#[tokio::test]+async fn clearing_the_region_restriction_fields_reaches_the_api_as_empty_lists() {+ let app = setup().await;+ let csrf_token = csrf_token(&app).await;+ let status = post_form(+ &app,+ "/voice-regions?action=update",+ &format!(+ "_csrf={csrf_token}&id={REGION_ID}&name=Northern%20Europe&emoji=%F0%9F%87%B8%F0%9F%87%AA\+ &latitude=59.33&longitude=18.06&required_guild_features=&allowed_guild_ids="+ ),+ )+ .await;+ assert_eq!(status, StatusCode::SEE_OTHER);++ let body = captured_body(&app, "PATCH /admin/voice/regions/europe-north");+ assert_eq!(body["required_guild_features"], json!([]));+ assert_eq!(body["allowed_guild_ids"], json!([]));+}++struct TestApp {+ router: Router,+ session_cookie: String,+ captured: CapturedBodies,+}++async fn setup() -> TestApp {+ let captured: CapturedBodies = Arc::new(Mutex::new(Vec::new()));+ let api_endpoint = spawn_mock_api(Arc::clone(&captured)).await;+ let router = build_router(test_config(api_endpoint));+ let session_value = session::create_session("1500000000000000000", "test-token", SECRET_KEY);+ TestApp {+ router,+ session_cookie: format!("{}={session_value}", session::SESSION_COOKIE_NAME),+ captured,+ }+}++fn captured_body(app: &TestApp, route: &str) -> Value {+ let captured = app.captured.lock().expect("captured bodies");+ captured+ .iter()+ .find(|(seen, _)| seen == route)+ .map(|(_, body)| body.clone())+ .unwrap_or_else(|| {+ panic!(+ "no request captured for {route}, saw {:?}",+ captured.iter().map(|(seen, _)| seen).collect::<Vec<_>>()+ )+ })+}++async fn csrf_token(app: &TestApp) -> String {+ let response = app+ .router+ .clone()+ .oneshot(+ Request::builder()+ .method(Method::GET)+ .uri("/voice-regions")+ .header(header::COOKIE, &app.session_cookie)+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();+ assert_eq!(response.status(), StatusCode::OK);+ response+ .headers()+ .get_all(header::SET_COOKIE)+ .iter()+ .filter_map(|value| value.to_str().ok())+ .find_map(|value| {+ let pair = value.split(';').next()?;+ let token = pair+ .strip_prefix("__Host-csrf_token=")+ .or_else(|| pair.strip_prefix("csrf_token="))?;+ (!token.is_empty()).then(|| token.to_owned())+ })+ .expect("csrf_token cookie")+}++async fn post_form(app: &TestApp, uri: &str, body: &str) -> StatusCode {+ let csrf = body+ .split('&')+ .find_map(|pair| pair.strip_prefix("_csrf="))+ .expect("form carries a csrf token");+ let response = app+ .router+ .clone()+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri(uri)+ .header(header::CONTENT_TYPE, "application/x-www-form-urlencoded")+ .header(+ header::COOKIE,+ format!("{}; __Host-csrf_token={csrf}", app.session_cookie),+ )+ .body(Body::from(body.to_owned()))+ .unwrap(),+ )+ .await+ .unwrap();+ response.status()+}++async fn spawn_mock_api(captured: CapturedBodies) -> String {+ let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();+ let addr = listener.local_addr().unwrap();+ tokio::spawn(async move {+ axum::serve(+ listener,+ Router::new().fallback(mock_api).with_state(captured),+ )+ .await+ .unwrap();+ });+ format!("http://{addr}")+}++async fn mock_api(+ State(captured): State<CapturedBodies>,+ method: Method,+ uri: Uri,+ request: Request<Body>,+) -> Response {+ let path = uri.path().to_owned();+ if method == Method::PATCH {+ let bytes = to_bytes(request.into_body(), usize::MAX).await.unwrap();+ let body: Value = serde_json::from_slice(&bytes).unwrap_or(Value::Null);+ captured+ .lock()+ .expect("captured bodies")+ .push((format!("PATCH {path}"), body));+ }+ match (method, path.as_str()) {+ (Method::GET, "/admin/users/@me") => Json(json!({ "user": admin_user() })).into_response(),+ (Method::PATCH, "/admin/voice/regions/europe-north") => {+ Json(json!({ "region": region() })).into_response()+ }+ (Method::PATCH, "/admin/voice/regions/europe-north/servers/europe-north-server-1") => {+ Json(json!({ "server": server() })).into_response()+ }+ (Method::GET, "/admin/voice/regions") => {+ Json(json!({ "regions": [region()] })).into_response()+ }+ _ => (+ StatusCode::NOT_FOUND,+ Json(json!({ "message": "not found" })),+ )+ .into_response(),+ }+}++fn region() -> Value {+ json!({+ "id": REGION_ID,+ "name": "Northern Europe",+ "emoji": "flag",+ "latitude": 59.33,+ "longitude": 18.06,+ "is_default": true,+ "vip_only": false,+ "required_guild_features": [],+ "allowed_guild_ids": [],+ "allowed_user_ids": [],+ "created_at": null,+ "updated_at": null+ })+}++fn server() -> Value {+ json!({+ "region_id": REGION_ID,+ "server_id": SERVER_ID,+ "endpoint": "wss://voice.example.com",+ "latitude": null,+ "longitude": null,+ "is_active": true,+ "soft_connection_limit": null,+ "vip_only": false,+ "required_guild_features": [],+ "allowed_guild_ids": [],+ "allowed_user_ids": [],+ "created_at": null,+ "updated_at": null+ })+}++fn admin_user() -> Value {+ json!({+ "id": "1500000000000000000",+ "username": "AdminUser",+ "discriminator": 1,+ "avatar": null,+ "banner": null,+ "email": "[email protected]",+ "email_verified": true,+ "email_bounced": false,+ "global_name": "AdminUser",+ "bio": null,+ "pronouns": null,+ "accent_color": null,+ "date_of_birth": null,+ "locale": "en-US",+ "acls": ["*"],+ "traits": [],+ "flags": "0",+ "premium_flags": 0,+ "bot": false,+ "system": false,+ "premium_type": null,+ "premium_since": null,+ "premium_until": null,+ "premium_grace_ends_at": null,+ "premium_lifetime_sequence": null,+ "suspicious_activity_flags": 0,+ "phone_verification_deferred": false,+ "has_totp": false,+ "authenticator_types": [],+ "has_verified_phone": false,+ "temp_banned_until": null,+ "pending_deletion_at": null,+ "pending_bulk_message_deletion_at": null,+ "deletion_reason_code": null,+ "deletion_public_reason": null,+ "last_active_at": null,+ "last_active_ip": null,+ "last_active_ip_reverse": null,+ "last_active_location": null+ })+}++fn test_config(api_endpoint: String) -> AdminConfig {+ AdminConfig {+ env: RuntimeEnv::Test,+ host: "127.0.0.1".to_owned(),+ port: 0,+ secret_key_base: SECRET_KEY.to_owned(),+ base_path: String::new(),+ api_endpoint,+ media_endpoint: "https://media.example.test".to_owned(),+ static_cdn_endpoint: "https://static.example.test".to_owned(),+ admin_endpoint: "https://admin.example.test".to_owned(),+ web_app_endpoint: "https://app.example.test".to_owned(),+ kv_url: String::new(),+ oauth_client_id: "admin-client".to_owned(),+ oauth_client_secret: "admin-secret".to_owned(),+ oauth_redirect_uri: "https://admin.example.test/callback".to_owned(),+ build_version: "test".to_owned(),+ release_channel: "test".to_owned(),+ self_hosted: false,+ proxy: ProxyConfig {+ trust_client_ip_header: false,+ client_ip_header_name: "x-forwarded-for".to_owned(),+ },+ }+}diff --git a/fluxer_api/src/api/admin/tests/VoiceAdminController.test.ts b/fluxer_api/src/api/admin/tests/VoiceAdminController.test.tsindex d39c9c4fb..e4d9b0fed 100644--- a/fluxer_api/src/api/admin/tests/VoiceAdminController.test.ts+++ b/fluxer_api/src/api/admin/tests/VoiceAdminController.test.ts@@ -313,6 +313,90 @@ describe('VoiceAdminController', () => {expect(cleared.server.soft_connection_limit).toBeNull();expect((await voiceRepository.getServer(regionId, serverId))?.softConnectionLimit).toBeNull();});+ test('clears voice server restriction lists when empty arrays are supplied', async () => {+ const admin = await createAdminWithAcls(harness, [+ AdminACLs.VOICE_REGION_CREATE,+ AdminACLs.VOICE_SERVER_CREATE,+ AdminACLs.VOICE_SERVER_UPDATE,+ ]);+ const regionId = 'voice-region-clear-restrictions';+ const serverId = 'voice-server-clear-restrictions';+ await createBuilder<CreateVoiceRegionResponse>(harness, `${admin.token}`)+ .post('/admin/voice/regions')+ .body({+ id: regionId,+ name: `Region ${regionId}`,+ emoji: ':earth_americas:',+ latitude: 1,+ longitude: 2,+ })+ .expect(HTTP_STATUS.OK)+ .execute();+ await createBuilder<CreateVoiceServerResponse>(harness, `${admin.token}`)+ .post(`/admin/voice/regions/${regionId}/servers`)+ .body({+ server_id: serverId,+ endpoint: 'https://voice-clear.example.com/socket',+ api_key: 'clear-api-key',+ api_secret: 'clear-api-secret',+ required_guild_features: ['VIP_VOICE'],+ allowed_guild_ids: [1234567890123456789n.toString()],+ })+ .expect(HTTP_STATUS.OK)+ .execute();+ const stored = await voiceRepository.getServer(regionId, serverId);+ expect(Array.from(stored?.restrictions.requiredGuildFeatures ?? [])).toEqual(['VIP_VOICE']);+ expect(stored?.restrictions.allowedGuildIds.size).toBe(1);+ const cleared = await createBuilder<UpdateVoiceServerResponse>(harness, `${admin.token}`)+ .patch(`/admin/voice/regions/${regionId}/servers/${serverId}`)+ .body({required_guild_features: [], allowed_guild_ids: []})+ .expect(HTTP_STATUS.OK)+ .execute();+ expect(cleared.server.required_guild_features).toEqual([]);+ expect(cleared.server.allowed_guild_ids).toEqual([]);+ const persisted = await voiceRepository.getServer(regionId, serverId);+ expect(persisted?.restrictions.requiredGuildFeatures.size).toBe(0);+ expect(persisted?.restrictions.allowedGuildIds.size).toBe(0);+ });+ test('leaves voice server restriction lists unchanged when they are omitted', async () => {+ const admin = await createAdminWithAcls(harness, [+ AdminACLs.VOICE_REGION_CREATE,+ AdminACLs.VOICE_SERVER_CREATE,+ AdminACLs.VOICE_SERVER_UPDATE,+ ]);+ const regionId = 'voice-region-keep-restrictions';+ const serverId = 'voice-server-keep-restrictions';+ await createBuilder<CreateVoiceRegionResponse>(harness, `${admin.token}`)+ .post('/admin/voice/regions')+ .body({+ id: regionId,+ name: `Region ${regionId}`,+ emoji: ':earth_americas:',+ latitude: 1,+ longitude: 2,+ })+ .expect(HTTP_STATUS.OK)+ .execute();+ await createBuilder<CreateVoiceServerResponse>(harness, `${admin.token}`)+ .post(`/admin/voice/regions/${regionId}/servers`)+ .body({+ server_id: serverId,+ endpoint: 'https://voice-keep.example.com/socket',+ api_key: 'keep-api-key',+ api_secret: 'keep-api-secret',+ required_guild_features: ['VIP_VOICE'],+ })+ .expect(HTTP_STATUS.OK)+ .execute();+ await createBuilder<UpdateVoiceServerResponse>(harness, `${admin.token}`)+ .patch(`/admin/voice/regions/${regionId}/servers/${serverId}`)+ .body({is_active: false})+ .expect(HTTP_STATUS.OK)+ .execute();+ const persisted = await voiceRepository.getServer(regionId, serverId);+ expect(Array.from(persisted?.restrictions.requiredGuildFeatures ?? [])).toEqual(['VIP_VOICE']);+ expect(persisted?.isActive).toBe(false);+ });test('rejects a voice server soft connection limit below one', async () => {const admin = await createAdminWithAcls(harness, [AdminACLs.VOICE_REGION_CREATE, AdminACLs.VOICE_SERVER_CREATE]);const regionId = 'voice-region-soft-limit-invalid';