Skip to content

Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.

fix(addons): isolate series episode streams and route direct playback headers

Samir Hossains9029a4b04162
diff --git a/src/providers/addons/adapter.rs b/src/providers/addons/adapter.rs
index 6e3bdc6..e99f4cb 100644
--- a/src/providers/addons/adapter.rs
+++ b/src/providers/addons/adapter.rs
@@ -111,7 +111,7 @@ pub fn meta_detail_to_moviebox_json(detail: &MetaDetail) -> serde_json::Value {
eps.sort_unstable();
}
- let seasons_json = season_map
+ let mut seasons_json = season_map
.into_iter()
.map(|(season_num, eps)| {
serde_json::json!({
@@ -122,6 +122,14 @@ pub fn meta_detail_to_moviebox_json(detail: &MetaDetail) -> serde_json::Value {
})
.collect::<Vec<_>>();
+ if is_series && seasons_json.is_empty() {
+ seasons_json = vec![serde_json::json!({
+ "se": 1,
+ "maxEp": 1,
+ "episodeNumbers": vec![1]
+ })];
+ }
+
let year_raw = detail
.release_info
.as_deref()
@@ -375,6 +383,120 @@ pub fn detect_stream_host(
}
}
+pub fn parse_season_episode(text: &str) -> Option<(usize, usize)> {
+ let bytes = text.as_bytes();
+ let len = bytes.len();
+
+ let mut i = 0;
+ while i < len {
+ if (bytes[i] == b'S' || bytes[i] == b's') && i + 1 < len && bytes[i + 1].is_ascii_digit() {
+ if i == 0 || !bytes[i - 1].is_ascii_alphanumeric() {
+ let s_start = i + 1;
+ let mut s_end = s_start;
+ while s_end < len && bytes[s_end].is_ascii_digit() {
+ s_end += 1;
+ }
+ if s_end < len && (s_end - s_start) <= 3 {
+ if let Ok(s_num) = text[s_start..s_end].parse::<usize>() {
+ let mut e_idx = s_end;
+ while e_idx < len
+ && (bytes[e_idx] == b'.'
+ || bytes[e_idx] == b' '
+ || bytes[e_idx] == b'_'
+ || bytes[e_idx] == b'-')
+ {
+ e_idx += 1;
+ }
+ if e_idx < len
+ && (bytes[e_idx] == b'E' || bytes[e_idx] == b'e')
+ && e_idx + 1 < len
+ && bytes[e_idx + 1].is_ascii_digit()
+ {
+ let e_start = e_idx + 1;
+ let mut e_end = e_start;
+ while e_end < len && bytes[e_end].is_ascii_digit() {
+ e_end += 1;
+ }
+ if (e_end - e_start) <= 4 {
+ if let Ok(e_num) = text[e_start..e_end].parse::<usize>() {
+ return Some((s_num, e_num));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (bytes[i] == b'x' || bytes[i] == b'X')
+ && i > 0
+ && bytes[i - 1].is_ascii_digit()
+ && i + 1 < len
+ && bytes[i + 1].is_ascii_digit()
+ {
+ let mut s_start = i - 1;
+ while s_start > 0 && bytes[s_start - 1].is_ascii_digit() {
+ s_start -= 1;
+ }
+ if s_start == 0 || !bytes[s_start - 1].is_ascii_alphanumeric() {
+ let s_str = &text[s_start..i];
+ let mut e_end = i + 1;
+ while e_end < len && bytes[e_end].is_ascii_digit() {
+ e_end += 1;
+ }
+ let e_str = &text[i + 1..e_end];
+ if s_str.len() <= 3 && e_str.len() <= 4 {
+ if let (Ok(s_num), Ok(e_num)) = (s_str.parse::<usize>(), e_str.parse::<usize>())
+ {
+ if s_num > 0 && s_num < 100 && e_num > 0 && e_num < 10000 {
+ return Some((s_num, e_num));
+ }
+ }
+ }
+ }
+ }
+
+ i += 1;
+ }
+
+ let upper = text.to_ascii_uppercase();
+ if let Some(season_pos) = upper.find("SEASON ") {
+ let after_season = &upper[season_pos + 7..];
+ let s_digits: String = after_season
+ .chars()
+ .skip_while(|c| *c == ' ')
+ .take_while(|c| c.is_ascii_digit())
+ .collect();
+ if let Ok(s_num) = s_digits.parse::<usize>() {
+ if let Some(ep_pos) = upper.find("EPISODE ") {
+ let after_ep = &upper[ep_pos + 8..];
+ let e_digits: String = after_ep
+ .chars()
+ .skip_while(|c| *c == ' ')
+ .take_while(|c| c.is_ascii_digit())
+ .collect();
+ if let Ok(e_num) = e_digits.parse::<usize>() {
+ return Some((s_num, e_num));
+ }
+ }
+ }
+ }
+
+ if let Some(ep_pos) = upper.find("EPISODE ") {
+ let after = &upper[ep_pos + 8..];
+ let digits: String = after
+ .chars()
+ .skip_while(|c| *c == ' ')
+ .take_while(|c| c.is_ascii_digit())
+ .collect();
+ if let Ok(e_num) = digits.parse::<usize>() {
+ return Some((1, e_num));
+ }
+ }
+
+ None
+}
+
pub fn stream_item_to_release(
addon_name: &str,
stream: &StreamItem,
@@ -392,6 +514,14 @@ pub fn stream_item_to_release(
let combined_text = format!("{stream_name_str} {title_str} {desc_str}");
+ if season > 0 && episode > 0 {
+ if let Some((stream_s, stream_e)) = parse_season_episode(&combined_text) {
+ if stream_s != season || stream_e != episode {
+ return None;
+ }
+ }
+ }
+
let quality = parse_quality(&combined_text);
let codec = parse_codec(&combined_text);
let language = parse_audio_tracks(&combined_text);
diff --git a/src/service.rs b/src/service.rs
index eeeb492..65cc24f 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -202,16 +202,28 @@ impl MovieBoxService {
.filter(|a| a.enabled && a.provides_meta)
.collect();
- let types_to_try = ["movie", "series", "anime", "tv", "other"];
+ let types_to_try = ["series", "tv", "anime", "movie", "other"];
+ let mut best_detail: Option<crate::providers::addons::models::MetaDetail> = None;
+
for addon in &meta_addons {
let base_url =
crate::providers::addons::AddonClient::base_addon_url(&addon.manifest_url);
for t in types_to_try {
if let Ok(d) = self.addon_client.fetch_meta(&base_url, t, subject_id).await
{
- return Ok(
- crate::providers::addons::adapter::meta_detail_to_moviebox_json(&d),
- );
+ if !d.videos.is_empty()
+ || d.r#type.eq_ignore_ascii_case("series")
+ || d.r#type.eq_ignore_ascii_case("tv")
+ {
+ return Ok(
+ crate::providers::addons::adapter::meta_detail_to_moviebox_json(
+ &d,
+ ),
+ );
+ }
+ if best_detail.is_none() {
+ best_detail = Some(d);
+ }
}
}
}
@@ -229,16 +241,26 @@ impl MovieBoxService {
if let Ok(d) =
self.addon_client.fetch_meta(&base_url, t, subject_id).await
{
- return Ok(
- crate::providers::addons::adapter::meta_detail_to_moviebox_json(
- &d,
- ),
- );
+ if !d.videos.is_empty()
+ || d.r#type.eq_ignore_ascii_case("series")
+ || d.r#type.eq_ignore_ascii_case("tv")
+ {
+ return Ok(
+ crate::providers::addons::adapter::meta_detail_to_moviebox_json(&d),
+ );
+ }
+ if best_detail.is_none() {
+ best_detail = Some(d);
+ }
}
}
}
}
+ if let Some(d) = best_detail {
+ return Ok(crate::providers::addons::adapter::meta_detail_to_moviebox_json(&d));
+ }
+
Err(format!("Could not fetch metadata for ID '{subject_id}'."))
}
}
diff --git a/src/tui/app/download.rs b/src/tui/app/download.rs
index 13675ab..4b46638 100644
--- a/src/tui/app/download.rs
+++ b/src/tui/app/download.rs
@@ -288,7 +288,10 @@ impl App {
return None;
}
self.state.is_resolving_playback = true;
- if self.current_subject_provider() == ProviderKind::FourKHdHub {
+ if self.current_subject_provider() == ProviderKind::FourKHdHub
+ || self.current_subject_provider() == ProviderKind::Addons
+ || self.current_subject_provider().is_bdix()
+ {
if let Some(release) = self.get_selected_release() {
let Some(first_mirror) = release.mirrors.first().cloned() else {
self.state.is_resolving_playback = false;
@@ -304,15 +307,16 @@ impl App {
"Preparing download",
"Resolving the selected mirror.",
);
- let client = if release.provider == ProviderKind::BdixCircleFtp {
+ let client = if release.provider == ProviderKind::Addons
+ || release.provider == ProviderKind::BdixCircleFtp
+ || release.provider == ProviderKind::BdixDhakaFlix
+ {
let sender_clone = self.action_sender.clone();
- let source = crate::providers::models::PlaybackSource::bare(
- ProviderKind::BdixCircleFtp,
- first_mirror.resolver_url.clone(),
- None,
- );
sender_clone
- .send(Action::StartDownload(subtitle_url, Some(source.url)))
+ .send(Action::StartDownload(
+ subtitle_url,
+ Some(first_mirror.resolver_url.clone()),
+ ))
.ok();
return None;
} else {
diff --git a/src/tui/app/playback.rs b/src/tui/app/playback.rs
index 4da2e0c..f00e4b4 100644
--- a/src/tui/app/playback.rs
+++ b/src/tui/app/playback.rs
@@ -295,7 +295,10 @@ impl App {
return None;
}
self.state.is_resolving_playback = true;
- if self.current_subject_provider() == ProviderKind::FourKHdHub {
+ if self.current_subject_provider() == ProviderKind::FourKHdHub
+ || self.current_subject_provider() == ProviderKind::Addons
+ || self.current_subject_provider().is_bdix()
+ {
if let Some(release) = self.get_selected_release() {
let Some(first_mirror) = release.mirrors.first().cloned() else {
self.state.is_resolving_playback = false;
@@ -311,41 +314,27 @@ impl App {
"Preparing playback",
"Resolving the selected mirror.",
);
- let default_player = self.preferred_playback_player(
- &crate::providers::models::PlaybackSource::bare(
- release.provider,
- first_mirror.resolver_url.clone(),
- None,
- ),
- );
+ let direct_source = crate::providers::models::PlaybackSource {
+ provider: release.provider,
+ url: first_mirror.resolver_url.clone(),
+ headers: first_mirror.headers.clone(),
+ subtitle: None,
+ source_label: first_mirror.label.clone(),
+ };
+ let default_player = self.preferred_playback_player(&direct_source);
let available_players = self.state.available_players.clone();
- let client = if release.provider == ProviderKind::Addons {
+ let client = if release.provider == ProviderKind::Addons
+ || release.provider == ProviderKind::BdixCircleFtp
+ || release.provider == ProviderKind::BdixDhakaFlix
+ {
let sender_clone = self.action_sender.clone();
- let source = crate::providers::models::PlaybackSource::bare(
- ProviderKind::Addons,
- first_mirror.resolver_url.clone(),
- None,
- );
if open_with || default_player.is_none() {
- sender_clone.send(Action::ShowPlaybackPicker(source)).ok();
- } else if let Some(player) = default_player {
sender_clone
- .send(Action::LaunchPlayback(player, source))
+ .send(Action::ShowPlaybackPicker(direct_source))
.ok();
- }
- return None;
- } else if release.provider == ProviderKind::BdixCircleFtp {
- let sender_clone = self.action_sender.clone();
- let source = crate::providers::models::PlaybackSource::bare(
- ProviderKind::BdixCircleFtp,
- first_mirror.resolver_url.clone(),
- None,
- );
- if open_with || default_player.is_none() {
- sender_clone.send(Action::ShowPlaybackPicker(source)).ok();
} else if let Some(player) = default_player {
sender_clone
- .send(Action::LaunchPlayback(player, source))
+ .send(Action::LaunchPlayback(player, direct_source))
.ok();
}
return None;
diff --git a/src/tui/app/requests.rs b/src/tui/app/requests.rs
index ccffd58..9e3ae3c 100644
--- a/src/tui/app/requests.rs
+++ b/src/tui/app/requests.rs
@@ -1092,6 +1092,7 @@ impl App {
.get("seasons")
.and_then(|s| s.get("seasons"))
.and_then(|s| s.as_array())
+ .filter(|a| !a.is_empty())
{
self.state.available_seasons = seasons_arr.clone();
} else if stype == 2 {
@@ -1120,6 +1121,12 @@ impl App {
.split(',')
.filter_map(|s| s.trim().parse().ok())
.collect()
+ } else if let Some(arr) =
+ season.get("episodeNumbers").and_then(|e| e.as_array())
+ {
+ arr.iter()
+ .filter_map(|v| v.as_u64().map(|n| n as usize))
+ .collect()
} else {
let max_ep =
season.get("maxEp").and_then(|m| m.as_i64()).unwrap_or(1) as usize;
@@ -1862,6 +1869,9 @@ impl App {
if target_se == 0 && target_ep == 0 {
se = 0;
ep = 0;
+ } else if se == 0 && ep == 0 {
+ se = target_se;
+ ep = target_ep;
}
let entry = pool.episode_index.entry((se, ep)).or_insert_with(Vec::new);
diff --git a/tests/addons_manifest.rs b/tests/addons_manifest.rs
index b8f9594..6994724 100644
--- a/tests/addons_manifest.rs
+++ b/tests/addons_manifest.rs
@@ -1,4 +1,11 @@
-use moviebox_tui::providers::addons::models::AddonManifest;
+use moviebox_tui::providers::addons::adapter::{
+ meta_detail_to_moviebox_json, metas_to_moviebox_search_json, parse_audio_tracks, parse_codec,
+ parse_quality, parse_season_episode, parse_size_bytes_from_text, stream_item_to_release,
+};
+use moviebox_tui::providers::addons::models::{
+ AddonManifest, InstalledAddon, MetaDetail, MetaItem, MetaVideo, StreamBehaviorHints, StreamItem,
+};
+use std::collections::HashMap;
#[test]
fn test_addon_manifest_fixture_deserialization() {
@@ -20,4 +27,402 @@ fn test_addon_manifest_fixture_deserialization() {
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_meta_item_and_search_mapping() {
+ let meta_item = MetaItem {
+ id: "tt0111161".to_string(),
+ r#type: "movie".to_string(),
+ name: "The Shawshank Redemption".to_string(),
+ title: None,
+ poster: Some("https://images.metahub.space/poster/medium/tt0111161/img.jpg".to_string()),
+ cover: None,
+ description: Some("Two imprisoned men bond over a number of years...".to_string()),
+ overview: None,
+ synopsis: None,
+ release_info: Some("1994".to_string()),
+ year: None,
+ released: None,
+ imdb_rating: Some("9.3".to_string()),
+ rating: None,
+ genres: vec!["Drama".to_string(), "Crime".to_string()],
+ genre: vec![],
+ };
+
+ let search_json = metas_to_moviebox_search_json(vec![meta_item]);
+ let subjects = search_json["results"][0]["subjects"]
+ .as_array()
+ .expect("subjects array");
+ assert_eq!(subjects.len(), 1);
+ let subject = &subjects[0];
+ assert_eq!(subject["subjectId"], "tt0111161");
+ assert_eq!(subject["title"], "The Shawshank Redemption");
+ assert_eq!(subject["subjectType"], 1);
+ assert_eq!(subject["releaseDate"], "1994");
+ assert_eq!(subject["imdbRatingValue"], "9.3");
+ assert_eq!(
+ subject["cover"]["url"],
+ "https://images.metahub.space/poster/medium/tt0111161/img.jpg"
+ );
+}
+
+#[test]
+fn test_addon_series_metadata_and_episodes_decomposition() {
+ let series_detail = MetaDetail {
+ id: "tt0903747".to_string(),
+ r#type: "series".to_string(),
+ name: "Breaking Bad".to_string(),
+ title: None,
+ poster: Some("https://images.metahub.space/poster/medium/tt0903747/img.jpg".to_string()),
+ cover: None,
+ background: None,
+ logo: None,
+ description: Some(
+ "A chemistry teacher diagnosed with inoperable lung cancer...".to_string(),
+ ),
+ overview: None,
+ synopsis: None,
+ release_info: Some("2008-2013".to_string()),
+ year: Some("2008".to_string()),
+ released: None,
+ imdb_rating: Some("9.5".to_string()),
+ rating: None,
+ genres: vec![
+ "Crime".to_string(),
+ "Drama".to_string(),
+ "Thriller".to_string(),
+ ],
+ genre: vec![],
+ runtime: Some("49 min".to_string()),
+ cast: vec!["Bryan Cranston".to_string(), "Aaron Paul".to_string()],
+ director: vec!["Vince Gilligan".to_string()],
+ videos: vec![
+ MetaVideo {
+ id: Some("tt0903747:1:1".to_string()),
+ title: Some("Pilot".to_string()),
+ name: None,
+ season: Some(1),
+ episode: Some(1),
+ number: None,
+ released: Some("2008-01-20".to_string()),
+ thumbnail: None,
+ },
+ MetaVideo {
+ id: Some("tt0903747:1:2".to_string()),
+ title: Some("Cat's in the Bag...".to_string()),
+ name: None,
+ season: Some(1),
+ episode: Some(2),
+ number: None,
+ released: Some("2008-01-27".to_string()),
+ thumbnail: None,
+ },
+ MetaVideo {
+ id: Some("tt0903747:2:1".to_string()),
+ title: Some("Seven Thirty-Seven".to_string()),
+ name: None,
+ season: Some(2),
+ episode: Some(1),
+ number: None,
+ released: Some("2009-03-08".to_string()),
+ thumbnail: None,
+ },
+ ],
+ };
+
+ let mb_json = meta_detail_to_moviebox_json(&series_detail);
+ assert_eq!(mb_json["id"], "tt0903747");
+ assert_eq!(mb_json["subjectType"], 2);
+ assert_eq!(mb_json["releaseDate"], "2008");
+ assert_eq!(mb_json["imdbRatingValue"], "9.5");
+ assert_eq!(mb_json["duration"], "49 min");
+ assert_eq!(mb_json["stars"], "Bryan Cranston, Aaron Paul");
+ assert_eq!(mb_json["director"], "Vince Gilligan");
+
+ let seasons = mb_json["seasons"]["seasons"]
+ .as_array()
+ .expect("seasons array");
+ assert_eq!(seasons.len(), 2);
+ assert_eq!(seasons[0]["se"], 1);
+ assert_eq!(seasons[0]["maxEp"], 2);
+ assert_eq!(seasons[0]["episodeNumbers"], serde_json::json!([1, 2]));
+
+ assert_eq!(seasons[1]["se"], 2);
+ assert_eq!(seasons[1]["maxEp"], 1);
+ assert_eq!(seasons[1]["episodeNumbers"], serde_json::json!([1]));
+}
+
+#[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![],
+ director: vec![],
+ videos: vec![], // Empty videos array from metadata provider
+ };
+
+ let mb_json = meta_detail_to_moviebox_json(&off_campus_series);
+ assert_eq!(mb_json["id"], "tt32034988");
+ assert_eq!(mb_json["title"], "Off Campus");
+ assert_eq!(mb_json["subjectType"], 2); // Identified as Series, not Movie!
+ assert_eq!(mb_json["releaseDate"], "2026");
+
+ let seasons = mb_json["seasons"]["seasons"]
+ .as_array()
+ .expect("seasons array");
+ assert_eq!(seasons.len(), 1);
+ assert_eq!(seasons[0]["se"], 1);
+ assert_eq!(seasons[0]["maxEp"], 1);
+ assert_eq!(seasons[0]["episodeNumbers"], serde_json::json!([1]));
+}
+
+#[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,
+ },
+ ];
+
+ // Requesting S01E08: Must only return streams for S01E08!
+ 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"
+ );
+
+ // Requesting S01E06: Must only return streams for S01E06!
+ 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"
+ );
+
+ // Requesting S01E07: Must only return streams for S01E07!
+ 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_from_text("Size: 1.15 GB"),
+ Some(1_234_803_097)
+ );
+ assert_eq!(
+ parse_size_bytes_from_text("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());
}