Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use moviebox_tui::models::MediaType;
use moviebox_tui::providers::addons::adapter::{
meta_detail_to_media_details, parse_audio_tracks, parse_codec, parse_quality,
parse_season_episode, stream_item_to_release,
};
use moviebox_tui::providers::addons::models::{
AddonManifest, InstalledAddon, MetaDetail, StreamBehaviorHints, StreamItem,
};
use moviebox_tui::providers::models::parse_size_bytes;
use std::collections::HashMap;
#[test]
fn test_addon_manifest_fixture_deserialization() {
let fixture_content = include_str!("fixtures/addons/manifest.json");
let manifest: AddonManifest = serde_json::from_str(fixture_content)
.expect("failed to deserialize Cinemeta addon manifest");
assert_eq!(manifest.id, "org.stremio.cinemeta");
assert_eq!(manifest.name, "Cinemeta");
assert_eq!(manifest.version.as_deref(), Some("3.0.12"));
assert_eq!(manifest.resources.len(), 3);
assert_eq!(manifest.resources[0].name(), "catalog");
assert_eq!(manifest.resources[1].name(), "meta");
assert_eq!(manifest.resources[2].name(), "stream");
assert_eq!(manifest.catalogs.len(), 2);
assert_eq!(manifest.catalogs[0].r#type, "movie");
assert_eq!(manifest.catalogs[0].id, "top");
assert_eq!(manifest.catalogs[0].name.as_deref(), Some("Popular Movies"));
assert_eq!(manifest.catalogs[0].extra.len(), 1);
assert_eq!(manifest.catalogs[0].extra[0].name, "genre");
assert!(manifest.provides_catalog());
assert!(manifest.provides_meta());
assert!(manifest.provides_stream());
}
#[test]
fn test_addon_series_classification_and_default_season_structure() {
let off_campus_series = MetaDetail {
id: "tt32034988".to_string(),
r#type: "series".to_string(),
name: "Off Campus".to_string(),
title: None,
poster: Some("https://images.metahub.space/poster/medium/tt32034988/img.jpg".to_string()),
cover: None,
background: None,
logo: None,
description: Some("College drama series".to_string()),
overview: None,
synopsis: None,
release_info: Some("2026".to_string()),
year: Some("2026".to_string()),
released: None,
imdb_rating: Some("7.8".to_string()),
rating: None,
genres: vec!["Drama".to_string(), "Romance".to_string()],
genre: vec![],
runtime: Some("45 min".to_string()),
cast: vec![],
stars: vec![],
director: vec![],
directors: vec![],
writer: vec![],
writers: vec![],
videos: vec![],
};
let details = meta_detail_to_media_details(&off_campus_series);
assert_eq!(details.id.value, "series:tt32034988");
assert_eq!(details.title, "Off Campus");
assert_eq!(details.media_type, MediaType::Series);
assert_eq!(details.year.as_deref(), Some("2026"));
assert!(details.seasons.is_empty());
}
#[test]
fn test_addon_season_episode_token_parsing() {
assert_eq!(
parse_season_episode("Off.Campus.S01E08.1080p.mkv"),
Some((1, 8))
);
assert_eq!(
parse_season_episode("Off.Campus.s1e8.720p.mkv"),
Some((1, 8))
);
assert_eq!(
parse_season_episode("Off.Campus.S01.E06.1080p.mkv"),
Some((1, 6))
);
assert_eq!(
parse_season_episode("Off_Campus_S02_E05_HDR.mkv"),
Some((2, 5))
);
assert_eq!(
parse_season_episode("Breaking.Bad.1x02.720p.mkv"),
Some((1, 2))
);
assert_eq!(
parse_season_episode("Stranger Things Season 3 Episode 4"),
Some((3, 4))
);
assert_eq!(
parse_season_episode("Attack on Titan Episode 15 1080p"),
Some((1, 15))
);
assert_eq!(parse_season_episode("Inception 2010 1080p BluRay"), None);
}
#[test]
fn test_addon_episode_stream_filtering_and_isolation() {
let raw_streams = [
StreamItem {
name: Some("HdHub\n1080p".to_string()),
title: Some("Off.Campus.S01E08.1080p.BluRay.x265.mkv\n1.2 GB".to_string()),
description: None,
url: Some("https://cdn.example.com/s01e08_1080p.mp4".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("HdHub\n1080p".to_string()),
title: Some("Off.Campus.S01E06.1080p.BluRay.x265.mkv\n1.1 GB".to_string()),
description: None,
url: Some("https://cdn.example.com/s01e06_1080p.mp4".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("HdHub\n720p".to_string()),
title: Some("Off.Campus.S01E08.720p.HD.mkv\n700 MB".to_string()),
description: None,
url: Some("https://cdn.example.com/s01e08_720p.mp4".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("HdHub\n720p".to_string()),
title: Some("Off.Campus.S01E07.720p.HD.mkv\n680 MB".to_string()),
description: None,
url: Some("https://cdn.example.com/s01e07_720p.mp4".to_string()),
behavior_hints: None,
},
];
let s01e08_releases: Vec<_> = raw_streams
.iter()
.filter_map(|s| stream_item_to_release("HdHub", s, 1, 8))
.collect();
assert_eq!(s01e08_releases.len(), 2);
assert_eq!(
s01e08_releases[0].mirrors[0].resolver_url,
"https://cdn.example.com/s01e08_1080p.mp4"
);
assert_eq!(
s01e08_releases[1].mirrors[0].resolver_url,
"https://cdn.example.com/s01e08_720p.mp4"
);
let s01e06_releases: Vec<_> = raw_streams
.iter()
.filter_map(|s| stream_item_to_release("HdHub", s, 1, 6))
.collect();
assert_eq!(s01e06_releases.len(), 1);
assert_eq!(
s01e06_releases[0].mirrors[0].resolver_url,
"https://cdn.example.com/s01e06_1080p.mp4"
);
let s01e07_releases: Vec<_> = raw_streams
.iter()
.filter_map(|s| stream_item_to_release("HdHub", s, 1, 7))
.collect();
assert_eq!(s01e07_releases.len(), 1);
assert_eq!(
s01e07_releases[0].mirrors[0].resolver_url,
"https://cdn.example.com/s01e07_720p.mp4"
);
}
#[test]
fn test_addon_movie_stream_resolution_remains_unaffected() {
let movie_stream = StreamItem {
name: Some("Cinemeta\n1080p".to_string()),
title: Some("Inception.2010.1080p.BluRay.x264.mkv\n2.4 GB".to_string()),
description: None,
url: Some("https://cdn.example.com/inception_1080p.mp4".to_string()),
behavior_hints: None,
};
let release = stream_item_to_release("Cinemeta", &movie_stream, 0, 0)
.expect("movie release should parse");
assert_eq!(release.quality.as_deref(), Some("1080p"));
assert_eq!(release.season, None);
assert_eq!(release.episode, None);
assert_eq!(
release.mirrors[0].resolver_url,
"https://cdn.example.com/inception_1080p.mp4"
);
}
#[test]
fn test_addon_stream_parsing_and_release_mapping() {
let mut headers = HashMap::new();
headers.insert("User-Agent".to_string(), "Mozilla/5.0 (Custom)".to_string());
headers.insert("Referer".to_string(), "https://hubcloud.club/".to_string());
let stream = StreamItem {
name: Some("HdHub\n1080p".to_string()),
title: Some(
"Breaking.Bad.S01E01.1080p.BluRay.x265.HEVC.Hindi.English-FSL.mkv\n1.15 GB".to_string(),
),
description: None,
url: Some("https://cdn.hubcloud.club/stream/breakingbad_s01e01.mp4".to_string()),
behavior_hints: Some(StreamBehaviorHints {
not_web_ready: false,
headers: Some(headers),
video_size: Some(1_234_567_890),
filename: Some("Breaking.Bad.S01E01.1080p.mkv".to_string()),
}),
};
let release = stream_item_to_release("HdHub", &stream, 1, 1).expect("valid release");
assert_eq!(release.quality.as_deref(), Some("1080p"));
assert_eq!(release.codec.as_deref(), Some("HEVC/x265"));
assert_eq!(release.language.as_deref(), Some("Hindi + English"));
assert_eq!(release.size_bytes, Some(1_234_567_890));
assert_eq!(release.season, Some(1));
assert_eq!(release.episode, Some(1));
let mirror = &release.mirrors[0];
assert_eq!(
mirror.resolver_url,
"https://cdn.hubcloud.club/stream/breakingbad_s01e01.mp4"
);
assert_eq!(mirror.headers.len(), 2);
assert!(
mirror
.headers
.iter()
.any(|(k, v)| k == "Referer" && v == "https://hubcloud.club/")
);
}
#[test]
fn test_addon_token_and_audio_parsers() {
assert_eq!(
parse_quality("Movie.2024.2160p.UHD.HDR"),
Some("2160p".to_string())
);
assert_eq!(parse_quality("Movie.1080p.FHD"), Some("1080p".to_string()));
assert_eq!(parse_quality("Movie.720p.HD"), Some("720p".to_string()));
assert_eq!(parse_quality("Movie.480p.SD"), Some("480p".to_string()));
assert_eq!(
parse_codec("x265 HEVC 10bit"),
Some("HEVC/x265".to_string())
);
assert_eq!(parse_codec("H.264 AVC"), Some("AVC/x264".to_string()));
assert_eq!(parse_codec("Movie AV1 HDR"), Some("AV1".to_string()));
assert_eq!(parse_size_bytes("Size: 1.15 GB"), Some(1_234_803_097));
assert_eq!(parse_size_bytes("File size: 850 MB"), Some(891_289_600));
assert_eq!(
parse_audio_tracks("Hindi + English Dual Audio"),
Some("Hindi + English + Dual Audio".to_string())
);
assert_eq!(
parse_audio_tracks("Japanese Audio [Eng Sub]"),
Some("English + Japanese".to_string())
);
}
#[test]
fn test_installed_addon_cinemeta_protection() {
let cinemeta = InstalledAddon::cinemeta_default();
assert!(cinemeta.is_core());
assert!(cinemeta.enabled);
assert!(cinemeta.provides_catalog);
assert!(cinemeta.provides_meta);
assert!(!cinemeta.provides_stream);
let community_addon = InstalledAddon {
manifest_url: "https://addon.example.com/manifest.json".to_string(),
name: "Community Streams".to_string(),
version: Some("1.0.0".to_string()),
description: Some("Direct HTTP Streams".to_string()),
enabled: true,
provides_catalog: false,
provides_meta: false,
provides_stream: true,
id_prefixes: vec!["tt".to_string()],
types: vec!["movie".to_string(), "series".to_string()],
};
assert!(!community_addon.is_core());
}
#[tokio::test]
async fn test_invalid_addon_manifest_url_shows_actionable_error_and_preserves_state() {
let client = moviebox_tui::providers::addons::client::AddonClient::new();
let err = client
.fetch_manifest("https://invalid-nonexistent-domain.test/manifest.json")
.await
.unwrap_err();
assert!(err.contains("Failed to reach manifest") || err.contains("Manifest returned HTTP"));
let mut app = moviebox_tui::tui::app::App::new();
let initial_addons_count = app.state().installed_addons.len();
app.handle_action(moviebox_tui::tui::action::Action::SetStatus(format!(
"Error: Addon install failed: {err}"
)))
.await;
assert!(!app.state().notifications.is_empty());
let notif = app.state().notifications.back().unwrap();
assert_eq!(notif.kind, moviebox_tui::models::NotificationKind::Error);
assert_eq!(app.state().installed_addons.len(), initial_addons_count);
}
#[test]
fn test_addon_mixed_stream_filtering_and_magnet_rejection() {
let raw_streams = vec![
StreamItem {
name: Some("HTTP 1080p Stream".to_string()),
title: Some("Direct Video Stream".to_string()),
description: None,
url: Some("https://example.test/stream1.mp4".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("HTTP 720p Stream".to_string()),
title: Some("Direct Video Stream".to_string()),
description: None,
url: Some("http://example.test/stream2.mp4".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("Magnet Link".to_string()),
title: Some("Torrent Stream".to_string()),
description: None,
url: Some("magnet:?xt=urn:btih:d08244124e9f0863014f56947ab51404ec102770".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("Local File".to_string()),
title: Some("File Protocol".to_string()),
description: None,
url: Some("file:///etc/passwd".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("FTP Stream".to_string()),
title: Some("FTP Protocol".to_string()),
description: None,
url: Some("ftp://example.test/video.mkv".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("Invalid".to_string()),
title: Some("Invalid URL".to_string()),
description: None,
url: Some("not-a-valid-url-string".to_string()),
behavior_hints: None,
},
StreamItem {
name: Some("Empty".to_string()),
title: Some("Empty URL".to_string()),
description: None,
url: None,
behavior_hints: None,
},
];
let mut accepted_releases = Vec::new();
for stream in &raw_streams {
if let Some(release) = stream_item_to_release("Torrentio", stream, 0, 0) {
accepted_releases.push(release);
}
}
assert_eq!(accepted_releases.len(), 2);
assert_eq!(
accepted_releases[0].mirrors[0].resolver_url,
"https://example.test/stream1.mp4"
);
assert_eq!(
accepted_releases[1].mirrors[0].resolver_url,
"http://example.test/stream2.mp4"
);
}
#[tokio::test]
async fn test_addon_enable_disable_and_removal_lifecycle() {
let mut app = moviebox_tui::tui::app::App::new();
let initial_count = app.state().installed_addons.len();
let custom_manifest = serde_json::json!({
"id": "community.streams.test",
"version": "1.0.0",
"name": "Community Direct Streams",
"description": "Test HTTP streams",
"resources": ["stream"],
"types": ["movie"],
"catalogs": []
});
let manifest: AddonManifest = serde_json::from_value(custom_manifest).unwrap();
let installed =
InstalledAddon::from_manifest("https://example.test/manifest.json".to_string(), &manifest);
app.state_mut().installed_addons.push(installed);
assert_eq!(app.state().installed_addons.len(), initial_count + 1);
let idx = initial_count;
app.handle_action(moviebox_tui::tui::action::Action::AddonToggleEnabled(idx))
.await;
assert!(!app.state().installed_addons[idx].enabled);
app.handle_action(moviebox_tui::tui::action::Action::AddonToggleEnabled(idx))
.await;
assert!(app.state().installed_addons[idx].enabled);
app.handle_action(moviebox_tui::tui::action::Action::AddonRemove(idx))
.await;
assert_eq!(app.state().installed_addons.len(), initial_count);
}