Spaces:
Paused
Paused
Download api/tests/db_operations.rs from stremio-db/a: direct link, hf CLI and curl.
- Browser
- Download file 29.5 kB
-
https://huggingface.co/spaces/stremio-db/a/resolve/main/api/tests/db_operations.rs
- Command line
-
hf download hf://spaces/stremio-db/a/api/tests/db_operations.rs
-
curl -L -o db_operations.rs https://huggingface.co/spaces/stremio-db/a/resolve/main/api/tests/db_operations.rs
29.5 kB
| 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 --- | |
| 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" | |
| ); | |
| } | |
| } | |
| 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(); | |
| } | |
| 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(); | |
| } | |
| 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 --- | |
| 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"); | |
| } | |
| 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 --- | |
| 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 --- | |
| 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()); | |
| } | |
| 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 --- | |
| 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()); | |
| } | |
| 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 --- | |
| 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()); | |
| } | |
| 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"); | |
| } | |
| 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"); | |
| } | |
| 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 --- | |
| 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()); | |
| } | |
| 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"); | |
| } | |
| 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"); | |
| } | |
| 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"); | |
| } | |
| 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); | |
| } | |
| 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); | |
| } | |
| 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 --- | |
| 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); | |
| } | |
| 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" | |
| } | |
| 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 | |
| } | |
| 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); | |
| } | |
| 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 --- | |
| 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); | |
| } | |
| 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); | |
| } | |
| 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); | |
| } | |