Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use moviebox_tui::providers::ReleaseProvider;
use moviebox_tui::providers::moviebox::client::MovieBoxClient;
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_movie_stream_real_urls() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let releases = client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let mut real_streams_found = 0;
for release in &releases {
if let Some(link) = release.direct_url() {
println!("Movie stream link: {}", link);
assert!(
!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(link),
"Stream URL should NOT be the legacy upgrade notice video: {}",
link
);
assert!(
url::Url::parse(link).is_ok_and(|url| {
url.scheme() == "https"
&& (url.path().ends_with("/index.mpd") || url.path().ends_with(".mp4"))
}),
"Stream URL should be a DASH manifest or recovered MP4 file: {}",
link
);
// Resolving a URL is insufficient: verify the CDN serves media bytes.
let mut request = client.http_client().get(link).header("Range", "bytes=0-31");
for (name, value) in &release.mirrors[0].headers {
request = request.header(name.as_str(), value.as_str());
}
let mut response = request.send().await.expect("request media bytes");
assert!(
response.status().is_success(),
"CDN returned {}",
response.status()
);
let chunk = response
.chunk()
.await
.expect("read media bytes")
.expect("nonempty media");
if url::Url::parse(link).unwrap().path().ends_with(".mp4") {
assert!(
chunk.windows(4).any(|bytes| bytes == b"ftyp"),
"expected an MP4 file header"
);
}
real_streams_found += 1;
}
}
assert!(
real_streams_found > 0,
"Should find at least one real movie stream"
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_series_resolutions_and_streams() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let search_res = client
.search("Breaking Bad", 1)
.await
.expect("search series");
let catalog =
moviebox_tui::providers::moviebox::adapt::moviebox_search_json_to_catalog(&search_res);
assert!(!catalog.is_empty(), "search should return catalog items");
let series = catalog
.iter()
.find(|item| item.media_type == moviebox_tui::providers::models::MediaType::Series)
.unwrap_or(&catalog[0]);
println!(
"Testing live series: {} ({})",
series.title, series.id.value
);
let releases_ep1 = client
.episode_streams(&series.id.value, 1, 1)
.await
.expect("fetch episode 1 streams");
assert!(!releases_ep1.is_empty(), "should find episode 1 streams");
let ep1_url = releases_ep1[0].direct_url().expect("valid direct url");
println!("Resolved S01E01 direct URL: {}", ep1_url);
assert!(!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(ep1_url));
let releases_ep2 = client
.episode_streams(&series.id.value, 1, 2)
.await
.expect("fetch episode 2 streams");
assert!(!releases_ep2.is_empty(), "should find episode 2 streams");
let ep2_url = releases_ep2[0].direct_url().expect("valid direct url");
println!("Resolved S01E02 direct URL: {}", ep2_url);
assert!(!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(ep2_url));
assert_ne!(
ep1_url, ep2_url,
"different episodes must have different manifests"
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_multiple_seasons_and_episodes_return_distinct_streams() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
for (subject_id, series_title, test_cases) in [
(
"6207982430134357800",
"Breaking Bad",
vec![(1, 1), (1, 2), (2, 1), (2, 2), (5, 1)],
),
(
"4585605580068379856",
"One Piece S1-S2",
vec![(1, 1), (1, 2), (2, 1), (2, 2)],
),
] {
println!("\n=== Verifying {} ({}) ===", series_title, subject_id);
let mut urls = Vec::new();
for (season, episode) in test_cases {
let releases = client
.episode_streams(subject_id, season, episode)
.await
.expect("fetch streams");
assert!(
!releases.is_empty(),
"expected streams for {} S{:02}E{:02}",
series_title,
season,
episode
);
let url = releases[0]
.direct_url()
.expect("must have direct url")
.to_string();
println!(
"{} S{:02}E{:02} -> filename: {}, url: {}",
series_title, season, episode, releases[0].filename, url
);
assert_eq!(releases[0].season, Some(season));
assert_eq!(releases[0].episode, Some(episode));
assert!(!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(&url));
urls.push(((season, episode), url));
}
for i in 0..urls.len() {
for j in (i + 1)..urls.len() {
assert_ne!(
urls[i].1, urls[j].1,
"Streams for {} S{:02}E{:02} and S{:02}E{:02} must not be the same! Got identical URL: {}",
series_title, urls[i].0.0, urls[i].0.1, urls[j].0.0, urls[j].0.1, urls[i].1
);
}
}
}
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_inspect_live_mpd_manifest() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let releases = client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let mirror = &releases[0].mirrors[0];
println!("Fetching MPD Manifest from: {}", mirror.resolver_url);
let mut req = client.http_client().get(&mirror.resolver_url);
for (name, val) in &mirror.headers {
req = req.header(name, val);
}
let resp = req.send().await.expect("send mpd request");
let xml = resp.text().await.expect("read mpd xml");
println!(
"=== RAW MPD MANIFEST ===\n{}\n========================",
xml
);
for (target_label, _height_constraint, expected_res) in [
(
"1080p",
"bestvideo[height<=1080]+bestaudio/best",
"1920x1080",
),
("720p", "bestvideo[height<=720]+bestaudio/best", "1280x720"),
("480p", "bestvideo[height<=480]+bestaudio/best", "854x480"),
] {
let mut cmd = moviebox_tui::player::command(
moviebox_tui::player::PlayerKind::Mpv,
&mirror.resolver_url,
None,
&mirror.headers,
None,
None,
None,
Some(if target_label == "1080p" {
1080
} else if target_label == "720p" {
720
} else {
480
}),
);
println!("Generated command: {:?}", cmd);
cmd.arg("--vo=null").arg("--ao=null").arg("--frames=15");
let output = cmd.output().expect("run mpv with quality format");
let out = String::from_utf8_lossy(&output.stdout);
let err = String::from_utf8_lossy(&output.stderr);
let combined = format!("{out}\n{err}");
println!("Quality [{target_label}] output:\n{}", combined);
assert!(
combined.contains(expected_res),
"mpv should select resolution {} for quality {}",
expected_res,
target_label
);
}
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_mpv_end_to_end_playback() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let releases = client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let release = &releases[0];
let mirror = &release.mirrors[0];
println!(
"Testing mpv playback on live manifest: {}",
mirror.resolver_url
);
let mut cmd = moviebox_tui::player::command(
moviebox_tui::player::PlayerKind::Mpv,
&mirror.resolver_url,
None,
&mirror.headers,
None,
None,
None,
None,
);
cmd.arg("--vo=null").arg("--ao=null").arg("--frames=20");
let output = cmd.output().expect("execute mpv command");
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
let combined = format!("{stdout}\n{stderr}");
println!("MPV execution output:\n{}", combined);
assert!(
combined.contains("Video") || combined.contains("hevc"),
"mpv should detect video stream"
);
assert!(
combined.contains("Audio") || combined.contains("aac"),
"mpv should detect audio stream"
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_iina_invocation() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let releases = client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let release = &releases[0];
let mirror = &release.mirrors[0];
let cmd = moviebox_tui::player::command(
moviebox_tui::player::PlayerKind::Iina,
&mirror.resolver_url,
None,
&mirror.headers,
None,
None,
None,
Some(480),
);
let args: Vec<String> = cmd
.get_args()
.map(|a| a.to_string_lossy().into_owned())
.collect();
println!(
"IINA cmd program: {:?}, args: {:?}",
cmd.get_program(),
args
);
assert!(args.iter().any(|a| a.contains("height<=480")));
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_dynamic_movie_mpv_playback() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let search_res = client.search("Avengers", 1).await.expect("search Avengers");
let catalog =
moviebox_tui::providers::moviebox::adapt::moviebox_search_json_to_catalog(&search_res);
assert!(!catalog.is_empty(), "search should return results");
let movie = catalog
.iter()
.find(|item| item.media_type == moviebox_tui::providers::models::MediaType::Movie)
.unwrap_or(&catalog[0]);
println!(
"Testing live dynamic movie: {} ({})",
movie.title, movie.id.value
);
let releases = client
.episode_streams(&movie.id.value, 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let mirror = &releases[0].mirrors[0];
println!("Dynamic movie direct URL: {}", mirror.resolver_url);
let mut cmd = moviebox_tui::player::command(
moviebox_tui::player::PlayerKind::Mpv,
&mirror.resolver_url,
None,
&mirror.headers,
None,
None,
None,
None,
);
cmd.arg("--vo=null").arg("--ao=null").arg("--frames=20");
let output = cmd.output().expect("execute mpv command");
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
let combined = format!("{stdout}\n{stderr}");
println!("MPV execution output:\n{}", combined);
assert!(
combined.contains("Video") || combined.contains("Audio"),
"mpv should successfully decode stream"
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_dash_download_stream_with_headers() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let releases = client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let mirror = &releases[0].mirrors[0];
assert!(
!mirror.headers.is_empty(),
"mirror should contain auth headers"
);
let dest = std::env::temp_dir().join("test_live_moviebox_download.mp4");
let dest_str = dest.to_string_lossy().into_owned();
let part_dest = std::env::temp_dir().join("test_live_moviebox_download.mp4.part");
let _ = std::fs::remove_file(&dest);
let _ = std::fs::remove_file(&part_dest);
let mut cmd = std::process::Command::new("yt-dlp");
for (k, v) in &mirror.headers {
if k.eq_ignore_ascii_case("user-agent") {
cmd.arg("--user-agent").arg(v);
} else {
cmd.arg("--add-header").arg(format!("{k}: {v}"));
}
}
cmd.arg("-f")
.arg("bestvideo+bestaudio/best")
.arg("--newline")
.arg("--part")
.arg("-o")
.arg(&dest_str)
.arg("--force-overwrites")
.arg(&mirror.resolver_url);
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(0x08000000);
}
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().expect("spawn yt-dlp");
let stdout = child.stdout.take().expect("capture stdout");
use std::io::{BufRead, BufReader};
let reader = BufReader::new(stdout);
let mut saw_progress = false;
for l in reader.lines().map_while(Result::ok) {
println!("yt-dlp output: {l}");
if l.contains("[download]") && l.contains('%') {
saw_progress = true;
break;
}
}
let _ = child.kill();
let _ = child.wait();
let _ = std::fs::remove_file(&dest);
let _ = std::fs::remove_file(&part_dest);
assert!(
saw_progress,
"yt-dlp must start downloading MovieBox DASH fragments without 403 Forbidden"
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_download_selected_resolution_verifies_format() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
let releases = client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(
releases.len() >= 2,
"releases must contain multiple resolutions"
);
for expected_h in [480, 720, 1080] {
let format_spec = format!(
"bestvideo[height<={expected_h}]+bestaudio/best[height<={expected_h}]/bestvideo+bestaudio/best"
);
let mirror = &releases[0].mirrors[0];
let mut cmd = std::process::Command::new("yt-dlp");
for (k, v) in &mirror.headers {
if k.eq_ignore_ascii_case("user-agent") {
cmd.arg("--user-agent").arg(v);
} else {
cmd.arg("--add-header").arg(format!("{k}: {v}"));
}
}
cmd.arg("-f")
.arg(&format_spec)
.arg("-s")
.arg("--print")
.arg("%(resolution)s|%(height)s")
.arg(&mirror.resolver_url);
let output = cmd.output().expect("execute yt-dlp simulation");
let stdout = String::from_utf8_lossy(&output.stdout);
eprintln!("yt-dlp format resolution for target {expected_h}p: {stdout}");
let mut selected_height: Option<u64> = None;
for line in stdout.lines() {
let parts: Vec<&str> = line.trim().split('|').collect();
if let Some(h_str) = parts.get(1) {
if let Ok(h) = h_str.parse::<u64>() {
selected_height = Some(h);
break;
}
}
}
let resolved_h = selected_height.expect("yt-dlp must resolve a video height");
assert!(
resolved_h <= expected_h,
"Selected stream height {resolved_h} must not exceed target height {expected_h}"
);
}
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_session_persistence_and_reuse() {
let client1 = MovieBoxClient::new();
let token1 = client1.ensure_session().await.expect("ensure session 1");
assert!(!token1.is_empty(), "token1 should not be empty");
let client2 = MovieBoxClient::new();
let token2 = client2.ensure_session().await.expect("ensure session 2");
assert_eq!(
token1, token2,
"client2 must reuse the persisted valid session token"
);
let search_res = client2
.search("Inception", 1)
.await
.expect("search with client2");
assert!(!search_res.is_null());
client2.invalidate_session();
let token3 = client2
.ensure_session()
.await
.expect("ensure session 3 after invalidation");
assert!(!token3.is_empty(), "token3 should be acquired");
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_fourkhdhub_movie_resolution() {
let client = moviebox_tui::providers::fourkhdhub::FourKHdHubClient::new()
.expect("fourkhdhub client creation");
let items = client.search("Inception").await.expect("search Inception");
assert!(!items.is_empty(), "Inception search should return results");
let target = &items[0];
println!("Found item: {} ({:?})", target.title, target.id);
let releases = client
.releases(&target.id.value, 0, 0)
.await
.expect("fetch movie releases");
assert!(!releases.is_empty(), "releases should not be empty");
for release in &releases {
println!("Attempting resolve for: {}", release.filename);
let start = std::time::Instant::now();
match client
.resolve_release(release, moviebox_tui::providers::ResolutionIntent::Playback)
.await
{
Ok(source) => {
println!(
"Resolved in {:?}: {} [{}]",
start.elapsed(),
source.url,
source.source_label
);
assert!(source.url.starts_with("https://"));
break;
}
Err(e) => {
println!("Failed fast in {:?}: {e}", start.elapsed());
assert!(start.elapsed() < std::time::Duration::from_secs(12));
}
}
}
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_fourkhdhub_game_of_thrones_resolution() {
let client = moviebox_tui::providers::fourkhdhub::FourKHdHubClient::new()
.expect("fourkhdhub client creation");
let items = client
.search("Game of Thrones")
.await
.expect("search Game of Thrones");
assert!(!items.is_empty(), "Game of Thrones search results");
let target = items
.iter()
.find(|item| item.title.to_lowercase().contains("thrones"))
.expect("Game of Thrones entry");
println!("Found series: {} ({:?})", target.title, target.id);
let releases = client
.releases(&target.id.value, 1, 1)
.await
.expect("releases for S01E01");
assert!(!releases.is_empty(), "S01E01 releases found");
for release in &releases {
println!(
"Attempting resolve for S01E01 release: {}",
release.filename
);
let start = std::time::Instant::now();
match client
.resolve_release(release, moviebox_tui::providers::ResolutionIntent::Playback)
.await
{
Ok(source) => {
println!(
"SUCCESS in {:?}: {} [{}]",
start.elapsed(),
source.url,
source.source_label
);
assert!(source.url.starts_with("https://"));
break;
}
Err(e) => {
println!("Failed fast in {:?}: {e}", start.elapsed());
assert!(start.elapsed() < std::time::Duration::from_secs(12));
}
}
}
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_captions_end_to_end() {
let service = moviebox_tui::service::MovieBoxService::new();
service.client.init().await.expect("client init successful");
let releases = service
.client
.episode_streams("4179386086617137184", 0, 0)
.await
.expect("fetch movie streams");
assert!(!releases.is_empty(), "releases should not be empty");
let release = &releases[0];
let resource_id = release
.resource_id
.as_deref()
.expect("moviebox release must include resource_id");
assert!(!resource_id.is_empty());
let sibling_ids = vec!["3264772588333157424".to_string()];
let captions = service
.get_ext_captions("4179386086617137184", resource_id, &sibling_ids, 0, 0)
.await
.expect("fetch captions");
assert!(
captions.len() >= 5,
"should return aggregated subtitles across dub siblings, got {}",
captions.len()
);
assert!(
captions
.iter()
.all(|c| !c.url.is_empty() && !c.url.contains("aa348f2541d13ffe"))
);
assert!(
captions
.iter()
.any(|c| c.name.eq_ignore_ascii_case("English"))
);
assert!(
captions
.iter()
.any(|c| c.name.contains("বাংলা") || c.name.eq_ignore_ascii_case("Bengali"))
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_moviebox_breaking_bad_series_captions_latency() {
let service = moviebox_tui::service::MovieBoxService::new();
service.client.init().await.expect("client init successful");
let subject_id = "6207982430134357800";
let releases = service
.client
.episode_streams(subject_id, 1, 1)
.await
.expect("fetch episode streams");
assert!(!releases.is_empty());
let release = &releases[0];
let resource_id = release
.resource_id
.as_deref()
.expect("must have resource_id");
let sibling_ids = vec![
"1382465867459478920".to_string(),
"9185019261486531816".to_string(),
];
let t0 = std::time::Instant::now();
let captions = service
.get_ext_captions(subject_id, resource_id, &sibling_ids, 1, 1)
.await
.expect("fetch captions");
let elapsed = t0.elapsed();
assert!(
elapsed < std::time::Duration::from_secs(3),
"captions resolution should complete within 3 seconds, took {:.2?}",
elapsed
);
assert!(
captions.len() >= 10,
"should return >= 10 languages for Breaking Bad S1E1, got {}",
captions.len()
);
assert!(
captions
.iter()
.any(|c| c.name.eq_ignore_ascii_case("English")),
"must include English"
);
}
#[tokio::test]
#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
async fn test_live_dramachi_search_details_and_streams() {
let client = moviebox_tui::providers::dramachi::DramachiClient::new();
let items = client
.search("Squid Game", 1)
.await
.expect("dramachi search");
assert!(!items.is_empty());
let details = client
.details(&items[0].id.value)
.await
.expect("dramachi details");
assert!(!details.title.is_empty());
let streams = client
.episode_streams(&items[0].id.value, 1, 1)
.await
.expect("dramachi streams");
assert!(!streams.is_empty());
assert!(streams[0].direct_url().unwrap().starts_with("http"));
}