243 lines
8.9 KiB
Rust
243 lines
8.9 KiB
Rust
//! End-to-end contract test for the card feeder's HTTP surface: boots the real
|
|
//! `serve_feeders` router (card-feeder hosting the TMDB plugin) on an ephemeral
|
|
//! port, pointed at a wiremock TMDB, and drives `/manifest`, `/query` and
|
|
//! `/compute` over HTTP. Deterministic — no live TMDB.
|
|
//!
|
|
//! What this pins is the *card contract* specifically:
|
|
//! - the manifest advertises `fileType=card`, which is the only reason
|
|
//! meta-search routes a `fileType:card` query here;
|
|
//! - a query yields records carrying both type axes plus the whole id bag;
|
|
//! - `/compute` yields a **byte-less** `card_locator` outcome — the shape that
|
|
//! lands in the gateway core's metadata-only auto-store branch.
|
|
|
|
use card_feeder::tmdb::TmdbCardPlugin;
|
|
use meta_feeder_sdk::{
|
|
configure_plugins, router, ComputeRequest, ComputeResponse, GatewayQuery, HashKindDto,
|
|
ManifestResponse, QueryRequest, QueryResponse,
|
|
};
|
|
use wiremock::matchers::{method, path, query_param};
|
|
use wiremock::{Mock, MockServer, ResponseTemplate};
|
|
|
|
/// Spawn the feeder router (TMDB pointed at `upstream`) on an ephemeral port.
|
|
/// The TempDir is returned so the per-plugin cache outlives the test.
|
|
async fn spawn_feeder(upstream: &MockServer) -> (String, tempfile::TempDir) {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let plugin = TmdbCardPlugin::with_api_base("test-token", upstream.uri(), upstream.uri());
|
|
let plugins = configure_plugins(vec![Box::new(plugin)], dir.path()).expect("configure plugins");
|
|
let app = router(plugins, "card-feeder-test".to_string(), dir.path());
|
|
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
|
.await
|
|
.expect("bind ephemeral");
|
|
let addr = listener.local_addr().expect("local_addr");
|
|
tokio::spawn(async move {
|
|
axum::serve(listener, app).await.expect("serve");
|
|
});
|
|
(format!("http://{addr}"), dir)
|
|
}
|
|
|
|
/// `search/multi` → one confident TV hit for "frieren".
|
|
fn multi_json() -> serde_json::Value {
|
|
serde_json::json!({
|
|
"results": [{
|
|
"id": 95479,
|
|
"media_type": "tv",
|
|
"name": "Frieren: Beyond Journey's End",
|
|
"original_name": "\u{845}\u{9001}\u{306e}\u{30d5}\u{30ea}\u{30fc}\u{30ec}\u{30f3}",
|
|
"overview": "The story follows the elf mage Frieren.",
|
|
"poster_path": "/poster.jpg",
|
|
"first_air_date": "2023-09-29",
|
|
"popularity": 300.0,
|
|
"vote_count": 900
|
|
}]
|
|
})
|
|
}
|
|
|
|
fn tv_details_json() -> serde_json::Value {
|
|
serde_json::json!({
|
|
"id": 95479,
|
|
"name": "Frieren: Beyond Journey's End",
|
|
"original_name": "\u{845}\u{9001}\u{306e}\u{30d5}\u{30ea}\u{30fc}\u{30ec}\u{30f3}",
|
|
"original_language": "ja",
|
|
"overview": "The story follows the elf mage Frieren.",
|
|
"first_air_date": "2023-09-29",
|
|
"poster_path": "/poster.jpg",
|
|
"number_of_seasons": 1,
|
|
"seasons": [{"season_number": 1, "episode_count": 28}],
|
|
"alternative_titles": { "results": [{"iso_3166_1": "JP", "title": "Sousou no Frieren"}] }
|
|
})
|
|
}
|
|
|
|
fn external_ids_json() -> serde_json::Value {
|
|
serde_json::json!({ "imdb_id": "tt22248376", "tvdb_id": 367189 })
|
|
}
|
|
|
|
async fn mount_tmdb(upstream: &MockServer) {
|
|
Mock::given(method("GET"))
|
|
.and(path("/search/multi"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(multi_json()))
|
|
.mount(upstream)
|
|
.await;
|
|
Mock::given(method("GET"))
|
|
.and(path("/tv/95479"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(tv_details_json()))
|
|
.mount(upstream)
|
|
.await;
|
|
Mock::given(method("GET"))
|
|
.and(path("/tv/95479/external_ids"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(external_ids_json()))
|
|
.mount(upstream)
|
|
.await;
|
|
}
|
|
|
|
fn card_query(text: &str) -> GatewayQuery {
|
|
let mut q = GatewayQuery::from_free_text(text);
|
|
q.filters
|
|
.insert("fileType".to_string(), vec!["card".to_string()]);
|
|
q
|
|
}
|
|
|
|
/// The routing declaration. `served_file_types = ["card"]` is what makes
|
|
/// meta-search fan a `fileType:card` query out to this gateway at all.
|
|
#[tokio::test]
|
|
async fn manifest_advertises_the_card_file_type() {
|
|
let upstream = MockServer::start().await;
|
|
let (base, _dir) = spawn_feeder(&upstream).await;
|
|
|
|
let manifest: ManifestResponse = reqwest::Client::new()
|
|
.get(format!("{base}/manifest"))
|
|
.send()
|
|
.await
|
|
.expect("GET /manifest")
|
|
.json()
|
|
.await
|
|
.expect("decode manifest");
|
|
|
|
assert_eq!(manifest.plugins.len(), 1);
|
|
let p = &manifest.plugins[0];
|
|
assert_eq!(p.id, "tmdb");
|
|
assert_eq!(p.served_file_types, vec!["card".to_string()]);
|
|
assert_eq!(
|
|
p.served_content_kinds,
|
|
vec!["movie".to_string(), "series".to_string()]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn query_returns_a_card_with_both_axes_and_the_id_bag() {
|
|
let upstream = MockServer::start().await;
|
|
mount_tmdb(&upstream).await;
|
|
let (base, _dir) = spawn_feeder(&upstream).await;
|
|
|
|
let resp: QueryResponse = reqwest::Client::new()
|
|
.post(format!("{base}/query"))
|
|
.json(&QueryRequest {
|
|
upstream_id: "tmdb".to_string(),
|
|
query: card_query("frieren"),
|
|
max_results: 10,
|
|
})
|
|
.send()
|
|
.await
|
|
.expect("POST /query")
|
|
.json()
|
|
.await
|
|
.expect("decode query response");
|
|
|
|
assert_eq!(resp.records.len(), 1, "one confident TMDB hit → one card");
|
|
let f = &resp.records[0].fields;
|
|
assert_eq!(f["fileType"], "card");
|
|
assert_eq!(f["contentKind"], "series");
|
|
assert_eq!(f["title"], "Frieren: Beyond Journey's End");
|
|
// Every name as the language-nested key-set: original (ja), the en-US
|
|
// title, and the JP-market AKA.
|
|
for key in [
|
|
"titles/jpn/\u{845}\u{9001}\u{306e}\u{30d5}\u{30ea}\u{30fc}\u{30ec}\u{30f3}",
|
|
"titles/eng/Frieren: Beyond Journey's End",
|
|
"titles/jpn/Sousou no Frieren",
|
|
] {
|
|
assert_eq!(f.get(key).map(String::as_str), Some("true"), "{key}");
|
|
}
|
|
// The id bag — phase 2 selects from this rather than assuming `tmdbid`.
|
|
assert_eq!(f["tmdbid"], "95479");
|
|
assert_eq!(f["tvdbid"], "367189");
|
|
assert_eq!(f["imdbid"], "tt22248376");
|
|
// Display trio that meta-watch's quality gate requires.
|
|
assert!(f.contains_key("description/eng"));
|
|
assert!(f["poster_url"].contains("poster.jpg"));
|
|
// The record id is the CID preimage.
|
|
assert_eq!(resp.records[0].record_id, "tmdb:tv:95479");
|
|
}
|
|
|
|
/// The core of the design: a card resolves to a locator with **no bytes**.
|
|
/// That `bytes_b64: None` is what routes it to `store_metadata_only` in the
|
|
/// gateway core's three-branch auto-store.
|
|
#[tokio::test]
|
|
async fn compute_returns_a_byteless_card_locator() {
|
|
let upstream = MockServer::start().await;
|
|
mount_tmdb(&upstream).await;
|
|
let (base, _dir) = spawn_feeder(&upstream).await;
|
|
|
|
let resp: ComputeResponse = reqwest::Client::new()
|
|
.post(format!("{base}/compute"))
|
|
.json(&ComputeRequest {
|
|
upstream_id: "tmdb".to_string(),
|
|
record_id: "tmdb:tv:95479".to_string(),
|
|
})
|
|
.send()
|
|
.await
|
|
.expect("POST /compute")
|
|
.json()
|
|
.await
|
|
.expect("decode compute response");
|
|
|
|
assert_eq!(resp.outcomes.len(), 1);
|
|
let o = &resp.outcomes[0];
|
|
assert!(matches!(o.hash_kind, HashKindDto::CardLocator));
|
|
assert!(o.bytes_b64.is_none(), "a card has no bytes, ever");
|
|
assert!(o.file_extension.is_none());
|
|
assert!(o.record.is_some(), "the record IS the payload");
|
|
// Deterministic in (source, id) — any peer derives the same address.
|
|
assert_eq!(
|
|
o.hash,
|
|
meta_feeder_sdk::hash::compute_card_cid("tmdb", "tv:95479").unwrap()
|
|
);
|
|
}
|
|
|
|
/// A card query never reaches an indexer, and a *typed* query for something the
|
|
/// card tier does not serve short-circuits before TMDB is touched at all.
|
|
#[tokio::test]
|
|
async fn a_video_query_does_not_hit_tmdb() {
|
|
let upstream = MockServer::start().await;
|
|
// Deliberately mount nothing: any outbound call would 404 and surface as an
|
|
// empty result, but the assertion below is that we never even get there.
|
|
Mock::given(method("GET"))
|
|
.and(path("/search/multi"))
|
|
.and(query_param("query", "frieren"))
|
|
.respond_with(ResponseTemplate::new(500))
|
|
.expect(0)
|
|
.mount(&upstream)
|
|
.await;
|
|
let (base, _dir) = spawn_feeder(&upstream).await;
|
|
|
|
let mut q = GatewayQuery::from_free_text("frieren");
|
|
q.filters
|
|
.insert("fileType".to_string(), vec!["video".to_string()]);
|
|
|
|
let resp: QueryResponse = reqwest::Client::new()
|
|
.post(format!("{base}/query"))
|
|
.json(&QueryRequest {
|
|
upstream_id: "tmdb".to_string(),
|
|
query: q,
|
|
max_results: 10,
|
|
})
|
|
.send()
|
|
.await
|
|
.expect("POST /query")
|
|
.json()
|
|
.await
|
|
.expect("decode query response");
|
|
|
|
assert!(resp.records.is_empty());
|
|
// `expect(0)` above is asserted on MockServer drop.
|
|
}
|