577 lines
22 KiB
Rust
577 lines
22 KiB
Rust
use super::*;
|
|
use ratatui::crossterm::event::KeyModifiers;
|
|
use std::{
|
|
fs,
|
|
io::Write,
|
|
sync::atomic::{AtomicU64, Ordering},
|
|
};
|
|
use tubular::miruro::Detail;
|
|
|
|
struct Directory(PathBuf);
|
|
impl Directory {
|
|
fn new() -> Self {
|
|
static NEXT: AtomicU64 = AtomicU64::new(0);
|
|
let directory = std::env::temp_dir().join(format!(
|
|
"tubular-miruro-ui-{}-{}",
|
|
std::process::id(),
|
|
NEXT.fetch_add(1, Ordering::Relaxed)
|
|
));
|
|
fs::create_dir(&directory).unwrap();
|
|
Self(directory)
|
|
}
|
|
fn browser(&self, query: Option<&str>) -> Browser {
|
|
let path = self.0.join("config.toml");
|
|
fs::write(&path, "").unwrap();
|
|
let options = Options {
|
|
player: self.0.join("missing-player").into_os_string(),
|
|
default_config: false,
|
|
miruro: true,
|
|
query: query.map(str::to_owned),
|
|
};
|
|
Browser::new(
|
|
options,
|
|
path.clone(),
|
|
config::Config::default(),
|
|
State::open(&path).unwrap(),
|
|
)
|
|
}
|
|
}
|
|
impl Drop for Directory {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
fn media(id: &str) -> Media {
|
|
miruro_browser::catalog(vec![serde_json::json!({"id":id, "title":{"english":format!("Series {id}")}, "episode_count":12, "description":"Series synopsis", "episode_counts":{"sub":null}})]).unwrap().remove(0)
|
|
}
|
|
fn series(media: &Media) -> miruro_browser::Series {
|
|
let mut metadata = media.metadata.clone();
|
|
metadata.as_object_mut().unwrap().remove("episode_count");
|
|
miruro_browser::series(&media.id, Detail { media: metadata, episodes: vec![
|
|
serde_json::json!({"episode_number":3, "absolute_number":49, "title":"Actual episode", "synopsis":"Episode synopsis", "aired_on":"2026-10-02", "duration_seconds":1500}),
|
|
serde_json::json!({"episode_number":7, "absolute_number":53, "title":null, "duration_seconds":null}),
|
|
] }).unwrap()
|
|
}
|
|
fn catalog_results(browser: &mut Browser) {
|
|
browser.accept(
|
|
browser.generation,
|
|
Ok(Response::Catalog(vec![media("first"), media("second")])),
|
|
);
|
|
}
|
|
fn enter_series(browser: &mut Browser) {
|
|
browser.open();
|
|
let Content::Series { media, .. } = &browser.screen().content else {
|
|
panic!("series screen");
|
|
};
|
|
let result = series(media);
|
|
browser.accept(browser.generation, Ok(Response::Series(result)));
|
|
}
|
|
|
|
#[test]
|
|
fn metadata_popup_scrolls_and_closes_without_moving_the_episode_selection() {
|
|
use ratatui::{Terminal, backend::TestBackend};
|
|
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("anime"));
|
|
catalog_results(&mut browser);
|
|
enter_series(&mut browser);
|
|
browser
|
|
.screen_mut()
|
|
.overview
|
|
.push_str(&"\nMore synopsis".repeat(40));
|
|
browser.screen_mut().overview.push_str("\nTAIL");
|
|
browser.screen_mut().update_description();
|
|
let selected = browser.screen().selected_video().unwrap().id;
|
|
for (width, height) in [(120, 40), (60, 24), (24, 12)] {
|
|
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
|
|
browser.key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
|
|
assert_eq!(browser.context(), Context::Info);
|
|
browser.key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
|
|
assert_eq!(browser.context(), Context::Description);
|
|
terminal
|
|
.draw(|frame| browser.draw(frame, Duration::ZERO))
|
|
.unwrap();
|
|
let popup = crate::preview_area(terminal.backend().buffer().area);
|
|
let popup_text = |terminal: &Terminal<TestBackend>| -> String {
|
|
(popup.y + 1..popup.bottom() - 1)
|
|
.flat_map(|y| {
|
|
(popup.x + 1..popup.right() - 1)
|
|
.map(move |x| terminal.backend().buffer()[(x, y)].symbol())
|
|
})
|
|
.collect()
|
|
};
|
|
assert!(popup_text(&terminal).contains("Episode 3"));
|
|
browser.key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
|
|
terminal
|
|
.draw(|frame| browser.draw(frame, Duration::ZERO))
|
|
.unwrap();
|
|
assert_eq!(browser.screen().description_scroll, 1);
|
|
assert_eq!(browser.screen().selected_video().unwrap().id, selected);
|
|
browser.screen_mut().description_scroll = u16::MAX;
|
|
terminal
|
|
.draw(|frame| browser.draw(frame, Duration::ZERO))
|
|
.unwrap();
|
|
assert!(popup_text(&terminal).contains("TAIL"));
|
|
browser.key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
|
|
assert_eq!(browser.context(), Context::Info);
|
|
browser.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
assert!(browser.preview.is_none());
|
|
assert_eq!(browser.screen().selected_video().unwrap().id, selected);
|
|
browser.screen_mut().description_scroll = 0;
|
|
}
|
|
browser.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
|
|
assert_eq!(
|
|
browser.screen().selected_video().unwrap().id,
|
|
"miruro:first:7"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn catalog_series_back_forward_keep_native_query_selection_and_actual_episodes() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("apothecary"));
|
|
assert!(matches!(&browser.pending, Some(Request::Search(query)) if query == "apothecary"));
|
|
catalog_results(&mut browser);
|
|
browser.select(Action::VideoNext);
|
|
enter_series(&mut browser);
|
|
assert_eq!(browser.screen().len(), 2); // Neither planned 12 nor absolute 49 creates rows.
|
|
assert!(
|
|
matches!(&browser.screen().content, Content::Series { media, .. } if media.metadata["episode_count"] == 12 && media.metadata["episode_counts"]["sub"].is_null())
|
|
);
|
|
assert_eq!(
|
|
browser.screen().selected_video().unwrap().id,
|
|
"miruro:second:3"
|
|
);
|
|
browser.select(Action::VideoNext);
|
|
browser.save(CollectionKind::Saved);
|
|
browser.history(false);
|
|
assert_eq!(browser.screen().selection.selected(), Some(1));
|
|
assert!(
|
|
matches!(&browser.screen().content, Content::Catalog { query, media, .. } if query == "apothecary" && media.len() == 2)
|
|
);
|
|
assert!(browser.pending.is_none());
|
|
browser.history(true);
|
|
assert_eq!(
|
|
browser.screen().selected_video().unwrap().id,
|
|
"miruro:second:7"
|
|
);
|
|
assert!(browser.pending.is_none());
|
|
assert!(
|
|
browser
|
|
.state
|
|
.contains(CollectionKind::Saved, "miruro:second:7")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn latest_intent_and_navigation_reject_stale_catalog_and_series() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("old"));
|
|
let old = browser.generation;
|
|
browser.edit_search();
|
|
browser.input = Some("latest".into());
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
assert!(matches!(&browser.pending, Some(Request::Search(query)) if query == "latest"));
|
|
browser.accept(old, Ok(Response::Catalog(vec![media("stale")])));
|
|
assert_eq!(browser.screen().len(), 0);
|
|
catalog_results(&mut browser);
|
|
browser.open();
|
|
let stale = browser.generation;
|
|
let Content::Series { media, .. } = &browser.screen().content else {
|
|
panic!("series");
|
|
};
|
|
let data = series(media);
|
|
browser.history(false);
|
|
browser.accept(stale, Ok(Response::Series(data)));
|
|
assert!(matches!(browser.screen().content, Content::Catalog { .. }));
|
|
browser.history(true);
|
|
let Content::Series { media, .. } = &browser.screen().content else {
|
|
panic!("series");
|
|
};
|
|
let data = series(media);
|
|
browser.accept(browser.generation, Ok(Response::Series(data)));
|
|
assert_eq!(
|
|
browser.screen().selected_video().unwrap().id,
|
|
"miruro:first:3"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn manual_watch_status_refreshes_filters_and_preserves_other_providers() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("anime"));
|
|
catalog_results(&mut browser);
|
|
browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE));
|
|
assert!(browser.state.videos(CollectionKind::Watching).is_empty());
|
|
assert!(!browser.bindings().iter().any(|(action, _)| {
|
|
matches!(
|
|
action,
|
|
Action::WatchStatusWatching | Action::WatchStatusWatched
|
|
)
|
|
}));
|
|
enter_series(&mut browser);
|
|
let episode = browser.screen().selected_video().unwrap();
|
|
let mut youtube = episode.clone();
|
|
youtube.id = "jNQXAC9IVRw".into();
|
|
youtube.channel_id = Some("UC4QobU6STFB0P71PMvOGN5A".into());
|
|
youtube.uploader_id = Some("@jawed".into());
|
|
browser
|
|
.state
|
|
.save(CollectionKind::Watching, &youtube)
|
|
.unwrap();
|
|
browser.save(CollectionKind::WatchLater);
|
|
browser.preview = Some(PreviewMode::Info);
|
|
browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE));
|
|
assert!(
|
|
browser
|
|
.state
|
|
.contains(CollectionKind::Watching, &episode.id)
|
|
);
|
|
assert!(!browser.state.is_watched(&episode.id));
|
|
browser.preview = None;
|
|
browser.collection(CollectionKind::Watching);
|
|
browser.key(KeyEvent::new(KeyCode::Char('M'), KeyModifiers::NONE));
|
|
assert!(browser.state.is_watched(&episode.id));
|
|
assert_eq!(browser.screen().len(), 0);
|
|
browser.collection(CollectionKind::WatchLater);
|
|
browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
|
|
assert_eq!(browser.screen().len(), 0);
|
|
browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
|
|
assert_eq!(browser.screen().len(), 1);
|
|
browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE));
|
|
assert_eq!(browser.screen().len(), 0);
|
|
assert!(!browser.state.is_watched(&episode.id));
|
|
assert!(
|
|
browser
|
|
.state
|
|
.contains(CollectionKind::Watching, &episode.id)
|
|
);
|
|
assert!(
|
|
browser
|
|
.state
|
|
.contains(CollectionKind::Watching, &youtube.id)
|
|
);
|
|
assert!(!browser.state.is_watched(&youtube.id));
|
|
let state = State::open(&browser.config_path).unwrap();
|
|
assert!(state.contains(CollectionKind::Watching, &episode.id));
|
|
assert!(state.contains(CollectionKind::WatchLater, &episode.id));
|
|
let overrides: toml_edit::DocumentMut =
|
|
"[keys.video.status]\nwatched = 'alt+m'\n".parse().unwrap();
|
|
browser.config.keys = crate::keys::Bindings::from_toml(overrides.get("keys")).unwrap();
|
|
browser.collection(CollectionKind::Watching);
|
|
browser.key(KeyEvent::new(KeyCode::Char('M'), KeyModifiers::NONE));
|
|
assert!(!browser.state.is_watched(&episode.id));
|
|
browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::ALT));
|
|
assert!(browser.state.is_watched(&episode.id));
|
|
assert!(state.contains(CollectionKind::Watching, &youtube.id));
|
|
}
|
|
|
|
#[test]
|
|
fn offline_collections_and_filtered_bulk_removal_never_touch_youtube() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("anime"));
|
|
catalog_results(&mut browser);
|
|
enter_series(&mut browser);
|
|
let episode = browser.screen().selected_video().unwrap();
|
|
let mut youtube = episode.clone();
|
|
youtube.id = "jNQXAC9IVRw".into();
|
|
youtube.title = "YouTube title".into();
|
|
youtube.channel = Some("jawed".into());
|
|
youtube.channel_id = Some("UC4QobU6STFB0P71PMvOGN5A".into());
|
|
youtube.uploader_id = Some("@jawed".into());
|
|
for kind in [
|
|
CollectionKind::Saved,
|
|
CollectionKind::WatchLater,
|
|
CollectionKind::Watching,
|
|
] {
|
|
browser.state.save(kind, &episode).unwrap();
|
|
browser.state.save(kind, &youtube).unwrap();
|
|
}
|
|
browser.collection(CollectionKind::Saved);
|
|
assert_eq!(browser.screen().len(), 1);
|
|
browser.remove(true);
|
|
assert_eq!(
|
|
browser.removal.as_ref().unwrap().1.as_slice(),
|
|
std::slice::from_ref(&episode.id)
|
|
);
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
assert!(browser.state.contains(CollectionKind::Saved, &youtube.id));
|
|
assert!(!browser.state.contains(CollectionKind::Saved, &episode.id));
|
|
assert!(
|
|
browser
|
|
.state
|
|
.contains(CollectionKind::WatchLater, &episode.id)
|
|
);
|
|
let report = browser.state.progress_file(&episode).unwrap();
|
|
crate::video_state::register_identity(&report, &episode.id).unwrap();
|
|
let mut output = fs::OpenOptions::new();
|
|
output.write(true).create_new(true);
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::OpenOptionsExt;
|
|
output.mode(0o600);
|
|
}
|
|
let mut output = output.open(report).unwrap();
|
|
writeln!(output, "{}", serde_json::json!({"version":2,"event":"ended","media_identity":Identity::from_key(&episode.id).unwrap(),"position_seconds":95.0,"duration_seconds":100.0,"completion_eligible":true})).unwrap();
|
|
assert!(browser.state.poll_progress().unwrap());
|
|
browser.rebuild_collections();
|
|
assert!(browser.state.is_watched(&episode.id));
|
|
assert!(
|
|
!browser
|
|
.state
|
|
.contains(CollectionKind::Watching, &episode.id)
|
|
);
|
|
for kind in [CollectionKind::Watching, CollectionKind::WatchLater] {
|
|
browser.collection(kind);
|
|
if matches!(kind, CollectionKind::WatchLater) {
|
|
browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
|
|
assert_eq!(browser.screen().len(), 0);
|
|
browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
|
|
assert_eq!(browser.screen().len(), 1);
|
|
browser.remove(true);
|
|
browser.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
|
|
assert!(browser.state.is_watched(&episode.id));
|
|
}
|
|
assert!(browser.state.contains(kind, &youtube.id));
|
|
}
|
|
let state = State::open(&browser.config_path).unwrap();
|
|
assert!(state.contains(CollectionKind::Saved, &youtube.id));
|
|
assert!(state.contains(CollectionKind::Watching, &youtube.id));
|
|
}
|
|
|
|
#[test]
|
|
fn launcher_failure_does_not_mark_series_or_offline_episodes_as_started() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("anime"));
|
|
catalog_results(&mut browser);
|
|
enter_series(&mut browser);
|
|
browser.select(Action::VideoNext);
|
|
let selected = browser.screen().selected_video().unwrap();
|
|
assert_eq!(Identity::from_key(&selected.id).unwrap().episode, 7);
|
|
browser.open();
|
|
assert!(browser.screen().error.is_some());
|
|
assert!(!browser.state.is_watched(&selected.id));
|
|
assert!(
|
|
!browser
|
|
.state
|
|
.contains(CollectionKind::Watching, &selected.id)
|
|
);
|
|
browser.save(CollectionKind::Saved);
|
|
browser.collection(CollectionKind::Saved);
|
|
browser.open();
|
|
assert!(browser.screen().error.is_some());
|
|
assert!(!browser.state.is_watched(&selected.id));
|
|
assert!(
|
|
!browser
|
|
.state
|
|
.contains(CollectionKind::Watching, &selected.id)
|
|
);
|
|
assert!(browser.state.contains(CollectionKind::Saved, &selected.id));
|
|
}
|
|
|
|
#[test]
|
|
fn configured_modal_keys_and_inputs_do_not_leak_to_main_actions() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("anime"));
|
|
catalog_results(&mut browser);
|
|
let overrides: toml_edit::DocumentMut =
|
|
"[keys]\nchannel.tags = 'f2'\ntags.new = 'f3'\ntags.save = 'f4'\ninput.submit = 'f5'\n"
|
|
.parse()
|
|
.unwrap();
|
|
browser.config.keys = crate::keys::Bindings::from_toml(overrides.get("keys")).unwrap();
|
|
browser.key(KeyEvent::new(KeyCode::F(2), KeyModifiers::NONE));
|
|
assert_eq!(browser.context(), Context::TagList);
|
|
browser.key(KeyEvent::new(KeyCode::F(3), KeyModifiers::NONE));
|
|
assert_eq!(browser.context(), Context::TagInput);
|
|
browser.paste("Safe");
|
|
browser.key(KeyEvent::new(KeyCode::Char('\u{7}'), KeyModifiers::NONE));
|
|
browser.key(KeyEvent::new(KeyCode::F(5), KeyModifiers::NONE));
|
|
assert_eq!(browser.context(), Context::TagList);
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
assert!(browser.state.shows().is_empty());
|
|
assert_eq!(browser.index, 0);
|
|
browser.key(KeyEvent::new(KeyCode::F(4), KeyModifiers::NONE));
|
|
assert_eq!(
|
|
browser.state.shows()[0].tags,
|
|
BTreeSet::from(["Safe".into()])
|
|
);
|
|
assert!(browser.modal.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn checked_show_categories_survive_hover_and_filter_changes() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(None);
|
|
for (id, tag) in [("first", "Drama"), ("second", "Favorites")] {
|
|
browser
|
|
.state
|
|
.save_show(&media(id), &[tag.into()].into())
|
|
.unwrap();
|
|
}
|
|
for filter in [None, Some("no matching category")] {
|
|
browser.category_picker();
|
|
for code in [KeyCode::Char('j'), KeyCode::Char(' '), KeyCode::Char('k')] {
|
|
browser.key(KeyEvent::new(code, KeyModifiers::NONE));
|
|
}
|
|
if let Some(filter) = filter {
|
|
browser.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
|
|
browser.paste(filter);
|
|
}
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
let Content::Library { shows, .. } = &browser.screen().content else {
|
|
panic!("Checked categories must open even without a hovered match");
|
|
};
|
|
assert_eq!(
|
|
shows
|
|
.iter()
|
|
.map(|show| show.media.id.as_str())
|
|
.collect::<Vec<_>>(),
|
|
["first"]
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn saved_shows_stage_cancel_reopen_and_remove_without_touching_episodes() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(Some("anime"));
|
|
catalog_results(&mut browser);
|
|
let key = |browser: &mut Browser, code| {
|
|
browser.key(KeyEvent::new(code, KeyModifiers::NONE));
|
|
};
|
|
key(&mut browser, KeyCode::Char('s'));
|
|
key(&mut browser, KeyCode::Char('n'));
|
|
browser.paste("Drama");
|
|
key(&mut browser, KeyCode::Enter);
|
|
key(&mut browser, KeyCode::Esc);
|
|
assert!(browser.state.shows().is_empty());
|
|
key(&mut browser, KeyCode::Char('s'));
|
|
key(&mut browser, KeyCode::Enter);
|
|
assert!(browser.state.shows()[0].tags.is_empty());
|
|
enter_series(&mut browser);
|
|
browser.select(Action::VideoNext);
|
|
browser.save(CollectionKind::Saved);
|
|
let episode = browser.screen().selected_video().unwrap().id;
|
|
key(&mut browser, KeyCode::Char('s'));
|
|
for tag in ["Drama", "Favorites"] {
|
|
key(&mut browser, KeyCode::Char('n'));
|
|
browser.paste(tag);
|
|
key(&mut browser, KeyCode::Enter);
|
|
}
|
|
key(&mut browser, KeyCode::Enter);
|
|
assert_eq!(browser.state.shows()[0].media.id, "first");
|
|
browser
|
|
.state
|
|
.save_show(&media("second"), &BTreeSet::from(["Drama".into()]))
|
|
.unwrap();
|
|
assert_eq!(
|
|
library_shows(
|
|
&browser.state,
|
|
&BTreeSet::from(["Drama".into(), "Favorites".into()])
|
|
)
|
|
.len(),
|
|
2
|
|
);
|
|
browser.state = State::open(&browser.config_path).unwrap();
|
|
key(&mut browser, KeyCode::Char('c'));
|
|
key(&mut browser, KeyCode::Char('i'));
|
|
browser.paste("Favorites");
|
|
key(&mut browser, KeyCode::Enter);
|
|
assert_eq!(browser.screen().len(), 1);
|
|
browser.open();
|
|
assert!(
|
|
matches!(&browser.pending, Some(Request::Episodes { media_id, .. }) if media_id == "first")
|
|
);
|
|
browser.history(false);
|
|
browser.library(BTreeSet::new());
|
|
key(&mut browser, KeyCode::Char('x'));
|
|
assert_eq!(browser.screen().len(), 1);
|
|
browser.history(false);
|
|
assert_eq!(browser.screen().len(), 0);
|
|
assert!(browser.state.contains(CollectionKind::Saved, &episode));
|
|
assert_eq!(
|
|
State::open(&browser.config_path).unwrap().shows()[0]
|
|
.media
|
|
.id,
|
|
"second"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn empty_errors_and_query_controls_do_not_create_results_or_commands() {
|
|
let directory = Directory::new();
|
|
let mut browser = directory.browser(None);
|
|
assert!(browser.pending.is_none());
|
|
browser.open();
|
|
assert_eq!(browser.index, 0);
|
|
browser.edit_search();
|
|
browser.paste("Anime\nquery\t\u{1b}[31m");
|
|
browser.key(KeyEvent::new(KeyCode::Char('\u{7}'), KeyModifiers::NONE));
|
|
assert!(
|
|
browser
|
|
.input
|
|
.as_ref()
|
|
.unwrap()
|
|
.chars()
|
|
.all(|ch| !ch.is_control())
|
|
);
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
let old = browser.generation;
|
|
browser.accept(old, Err(io::Error::other("Catalog request failed")));
|
|
assert!(browser.screen().error.is_some());
|
|
assert_eq!(browser.screen().len(), 0);
|
|
browser.search();
|
|
browser.accept(browser.generation, Ok(Response::Catalog(Vec::new())));
|
|
assert!(browser.screen().error.is_none());
|
|
assert!(matches!(
|
|
browser.screen().content,
|
|
Content::Catalog { searched: true, .. }
|
|
));
|
|
browser.edit_search();
|
|
browser.input = Some(" ".into());
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
assert!(browser.pending.is_none());
|
|
assert!(matches!(
|
|
browser.screen().content,
|
|
Content::Catalog {
|
|
searched: false,
|
|
..
|
|
}
|
|
));
|
|
browser.accept(old, Ok(Response::Catalog(vec![media("stale")])));
|
|
assert_eq!(browser.screen().len(), 0);
|
|
assert!(browser.screen().rows.is_empty());
|
|
fs::write(
|
|
&browser.config_path,
|
|
"[keys]\nsearch.edit = 'f8'\napp.quit = 'f9'\n",
|
|
)
|
|
.unwrap();
|
|
browser.config = config::load(&browser.config_path).unwrap();
|
|
browser.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
|
|
assert!(browser.input.is_some());
|
|
browser.input = Some("safe".into());
|
|
browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
let metadata = miruro_browser::catalog(vec![serde_json::json!({
|
|
"id":"safe", "title":{"english":"薬屋 Café\u{1b}[31m"},
|
|
"description":"<p>First\u{1b}[31m</p><p>Second<br/>Third</p>"
|
|
})])
|
|
.unwrap();
|
|
browser.accept(browser.generation, Ok(Response::Catalog(metadata)));
|
|
assert!(
|
|
browser
|
|
.screen()
|
|
.rows
|
|
.iter()
|
|
.all(|row| row.title.chars().all(|ch| !ch.is_control()))
|
|
);
|
|
assert!(
|
|
browser
|
|
.screen()
|
|
.description
|
|
.chars()
|
|
.all(|ch| !ch.is_control() || ch == '\n')
|
|
);
|
|
assert!(!browser.key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE)));
|
|
assert!(browser.key(KeyEvent::new(KeyCode::F(9), KeyModifiers::NONE)));
|
|
}
|