Spaces:
Paused
Paused
Download api/tests/logo_backdrop.rs from stremio-db/a: direct link, hf CLI and curl.
- Browser
- Download file 19 kB
-
https://huggingface.co/spaces/stremio-db/a/resolve/main/api/tests/logo_backdrop.rs
- Command line
-
hf download hf://spaces/stremio-db/a/api/tests/logo_backdrop.rs
-
curl -L -o logo_backdrop.rs https://huggingface.co/spaces/stremio-db/a/resolve/main/api/tests/logo_backdrop.rs
19 kB
| mod common; | |
| use axum::body::Body; | |
| use axum::http::{Request, StatusCode}; | |
| use http_body_util::BodyExt; | |
| use tower::ServiceExt; | |
| use common::TestAppOptions; | |
| fn json_body(json: serde_json::Value) -> Body { | |
| Body::from(json.to_string()) | |
| } | |
| /// Helper: create an API key and return the raw key string. | |
| async fn create_api_key(app: &axum::Router, token: &str, name: &str) -> String { | |
| let req = Request::builder() | |
| .method("POST") | |
| .uri("/api/keys") | |
| .header("content-type", "application/json") | |
| .header("authorization", format!("Bearer {token}")) | |
| .body(json_body(serde_json::json!({"name": name}))) | |
| .unwrap(); | |
| let res = app.clone().oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::OK); | |
| let body = res.into_body().collect().await.unwrap().to_bytes(); | |
| let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); | |
| json["key"].as_str().unwrap().to_string() | |
| } | |
| /// Helper: enable the free API key setting. | |
| async fn set_free_api_key_enabled(app: &axum::Router, token: &str, enabled: bool) { | |
| let req = Request::builder() | |
| .method("PUT") | |
| .uri("/api/admin/settings") | |
| .header("content-type", "application/json") | |
| .header("authorization", format!("Bearer {token}")) | |
| .body(json_body(serde_json::json!({ | |
| "image_source": "t", | |
| "free_api_key_enabled": enabled | |
| }))) | |
| .unwrap(); | |
| let res = app.clone().oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::OK); | |
| } | |
| // --- Logo endpoint auth --- | |
| async fn logo_endpoint_rejects_invalid_api_key() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let req = Request::builder() | |
| .uri("/bogus-key/imdb/logo-default/tt0000001.png") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn logo_endpoint_accepts_valid_api_key() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-test").await; | |
| // The fanart call will fail (fake key), but should NOT be 401 | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt0000001.png")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED, "valid API key should not return 401"); | |
| } | |
| // --- Backdrop endpoint auth --- | |
| async fn backdrop_endpoint_rejects_invalid_api_key() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let req = Request::builder() | |
| .uri("/bogus-key/imdb/backdrop-default/tt0000001.jpg") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_endpoint_accepts_valid_api_key() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-test").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/backdrop-default/tt0000001.jpg")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED, "valid API key should not return 401"); | |
| } | |
| // --- Free API key on logo/backdrop --- | |
| async fn logo_free_key_rejected_when_disabled() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let req = Request::builder() | |
| .uri("/t0-free-rpdb/imdb/logo-default/tt0111161.png") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn logo_free_key_accepted_when_enabled() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| set_free_api_key_enabled(&app, &token, true).await; | |
| let req = Request::builder() | |
| .uri("/t0-free-rpdb/imdb/logo-default/tt0111161.png") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED, "free key should not return 401 when enabled"); | |
| } | |
| async fn backdrop_free_key_rejected_when_disabled() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let req = Request::builder() | |
| .uri("/t0-free-rpdb/imdb/backdrop-default/tt0111161.jpg") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_free_key_accepted_when_enabled() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| set_free_api_key_enabled(&app, &token, true).await; | |
| let req = Request::builder() | |
| .uri("/t0-free-rpdb/imdb/backdrop-default/tt0111161.jpg") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED, "free key should not return 401 when enabled"); | |
| } | |
| // --- Free key does not track last_used for logo/backdrop --- | |
| async fn logo_free_key_does_not_track_last_used() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| set_free_api_key_enabled(&app, &token, true).await; | |
| let req = Request::builder() | |
| .uri("/t0-free-rpdb/imdb/logo-default/tt0111161.png") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let _res = app.oneshot(req).await.unwrap(); | |
| assert!( | |
| state.pending_last_used.is_empty(), | |
| "free API key should not track last_used for logo" | |
| ); | |
| } | |
| async fn backdrop_free_key_does_not_track_last_used() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| set_free_api_key_enabled(&app, &token, true).await; | |
| let req = Request::builder() | |
| .uri("/t0-free-rpdb/imdb/backdrop-default/tt0111161.jpg") | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let _res = app.oneshot(req).await.unwrap(); | |
| assert!( | |
| state.pending_last_used.is_empty(), | |
| "free API key should not track last_used for backdrop" | |
| ); | |
| } | |
| // --- Logo/backdrop track last_used for regular keys --- | |
| async fn logo_tracks_last_used_for_regular_key() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-track").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt0000001.png")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let _res = app.oneshot(req).await.unwrap(); | |
| assert!( | |
| !state.pending_last_used.is_empty(), | |
| "regular API key should track last_used for logo" | |
| ); | |
| } | |
| async fn backdrop_tracks_last_used_for_regular_key() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-track").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/backdrop-default/tt0000001.jpg")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let _res = app.oneshot(req).await.unwrap(); | |
| assert!( | |
| !state.pending_last_used.is_empty(), | |
| "regular API key should track last_used for backdrop" | |
| ); | |
| } | |
| // --- Fallback param is accepted but has no effect (no placeholder) --- | |
| async fn logo_fallback_returns_error() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-fallback").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt0000001.png?fallback=true")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| // fallback=true is accepted but ignored — should return error, not 200 placeholder | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_fallback_returns_error() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-fallback").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/backdrop-default/tt0000001.jpg?fallback=true")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| // --- Without fallback, errors return non-200 --- | |
| async fn logo_no_fallback_returns_error() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-nofallback").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt0000001.png")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| // Without fallback, should get an error status (not 200, not 401) | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_no_fallback_returns_error() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-nofallback").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/backdrop-default/tt0000001.jpg")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| // --- Negative cache skips fanart but tries TMDB fallback --- | |
| async fn logo_negative_cache_skips_fanart_tries_tmdb() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-neg").await; | |
| // Set fanart as the image source | |
| let req = Request::builder() | |
| .method("PUT") | |
| .uri("/api/admin/settings") | |
| .header("content-type", "application/json") | |
| .header("authorization", format!("Bearer {token}")) | |
| .body(json_body(serde_json::json!({ "image_source": "f" }))) | |
| .unwrap(); | |
| assert_eq!(app.clone().oneshot(req).await.unwrap().status(), StatusCode::OK); | |
| // Pre-populate the negative cache for this ID's logo | |
| // Key format: "{id_type}/{id_value}{kind_prefix}_f_{lang}_neg" | |
| state.fanart_negative.insert("imdb/tt9999999_l_f_en_neg".to_string(), ()).await; | |
| state.fanart_negative.run_pending_tasks().await; | |
| // Fanart is skipped (negative-cached), TMDB is tried as fallback. | |
| // Both fail in test env (fake API keys) so request returns an error. | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt9999999.png")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_negative_cache_skips_fanart_tries_tmdb() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-neg").await; | |
| // Set fanart as the image source | |
| let req = Request::builder() | |
| .method("PUT") | |
| .uri("/api/admin/settings") | |
| .header("content-type", "application/json") | |
| .header("authorization", format!("Bearer {token}")) | |
| .body(json_body(serde_json::json!({ "image_source": "f" }))) | |
| .unwrap(); | |
| assert_eq!(app.clone().oneshot(req).await.unwrap().status(), StatusCode::OK); | |
| // Key format: "{id_type}/{id_value}{kind_prefix}_f_{lang}_neg" (backdrop lang is empty) | |
| state.fanart_negative.insert("imdb/tt9999999_b_f__neg".to_string(), ()).await; | |
| state.fanart_negative.run_pending_tasks().await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/backdrop-default/tt9999999.jpg")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn logo_negative_cache_with_fallback_returns_error() { | |
| let (app, state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-neg-fb").await; | |
| // Set fanart as the image source | |
| let req = Request::builder() | |
| .method("PUT") | |
| .uri("/api/admin/settings") | |
| .header("content-type", "application/json") | |
| .header("authorization", format!("Bearer {token}")) | |
| .body(json_body(serde_json::json!({ "image_source": "f" }))) | |
| .unwrap(); | |
| assert_eq!(app.clone().oneshot(req).await.unwrap().status(), StatusCode::OK); | |
| state.fanart_negative.insert("imdb/tt9999999_l_f_en_neg".to_string(), ()).await; | |
| state.fanart_negative.run_pending_tasks().await; | |
| // fallback=true is accepted but ignored — request still fails | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt9999999.png?fallback=true")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::OK); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| // --- Language override on logo/backdrop --- | |
| async fn logo_with_valid_lang_param_accepted() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-lang").await; | |
| let req = Request::builder() | |
| .uri(format!( | |
| "/{api_key}/imdb/logo-default/tt0000001.png?lang=de" | |
| )) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| // Should not be 400 (bad request) — the lang param is valid. | |
| assert_ne!(res.status(), StatusCode::BAD_REQUEST); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn logo_with_invalid_lang_param_rejected() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-lang-bad").await; | |
| let req = Request::builder() | |
| .uri(format!( | |
| "/{api_key}/imdb/logo-default/tt0000001.png?lang=toolongvalue" | |
| )) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::BAD_REQUEST); | |
| } | |
| async fn backdrop_with_valid_lang_param_accepted() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-lang").await; | |
| let req = Request::builder() | |
| .uri(format!( | |
| "/{api_key}/imdb/backdrop-default/tt0000001.jpg?lang=de" | |
| )) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::BAD_REQUEST); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_with_invalid_lang_param_rejected() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-lang-bad").await; | |
| let req = Request::builder() | |
| .uri(format!( | |
| "/{api_key}/imdb/backdrop-default/tt0000001.jpg?lang=toolongvalue" | |
| )) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::BAD_REQUEST); | |
| } | |
| // --- Invalid id_type returns 400 --- | |
| async fn logo_rejects_invalid_id_type() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-badtype").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/invalid_type/logo-default/tt0000001.png")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::BAD_REQUEST); | |
| } | |
| async fn backdrop_rejects_invalid_id_type() { | |
| let (app, _state) = common::setup_test_app().await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-badtype").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/invalid_type/backdrop-default/tt0000001.jpg")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_eq!(res.status(), StatusCode::BAD_REQUEST); | |
| } | |
| // --- Logos and backdrops work without fanart configured --- | |
| async fn logo_without_fanart_does_not_return_501() { | |
| let (app, _state) = common::setup_test_app_with_options(TestAppOptions { | |
| disable_fanart: true, | |
| ..Default::default() | |
| }) | |
| .await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "logo-no-fanart").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/logo-default/tt0000001.png")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| // Should NOT return 501 (Not Implemented) — fanart is no longer required | |
| assert_ne!(res.status(), StatusCode::NOT_IMPLEMENTED, "logo should not return 501 without fanart"); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |
| async fn backdrop_without_fanart_does_not_return_501() { | |
| let (app, _state) = common::setup_test_app_with_options(TestAppOptions { | |
| disable_fanart: true, | |
| ..Default::default() | |
| }) | |
| .await; | |
| let token = common::setup_admin(&app).await; | |
| let api_key = create_api_key(&app, &token, "backdrop-no-fanart").await; | |
| let req = Request::builder() | |
| .uri(format!("/{api_key}/imdb/backdrop-default/tt0000001.jpg")) | |
| .body(Body::empty()) | |
| .unwrap(); | |
| let res = app.oneshot(req).await.unwrap(); | |
| assert_ne!(res.status(), StatusCode::NOT_IMPLEMENTED, "backdrop should not return 501 without fanart"); | |
| assert_ne!(res.status(), StatusCode::UNAUTHORIZED); | |
| } | |