mod common; use openposterdb_api::services::db::{self, UpsertApiKeySettings}; /// Build a `UpsertApiKeySettings` with sensible defaults for all fields. /// Tests override only the fields they care about via struct update syntax. fn test_upsert(key_id: i32) -> UpsertApiKeySettings<'static> { UpsertApiKeySettings { api_key_id: key_id, image_source: "t", lang: "en", textless: false, ratings_limit: 0, ratings_order: "", poster_position: "bc", logo_ratings_limit: 3, backdrop_ratings_limit: 3, poster_badge_style: "h", logo_badge_style: "h", backdrop_badge_style: "v", poster_label_style: "t", logo_label_style: "t", backdrop_label_style: "t", poster_badge_direction: "d", poster_badge_split: false, poster_fit: "cover", poster_badge_size: "m", logo_badge_size: "m", backdrop_badge_size: "m", backdrop_position: "tr", backdrop_badge_direction: "v", episode_ratings_limit: 2, episode_badge_style: "v", episode_label_style: "o", episode_badge_size: "m", episode_position: "tr", episode_badge_direction: "v", episode_blur: false, ratings_exclude: "", poster_badge_shape: "r", logo_badge_shape: "r", backdrop_badge_shape: "r", episode_badge_shape: "r", poster_badge_background: "d", logo_badge_background: "d", backdrop_badge_background: "d", episode_badge_background: "d", backdrop_edge_inset_x: 0, backdrop_edge_inset_y: 0, } } // --- Batch last_used_at updates --- #[tokio::test] async fn batch_update_last_used_updates_timestamps() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; // Create two API keys let mut key_ids = Vec::new(); for name in ["key-1", "key-2"] { let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from( serde_json::json!({"name": name}).to_string(), )) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); key_ids.push(json["id"].as_i64().unwrap() as i32); } // Verify last_used_at is initially null let keys = db::list_api_keys(&state.db).await.unwrap(); for key in &keys { assert!(key.last_used_at.is_none(), "last_used_at should start null"); } // Run batch update db::batch_update_last_used(&state.db, &key_ids).await.unwrap(); // Verify last_used_at is now set let keys = db::list_api_keys(&state.db).await.unwrap(); for key in &keys { assert!( key.last_used_at.is_some(), "last_used_at should be set after batch update" ); } } #[tokio::test] async fn batch_update_last_used_empty_ids_is_noop() { let (_app, state) = common::setup_test_app().await; // Should succeed without error db::batch_update_last_used(&state.db, &[]).await.unwrap(); } #[tokio::test] async fn batch_update_last_used_nonexistent_ids_succeeds() { let (_app, state) = common::setup_test_app().await; // Should not error even with IDs that don't exist db::batch_update_last_used(&state.db, &[999, 1000, 1001]) .await .unwrap(); } #[tokio::test] async fn batch_update_large_chunk() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; // Create more keys than the chunk size (100) let mut key_ids = Vec::new(); for i in 0..105 { let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from( serde_json::json!({"name": format!("key-{i}")}).to_string(), )) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); key_ids.push(json["id"].as_i64().unwrap() as i32); } // Batch update should handle chunking correctly db::batch_update_last_used(&state.db, &key_ids).await.unwrap(); // Verify all got updated let keys = db::list_api_keys(&state.db).await.unwrap(); let updated_count = keys.iter().filter(|k| k.last_used_at.is_some()).count(); assert_eq!(updated_count, 105); } // --- Delete expired refresh tokens --- #[tokio::test] async fn delete_expired_refresh_tokens_removes_only_expired() { let (_app, state) = common::setup_test_app().await; // Create an admin user directly let user = db::create_admin_user( &state.db, "admin", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000000", ) .await .unwrap(); // Create an expired token db::create_refresh_token(&state.db, user.id, "expired_hash", "2020-01-01 00:00:00") .await .unwrap(); // Create a valid (future) token db::create_refresh_token(&state.db, user.id, "valid_hash", "2099-01-01 00:00:00") .await .unwrap(); // Delete expired let deleted = db::delete_expired_refresh_tokens(&state.db).await.unwrap(); assert_eq!(deleted, 1); // Verify the valid token still exists let remaining = db::find_refresh_token_by_hash(&state.db, "valid_hash") .await .unwrap(); assert!(remaining.is_some(), "valid token should still exist"); // Verify the expired token is gone let gone = db::find_refresh_token_by_hash(&state.db, "expired_hash") .await .unwrap(); assert!(gone.is_none(), "expired token should be deleted"); } #[tokio::test] async fn delete_expired_refresh_tokens_none_expired() { let (_app, state) = common::setup_test_app().await; let deleted = db::delete_expired_refresh_tokens(&state.db).await.unwrap(); assert_eq!(deleted, 0); } // --- API key hash storage --- #[tokio::test] async fn api_key_lookup_by_hash() { let (_app, state) = common::setup_test_app().await; let user = db::create_admin_user( &state.db, "admin", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000000", ) .await .unwrap(); // Create a key with known hash use sha2::{Digest, Sha256}; let raw_key = "test_api_key_value_1234567890abcdef"; let mut hasher = Sha256::new(); hasher.update(raw_key.as_bytes()); let key_hash = format!("{:x}", hasher.finalize()); let key_prefix = &raw_key[..8]; db::create_api_key(&state.db, "test-key", &key_hash, key_prefix, user.id) .await .unwrap(); // Look up by hash let found = db::find_api_key_by_hash(&state.db, &key_hash) .await .unwrap(); assert!(found.is_some()); let found = found.unwrap(); assert_eq!(found.name, "test-key"); assert_eq!(found.key_prefix, key_prefix); // Look up with wrong hash let not_found = db::find_api_key_by_hash(&state.db, "0000000000000000") .await .unwrap(); assert!(not_found.is_none()); } // --- Admin user operations --- #[tokio::test] async fn create_first_admin_prevents_second() { let (_app, state) = common::setup_test_app().await; let result1 = db::create_first_admin_user( &state.db, "admin1", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000000", ) .await; assert!(result1.is_ok()); let result2 = db::create_first_admin_user( &state.db, "admin2", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000001", ) .await; assert!(result2.is_err()); } #[tokio::test] async fn find_admin_by_username_and_id() { let (_app, state) = common::setup_test_app().await; let user = db::create_admin_user( &state.db, "testadmin", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000000", ) .await .unwrap(); // Find by username let found = db::find_admin_user_by_username(&state.db, "testadmin") .await .unwrap(); assert!(found.is_some()); assert_eq!(found.unwrap().id, user.id); // Find by id let found = db::find_admin_user_by_id(&state.db, user.id) .await .unwrap(); assert!(found.is_some()); assert_eq!(found.unwrap().username, "testadmin"); // Not found let not_found = db::find_admin_user_by_username(&state.db, "nobody") .await .unwrap(); assert!(not_found.is_none()); let not_found = db::find_admin_user_by_id(&state.db, 99999) .await .unwrap(); assert!(not_found.is_none()); } // --- Refresh token CRUD --- #[tokio::test] async fn refresh_token_create_find_delete() { let (_app, state) = common::setup_test_app().await; let user = db::create_admin_user( &state.db, "admin", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000000", ) .await .unwrap(); // Create let token = db::create_refresh_token( &state.db, user.id, "test_token_hash", "2099-12-31 23:59:59", ) .await .unwrap(); assert_eq!(token.user_id, user.id); assert_eq!(token.token_hash, "test_token_hash"); // Find let found = db::find_refresh_token_by_hash(&state.db, "test_token_hash") .await .unwrap(); assert!(found.is_some()); assert_eq!(found.unwrap().id, token.id); // Delete db::delete_refresh_token(&state.db, token.id) .await .unwrap(); let gone = db::find_refresh_token_by_hash(&state.db, "test_token_hash") .await .unwrap(); assert!(gone.is_none()); } #[tokio::test] async fn delete_refresh_tokens_for_user_clears_all() { let (_app, state) = common::setup_test_app().await; let user = db::create_admin_user( &state.db, "admin", "$argon2id$v=19$m=19456,t=2,p=1$fakesalt$fakehash000000000000000000000000", ) .await .unwrap(); // Create multiple tokens for i in 0..3 { db::create_refresh_token( &state.db, user.id, &format!("hash_{i}"), "2099-12-31 23:59:59", ) .await .unwrap(); } // Delete all for user db::delete_refresh_tokens_for_user(&state.db, user.id) .await .unwrap(); // All should be gone for i in 0..3 { let found = db::find_refresh_token_by_hash(&state.db, &format!("hash_{i}")) .await .unwrap(); assert!(found.is_none()); } } // --- Global settings --- #[tokio::test] async fn global_settings_empty_by_default() { let (_app, state) = common::setup_test_app().await; let settings = db::get_global_settings(&state.db).await.unwrap(); assert!(settings.is_empty()); } #[tokio::test] async fn set_and_get_global_setting() { let (_app, state) = common::setup_test_app().await; db::set_global_setting(&state.db, "image_source", "f").await.unwrap(); db::set_global_setting(&state.db, "lang", "de").await.unwrap(); let settings = db::get_global_settings(&state.db).await.unwrap(); assert_eq!(settings.get("image_source").unwrap(), "f"); assert_eq!(settings.get("lang").unwrap(), "de"); } #[tokio::test] async fn set_global_setting_upserts() { let (_app, state) = common::setup_test_app().await; db::set_global_setting(&state.db, "image_source", "t").await.unwrap(); db::set_global_setting(&state.db, "image_source", "f").await.unwrap(); let settings = db::get_global_settings(&state.db).await.unwrap(); assert_eq!(settings.get("image_source").unwrap(), "f"); } #[tokio::test] async fn set_global_settings_batch_atomic() { let (_app, state) = common::setup_test_app().await; db::set_global_settings_batch( &state.db, &[ ("image_source", "f"), ("lang", "fr"), ("textless", "true"), ], ) .await .unwrap(); let settings = db::get_global_settings(&state.db).await.unwrap(); assert_eq!(settings.get("image_source").unwrap(), "f"); assert_eq!(settings.get("lang").unwrap(), "fr"); assert_eq!(settings.get("textless").unwrap(), "true"); } // --- Per-key settings --- #[tokio::test] async fn api_key_settings_none_by_default() { let (_app, state) = common::setup_test_app().await; let settings = db::get_api_key_settings(&state.db, 999).await.unwrap(); assert!(settings.is_none()); } #[tokio::test] async fn upsert_and_get_api_key_settings() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; // Create an API key via the API to get a valid id use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { image_source: "f", lang: "ja", textless: true, ..test_upsert(key_id) }).await.unwrap(); let settings = db::get_api_key_settings(&state.db, key_id).await.unwrap(); assert!(settings.is_some()); let s = settings.unwrap(); assert_eq!(s.image_source, "f"); assert_eq!(s.lang, "ja"); assert!(s.textless); assert_eq!(s.ratings_limit, 0); assert_eq!(s.ratings_order, ""); assert_eq!(s.poster_badge_direction, "d"); } #[tokio::test] async fn upsert_api_key_settings_with_ratings() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { ratings_limit: 3, ratings_order: "mal,imdb,trakt", ..test_upsert(key_id) }).await.unwrap(); let s = db::get_api_key_settings(&state.db, key_id).await.unwrap().unwrap(); assert_eq!(s.ratings_limit, 3); assert_eq!(s.ratings_order, "mal,imdb,trakt"); } #[tokio::test] async fn effective_settings_includes_ratings_from_global() { let (_app, state) = common::setup_test_app().await; db::set_global_settings_batch( &state.db, &[ ("image_source", "t"), ("ratings_limit", "4"), ("ratings_order", "imdb,tmdb,rt,rta"), ], ) .await .unwrap(); let s = db::get_effective_render_settings(&state.db, 999, None).await; assert_eq!(s.ratings_limit, 4); assert_eq!(&*s.ratings_order, "imdb,tmdb,rt,rta"); } #[tokio::test] async fn effective_settings_per_key_ratings_override_global() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::set_global_settings_batch( &state.db, &[("ratings_limit", "2"), ("ratings_order", "imdb,tmdb")], ) .await .unwrap(); db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { ratings_limit: 5, ratings_order: "mal,lb", ..test_upsert(key_id) }).await.unwrap(); let s = db::get_effective_render_settings(&state.db, key_id, None).await; assert_eq!(s.ratings_limit, 5); assert_eq!(&*s.ratings_order, "mal,lb"); assert!(!s.is_default); } #[tokio::test] async fn upsert_api_key_settings_overwrites() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, test_upsert(key_id)).await.unwrap(); db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { image_source: "f", lang: "de", textless: true, ..test_upsert(key_id) }).await.unwrap(); let s = db::get_api_key_settings(&state.db, key_id).await.unwrap().unwrap(); assert_eq!(s.image_source, "f"); assert_eq!(s.lang, "de"); assert!(s.textless); } #[tokio::test] async fn delete_api_key_settings_removes() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { image_source: "f", ..test_upsert(key_id) }).await.unwrap(); db::delete_api_key_settings(&state.db, key_id).await.unwrap(); let s = db::get_api_key_settings(&state.db, key_id).await.unwrap(); assert!(s.is_none()); } // --- Effective settings cascade --- #[tokio::test] async fn effective_settings_defaults_when_nothing_configured() { let (_app, state) = common::setup_test_app().await; let s = db::get_effective_render_settings(&state.db, 999, None).await; assert_eq!(s.image_source, db::ImageSource::Tmdb); assert_eq!(&*s.lang, "en"); assert!(!s.textless); assert!(s.is_default); } #[tokio::test] async fn effective_settings_uses_global_when_no_per_key() { let (_app, state) = common::setup_test_app().await; db::set_global_settings_batch( &state.db, &[ ("image_source", "f"), ("lang", "fr"), ("textless", "true"), ], ) .await .unwrap(); let s = db::get_effective_render_settings(&state.db, 999, None).await; assert_eq!(s.image_source, db::ImageSource::Fanart); assert_eq!(&*s.lang, "fr"); assert!(s.textless); assert!(s.is_default); // global settings still marked as "default" } #[tokio::test] async fn effective_settings_per_key_overrides_global() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; // Set global to fanart/fr db::set_global_settings_batch( &state.db, &[("image_source", "f"), ("lang", "fr")], ) .await .unwrap(); // Set per-key to tmdb/ja db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { lang: "ja", textless: true, ..test_upsert(key_id) }).await.unwrap(); let s = db::get_effective_render_settings(&state.db, key_id, None).await; assert_eq!(s.image_source, db::ImageSource::Tmdb); assert_eq!(&*s.lang, "ja"); assert!(s.textless); assert!(!s.is_default); // per-key override } #[tokio::test] async fn upsert_api_key_settings_with_poster_position() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from( serde_json::json!({"name": "pos-test"}).to_string(), )) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { ratings_limit: 3, ratings_order: "imdb,rt", poster_position: "l", logo_ratings_limit: 5, backdrop_ratings_limit: 1, ..test_upsert(key_id) }).await.unwrap(); let settings = db::get_api_key_settings(&state.db, key_id).await.unwrap(); let s = settings.unwrap(); assert_eq!(s.poster_position, "l"); assert_eq!(s.logo_ratings_limit, 5); assert_eq!(s.backdrop_ratings_limit, 1); } #[tokio::test] async fn effective_settings_include_new_fields() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from( serde_json::json!({"name": "eff-test"}).to_string(), )) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; // Without per-key settings, effective should have defaults let s = db::get_effective_render_settings(&state.db, key_id, None).await; assert_eq!(s.poster_position, db::BadgePosition::BottomCenter); assert_eq!(s.logo_ratings_limit, 5); assert_eq!(s.backdrop_ratings_limit, 5); // Set per-key with custom values db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { ratings_limit: 3, poster_position: "r", logo_ratings_limit: 2, backdrop_ratings_limit: 0, ..test_upsert(key_id) }).await.unwrap(); let s = db::get_effective_render_settings(&state.db, key_id, None).await; assert_eq!(s.poster_position, db::BadgePosition::Right); assert_eq!(s.logo_ratings_limit, 2); assert_eq!(s.backdrop_ratings_limit, 0); } // --- Episode settings --- #[tokio::test] async fn upsert_and_get_episode_settings() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "ep-test"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { episode_ratings_limit: 3, episode_badge_style: "h", episode_label_style: "t", episode_badge_size: "xl", episode_position: "bl", episode_badge_direction: "h", episode_blur: true, ..test_upsert(key_id) }).await.unwrap(); let s = db::get_api_key_settings(&state.db, key_id).await.unwrap().unwrap(); assert_eq!(s.episode_ratings_limit, 3); assert_eq!(s.episode_badge_style, "h"); assert_eq!(s.episode_label_style, "t"); assert_eq!(s.episode_badge_size, "xl"); assert_eq!(s.episode_position, "bl"); assert_eq!(s.episode_badge_direction, "h"); assert!(s.episode_blur); } #[tokio::test] async fn effective_settings_episode_defaults() { let (_app, state) = common::setup_test_app().await; let s = db::get_effective_render_settings(&state.db, 999, None).await; assert_eq!(s.episode_ratings_limit, 1); assert_eq!(s.episode_badge_style, db::BadgeStyle::Vertical); assert_eq!(s.episode_label_style, db::LabelStyle::Official); assert_eq!(s.episode_badge_size, db::BadgeSize::Large); assert_eq!(s.episode_position, db::BadgePosition::TopRight); assert_eq!(s.episode_badge_direction, db::BadgeDirection::Vertical); assert!(!s.episode_blur); } #[tokio::test] async fn effective_settings_episode_per_key_overrides() { let (app, state) = common::setup_test_app().await; let token = common::setup_admin(&app).await; use axum::body::Body; use axum::http::Request; use http_body_util::BodyExt; use tower::ServiceExt; let req = Request::builder() .method("POST") .uri("/api/keys") .header("content-type", "application/json") .header("authorization", format!("Bearer {token}")) .body(Body::from(serde_json::json!({"name": "ep-eff"}).to_string())) .unwrap(); let res = app.clone().oneshot(req).await.unwrap(); let body = res.into_body().collect().await.unwrap().to_bytes(); let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); let key_id = json["id"].as_i64().unwrap() as i32; db::upsert_api_key_settings(&state.db, UpsertApiKeySettings { episode_ratings_limit: 4, episode_badge_style: "h", episode_label_style: "i", episode_badge_size: "s", episode_position: "tl", episode_badge_direction: "h", episode_blur: true, ..test_upsert(key_id) }).await.unwrap(); let s = db::get_effective_render_settings(&state.db, key_id, None).await; assert_eq!(s.episode_ratings_limit, 4); assert_eq!(s.episode_badge_style, db::BadgeStyle::Horizontal); assert_eq!(s.episode_label_style, db::LabelStyle::Icon); assert_eq!(s.episode_badge_size, db::BadgeSize::Small); assert_eq!(s.episode_position, db::BadgePosition::TopLeft); assert_eq!(s.episode_badge_direction, db::BadgeDirection::Horizontal); assert!(s.episode_blur); }