Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use moviebox_tui::{
models::SearchResult,
providers::models::{
CatalogItem, Episode, MediaDetails, MediaType, ProviderKind, ProviderMediaId,
RequestContext, Season,
},
tui::{
action::Action,
app::App,
state::{AppMode, InputMode, Screen},
},
};
#[tokio::test]
async fn test_stale_details_response_protection() {
let mut app = App::new();
app.state_mut().update_available = None;
app.state_mut().active_provider = ProviderKind::MovieBox;
app.state_mut().active_screen = Screen::Details;
let context_a = RequestContext {
provider: ProviderKind::MovieBox,
generation: app.state().provider_generation,
};
app.state_mut().active_details_request = 1;
app.state_mut().active_subject_id = Some("movie_a".to_string());
app.state_mut().selected_details = Some(MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "movie_a".to_string(),
},
title: "Movie A".to_string(),
media_type: MediaType::Movie,
year: None,
description: None,
tagline: None,
imdb_rating: None,
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
});
let context_b = RequestContext {
provider: ProviderKind::MovieBox,
generation: app.state().provider_generation,
};
app.state_mut().active_details_request = 2;
app.state_mut().active_subject_id = Some("movie_b".to_string());
app.state_mut().selected_details = Some(MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "movie_b".to_string(),
},
title: "Movie B Draft".to_string(),
media_type: MediaType::Movie,
year: None,
description: None,
tagline: None,
imdb_rating: None,
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
});
let stale_payload = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "movie_a".to_string(),
},
title: "Movie A Full Metadata".to_string(),
media_type: MediaType::Movie,
year: None,
description: Some("Stale synopsis from Movie A".to_string()),
tagline: None,
imdb_rating: None,
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
};
app.handle_action(Action::DetailsSuccess(
context_a,
1,
"movie_a".to_string(),
Box::new(stale_payload),
))
.await;
assert_eq!(app.state().active_subject_id.as_deref(), Some("movie_b"));
assert_eq!(
app.state().selected_details.as_ref().unwrap().title,
"Movie B Draft"
);
let valid_payload = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "movie_b".to_string(),
},
title: "Movie B Full Metadata".to_string(),
media_type: MediaType::Movie,
year: None,
description: Some("Correct synopsis for Movie B".to_string()),
tagline: None,
imdb_rating: None,
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
};
app.handle_action(Action::DetailsSuccess(
context_b,
2,
"movie_b".to_string(),
Box::new(valid_payload),
))
.await;
assert_eq!(app.state().active_subject_id.as_deref(), Some("movie_b"));
assert_eq!(
app.state().selected_details.as_ref().unwrap().title,
"Movie B Full Metadata"
);
assert_eq!(
app.state()
.selected_details
.as_ref()
.unwrap()
.description
.as_deref(),
Some("Correct synopsis for Movie B")
);
}
#[test]
fn test_cache_key_isolation_across_providers_queries_and_dimensions() {
use moviebox_tui::cache::{
get_provider_details_path, get_provider_search_path, get_provider_stream_path,
};
let search_mb_batman_p1 = get_provider_search_path(ProviderKind::MovieBox, "batman", 1);
let search_mb_batman_p2 = get_provider_search_path(ProviderKind::MovieBox, "batman", 2);
let search_mb_superman_p1 = get_provider_search_path(ProviderKind::MovieBox, "superman", 1);
let search_addon_batman_p1 = get_provider_search_path(ProviderKind::Addons, "batman", 1);
assert_ne!(search_mb_batman_p1, search_mb_batman_p2);
assert_ne!(search_mb_batman_p1, search_mb_superman_p1);
assert_ne!(search_mb_batman_p1, search_addon_batman_p1);
let details_mb_1 = get_provider_details_path(ProviderKind::MovieBox, "1001");
let details_mb_2 = get_provider_details_path(ProviderKind::MovieBox, "1002");
let details_4k_1 = get_provider_details_path(ProviderKind::FourKHdHub, "1001");
assert_ne!(details_mb_1, details_mb_2);
assert_ne!(details_mb_1, details_4k_1);
let stream_s1_e1 = get_provider_stream_path(ProviderKind::MovieBox, "series_1", 1, 1);
let stream_s1_e2 = get_provider_stream_path(ProviderKind::MovieBox, "series_1", 1, 2);
let stream_s2_e1 = get_provider_stream_path(ProviderKind::MovieBox, "series_1", 2, 1);
assert_ne!(stream_s1_e1, stream_s1_e2);
assert_ne!(stream_s1_e1, stream_s2_e1);
}
#[tokio::test]
async fn test_search_failure_vs_empty_result_distinction() {
let mut app = App::new();
app.state_mut().update_available = None;
app.state_mut().active_provider = ProviderKind::MovieBox;
app.state_mut().input_mode = InputMode::Normal;
app.state_mut().search_query.set_content("xyznonexistent");
let context = RequestContext {
provider: ProviderKind::MovieBox,
generation: app.state().provider_generation,
};
app.handle_action(Action::SearchSuccess {
context,
request_id: app.state().active_search_request,
query: "xyznonexistent".to_string(),
page: 1,
items: vec![],
})
.await;
assert!(app.state().search_results.is_empty());
assert!(app.state().search_error.is_none());
assert!(!app.state().is_loading);
app.handle_action(Action::SearchFailure(
context,
app.state().active_search_request,
1,
"Network connection reset by peer".to_string(),
))
.await;
assert!(app.state().search_results.is_empty());
assert_eq!(
app.state().search_error.as_deref(),
Some("Network connection reset by peer")
);
assert!(!app.state().is_loading);
}
#[tokio::test]
async fn test_mode_switch_stale_response_protection() {
let mut app = App::new();
app.state_mut().update_available = None;
app.state_mut().set_mode(AppMode::Streaming);
let streaming_generation = app.state().provider_generation;
let streaming_context = RequestContext {
provider: ProviderKind::MovieBox,
generation: streaming_generation,
};
app.state_mut().active_search_request = 1;
app.state_mut().search_query.set_content("avatar");
app.handle_action(Action::SwitchProvider(ProviderKind::Addons))
.await;
assert_eq!(app.state().active_provider, ProviderKind::Addons);
assert_ne!(app.state().provider_generation, streaming_generation);
let moviebox_items = vec![CatalogItem {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "mb_12345".to_string(),
},
title: "Avatar".to_string(),
media_type: MediaType::Movie,
year: Some("2009".to_string()),
poster_url: Some("https://example.com/avatar.jpg".to_string()),
season_count: None,
}];
app.handle_action(Action::SearchSuccess {
context: streaming_context,
request_id: 1,
query: "avatar".to_string(),
page: 1,
items: moviebox_items,
})
.await;
assert!(app.state().search_results.is_empty());
}
#[tokio::test]
async fn test_poster_identity_isolation() {
let mut app = App::new();
app.state_mut().update_available = None;
app.state_mut().active_screen = Screen::Details;
app.state_mut().active_subject_id = Some("target_movie_id".to_string());
app.state_mut().poster_image = None;
let dynamic_img = std::sync::Arc::new(image::DynamicImage::new_rgb8(10, 10));
app.handle_action(Action::PosterSuccess(
"other_movie_id".to_string(),
dynamic_img.clone(),
))
.await;
assert!(app.state().poster_image.is_none());
app.handle_action(Action::PosterSuccess(
"target_movie_id".to_string(),
dynamic_img.clone(),
))
.await;
assert!(app.state().poster_image.is_some());
}
#[tokio::test]
async fn test_search_preview_and_details_metadata_isolation() {
let mut app = App::new();
app.state_mut().update_available = None;
let old_preview = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::Addons,
value: "tt_old_movie".to_string(),
},
title: "Old Movie Title".to_string(),
media_type: MediaType::Movie,
year: Some("2020".to_string()),
description: Some("Old Movie Description".to_string()),
tagline: None,
imdb_rating: Some("8.5".to_string()),
director: Some("Old Director".to_string()),
stars: Some("Old Star".to_string()),
prints: None,
audios: None,
poster_url: Some("https://example.com/old.jpg".to_string()),
duration: Some("120 min".to_string()),
genres: vec!["Action".to_string()],
seasons: vec![],
dubs: vec![],
};
let new_search_result = SearchResult {
id: "tt_new_movie".to_string(),
title: "New Movie Title".to_string(),
stype: 1,
release_year: "2025".to_string(),
cover_url: Some("https://example.com/new.jpg".to_string()),
season: 0,
episode: 0,
provider: ProviderKind::Addons,
};
let fallback = MediaDetails::from_search_result(&new_search_result, Some(&old_preview));
assert_eq!(fallback.id.value, "tt_new_movie");
assert_eq!(fallback.title, "New Movie Title");
assert_eq!(fallback.year.as_deref(), Some("2025"));
assert!(fallback.description.is_none());
assert!(fallback.director.is_none());
assert!(fallback.stars.is_none());
assert!(fallback.imdb_rating.is_none());
let matching_preview = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::Addons,
value: "tt_new_movie".to_string(),
},
title: "New Movie Title".to_string(),
media_type: MediaType::Movie,
year: Some("2025".to_string()),
description: Some("New Movie Description".to_string()),
tagline: None,
imdb_rating: Some("7.9".to_string()),
director: Some("New Director".to_string()),
stars: Some("New Star".to_string()),
prints: None,
audios: None,
poster_url: Some("https://example.com/new.jpg".to_string()),
duration: Some("140 min".to_string()),
genres: vec!["Drama".to_string()],
seasons: vec![],
dubs: vec![],
};
let matching_fallback =
MediaDetails::from_search_result(&new_search_result, Some(&matching_preview));
assert_eq!(matching_fallback.id.value, "tt_new_movie");
assert_eq!(
matching_fallback.description.as_deref(),
Some("New Movie Description")
);
assert_eq!(matching_fallback.director.as_deref(), Some("New Director"));
}
#[tokio::test]
async fn test_series_details_defaults_to_season_one_when_no_history() {
let mut app = App::new();
app.state_mut().active_provider = ProviderKind::MovieBox;
app.state_mut().active_screen = Screen::Details;
app.state_mut().active_subject_id = Some("bb_series".to_string());
app.state_mut().selected_season = 1;
app.state_mut().selected_episode = 1;
app.state_mut().active_details_request = 1;
let context = RequestContext {
provider: ProviderKind::MovieBox,
generation: app.state().provider_generation,
};
let seasons = (1..=5)
.map(|s| Season {
number: s,
episodes: (1..=10)
.map(|e| Episode {
season: s,
number: e,
title: None,
overview: None,
})
.collect(),
})
.collect();
let details = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "bb_series".to_string(),
},
title: "Breaking Bad".to_string(),
media_type: MediaType::Series,
year: Some("2008".to_string()),
description: None,
tagline: None,
imdb_rating: Some("9.5".to_string()),
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons,
dubs: vec![],
};
app.handle_action(Action::DetailsSuccess(
context,
1,
"bb_series".to_string(),
Box::new(details),
))
.await;
assert_eq!(app.state().selected_season, 1);
assert_eq!(app.state().selected_episode, 1);
assert_eq!(app.state().season_list_state.selected(), Some(0));
assert_eq!(app.state().episode_list_state.selected(), Some(0));
}
#[tokio::test]
async fn test_series_details_resumes_watch_history() {
let mut app = App::new();
app.state_mut().active_provider = ProviderKind::MovieBox;
app.state_mut().active_screen = Screen::Details;
app.state_mut().selected_season = 1;
app.state_mut().selected_episode = 1;
app.state_mut()
.history
.recent
.push(moviebox_tui::history::WatchHistoryItem {
provider: "moviebox".to_string(),
subject_id: "bb_series".to_string(),
title: "Breaking Bad".to_string(),
stype: 2,
season: 3,
episode: 7,
duration_seconds: Some(3000),
progress_seconds: 500,
completed: false,
timestamp: 1000,
release_year: "2008".to_string(),
cover_url: None,
stream_filename: None,
});
app.state_mut().active_details_request = 1;
let context = RequestContext {
provider: ProviderKind::MovieBox,
generation: app.state().provider_generation,
};
let seasons = (1..=5)
.map(|s| Season {
number: s,
episodes: (1..=10)
.map(|e| Episode {
season: s,
number: e,
title: None,
overview: None,
})
.collect(),
})
.collect();
let details = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "bb_series".to_string(),
},
title: "Breaking Bad".to_string(),
media_type: MediaType::Series,
year: Some("2008".to_string()),
description: None,
tagline: None,
imdb_rating: Some("9.5".to_string()),
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons,
dubs: vec![],
};
app.handle_action(Action::DetailsSuccess(
context,
1,
"bb_series".to_string(),
Box::new(details),
))
.await;
assert_eq!(app.state().selected_season, 3);
assert_eq!(app.state().selected_episode, 7);
assert_eq!(app.state().season_list_state.selected(), Some(2));
assert_eq!(app.state().episode_list_state.selected(), Some(6));
}
#[tokio::test]
async fn test_series_details_preserves_season_and_episode_on_language_switch() {
let mut app = App::new();
app.state_mut().active_provider = ProviderKind::MovieBox;
app.state_mut().active_screen = Screen::Details;
app.state_mut().active_subject_id = Some("bb_series".to_string());
app.state_mut().language_chosen = true;
app.state_mut().selected_season = 4;
app.state_mut().selected_episode = 2;
app.state_mut().active_details_request = 1;
let context = RequestContext {
provider: ProviderKind::MovieBox,
generation: app.state().provider_generation,
};
let seasons = (1..=5)
.map(|s| Season {
number: s,
episodes: (1..=10)
.map(|e| Episode {
season: s,
number: e,
title: None,
overview: None,
})
.collect(),
})
.collect();
let details = MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "bb_series".to_string(),
},
title: "Breaking Bad".to_string(),
media_type: MediaType::Series,
year: Some("2008".to_string()),
description: None,
tagline: None,
imdb_rating: Some("9.5".to_string()),
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons,
dubs: vec![],
};
app.handle_action(Action::DetailsSuccess(
context,
1,
"bb_series".to_string(),
Box::new(details),
))
.await;
assert_eq!(app.state().selected_season, 4);
assert_eq!(app.state().selected_episode, 2);
assert_eq!(app.state().season_list_state.selected(), Some(3));
assert_eq!(app.state().episode_list_state.selected(), Some(1));
}