hl-valdemar/tubular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity
Files
acdd6dc3e9ecee7a76606d96cdd3fd5086d5118c
tubular/tests/unit/app.rs
T

6081 lines
237 KiB
Rust
Raw Blame History

use super::*;
impl App {
fn new(options: Options, config_path: PathBuf, config: config::Config) -> Self {
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let path = std::env::temp_dir()
.join(format!(
"tubular-ui-state-{}-{}",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
))
.join("config.toml");
Self::with_state(
options,
config_path,
config,
video_state::State::open(&path).unwrap(),
)
}
}
#[test]
fn startup_provider_selection_preserves_query_and_handles_boundaries_and_cancel() {
use std::ops::ControlFlow::{Break, Continue};
let mut selected = 0;
assert_eq!(
provider_selection(&mut selected, Some(Action::SelectorPrevious)),
Continue(())
);
for (action, miruro) in [(Action::SelectorOpen, false), (Action::SelectorNext, true)] {
if action == Action::SelectorNext {
assert_eq!(
provider_selection(&mut selected, Some(action)),
Continue(())
);
assert_eq!(
provider_selection(&mut selected, Some(action)),
Continue(())
);
}
let Break(Some(choice)) = provider_selection(&mut selected, Some(Action::SelectorOpen))
else {
panic!("Selected provider must open");
};
assert_eq!(choice, miruro);
let mut options = Options::parse_from(["tubular", "initial query"]);
options.miruro = choice;
assert_eq!(options.query.as_deref(), Some("initial query"));
assert_eq!(options.miruro, miruro);
if !miruro {
let app = App::new(options, PathBuf::new(), config::Config::default());
assert_eq!(app.views[0].query, "initial query");
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
}
}
for action in [Action::SelectorClose, Action::Quit, Action::Interrupt] {
assert_eq!(provider_selection(&mut selected, Some(action)), Break(None));
}
assert_eq!(provider_selection(&mut selected, None), Continue(()));
}
fn app(args: &[&str]) -> App {
App::new(
Options::parse_from(args),
PathBuf::new(),
config::Config::default(),
)
}
#[test]
fn playback_checks_follow_ids_across_feed_sort_and_clear_on_replacement() {
let mut app = app(&["tubular"]);
app.view_index = 1;
app.feed_channels = vec!["https://www.youtube.com/@fixture".into()];
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old","timestamp":100},{"id":"rQ_J9WH6CGk","title":"New","timestamp":200}]}"#,
true,
);
let view = &mut app.views[1];
view.selection.select(Some(1));
view.toggle_checked();
view.selection.select(Some(0));
view.toggle_checked();
assert_eq!(
view.playback_videos()
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["rQ_J9WH6CGk", "jNQXAC9IVRw"],
);
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"l-GaaivVJCE","title":"Newest","timestamp":300}]}"#,
false,
);
let view = &mut app.views[1];
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(
view.playback_videos()
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["rQ_J9WH6CGk", "jNQXAC9IVRw"],
);
view.reset();
assert!(view.checked.is_empty());
// Old rows remain during refresh, but checks made there cannot leak into replacement data.
view.toggle_checked();
assert!(!view.checked.is_empty());
view.accept_page(
youtube::search_results(r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Replacement"}]}"#)
.unwrap(),
false,
)
.unwrap();
assert!(view.checked.is_empty());
assert_eq!(view.playback_videos()[0].title, "Replacement");
}
#[test]
fn playback_checks_are_local_to_views_and_previews_and_pruned_with_collections() {
let mut app = app(&["tubular"]);
let videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@creator"}]}"#,
).unwrap().videos;
app.views[0].videos = videos.clone();
app.views[0].selection.select(Some(0));
app.views[0].loaded = true;
app.views[1].loaded = true;
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.switch_view(1);
assert!(app.views[1].checked.is_empty());
app.switch_view(0);
assert!(app.views[0].checked.contains(&videos[0].id));
app.mode = Mode::Insert;
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert_eq!(app.views[0].checked.len(), 1);
app.mode = Mode::Normal;
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.preview = preview;
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL));
assert!(app.views[0].checked.is_empty());
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert!(app.views[0].checked.contains(&videos[0].id));
}
app.preview = None;
for video in &videos {
app.video_state
.save(CollectionKind::WatchLater, video)
.unwrap();
}
app.browse_collection(CollectionKind::WatchLater);
let index = app.view_index;
app.views[index].selection.select(Some(0));
app.views[index].toggle_checked();
app.views[index].selection.select(Some(1));
app.views[index].toggle_checked();
let removed = app.views[index].videos[1].id.clone();
app.remove_collection();
assert!(!app.views[index].checked.contains(&removed));
assert_eq!(app.views[index].checked.len(), 1);
assert_eq!(app.views[index].playback_videos().len(), 1);
app.views[index].watch_filter = WatchFilter::Watched;
app.rebuild_collections();
assert!(app.views[index].videos.is_empty());
assert!(app.views[index].checked.is_empty());
app.views[index].watch_filter = WatchFilter::All;
app.rebuild_collections();
app.views[index].toggle_checked();
// Refresh is a replacement even for locally rebuilt collection views.
app.load_view();
assert!(app.views[index].checked.is_empty());
assert_eq!(app.views[0].checked.len(), 1);
// An empty category exercises query replacement entirely offline.
app.config.categories.insert("Empty".into(), Vec::new());
let mut view = View::new("Empty".into(), ViewSource::Category("Empty".into()));
view.videos = videos;
view.selection.select(Some(0));
view.toggle_checked();
view.query = "replacement query".into();
app.views.push(view);
app.view_index = app.views.len() - 1;
app.search();
assert!(app.views[app.view_index].checked.is_empty());
assert!(app.job.is_none());
}
#[test]
fn playback_checks_render_independently_and_live_hints_use_configured_keys() {
let mut app = app(&["tubular"]);
let document =
"[keys.video.select]\ntoggle = 'f20'\nclear = 'f21'\n[keys.video]\nenqueue = 'f22'\n"
.parse::<toml_edit::DocumentMut>()
.unwrap();
app.config.keys = keys::Bindings::from_toml(document.get("keys")).unwrap();
app.key_hints = KeyHints::new(&app.config.keys);
for context in [
Context::Normal,
Context::Info,
Context::Description,
Context::CollectionNormal,
Context::CollectionInfo,
Context::CollectionDescription,
] {
for key in ["F20", "F21", "F22"] {
assert!(app.key_hints.footer(context).contains(key));
assert!(app.key_hints.preview.iter().all(|hint| hint.contains(key)));
assert!(app.config.keys.help_text().to_string().contains(key));
}
}
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Checked"},{"id":"rQ_J9WH6CGk","title":"Unchecked"}]}"#,
).unwrap().videos;
for (index, video) in app.views[0].videos.iter_mut().enumerate() {
video.id = format!("offline:{index}");
}
app.views[0].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::F(20), KeyModifiers::NONE));
let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let rendered: String = terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect();
assert!(rendered.contains("1 checked"));
app.key(KeyEvent::new(KeyCode::F(21), KeyModifiers::NONE));
assert!(app.views[0].checked.is_empty());
}
#[test]
fn playback_checks_survive_spawn_failure_clear_after_spawn_and_fall_back_to_hover() {
for modifiers in [KeyModifiers::NONE, KeyModifiers::CONTROL] {
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#,
).unwrap().videos;
app.views[0].selection.select(Some(1));
assert_eq!(app.views[0].playback_videos()[0].id, "rQ_J9WH6CGk");
app.views[0].toggle_checked();
app.views[0].selection.select(Some(0));
app.options.player = "/nonexistent/tubular-test-player".into();
app.key(KeyEvent::new(KeyCode::Enter, modifiers));
assert!(app.player_launch.is_none());
assert!(app.views[0].checked.contains("rQ_J9WH6CGk"));
assert_eq!(app.views[0].playback_videos()[0].id, "rQ_J9WH6CGk");
app.options.player = "/usr/bin/true".into();
app.key(KeyEvent::new(KeyCode::Enter, modifiers));
assert!(app.player_launch.is_some());
assert!(app.views[0].checked.is_empty());
assert_eq!(app.views[0].playback_videos()[0].id, "jNQXAC9IVRw");
app.player_launch = None;
app.key(KeyEvent::new(KeyCode::Enter, modifiers));
assert!(app.player_launch.is_some());
}
}
#[test]
fn title_viewport_tracks_selected_two_line_rows_and_resize_without_changing_identity() {
let mut app = app(&["tubular"]);
let template =
youtube::search_results(r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Listing title"}]}"#)
.unwrap()
.videos
.remove(0);
app.views[0].videos = (0..12)
.map(|index| {
let mut video = template.clone();
// Non-YouTube IDs keep this rendering check entirely offline.
video.id = format!("offline:{index}");
video.title = format!("Row {index:02}");
video
})
.collect();
app.views[0].selection.select(Some(9));
let now = Instant::now();
let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
terminal
.draw(|frame| app.draw_at(frame, Duration::ZERO, now))
.unwrap();
assert_eq!(app.views[0].selection.offset(), 3);
assert_eq!(
app.views[0].videos[app.views[0].selection.selected().unwrap()].id,
"offline:9"
);
assert!(!app.titles.active());
terminal.backend_mut().resize(80, 17);
terminal
.draw(|frame| {
app.draw_at(
frame,
Duration::from_millis(20),
now + Duration::from_millis(20),
)
})
.unwrap();
assert_eq!(app.views[0].selection.offset(), 7);
assert_eq!(
app.views[0].videos[app.views[0].selection.selected().unwrap()].id,
"offline:9"
);
let rendered: String = terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect();
assert!(rendered.contains("Row 09"));
app.views[0].selection.select(Some(0));
terminal
.draw(|frame| {
app.draw_at(
frame,
Duration::from_millis(40),
now + Duration::from_millis(40),
)
})
.unwrap();
assert_eq!(app.views[0].selection.offset(), 0);
assert_eq!(
app.views[0].videos[app.views[0].selection.selected().unwrap()].id,
"offline:0"
);
}
#[test]
fn youtube_collections_isolate_mixed_provider_rows_and_removal_ids() {
let mut app = app(&["tubular"]);
let youtube = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"YouTube","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@creator"}]}"#,
).unwrap().videos.remove(0);
let mut miruro = youtube.clone();
miruro.id = "miruro:catalog_ID:1".into();
miruro.title = "Miruro episode".into();
miruro.channel = Some("Miruro".into());
miruro.channel_id = None;
miruro.uploader_id = None;
for kind in [
CollectionKind::WatchLater,
CollectionKind::Saved,
CollectionKind::Watching,
] {
app.video_state.save(kind, &youtube).unwrap();
app.video_state.save(kind, &miruro).unwrap();
app.browse_collection(kind);
assert_eq!(app.views[app.view_index].videos.len(), 1);
assert_eq!(app.views[app.view_index].videos[0].id, youtube.id);
assert_eq!(app.views[app.view_index].selection.selected(), Some(0));
app.remove_collection_bulk();
assert_eq!(
app.collection_removal.as_ref().unwrap().ids.as_slice(),
std::slice::from_ref(&youtube.id)
);
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert!(!app.video_state.contains(kind, &youtube.id));
assert!(app.video_state.contains(kind, &miruro.id));
assert!(app.views[app.view_index].videos.is_empty());
app.video_state.save(kind, &youtube).unwrap();
app.rebuild_collections();
app.remove_collection();
assert!(!app.video_state.contains(kind, &youtube.id));
assert!(app.video_state.contains(kind, &miruro.id));
}
}
#[test]
fn watching_direct_bindings_respect_modals_and_offline_history() {
for (label, overrides, binding) in [
("default", "", Some(KeyCode::Char('C'))),
(
"remapped",
"[keys]\nview.watching.browse = 'f8'\n",
Some(KeyCode::F(8)),
),
("disabled", "[keys]\nview.watching.browse = []\n", None),
] {
let mut app = rename_app(&format!("watching-{label}"), overrides);
for view in &mut app.views {
view.loaded = true;
}
app.mode = Mode::Insert;
rename_press(&mut app, KeyCode::Char('C'));
assert_eq!(app.views[0].query, "C");
rename_press(&mut app, KeyCode::Esc);
app.open_browser(BrowserKind::Categories);
rename_press(&mut app, binding.unwrap_or(KeyCode::Char('C')));
assert!(app.browser.is_some());
assert_eq!(app.view_index, 0);
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Char('?'));
rename_press(&mut app, binding.unwrap_or(KeyCode::Char('C')));
assert!(app.help_popup.is_some());
assert_eq!(app.view_index, 0);
rename_press(&mut app, KeyCode::Esc);
if binding != Some(KeyCode::Char('C')) {
rename_press(&mut app, KeyCode::Char('C'));
assert_eq!(app.view_index, 0);
}
if let Some(binding) = binding {
rename_press(&mut app, binding);
let index = app.view_index;
assert_eq!(app.views[index].source, ViewSource::Watching);
assert_eq!(app.temporary_view, Some(ViewSource::Watching));
assert_eq!(app.key_context(), Context::CollectionNormal);
assert!(app.browser.is_none());
app.load_page();
let config = std::mem::take(&mut app.config);
app.apply_config(config);
assert_eq!(app.views[app.view_index].source, ViewSource::Watching);
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('-'));
assert_eq!(app.view_index, index);
rename_press(&mut app, KeyCode::Char('+'));
assert_eq!(app.view_index, 0);
rename_press(&mut app, binding);
assert_eq!(app.view_index, index);
assert!(app.job.is_none());
assert!(!app.views[index].has_more);
}
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
}
#[test]
fn watching_progress_preserves_selection_and_removal_is_collection_only() {
use std::io::Write;
fn report(path: &std::path::Path, id: &str, position: u32) {
let mut options = std::fs::OpenOptions::new();
options.append(true).create(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
options.mode(0o600);
}
writeln!(
options.open(path).unwrap(),
"{{\"version\":1,\"event\":\"progress\",\"media_url\":\"https://www.youtube.com/watch?v={id}\",\"position_seconds\":{position},\"duration_seconds\":100,\"completion_eligible\":true}}"
).unwrap();
}
let mut app = rename_app("watching-progress", "");
for view in &mut app.views {
view.loaded = true;
}
let videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"},{"id":"l-GaaivVJCE","title":"Third","uploader_id":"@third"}]}"#,
).unwrap().videos;
let reports: Vec<_> = videos
.iter()
.map(|video| {
app.video_state.save(CollectionKind::Saved, video).unwrap();
app.video_state
.save(CollectionKind::WatchLater, video)
.unwrap();
let path = app.video_state.progress_file(video).unwrap();
video_state::register_identity(&path, &video.id).unwrap();
report(&path, &video.id, 1);
path
})
.collect();
app.update();
rename_press(&mut app, KeyCode::Char('C'));
assert_eq!(app.views[app.view_index].videos.len(), 3);
let second = app.views[app.view_index]
.videos
.iter()
.position(|video| video.id == videos[1].id)
.unwrap();
app.views[app.view_index].selection.select(Some(second));
app.preview = Some(PreviewMode::Description);
report(&reports[0], &videos[0].id, 95);
app.update();
let view = &app.views[app.view_index];
assert_eq!(view.videos.len(), 2);
assert_eq!(
view.videos[view.selection.selected().unwrap()].id,
videos[1].id
);
assert_eq!(app.preview, Some(PreviewMode::Description));
report(&reports[1], &videos[1].id, 95);
app.update();
assert_eq!(app.views[app.view_index].videos.len(), 1);
assert!(app.preview.is_none());
assert!(app.status.contains("1 videos"));
rename_press(&mut app, KeyCode::Char('x'));
assert!(app.video_state.videos(CollectionKind::Watching).is_empty());
report(&reports[2], &videos[2].id, 2);
app.update();
assert!(app.video_state.videos(CollectionKind::Watching).is_empty());
let fresh = app.video_state.progress_file(&videos[2]).unwrap();
video_state::register_identity(&fresh, &videos[2].id).unwrap();
report(&fresh, &videos[2].id, 1);
app.update();
rename_press(&mut app, KeyCode::Char('X'));
assert_eq!(
app.collection_removal.as_ref().unwrap().ids,
[videos[2].id.clone()]
);
rename_press(&mut app, KeyCode::Enter);
assert!(app.collection_removal.is_some());
rename_press(&mut app, KeyCode::Char('y'));
assert!(app.video_state.videos(CollectionKind::Watching).is_empty());
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 3);
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 3);
assert!(app.video_state.is_watched(&videos[0].id));
assert!(app.video_state.is_watched(&videos[1].id));
assert!(!app.video_state.is_watched(&videos[2].id));
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn direct_jumps_reuse_cached_views_and_navigation_with_configured_bindings() {
for (document, search, feed) in [
("", KeyCode::Char('/'), KeyCode::Char('F')),
(
"[keys]\nview.search = 'f6'\nview.feed = 'f7'\n",
KeyCode::F(6),
KeyCode::F(7),
),
] {
let mut app = app(&["tubular", "global draft"]);
if !document.is_empty() {
let document = document.parse::<toml_edit::DocumentMut>().unwrap();
app.config.keys = keys::Bindings::from_toml(document.get("keys")).unwrap();
}
let videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"l-GaaivVJCE","title":"Second"}]}"#
).unwrap().videos;
app.views.push(View::new(
"Temporary".into(),
ViewSource::Channel("creator".into()),
));
for view in &mut app.views {
view.loaded = true;
view.videos = videos.clone();
view.selection.select(Some(1));
view.next_start = 61;
}
app.view_index = 2;
app.preview = Some(PreviewMode::Description);
rename_press(&mut app, feed);
assert_eq!(app.view_index, 1);
assert_eq!(app.mode, Mode::Normal);
assert!(app.preview.is_none());
rename_press(&mut app, search);
assert_eq!(app.view_index, 0);
assert_eq!(app.views[0].query, "global draft");
rename_press(&mut app, KeyCode::Char('-'));
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Char('-'));
assert_eq!(app.view_index, 2);
rename_press(&mut app, KeyCode::Char('+'));
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Char('+'));
assert_eq!(app.view_index, 0);
for view in &app.views {
assert_eq!(view.videos[1].id, "l-GaaivVJCE");
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.next_start, 61);
}
assert!(app.job.is_none());
for source in [
ViewSource::Channel("creator".into()),
ViewSource::SavedVideos(None),
ViewSource::WatchLater(None),
ViewSource::Watching,
] {
app.views[2].source = source;
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.view_index = 2;
app.preview = preview;
rename_press(&mut app, search);
assert_eq!(app.view_index, 0);
assert_eq!(app.mode, Mode::Normal);
assert!(app.preview.is_none());
rename_press(&mut app, feed);
assert_eq!(app.view_index, 1);
}
}
app.view_index = 0;
if !document.is_empty() {
app.view_index = 2;
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.view_index, 2, "remapping replaces both defaults");
}
let document = "[keys]\nview.search = []\nview.feed = []\n"
.parse::<toml_edit::DocumentMut>()
.unwrap();
app.config.keys = keys::Bindings::from_toml(document.get("keys")).unwrap();
app.view_index = 2;
rename_press(&mut app, search);
rename_press(&mut app, feed);
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.view_index, 2);
assert!(app.job.is_none());
}
}
#[test]
fn direct_jump_keys_remain_literal_or_inert_in_modals() {
let mut app = app(&["tubular"]);
app.views[1].loaded = true;
app.view_index = 1;
rename_press(&mut app, KeyCode::Char('i'));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.views[0].query, "/F");
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Esc);
for kind in [BrowserKind::Categories, BrowserKind::Channels] {
app.open_browser(kind);
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Char('i'));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.browser.as_ref().unwrap().query, "/F");
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Esc);
}
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@creator".into(),
channel: "creator".into(),
},
"Creator".into(),
Default::default(),
));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Char('i'));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.category_dialog.as_ref().unwrap().query, "/F");
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Char('n'));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("/F")
);
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Char('?'));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert!(app.help_popup.is_some());
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Esc);
app.collection_removal = Some(CollectionRemoval {
kind: CollectionKind::Saved,
ids: Vec::new(),
category: None,
filter: None,
text: "Confirm removal".into(),
});
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert!(app.collection_removal.is_some());
assert_eq!(app.view_index, 1);
rename_press(&mut app, KeyCode::Esc);
let mut group = View::new("Combined".into(), ViewSource::CategoryGroup(vec![]));
group.loaded = true;
app.views.push(group);
let group_index = app.views.len() - 1;
app.view_index = group_index;
rename_press(&mut app, KeyCode::Char('P'));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('F'));
assert_eq!(app.category_name_input.as_ref().unwrap().name, "/F");
assert_eq!(app.view_index, group_index);
}
#[test]
fn category_and_group_queries_own_drafts_pages_and_errors_without_touching_search() {
for source in [
ViewSource::Category("Alpha".into()),
ViewSource::CategoryGroup(vec!["Alpha".into(), "Beta".into()]),
] {
let mut app = app(&["tubular", "global draft"]);
app.views[0].submitted_query = "global submitted".into();
app.views[0].loaded = true;
app.views[0].next_start = 61;
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"l-GaaivVJCE","title":"Global cached result"}]}"#,
)
.unwrap()
.videos;
app.views[0].selection.select(Some(0));
app.apply_config(config::Config {
categories: [("Alpha".into(), vec![]), ("Beta".into(), vec![])].into(),
..Default::default()
});
app.browse_view("Scoped creators".into(), source.clone());
let index = app.view_index;
let output = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached"}]}"#;
app.views[index].feed_cursor.plan(1).unwrap();
app.views[index]
.accept_page(feed_fixture(output).unwrap(), true)
.unwrap();
rename_press(&mut app, KeyCode::Char('i'));
app.paste(" robotics 日本語 ");
rename_press(&mut app, KeyCode::Enter);
assert_eq!(app.views[index].submitted_query, "robotics 日本語");
assert_eq!(app.view_index, index);
assert_eq!(app.mode, Mode::Normal);
assert!(app.views[index].videos.is_empty());
assert_eq!(app.views[index].selection.selected(), None);
assert_eq!(app.views[index].next_start, 1);
assert_eq!(app.views[index].feed_cursor.plan(1).unwrap()[0].start, 1);
app.finish_page(Err("Scoped request failed".into()));
rename_press(&mut app, KeyCode::Char('i'));
rename_press(&mut app, KeyCode::Enter);
assert_eq!(app.view_index, index);
assert!(app.views[index].page_error.is_some());
assert!(
app.job.is_none(),
"repeated failed query must not retry globally"
);
app.views[index]
.accept_page(feed_fixture(output).unwrap(), true)
.unwrap();
let next_start = app.views[index].next_start;
rename_press(&mut app, KeyCode::Char('i'));
rename_press(&mut app, KeyCode::Enter);
assert_eq!(app.views[index].videos[0].id, "jNQXAC9IVRw");
assert_eq!(app.views[index].next_start, next_start);
rename_press(&mut app, KeyCode::Char('i'));
app.paste(" draft");
rename_press(&mut app, KeyCode::Esc);
assert_eq!(app.views[index].submitted_query, "robotics 日本語");
assert!(app.views[index].query.ends_with(" draft"));
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(120, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let text: String = buffer.content.iter().map(|cell| cell.symbol()).collect();
assert!(text.contains("Category search"));
assert!(!text.contains("YouTube search"));
rename_press(&mut app, KeyCode::Char('/'));
rename_press(&mut app, KeyCode::Char('-'));
assert_eq!(app.views[app.view_index].source, source);
assert!(app.views[index].query.ends_with(" draft"));
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
rename_press(&mut app, KeyCode::Enter);
assert_eq!(app.view_index, index);
assert!(app.views[index].submitted_query.is_empty());
assert!(app.views[index].videos.is_empty());
assert_eq!(app.views[index].next_start, 1);
assert!(app.job.is_none());
assert_eq!(app.views[0].query, "global draft");
assert_eq!(app.views[0].submitted_query, "global submitted");
assert_eq!(app.views[0].next_start, 61);
assert_eq!(app.views[0].videos[0].id, "l-GaaivVJCE");
assert_eq!(app.views[0].selection.selected(), Some(0));
}
}
#[test]
fn other_sources_submit_to_general_search_and_blank_global_query_is_a_noop() {
let mut app = app(&["tubular", " cached global "]);
app.views[0].submitted_query = "cached global".into();
app.views[0].loaded = true;
app.views[0].next_start = 61;
for source in [
ViewSource::Feed,
ViewSource::Channel("creator".into()),
ViewSource::WatchLater(None),
ViewSource::SavedVideos(None),
] {
let mut view = View::new("Other".into(), source);
view.loaded = true;
app.views.push(view);
app.view_index = app.views.len() - 1;
rename_press(&mut app, KeyCode::Char('i'));
rename_press(&mut app, KeyCode::Enter);
assert_eq!(app.view_index, 0);
assert_eq!(app.views[0].next_start, 61);
assert!(app.job.is_none());
}
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
rename_press(&mut app, KeyCode::Enter);
assert!(app.views[0].query.is_empty());
assert_eq!(app.views[0].submitted_query, "cached global");
assert_eq!(app.views[0].next_start, 61);
assert!(app.job.is_none());
}
// Unrelated UI fixtures still parse real feed envelopes with a shared-budget plan.
fn feed_fixture(output: &str) -> Result<Page, String> {
let channels = serde_json::Deserializer::from_str(output)
.into_iter::<serde_json::Value>()
.count();
let requests = youtube::FeedCursor::default().plan(channels).unwrap();
youtube::feed_results(output, &requests)
}
fn finish_feed_fixture(app: &mut App, output: &str, full: bool) {
let view = &mut app.views[app.view_index];
let channels = view
.source
.channels(&app.config, &app.feed_channels, &view.group_channels)
.len();
view.feed_requests = view.feed_cursor.plan(channels).unwrap();
let mut envelopes: Vec<_> = serde_json::Deserializer::from_str(output)
.into_iter::<serde_json::Value>()
.map(Result::unwrap)
.collect();
assert!(envelopes.len() <= view.feed_requests.len());
envelopes.resize_with(
view.feed_requests.len(),
|| serde_json::json!({"entries":[]}),
);
if full {
for (envelope, request) in envelopes.iter_mut().zip(&view.feed_requests) {
let entries = envelope["entries"].as_array_mut().unwrap();
assert!(entries.len() <= request.count);
entries.resize(request.count, serde_json::Value::Null);
}
}
let output = envelopes
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join("\n");
app.finish_page(Ok(output));
}
fn choose_combined(app: &mut App, key: KeyEvent) {
app.key(key);
while app
.browser
.as_ref()
.unwrap()
.selection
.selected()
.unwrap_or(0)
!= 0
{
app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
}
fn rename_app(label: &str, keys: &str) -> App {
let root = std::env::temp_dir().join(format!("tubular-rename-{label}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
let path = root.join("config.toml");
std::fs::write(&path, format!(
"[settings]\npinned_categories = ['Alpha']\n[channels]\n'@Alpha' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n[categories]\nAlpha = ['@Alpha']\nOther = []\n{keys}"
)).unwrap();
App::new(
Options::parse_from(["tubular"]),
path.clone(),
config::load(&path).unwrap(),
)
}
fn rename_press(app: &mut App, code: KeyCode) {
app.key(KeyEvent::new(code, KeyModifiers::NONE));
}
fn rename_to(app: &mut App, name: &str) {
app.key(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT));
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
app.paste(name);
rename_press(app, KeyCode::Enter);
assert!(app.category_name_input.is_none());
}
fn group_app(label: &str, keys: &str) -> App {
let mut app = rename_app(&format!("group-{label}"), keys);
let config_text = |members: &str| {
format!(
"# keep this comment\n[settings]\npinned_categories = ['Alpha']\n[channels]\n'@Alpha' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n'@Alias' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n'@Beta' = 'UC4QobU6STFB0P71PMvOGN5A'\n[categories]\n{members}\n{keys}"
)
};
std::fs::write(
&app.config_path,
config_text("Alpha = []\nBeta = []\nGamma = []"),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Down);
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Enter);
std::fs::write(
&app.config_path,
config_text("Alpha = ['@Alpha']\nBeta = ['@Alias', '@Beta']\nGamma = []"),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
app.views[app.view_index].loaded = true;
app
}
#[test]
fn category_checks_survive_filters_and_enter_uses_zero_one_or_many_choices() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
categories: [
("Alpha".into(), vec![]),
("Beta".into(), vec![]),
("Gamma".into(), vec![]),
]
.into(),
..Default::default()
});
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Char('i'));
app.paste("beta");
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
app.paste("no match");
assert!(app.browser.as_ref().unwrap().matches.is_empty());
rename_press(&mut app, KeyCode::Enter);
let combined = app.views[app.view_index].source.clone();
assert_eq!(
combined,
ViewSource::CategoryGroup(vec!["Alpha".into(), "Beta".into()])
);
rename_press(&mut app, KeyCode::Char('c'));
assert_eq!(
app.browser
.as_ref()
.unwrap()
.checked
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
["Alpha", "Beta"]
);
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Enter);
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Beta".into())
);
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Down);
rename_press(&mut app, KeyCode::Enter);
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Gamma".into())
);
let before = app.views[app.view_index].source.clone();
let history = app.view_history.clone();
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Esc);
assert_eq!(app.views[app.view_index].source, before);
assert_eq!(app.view_history, history);
rename_press(&mut app, KeyCode::Char('c'));
assert!(app.browser.as_ref().unwrap().checked.is_empty());
rename_press(&mut app, KeyCode::Char('i'));
app.paste("no match");
rename_press(&mut app, KeyCode::Enter);
assert!(app.browser.is_some());
assert_eq!(app.views[app.view_index].source, before);
}
#[test]
fn combined_feed_deduplicates_overlapping_rows_and_restores_pages_through_history() {
let mut app = group_app("pages", "");
let group = app.views[app.view_index].source.clone();
assert_eq!(
app.views[app.view_index].group_channels,
[
"https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A",
"https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA",
]
);
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Shared","timestamp":300},{"id":"l-GaaivVJCE","title":"Old","timestamp":100}]}
{"entries":[{"id":"jNQXAC9IVRw","title":"Shared again","timestamp":300},{"id":"rQ_J9WH6CGk","title":"Middle","timestamp":200}]}"#,
true,
);
assert_eq!(
app.views[app.view_index]
.videos
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["jNQXAC9IVRw", "rQ_J9WH6CGk", "l-GaaivVJCE"]
);
rename_press(&mut app, KeyCode::Down);
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"l-GaaivVJCE","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Last","timestamp":50}]}"#,
false,
);
let next_start = app.views[app.view_index].next_start;
let names = vec!["Alpha".into(), "Gamma".into()];
let mut replacement = View::new(group_name(&names), ViewSource::CategoryGroup(names));
replacement.group_channels = app.config.categories["Alpha"].clone();
replacement.loaded = true;
app.views.push(replacement);
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Down);
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Down);
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Enter);
assert_eq!(
app.views[app.view_index].source,
ViewSource::CategoryGroup(vec!["Alpha".into(), "Gamma".into()])
);
assert_eq!(
app.visible_views()
.filter(|(_, view)| matches!(view.source, ViewSource::CategoryGroup(_)))
.count(),
1
);
rename_press(&mut app, KeyCode::Char('-'));
let view = &app.views[app.view_index];
assert_eq!(view.source, group);
assert_eq!(view.videos.len(), 4);
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.next_start, next_start);
assert!(app.job.is_none());
rename_press(&mut app, KeyCode::Char('+'));
assert_eq!(
app.views[app.view_index].source,
ViewSource::CategoryGroup(vec!["Alpha".into(), "Gamma".into()])
);
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn combined_cache_resets_only_for_changed_resolved_union_and_drops_deleted_members() {
let mut app = group_app("config", "");
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
false,
);
let group = app.views[app.view_index].source.clone();
let original = std::fs::read_to_string(&app.config_path).unwrap();
std::fs::write(
&app.config_path,
original
.replace("Alpha = ['@Alpha']", "Alpha = ['@Beta']")
.replace("Beta = ['@Alias', '@Beta']", "Beta = ['@Alpha']"),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
let view = &app.views[app.view_index];
assert_eq!(view.source, group);
assert_eq!(view.videos.len(), 1);
assert_eq!(view.next_start, PAGE_SIZE + 1);
std::fs::write(
&app.config_path,
original.replace("Beta = ['@Alias', '@Beta']", "Beta = ['@Alias']"),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
let view = &app.views[app.view_index];
assert_eq!(view.source, group);
assert_eq!(view.videos[0].title, "Cached");
assert!(!view.loaded);
assert_eq!(view.next_start, 1);
assert_eq!(view.group_channels.len(), 1);
app.views[app.view_index].loaded = true;
app.views[0].loaded = true;
app.switch_view(0);
std::fs::write(
&app.config_path,
original.replace("Beta = ['@Alias', '@Beta']\n", ""),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
rename_press(&mut app, KeyCode::Char('-'));
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
assert!(!app.views.iter().any(|view| view.source == group));
assert!(app.temporary_view.is_none());
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn checked_category_rename_preserves_canonical_group_pin_selection_and_history() {
let mut app = group_app("rename", "");
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
false,
);
app.views[app.view_index].query = "draft astronomy".into();
app.views[app.view_index].submitted_query = "astronomy".into();
let old = app.views[app.view_index].source.clone();
app.view_history.push(old.clone());
app.forward_history.push(old);
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Char('i'));
app.paste("Alpha");
rename_press(&mut app, KeyCode::Esc);
let original = std::fs::read_to_string(&app.config_path).unwrap();
std::fs::write(&app.config_path, format!("{original}Extra = []\n")).unwrap();
rename_press(&mut app, KeyCode::Char('p'));
assert_eq!(app.browser.as_ref().unwrap().checked.len(), 2);
assert!(app.browser.as_ref().unwrap().checked.contains("Alpha"));
assert!(!app.config.pinned_categories.contains(&"Alpha".into()));
rename_press(&mut app, KeyCode::Char('p'));
rename_to(&mut app, "Zeta");
let renamed = ViewSource::CategoryGroup(vec!["Beta".into(), "Zeta".into()]);
assert_eq!(app.views[app.view_index].source, renamed);
assert_eq!(app.temporary_view, Some(renamed.clone()));
assert!(app.view_history.contains(&renamed));
assert!(app.forward_history.contains(&renamed));
assert_eq!(app.views[app.view_index].videos.len(), 1);
assert_eq!(app.views[app.view_index].query, "draft astronomy");
assert_eq!(app.views[app.view_index].submitted_query, "astronomy");
assert_eq!(app.config.pinned_categories, ["Zeta"]);
let browser = app.browser.as_ref().unwrap();
assert_eq!(
browser
.checked
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
["Beta", "Zeta"]
);
assert_eq!(browser.selected_choice().unwrap().0, "Zeta");
rename_press(&mut app, KeyCode::Enter);
assert_eq!(app.views[app.view_index].source, renamed);
assert!(app.job.is_none());
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn saving_combined_view_copies_snapshot_and_preserves_cached_state_without_pinning() {
let mut app = group_app("save", "");
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","timestamp":200},{"id":"l-GaaivVJCE","title":"Second","timestamp":100}]}"#,
true,
);
rename_press(&mut app, KeyCode::Down);
let source = app.views[app.view_index].source.clone();
let channels = app.views[app.view_index].group_channels.clone();
let next_requests = app.views[app.view_index]
.feed_cursor
.plan(channels.len())
.unwrap();
app.views[app.view_index].feed_requests = next_requests.clone();
app.views[app.view_index].prefetch_requested = true;
app.views[app.view_index].has_more = true;
app.views[app.view_index].page_error = Some("keep failure".into());
app.views[app.view_index].query = "draft physics".into();
app.views[app.view_index].submitted_query = "physics".into();
let original = std::fs::read_to_string(&app.config_path).unwrap();
rename_press(&mut app, KeyCode::Char('P'));
app.paste("Saved union");
rename_press(&mut app, KeyCode::Esc);
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
assert_eq!(app.views[app.view_index].source, source);
for invalid in [" ", "Alpha", "Bad\nname"] {
rename_press(&mut app, KeyCode::Char('P'));
app.category_name_input.as_mut().unwrap().name = invalid.into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
assert_eq!(app.views[app.view_index].source, source);
rename_press(&mut app, KeyCode::Esc);
}
rename_press(&mut app, KeyCode::Char('P'));
app.paste("OnDisk");
let external = format!("{original}OnDisk = []\n");
std::fs::write(&app.config_path, &external).unwrap();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), external);
assert_eq!(app.views[app.view_index].source, source);
rename_press(&mut app, KeyCode::Esc);
std::fs::write(&app.config_path, &original).unwrap();
rename_press(&mut app, KeyCode::Char('P'));
app.paste(" Saved union ");
// External edits do not change the union being saved.
std::fs::write(
&app.config_path,
original.replace("Alpha = ['@Alpha']", "Alpha = []"),
)
.unwrap();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.is_none());
let view = &app.views[app.view_index];
assert_eq!(view.source, ViewSource::Category("Saved union".into()));
assert_eq!(view.query, "draft physics");
assert_eq!(view.submitted_query, "physics");
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.videos.len(), 2);
assert_eq!(view.next_start, PAGE_SIZE + 1);
assert_eq!(view.feed_requests, next_requests);
assert_eq!(
view.feed_cursor.clone().plan(channels.len()).unwrap(),
next_requests
);
assert!(view.prefetch_requested);
assert!(view.has_more);
assert_eq!(view.page_error.as_deref(), Some("keep failure"));
assert!(app.job.is_none());
assert_eq!(app.config.categories["Saved union"], channels);
assert_eq!(app.config.categories["Beta"].len(), 2);
assert!(app.config.categories["Alpha"].is_empty());
assert_eq!(app.config.pinned_categories, ["Alpha"]);
assert_eq!(
app.temporary_view,
Some(ViewSource::Category("Saved union".into()))
);
let disk = std::fs::read_to_string(&app.config_path)
.unwrap()
.parse::<toml_edit::DocumentMut>()
.unwrap();
assert_eq!(
disk["categories"]["Saved union"]
.as_array()
.unwrap()
.iter()
.map(|value| value.as_str().unwrap())
.collect::<Vec<_>>(),
["@Beta", "@Alias"]
);
assert!(
std::fs::read_to_string(&app.config_path)
.unwrap()
.starts_with("# keep this comment")
);
rename_press(&mut app, KeyCode::Char('-'));
assert_eq!(app.views[app.view_index].source, source);
assert_eq!(app.views[app.view_index].group_channels, channels);
let saved = std::fs::read_to_string(&app.config_path).unwrap();
std::fs::write(
&app.config_path,
saved.replace("Beta = ['@Alias', '@Beta']", "Beta = []"),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
assert!(app.views[app.view_index].group_channels.is_empty());
assert_eq!(app.views[app.view_index].query, "draft physics");
assert_eq!(app.views[app.view_index].submitted_query, "physics");
assert_eq!(app.config.categories["Saved union"], channels);
app.forward_view();
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Saved union".into())
);
assert_eq!(app.views[app.view_index].videos.len(), 2);
assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
assert_eq!(app.views[app.view_index].submitted_query, "physics");
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn configurable_group_controls_share_text_editing_and_are_inert_outside_groups() {
let keys = "[keys]\nselector.toggle = 'f5'\ncategory.save = 'f6'\ninput.submit = 'f7'\ninput.cancel = 'f8'\ninput.delete.line = 'f9'\ninput.delete.word = 'f10'\ninput.delete.character = 'f11'\n";
let mut app = group_app("remapped", "");
let doc = keys.parse::<toml_edit::DocumentMut>().unwrap();
app.config.keys = keys::Bindings::from_toml(doc.get("keys")).unwrap();
let original = std::fs::read_to_string(&app.config_path).unwrap();
rename_press(&mut app, KeyCode::Char('c'));
rename_press(&mut app, KeyCode::Char(' '));
assert_eq!(app.browser.as_ref().unwrap().checked.len(), 2);
rename_press(&mut app, KeyCode::F(5));
assert_eq!(app.browser.as_ref().unwrap().checked.len(), 1);
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::SHIFT));
app.paste("P R");
assert_eq!(app.browser.as_ref().unwrap().query, " P R");
assert_eq!(app.browser.as_ref().unwrap().checked.len(), 1);
rename_press(&mut app, KeyCode::F(8));
rename_press(&mut app, KeyCode::Esc);
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.preview = preview;
rename_press(&mut app, KeyCode::Char('P'));
assert!(app.category_name_input.is_none());
rename_press(&mut app, KeyCode::F(6));
assert!(app.category_name_input.is_some());
rename_press(&mut app, KeyCode::F(9));
app.paste("日本語 words");
rename_press(&mut app, KeyCode::F(10));
rename_press(&mut app, KeyCode::F(11));
app.key(KeyEvent::new(KeyCode::Char('P'), KeyModifiers::SHIFT));
app.paste("\nR\t");
assert_eq!(app.category_name_input.as_ref().unwrap().name, "日本語P R ");
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.is_some());
rename_press(&mut app, KeyCode::F(8));
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
}
app.views[0].loaded = true;
app.switch_view(0);
rename_press(&mut app, KeyCode::F(6));
assert!(app.category_name_input.is_none());
for kind in [
BrowserKind::Channels,
BrowserKind::WatchLater,
BrowserKind::SavedVideos,
] {
app.open_browser(kind);
rename_press(&mut app, KeyCode::F(5));
rename_press(&mut app, KeyCode::F(6));
assert!(app.browser.as_ref().unwrap().checked.is_empty());
assert!(app.category_name_input.is_none());
rename_press(&mut app, KeyCode::Esc);
}
app.back_view();
rename_press(&mut app, KeyCode::F(6));
app.paste("Remapped");
rename_press(&mut app, KeyCode::F(7));
assert!(app.category_name_input.is_none());
assert!(app.config.categories.contains_key("Remapped"));
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn combined_sources_do_not_infer_a_category_for_scoped_actions() {
let mut app = group_app("scopes", "");
let source = app.views[app.view_index].source.clone();
for key in [
KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT),
KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT),
KeyEvent::new(KeyCode::Char('w'), KeyModifiers::ALT),
KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT),
] {
app.key(key);
assert_eq!(app.views[app.view_index].source, source);
assert!(app.category_dialog.is_none());
assert!(app.category_name_input.is_none());
assert!(app.browser.is_none());
}
for key in ['W', 'V'] {
rename_press(&mut app, KeyCode::Char(key));
assert!(app.browser.is_some());
assert!(app.browser.as_ref().unwrap().checked.is_empty());
rename_press(&mut app, KeyCode::Esc);
assert_eq!(app.views[app.view_index].source, source);
}
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn empty_combined_view_can_be_saved_as_an_empty_category() {
let mut app = group_app("empty-save", "");
let original = std::fs::read_to_string(&app.config_path).unwrap();
std::fs::write(
&app.config_path,
original
.replace("Alpha = ['@Alpha']", "Alpha = []")
.replace("Beta = ['@Alias', '@Beta']", "Beta = []"),
)
.unwrap();
app.apply_config(config::load(&app.config_path).unwrap());
rename_press(&mut app, KeyCode::Char('P'));
app.paste("Empty union");
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.is_none());
assert!(app.config.categories["Empty union"].is_empty());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Empty union".into())
);
assert!(app.views[app.view_index].loaded);
assert!(app.views[app.view_index].videos.is_empty());
assert!(app.job.is_none());
assert_eq!(app.config.pinned_categories, ["Alpha"]);
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn category_checkboxes_and_dim_pins_remain_distinct_when_highlighted() {
use ratatui::{Terminal, backend::TestBackend, style::Modifier};
let mut app = group_app("markers", "");
rename_press(&mut app, KeyCode::Char('c'));
let mut terminal = Terminal::new(TestBackend::new(100, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let row = (0..buffer.area.height)
.find_map(|y| {
let text: String = (0..buffer.area.width)
.map(|x| buffer[(x, y)].symbol())
.collect();
text.find("[x] Alpha p")
.map(|byte| (text[..byte].chars().count() as u16, y))
})
.expect("checked and pinned category row");
assert!(buffer[(row.0 + 10, row.1)].modifier.contains(Modifier::DIM));
rename_press(&mut app, KeyCode::Char(' '));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let text: String = (0..buffer.area.width)
.map(|x| buffer[(x, row.1)].symbol())
.collect();
assert!(text.contains("[ ] Alpha p"));
assert!(buffer[(row.0 + 10, row.1)].modifier.contains(Modifier::DIM));
assert!(app.config.pinned_categories.contains(&"Alpha".into()));
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn category_rename_preserves_pins_cached_pages_collection_scopes_and_history() {
let mut app = rename_app("cache", "");
let videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"l-GaaivVJCE","title":"Second"}]}"#
).unwrap().videos;
for source in [
ViewSource::WatchLater(Some("Alpha".into())),
ViewSource::SavedVideos(Some("Alpha".into())),
] {
let mut view = View::new("Alpha collection".into(), source);
view.videos = videos.clone();
view.selection.select(Some(1));
view.loaded = true;
view.watch_filter = WatchFilter::Watched;
app.views.push(view);
}
app.view_index = 2;
let view = &mut app.views[2];
view.query = " draft robotics ".into();
view.submitted_query = "robotics".into();
view.videos = videos.clone();
view.feed_requests = view.feed_cursor.plan(1).unwrap();
view.prefetch_requested = true;
view.selection.select(Some(1));
view.loaded = true;
view.next_start = 41;
view.has_more = true;
view.page_error = Some("keep page failure".into());
app.temporary_view = Some(ViewSource::SavedVideos(Some("Alpha".into())));
app.view_history = vec![ViewSource::WatchLater(Some("Alpha".into()))];
app.forward_history = vec![ViewSource::SavedVideos(Some("Alpha".into()))];
rename_to(&mut app, "Zeta");
let view = &app.views[app.view_index];
assert_eq!(view.source, ViewSource::Category("Zeta".into()));
assert_eq!(view.name, "Zeta");
assert_eq!(view.query, " draft robotics ");
assert_eq!(view.submitted_query, "robotics");
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.videos.len(), 2);
assert_eq!(view.feed_requests.len(), 1);
assert!(view.prefetch_requested);
assert_eq!(view.next_start, 41);
assert!(view.loaded && view.has_more);
assert_eq!(view.page_error.as_deref(), Some("keep page failure"));
assert_eq!(app.config.pinned_categories, ["Zeta"]);
assert_eq!(app.views[2].source, ViewSource::Category("Other".into()));
assert_eq!(
app.temporary_view,
Some(ViewSource::SavedVideos(Some("Zeta".into())))
);
assert_eq!(
app.view_history,
[ViewSource::WatchLater(Some("Zeta".into()))]
);
assert_eq!(
app.forward_history,
[ViewSource::SavedVideos(Some("Zeta".into()))]
);
for view in &app.views {
if matches!(
view.source,
ViewSource::WatchLater(_) | ViewSource::SavedVideos(_)
) {
assert_eq!(view.source.category(), Some("Zeta"));
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.watch_filter, WatchFilter::Watched);
assert_eq!(view.videos.len(), 2);
}
}
app.back_view();
assert_eq!(
app.views[app.view_index].source,
ViewSource::WatchLater(Some("Zeta".into()))
);
app.forward_view();
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Zeta".into())
);
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn rename_selectors_keep_renamed_match_selected_and_ignore_noncategory_rows() {
for (label, kind) in [
("categories", BrowserKind::Categories),
("later", BrowserKind::WatchLater),
("saved", BrowserKind::SavedVideos),
("channels", BrowserKind::Channels),
] {
let mut app = rename_app(label, "");
app.open_browser(kind);
if kind != BrowserKind::Categories {
rename_press(&mut app, KeyCode::Char('R'));
assert!(app.category_name_input.is_none());
}
if kind == BrowserKind::Channels {
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
continue;
}
let browser = app.browser.as_mut().unwrap();
browser.query = "alp".into();
browser.refilter();
rename_press(&mut app, KeyCode::Char('R'));
rename_press(&mut app, KeyCode::Esc);
assert_eq!(app.browser.as_ref().unwrap().query, "alp");
rename_to(&mut app, "Zeta");
let browser = app.browser.as_ref().unwrap();
assert!(browser.query.is_empty());
let selected = browser.matches[browser.selection.selected().unwrap()];
assert_eq!(browser.choices[selected].1.category(), Some("Zeta"));
assert!(app.config.pinned_categories.contains(&"Zeta".into()));
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
for (label, source) in [
(
"later-current",
ViewSource::WatchLater(Some("Alpha".into())),
),
(
"saved-current",
ViewSource::SavedVideos(Some("Alpha".into())),
),
] {
let mut app = rename_app(label, "");
let mut view = View::new("Alpha collection".into(), source);
view.loaded = true;
app.views.push(view);
app.view_index = app.views.len() - 1;
rename_to(&mut app, "Zeta");
assert_eq!(app.views[app.view_index].source.category(), Some("Zeta"));
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
}
#[test]
fn rename_validation_keeps_prompt_and_disk_unchanged_including_external_edits() {
let mut app = rename_app("invalid", "");
app.view_index = 2;
let original = std::fs::read_to_string(&app.config_path).unwrap();
for name in ["", " ", "Other", "bad\nname"] {
rename_press(&mut app, KeyCode::Char('R'));
app.category_name_input.as_mut().unwrap().name = name.into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Alpha".into())
);
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
rename_press(&mut app, KeyCode::Esc);
}
rename_to(&mut app, "Alpha");
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
for external in [
original.replace("Alpha = ['@Alpha']", "Alpha = []"),
original.replace("Alpha = ['@Alpha']", "Removed = ['@Alpha']"),
original.replace("Other = []", "Other = []\nZeta = []"),
"not valid toml = [".into(),
] {
std::fs::write(&app.config_path, &external).unwrap();
rename_press(&mut app, KeyCode::Char('R'));
app.category_name_input.as_mut().unwrap().name = "Zeta".into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), external);
assert!(app.config.categories.contains_key("Alpha"));
rename_press(&mut app, KeyCode::Esc);
}
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn tag_rename_preserves_staging_retargets_bulk_source_and_saves_only_on_tag_submit() {
for bulk in [false, true] {
let mut app = rename_app(if bulk { "bulk" } else { "single" }, "");
app.view_index = 2;
let channel = app.config.categories["Alpha"][0].clone();
if bulk {
app.open_bulk_category_picker();
} else {
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@Alpha".into(),
channel: channel.clone(),
},
" @Alpha ".into(),
[("Alpha".into(), true), ("Other".into(), false)].into(),
));
}
let dialog = app.category_dialog.as_mut().unwrap();
dialog.tags.insert("Staged".into(), true);
dialog.tags.insert("Unchecked".into(), false);
dialog.tags.insert("Other".into(), true);
dialog.search_names = dialog.tags.keys().map(|tag| tag.to_lowercase()).collect();
dialog.query = "Alpha".into();
dialog.refilter();
rename_to(&mut app, "Zeta");
let disk = config::load(&app.config_path).unwrap();
assert_eq!(disk.categories["Zeta"], std::slice::from_ref(&channel));
assert!(disk.categories["Other"].is_empty());
assert!(!disk.categories.contains_key("Staged"));
let dialog = app.category_dialog.as_ref().unwrap();
assert!(dialog.tags["Zeta"] && dialog.tags["Other"] && dialog.tags["Staged"]);
assert!(!dialog.tags["Unchecked"]);
if let CategoryTarget::Category { name, channels } = &dialog.target {
assert_eq!(name, "Zeta");
assert_eq!(channels, std::slice::from_ref(&channel));
}
rename_press(&mut app, KeyCode::Esc);
assert!(app.category_dialog.is_none());
assert!(config::load(&app.config_path).unwrap().categories["Other"].is_empty());
// Reopen with staged memberships and rename the bulk source a second time;
// saving must use the new identity, not the now-missing original key.
app.category_dialog = Some(CategoryDialog::new(
if bulk {
CategoryTarget::Category {
name: "Zeta".into(),
channels: vec![channel.clone()],
}
} else {
CategoryTarget::Channel {
handle: "@Alpha".into(),
channel: channel.clone(),
}
},
" target ".into(),
[
("Zeta".into(), true),
("Other".into(), true),
("Staged".into(), true),
]
.into(),
));
let dialog = app.category_dialog.as_mut().unwrap();
dialog.query = "Zeta".into();
dialog.refilter();
rename_to(&mut app, "Beta");
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_dialog.is_none());
let disk = config::load(&app.config_path).unwrap();
for tag in ["Beta", "Other", "Staged"] {
assert_eq!(disk.categories[tag], std::slice::from_ref(&channel));
}
assert!(!disk.categories.contains_key("Zeta"));
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
}
#[test]
fn new_tag_rename_is_local_and_rejects_staged_and_external_collisions() {
let mut app = rename_app("new-tag", "");
let channel = app.config.categories["Alpha"][0].clone();
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@Alpha".into(),
channel,
},
" @Alpha ".into(),
[
("Alpha".into(), true),
("Other".into(), false),
("Staged".into(), false),
]
.into(),
));
let dialog = app.category_dialog.as_mut().unwrap();
dialog.query = "Staged".into();
dialog.refilter();
let original = std::fs::read_to_string(&app.config_path).unwrap();
rename_press(&mut app, KeyCode::Char('R'));
app.category_name_input.as_mut().unwrap().name = "Other".into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
app.category_name_input.as_mut().unwrap().name = "Alpha".into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
std::fs::write(&app.config_path, format!("{original}OnDisk = []\n")).unwrap();
app.category_name_input.as_mut().unwrap().name = "OnDisk".into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
std::fs::write(&app.config_path, format!("{original}Staged = []\n")).unwrap();
app.category_name_input.as_mut().unwrap().name = "Renamed new".into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.as_ref().unwrap().error.is_some());
std::fs::write(&app.config_path, &original).unwrap();
app.category_name_input.as_mut().unwrap().name = "Renamed new".into();
rename_press(&mut app, KeyCode::Enter);
assert!(app.category_name_input.is_none());
assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
let dialog = app.category_dialog.as_ref().unwrap();
assert!(!dialog.tags["Renamed new"]);
assert!(!dialog.tags.contains_key("Staged"));
rename_press(&mut app, KeyCode::Char(' '));
rename_press(&mut app, KeyCode::Enter);
assert!(
config::load(&app.config_path)
.unwrap()
.categories
.contains_key("Renamed new")
);
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn unpinned_category_rename_retains_its_temporary_tab_and_cached_rows() {
let mut app = rename_app("unpinned", "");
let config = config::set_category_pinned(&app.config_path, "Alpha", false).unwrap();
app.apply_config(config);
app.view_index = 2;
app.views[2].loaded = true;
app.views[2].next_start = 61;
app.temporary_view = Some(ViewSource::Category("Alpha".into()));
rename_to(&mut app, "Zeta");
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Zeta".into())
);
assert_eq!(app.views[app.view_index].next_start, 61);
assert_eq!(
app.temporary_view,
Some(ViewSource::Category("Zeta".into()))
);
assert!(app.config.pinned_categories.is_empty());
assert_eq!(
app.visible_views().last().unwrap().1.source,
ViewSource::Category("Zeta".into())
);
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn rename_uses_configured_actions_and_uppercase_r_stays_literal_in_all_inputs() {
let keys = "[keys]\ncategory.rename = 'f6'\ninput.submit = 'f7'\ninput.cancel = 'f8'\ninput.delete.line = 'f9'\ninput.delete.word = 'f10'\ninput.delete.character = 'f11'\n";
for entry in ["view", "browser", "tags"] {
let mut app = rename_app(&format!("remapped-{entry}"), keys);
app.view_index = 2;
match entry {
"browser" => app.open_browser(BrowserKind::Categories),
"tags" => {
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@Alpha".into(),
channel: app.config.categories["Alpha"][0].clone(),
},
" target ".into(),
[("Alpha".into(), true), ("Other".into(), false)].into(),
))
}
_ => {}
}
app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
assert!(
app.category_name_input.is_none(),
"default action is replaced"
);
rename_press(&mut app, KeyCode::F(6));
assert_eq!(app.key_context(), Context::CategoryNameInput);
rename_press(&mut app, KeyCode::F(9));
app.paste("日本語 words");
rename_press(&mut app, KeyCode::F(10));
assert_eq!(app.category_name_input.as_ref().unwrap().name, "日本語 ");
rename_press(&mut app, KeyCode::F(11));
app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
app.paste("\n?\t");
assert_eq!(app.category_name_input.as_ref().unwrap().name, "日本語R ? ");
assert!(app.help_popup.is_none());
rename_press(&mut app, KeyCode::F(8));
assert!(app.category_name_input.is_none());
assert!(app.config.categories.contains_key("Alpha"));
rename_press(&mut app, KeyCode::F(6));
rename_press(&mut app, KeyCode::F(9));
app.paste("Zeta");
rename_press(&mut app, KeyCode::Enter);
assert!(
app.category_name_input.is_some(),
"default submit is replaced"
);
rename_press(&mut app, KeyCode::F(7));
assert!(app.category_name_input.is_none());
assert!(
config::load(&app.config_path)
.unwrap()
.categories
.contains_key("Zeta")
);
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
let mut app = rename_app("literal-r", "");
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
assert_eq!(app.views[0].query, "R");
assert!(app.category_name_input.is_none());
rename_press(&mut app, KeyCode::Esc);
app.open_browser(BrowserKind::Categories);
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
assert_eq!(app.browser.as_ref().unwrap().query, "R");
assert!(app.category_name_input.is_none());
app.browser = None;
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@Alpha".into(),
channel: app.config.categories["Alpha"][0].clone(),
},
" target ".into(),
[("Alpha".into(), true)].into(),
));
rename_press(&mut app, KeyCode::Char('i'));
app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
assert_eq!(app.category_dialog.as_ref().unwrap().query, "R");
assert!(app.category_name_input.is_none());
rename_press(&mut app, KeyCode::Esc);
rename_press(&mut app, KeyCode::Char('n'));
app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("R")
);
assert!(app.category_name_input.is_none());
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn rename_prompt_cursor_scrolls_by_display_width_without_changing_selection() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = rename_app("rename-cursor", "");
app.view_index = 2;
rename_press(&mut app, KeyCode::Char('R'));
let mut terminal = Terminal::new(TestBackend::new(24, 16)).unwrap();
for (text, x) in [
("", 3),
("日本語", 9),
("e\u{301}", 4),
("abcdefghijklmnopqrstuvwxyz", 20),
] {
app.category_name_input.as_mut().unwrap().name = text.into();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert_eq!(terminal.get_cursor_position().unwrap(), (x, 4).into());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Alpha".into())
);
}
rename_press(&mut app, KeyCode::Esc);
assert!(app.category_name_input.is_none());
std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}
#[test]
fn collection_removal_is_inert_in_ordinary_views_and_their_previews() {
let mut app = app(&["tubular"]);
app.config.categories.insert("Category".into(), vec![]);
let videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].videos = videos.clone();
app.views[0].loaded = true;
for row in 0..2 {
app.views[0].selection.select(Some(row));
app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE));
}
for source in [
ViewSource::Search,
ViewSource::Feed,
ViewSource::Category("Category".into()),
ViewSource::Channel(config::normalize_channel("@creator").unwrap()),
] {
let mut view = View::new("Ordinary".into(), source);
view.videos = videos.clone();
view.loaded = true;
view.selection.select(Some(0));
let index = app.views.len();
app.views.push(view);
app.switch_view(index);
for (preview, context) in [
(None, Context::Normal),
(Some(PreviewMode::Info), Context::Info),
(Some(PreviewMode::Description), Context::Description),
] {
app.preview = preview;
assert_eq!(app.key_context(), context);
assert!(app.current_collection().is_none());
let status = app.status.clone();
for key in ['x', 'X', 'D'] {
app.key(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE));
}
app.remove_collection();
app.remove_collection_bulk();
assert!(app.collection_removal.is_none());
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
assert_eq!(app.views[index].selection.selected(), Some(0));
assert_eq!(app.preview, preview);
assert_eq!(app.status, status);
app.paste("xX");
assert!(app.views[0].query.is_empty());
}
}
}
#[test]
fn collection_contexts_preserve_modal_priorities_and_cancel_bulk_from_each_preview() {
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
for row in 0..2 {
app.views[0].selection.select(Some(row));
app.save_collection(CollectionKind::WatchLater);
app.save_collection(CollectionKind::Saved);
}
for kind in [CollectionKind::WatchLater, CollectionKind::Saved] {
app.switch_view(0);
app.browse_collection(kind);
for (preview, context, cancel) in [
(None, Context::CollectionNormal, KeyCode::Char('n')),
(
Some(PreviewMode::Info),
Context::CollectionInfo,
KeyCode::Esc,
),
(
Some(PreviewMode::Description),
Context::CollectionDescription,
KeyCode::Char('n'),
),
] {
app.preview = preview;
assert_eq!(app.key_context(), context);
app.key(KeyEvent::new(KeyCode::Char('D'), KeyModifiers::SHIFT));
assert!(app.collection_removal.is_none());
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
assert_eq!(app.preview, None);
let removal = app.collection_removal.as_ref().unwrap();
assert_eq!(removal.ids.len(), 2);
assert!(removal.category.is_none());
assert_eq!(
removal.filter,
matches!(kind, CollectionKind::WatchLater).then_some(WatchFilter::All)
);
let history = app.view_history.clone();
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
app.paste("y");
assert!(app.collection_removal.is_some());
assert!(app.player_launch.is_none());
assert_eq!(app.view_history, history);
assert!(app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)));
assert!(app.collection_removal.is_some());
app.key(KeyEvent::new(cancel, KeyModifiers::NONE));
assert!(app.collection_removal.is_none());
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
}
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::SearchInput);
app.paste("xX");
assert_eq!(app.views[0].query, "xX");
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::CollectionNormal);
app.views[0].query.clear();
app.key(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::Help);
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
assert!(app.collection_removal.is_none());
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::CollectionNormal);
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::SelectorNormal);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::SelectorInput);
app.paste("xX");
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::CollectionNormal);
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@creator".into(),
channel: config::normalize_channel("@creator").unwrap(),
},
"Creator".into(),
[("Category".into(), false)].into(),
));
assert_eq!(app.key_context(), Context::TagList);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::TagFilter);
app.paste("xX");
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::TagInput);
app.paste("xX");
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("xX")
);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.key_context(), Context::CollectionNormal);
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
}
}
#[test]
fn bulk_removal_snapshots_saved_categories_and_watch_filters_independently() {
let root = std::env::temp_dir().join(format!("tubular-collection-bulk-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("watch-state.toml"),
"version = 1\nwatched = ['jNQXAC9IVRw']\n",
)
.unwrap();
let category_channels = vec![config::normalize_channel("@creator").unwrap()];
let config = config::Config {
categories: [("Category".into(), category_channels.clone())].into(),
..Default::default()
};
let path = root.join("config.toml");
let mut app = App::with_state(
Options::parse_from(["tubular"]),
path.clone(),
config,
video_state::State::open(&path).unwrap(),
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Watched","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Unwatched","uploader_id":"@creator"},{"id":"l-GaaivVJCE","title":"Outside category","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
for row in 0..3 {
app.views[0].selection.select(Some(row));
app.save_collection(CollectionKind::WatchLater);
app.save_collection(CollectionKind::Saved);
}
app.views[2].loaded = true;
app.switch_view(2);
app.browse_category_collection(CollectionKind::Saved);
app.preview = Some(PreviewMode::Description);
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::NONE));
let removal = app.collection_removal.as_ref().unwrap();
assert!(matches!(removal.kind, CollectionKind::Saved));
assert_eq!(removal.category.as_deref(), Some("Category"));
assert_eq!(removal.filter, None);
assert_eq!(removal.ids, ["jNQXAC9IVRw", "rQ_J9WH6CGk"]);
let prompt = removal.text.clone();
app.apply_config(config::Config {
categories: [(
"Category".into(),
vec![
config::normalize_channel("@creator").unwrap(),
config::normalize_channel("@other").unwrap(),
],
)]
.into(),
..Default::default()
});
assert_eq!(app.views[app.view_index].videos.len(), 3);
assert_eq!(app.collection_removal.as_ref().unwrap().text, prompt);
app.browse_category_collection(CollectionKind::WatchLater);
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 1);
assert!(
app.video_state
.contains(CollectionKind::Saved, "l-GaaivVJCE")
);
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 3);
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
app.apply_config(config::Config {
categories: [("Category".into(), category_channels)].into(),
..Default::default()
});
app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].videos.len(), 1);
app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].watch_filter, WatchFilter::Watched);
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
let removal = app.collection_removal.as_ref().unwrap();
assert!(matches!(removal.kind, CollectionKind::WatchLater));
assert_eq!(removal.filter, Some(WatchFilter::Watched));
assert_eq!(removal.ids, ["jNQXAC9IVRw"]);
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
assert!(app.views[app.view_index].videos.is_empty());
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 1);
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
app.switch_view(0);
app.browse_collection(CollectionKind::WatchLater);
app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].watch_filter,
WatchFilter::Unwatched
);
assert_eq!(app.views[app.view_index].videos.len(), 2);
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
assert!(app.collection_removal.as_ref().unwrap().category.is_none());
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert!(
app.video_state
.videos(CollectionKind::WatchLater)
.is_empty()
);
app.browse_collection(CollectionKind::Saved);
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert!(app.video_state.videos(CollectionKind::Saved).is_empty());
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
drop(app);
let restarted = video_state::State::open(&path).unwrap();
assert!(restarted.videos(CollectionKind::Saved).is_empty());
assert!(restarted.videos(CollectionKind::WatchLater).is_empty());
assert!(restarted.is_watched("jNQXAC9IVRw"));
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn individual_watch_later_removal_keeps_siblings_saved_and_watched() {
let root = std::env::temp_dir().join(format!(
"tubular-single-watch-removal-{}",
std::process::id()
));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("watch-state.toml"),
"version = 1\nwatched = ['jNQXAC9IVRw']\n",
)
.unwrap();
let mut app = App::with_state(
Options::parse_from(["tubular"]),
root.join("config.toml"),
config::Config::default(),
video_state::State::open(&root.join("config.toml")).unwrap(),
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@creator"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(0));
app.save_collection(CollectionKind::WatchLater);
app.save_collection(CollectionKind::Saved);
app.views[0].selection.select(Some(1));
app.save_collection(CollectionKind::WatchLater);
app.browse_collection(CollectionKind::WatchLater);
app.views[app.view_index].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
assert!(
!app.video_state
.contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
);
assert!(
app.video_state
.contains(CollectionKind::WatchLater, "rQ_J9WH6CGk")
);
assert!(
app.video_state
.contains(CollectionKind::Saved, "jNQXAC9IVRw")
);
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
assert!(app.collection_removal.is_none());
app.views[app.view_index].selection.select(Some(0));
app.preview = Some(PreviewMode::Info);
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
assert!(
app.video_state
.videos(CollectionKind::WatchLater)
.is_empty()
);
assert_eq!(app.preview, None);
app.switch_view(0);
app.views[0].selection.select(Some(1));
app.save_collection(CollectionKind::WatchLater);
app.browse_collection(CollectionKind::WatchLater);
app.preview = Some(PreviewMode::Description);
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
assert!(
app.video_state
.videos(CollectionKind::WatchLater)
.is_empty()
);
assert_eq!(app.preview, None);
drop(app);
let restarted = video_state::State::open(&root.join("config.toml")).unwrap();
assert!(restarted.videos(CollectionKind::WatchLater).is_empty());
assert!(restarted.contains(CollectionKind::Saved, "jNQXAC9IVRw"));
assert!(restarted.is_watched("jNQXAC9IVRw"));
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn manual_status_updates_filtered_lists_and_closes_removed_previews() {
let mut app = app(&["tubular"]);
let document = "[keys]\nvideo.status.watching = 'f6'\nvideo.status.watched = 'f7'\n"
.parse::<toml_edit::DocumentMut>()
.unwrap();
app.apply_config(config::Config {
keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
..Default::default()
});
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
for row in 0..2 {
app.views[0].selection.select(Some(row));
app.save_collection(CollectionKind::WatchLater);
}
app.browse_collection(CollectionKind::WatchLater);
app.filter_watch_later();
app.views[app.view_index].selection.select(Some(0));
app.preview = Some(PreviewMode::Info);
app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
assert_eq!(app.views[app.view_index].videos[0].id, "rQ_J9WH6CGk");
assert_eq!(app.preview, None);
app.filter_watch_later();
assert_eq!(app.views[app.view_index].videos[0].id, "jNQXAC9IVRw");
app.preview = Some(PreviewMode::Description);
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
assert!(!app.video_state.is_watched("jNQXAC9IVRw"));
assert!(app.views[app.view_index].videos.is_empty());
assert_eq!(app.views[app.view_index].selection.selected(), None);
assert_eq!(app.preview, None);
assert!(
app.video_state
.contains(CollectionKind::Watching, "jNQXAC9IVRw")
);
assert!(
app.video_state
.contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
);
app.browse_collection(CollectionKind::Watching);
app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
assert!(app.views[app.view_index].videos.is_empty());
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
}
#[test]
fn watch_later_tracks_current_tags_filters_and_confirms_only_snapshot_removal() {
let root = std::env::temp_dir().join(format!(
"tubular-watch-ui-regression-{}",
std::process::id()
));
let path = root.join("config.toml");
let _ = std::fs::remove_dir_all(&root);
let state = video_state::State::open(&path).unwrap();
let channel = config::normalize_channel("UC4QobU6STFB0P71PMvOGN5A").unwrap();
let config = config::Config {
channels: [("@creator".into(), channel.clone())].into(),
categories: [("Category".into(), vec![channel.clone()])].into(),
..Default::default()
};
let mut app = App::with_state(
Options::parse_from(["tubular"]),
path.clone(),
config,
state,
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Mapped creator","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Other creator","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(0));
app.save_collection(CollectionKind::WatchLater);
app.save_collection(CollectionKind::WatchLater);
app.views[0].selection.select(Some(1));
app.save_collection(CollectionKind::WatchLater);
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
app.views[0].selection.select(None);
let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(120, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let title = buffer
.content
.iter()
.position(|cell| cell.symbol() == "M" && cell.fg == Color::Magenta);
assert!(title.is_some(), "saved video titles use a distinct color");
app.views[0].selection.select(Some(1));
// An empty loaded category avoids extraction while opening its derived offline list.
app.views[2].loaded = true;
app.switch_view(2);
app.browse_category_collection(CollectionKind::WatchLater);
let category_source = ViewSource::WatchLater(Some("Category".into()));
assert_eq!(app.views[app.view_index].source, category_source);
assert_eq!(app.views[app.view_index].videos.len(), 1);
app.browse_category_collection(CollectionKind::WatchLater);
assert_eq!(app.views[app.view_index].source, category_source);
assert!(app.job.is_none());
app.filter_watch_later();
assert_eq!(
app.views[app.view_index].watch_filter,
WatchFilter::Unwatched
);
assert_eq!(app.views[app.view_index].videos.len(), 1);
app.filter_watch_later();
assert_eq!(app.views[app.view_index].watch_filter, WatchFilter::Watched);
assert!(app.views[app.view_index].videos.is_empty());
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
assert!(app.collection_removal.is_none());
app.filter_watch_later();
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
let history = app.view_history.clone();
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
app.paste("y");
assert!(app.collection_removal.is_some());
assert!(app.player_launch.is_none());
assert_eq!(app.view_history, history);
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
assert!(app.collection_removal.is_none());
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
app.apply_config(config::Config {
channels: [("@creator".into(), channel.clone())].into(),
categories: [("Category".into(), vec![])].into(),
..Default::default()
});
assert_eq!(app.views[app.view_index].source, category_source);
assert!(app.views[app.view_index].videos.is_empty());
app.apply_config(config::Config {
channels: [("@creator".into(), channel.clone())].into(),
categories: [("Category".into(), vec![channel])].into(),
..Default::default()
});
assert_eq!(
app.views[app.view_index].videos.len(),
1,
"mapped handles follow canonical membership"
);
app.apply_config(config::Config {
categories: [(
"Category".into(),
vec![config::normalize_channel("@creator").unwrap()],
)]
.into(),
..Default::default()
});
assert_eq!(
app.views[app.view_index].videos.len(),
1,
"unmapped handles remain usable"
);
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
app.apply_config(config::Config {
categories: [(
"Category".into(),
vec![
config::normalize_channel("@creator").unwrap(),
config::normalize_channel("@other").unwrap(),
],
)]
.into(),
..Default::default()
});
assert_eq!(app.views[app.view_index].videos.len(), 2);
assert_eq!(
app.collection_removal.as_ref().unwrap().ids,
["jNQXAC9IVRw"]
);
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 1);
assert!(
app.video_state
.contains(CollectionKind::WatchLater, "rQ_J9WH6CGk")
);
assert_eq!(app.views[app.view_index].videos.len(), 1);
app.switch_view(0);
app.browse_collection(CollectionKind::WatchLater);
assert_eq!(
app.views[app.view_index].source,
ViewSource::WatchLater(None)
);
app.back_view();
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
app.forward_view();
drop(app);
let mut restarted = App::with_state(
Options::parse_from(["tubular"]),
path.clone(),
config::Config::default(),
video_state::State::open(&path).unwrap(),
);
restarted.browse_collection(CollectionKind::WatchLater);
assert!(restarted.job.is_none());
assert!(restarted.views[restarted.view_index].loaded);
assert_eq!(
restarted.views[restarted.view_index].videos[0].title,
"Other creator"
);
restarted.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
restarted.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert!(
restarted
.video_state
.videos(CollectionKind::WatchLater)
.is_empty()
);
drop(restarted);
assert!(
video_state::State::open(&path)
.unwrap()
.videos(CollectionKind::WatchLater)
.is_empty()
);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn saved_views_follow_current_categories_and_restore_offline_history() {
let root = std::env::temp_dir().join(format!("tubular-saved-ui-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
let path = root.join("config.toml");
std::fs::write(
root.join("watch-state.toml"),
"version = 1\nwatched = [\"jNQXAC9IVRw\"]\n",
)
.unwrap();
let channel = config::normalize_channel("UC4QobU6STFB0P71PMvOGN5A").unwrap();
let other = config::normalize_channel("@other").unwrap();
let config = config::Config {
channels: [("@creator".into(), channel.clone())].into(),
categories: [
("Category".into(), vec![channel.clone(), other.clone()]),
("Overlap".into(), vec![channel]),
]
.into(),
..Default::default()
};
let mut app = App::with_state(
Options::parse_from(["tubular"]),
path.clone(),
config,
video_state::State::open(&path).unwrap(),
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Mapped creator","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Other creator","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
for row in 0..2 {
app.views[0].selection.select(Some(row));
app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));
}
app.views[2].loaded = true;
app.switch_view(2);
app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT));
let saved_category = ViewSource::SavedVideos(Some("Category".into()));
assert_eq!(app.views[app.view_index].source, saved_category);
assert_eq!(app.views[app.view_index].videos.len(), 2);
app.views[app.view_index].selection.select(Some(1));
app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::ALT));
assert_eq!(
app.views[app.view_index].source,
ViewSource::WatchLater(Some("Category".into()))
);
app.filter_watch_later();
assert_eq!(app.views[app.view_index].videos.len(), 1);
assert!(app.views[app.view_index].title.contains("Unwatched"));
app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT));
assert_eq!(app.views[app.view_index].source, saved_category);
assert_eq!(
app.views[app.view_index].videos.len(),
2,
"saved lists ignore watch filters"
);
assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
let mut config = config::Config {
channels: app.config.channels.clone(),
categories: app.config.categories.clone(),
..Default::default()
};
config.categories.insert("Category".into(), vec![other]);
app.apply_config(config);
assert_eq!(app.views[app.view_index].source, saved_category);
assert_eq!(app.views[app.view_index].videos[0].id, "rQ_J9WH6CGk");
assert_eq!(app.views[app.view_index].selection.selected(), Some(0));
let watch = app
.views
.iter()
.find(|view| matches!(view.source, ViewSource::WatchLater(Some(_))))
.unwrap();
assert_eq!(watch.watch_filter, WatchFilter::Unwatched);
assert!(watch.title.contains("Unwatched"));
app.switch_view(0);
app.key(KeyEvent::new(KeyCode::Char('V'), KeyModifiers::SHIFT));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::SavedVideos(None)
);
assert_eq!(
app.views[app.view_index].videos.len(),
2,
"overlapping categories do not duplicate videos"
);
app.views[app.view_index].selection.select(Some(1));
app.back_view();
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
app.back_view();
assert_eq!(app.views[app.view_index].source, saved_category);
app.forward_view();
app.forward_view();
assert_eq!(
app.views[app.view_index].source,
ViewSource::SavedVideos(None)
);
assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
assert!(app.job.is_none());
app.views[app.view_index].selection.select(Some(0));
app.preview = Some(PreviewMode::Info);
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
assert!(
app.preview.is_none(),
"removing the selected row dismisses its preview"
);
assert_eq!(app.views[app.view_index].videos.len(), 1);
assert!(
app.video_state
.contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
);
assert!(app.video_state.is_watched("jNQXAC9IVRw"));
let config = std::mem::take(&mut app.config);
drop(app);
let mut restarted = App::with_state(
Options::parse_from(["tubular"]),
path.clone(),
config,
video_state::State::open(&path).unwrap(),
);
restarted.browse_collection(CollectionKind::Saved);
let view = &restarted.views[restarted.view_index];
assert!(view.loaded && !view.has_more);
assert_eq!(view.videos.len(), 1);
assert_eq!(view.videos[0].title, "Other creator");
assert!(restarted.job.is_none());
assert!(restarted.video_state.is_watched("jNQXAC9IVRw"));
assert_eq!(
restarted
.video_state
.videos(CollectionKind::WatchLater)
.len(),
2
);
drop(restarted);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn collection_shortcuts_separate_global_and_category_scopes_in_every_video_context() {
for custom in [false, true] {
let root = std::env::temp_dir().join(format!(
"tubular-collection-scopes-{}-{custom}",
std::process::id()
));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("watch-state.toml"),
"version = 1\nwatched = ['l-GaaivVJCE']\n",
)
.unwrap();
let path = root.join("config.toml");
let mut app = App::with_state(
Options::parse_from(["tubular"]),
path.clone(),
config::Config::default(),
video_state::State::open(&path).unwrap(),
);
let bindings = if custom {
let document = "[keys]\nview.watch_later.browse = 'f5'\nview.saved.browse = 'f6'\nview.watch_later.category = 'f7'\nview.saved.category = 'f8'\n"
.parse::<toml_edit::DocumentMut>().unwrap();
keys::Bindings::from_toml(document.get("keys")).unwrap()
} else {
keys::Bindings::default()
};
app.apply_config(config::Config {
categories: [(
"Category".into(),
vec![config::normalize_channel("@creator").unwrap()],
)]
.into(),
keys: bindings,
..Default::default()
});
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Category","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Other","uploader_id":"@other"},{"id":"l-GaaivVJCE","title":"Watched category","uploader_id":"@creator"}]}"#,
).unwrap().videos;
for view in &mut app.views {
view.loaded = true;
}
for row in 0..3 {
app.views[0].selection.select(Some(row));
app.save_collection(CollectionKind::WatchLater);
app.save_collection(CollectionKind::Saved);
}
let key = |function, character, modifiers| {
KeyEvent::new(
if custom {
KeyCode::F(function)
} else {
KeyCode::Char(character)
},
if custom {
KeyModifiers::NONE
} else {
modifiers
},
)
};
let global_watch = key(5, 'W', KeyModifiers::SHIFT);
let global_saved = key(6, 'V', KeyModifiers::SHIFT);
let category_watch = key(7, 'w', KeyModifiers::ALT);
let category_saved = key(8, 'v', KeyModifiers::ALT);
for (selector, expected) in [
(
global_watch,
ViewSource::WatchLater(Some("Category".into())),
),
(
global_saved,
ViewSource::SavedVideos(Some("Category".into())),
),
] {
app.switch_view(0);
let history = app.view_history.clone();
app.key(selector);
let browser = app.browser.as_ref().unwrap();
assert!(matches!(
browser.choices[0].1,
ViewSource::WatchLater(None) | ViewSource::SavedVideos(None)
));
app.key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
assert!(app.config.pinned_categories.is_empty());
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
for c in "zzzz".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.browser.as_ref().unwrap().matches.is_empty());
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
assert_eq!(app.view_history, history);
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
for c in "category".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
assert_eq!(app.browser.as_ref().unwrap().matches.len(), 1);
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].source, expected);
assert_eq!(app.views[app.view_index].videos.len(), 2);
assert!(app.browser.is_none());
}
// Seed a cached combined view with a different filter.
choose_combined(&mut app, global_watch);
assert_eq!(app.views[app.view_index].watch_filter, WatchFilter::All);
app.switch_view(2);
app.key(category_watch);
app.filter_watch_later();
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.preview = preview;
choose_combined(&mut app, global_watch);
let view = &app.views[app.view_index];
assert_eq!(view.source, ViewSource::WatchLater(None));
assert_eq!(view.watch_filter, WatchFilter::Unwatched);
assert_eq!(
view.videos
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["jNQXAC9IVRw", "rQ_J9WH6CGk"]
);
assert_eq!(app.preview, None);
let history = app.view_history.clone();
app.preview = preview;
choose_combined(&mut app, global_watch);
assert_eq!(app.preview, None);
assert_eq!(app.view_history, history);
app.back_view();
assert_eq!(
app.views[app.view_index].source,
ViewSource::WatchLater(Some("Category".into()))
);
assert_eq!(
app.views[app.view_index].watch_filter,
WatchFilter::Unwatched
);
assert_eq!(app.views[app.view_index].videos.len(), 1);
}
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.preview = preview;
app.key(category_saved);
assert_eq!(
app.views[app.view_index].source,
ViewSource::SavedVideos(Some("Category".into()))
);
assert_eq!(app.preview, None);
app.preview = preview;
choose_combined(&mut app, global_saved);
assert_eq!(
app.views[app.view_index].source,
ViewSource::SavedVideos(None)
);
assert_eq!(app.views[app.view_index].videos.len(), 3);
assert_eq!(app.preview, None);
app.back_view();
assert_eq!(
app.views[app.view_index].source,
ViewSource::SavedVideos(Some("Category".into()))
);
app.preview = preview;
app.key(category_watch);
assert_eq!(
app.views[app.view_index].source,
ViewSource::WatchLater(Some("Category".into()))
);
assert_eq!(
app.views[app.view_index].watch_filter,
WatchFilter::Unwatched
);
assert_eq!(app.preview, None);
}
app.switch_view(0);
choose_combined(&mut app, global_watch);
assert_eq!(
app.views[app.view_index].watch_filter,
WatchFilter::Unwatched
);
let mut channel = View::new(
"Creator".into(),
ViewSource::Channel(config::normalize_channel("@creator").unwrap()),
);
channel.loaded = true;
app.views.push(channel);
for index in [0, 1, app.views.len() - 1] {
app.switch_view(index);
for key in [category_watch, category_saved] {
let history = app.view_history.clone();
app.key(key);
assert_eq!(app.view_index, index);
assert_eq!(app.view_history, history);
}
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
for key in [global_watch, global_saved] {
app.preview = preview;
choose_combined(&mut app, key);
assert!(matches!(
app.views[app.view_index].source,
ViewSource::WatchLater(None) | ViewSource::SavedVideos(None)
));
assert_eq!(app.preview, None);
app.back_view();
assert_eq!(app.view_index, index);
}
}
}
for key in [global_watch, global_saved] {
choose_combined(&mut app, key);
let source = app.views[app.view_index].source.clone();
for category_key in [category_watch, category_saved] {
app.key(category_key);
assert_eq!(app.views[app.view_index].source, source);
}
}
assert!(app.job.is_none());
drop(app);
std::fs::remove_dir_all(root).unwrap();
}
}
#[test]
fn collection_shortcuts_leave_text_entry_bindings_unchanged() {
let mut app = app(&["tubular"]);
let type_keys = |app: &mut App| {
for character in ['W', 'V', 'w', 'v'] {
app.key(KeyEvent::new(KeyCode::Char(character), KeyModifiers::NONE));
}
for character in ['w', 'v'] {
app.key(KeyEvent::new(KeyCode::Char(character), KeyModifiers::ALT));
}
assert_eq!(app.view_index, 0);
assert!(app.view_history.is_empty());
};
app.mode = Mode::Insert;
type_keys(&mut app);
assert_eq!(app.views[0].query, "WVwv");
app.mode = Mode::Normal;
for kind in [BrowserKind::Categories, BrowserKind::Channels] {
app.open_browser(kind);
app.browser.as_mut().unwrap().mode = Mode::Insert;
type_keys(&mut app);
assert_eq!(app.browser.as_ref().unwrap().query, "WVwv");
app.browser = None;
}
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@creator".into(),
channel: "creator".into(),
},
"Creator".into(),
BTreeMap::new(),
));
app.category_dialog.as_mut().unwrap().mode = Mode::Insert;
type_keys(&mut app);
assert_eq!(app.category_dialog.as_ref().unwrap().query, "WVwv");
app.category_dialog.as_mut().unwrap().name = Some(String::new());
type_keys(&mut app);
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("WVwv")
);
}
#[test]
fn saved_actions_use_configured_keys_in_each_video_context_and_remove_only_selection() {
let mut app = app(&["tubular"]);
let document = "[keys]\nvideo.saved.save = 'f6'\nview.saved.browse = 'f7'\nview.collection.remove.selected = 'f8'\nview.collection.remove.bulk = 'f9'\n"
.parse::<toml_edit::DocumentMut>().unwrap();
app.apply_config(config::Config {
keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
..Default::default()
});
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"},{"id":"l-GaaivVJCE","title":"Missing creator"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(1));
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
app.views[0].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.preview = preview;
if !app
.video_state
.contains(CollectionKind::Saved, "jNQXAC9IVRw")
{
app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE));
assert!(
!app.video_state
.contains(CollectionKind::Saved, "jNQXAC9IVRw")
);
}
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
let status = app.status.clone();
app.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
assert_eq!(app.preview, preview);
assert_eq!(app.status, status);
}
for preview in [
None,
Some(PreviewMode::Info),
Some(PreviewMode::Description),
] {
app.preview = None;
app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
let row = app.views[app.view_index]
.videos
.iter()
.position(|video| video.id == "jNQXAC9IVRw")
.unwrap();
app.views[app.view_index].selection.select(Some(row));
app.preview = preview;
assert!(matches!(
app.current_collection(),
Some(CollectionKind::Saved)
));
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
app.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 1);
assert!(
app.video_state
.contains(CollectionKind::Saved, "rQ_J9WH6CGk")
);
assert!(
app.video_state
.contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
);
assert_eq!(app.preview, None);
app.switch_view(0);
app.views[0].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
}
app.preview = None;
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
app.views[0].selection.select(Some(2));
app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
assert!(app.status.contains("channel identity"));
assert!(
!app.video_state
.contains(CollectionKind::Saved, "l-GaaivVJCE")
);
app.views[0].selection.select(None);
let status = app.status.clone();
app.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
assert_eq!(app.status, status);
app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::SavedVideos(None)
);
assert!(app.job.is_none());
assert!(app.key_hints.footer(Context::Normal).contains("F6/F7"));
assert!(app.key_hints.saved_videos.contains("F8"));
app.key(KeyEvent::new(KeyCode::Char('W'), KeyModifiers::SHIFT));
app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
assert!(app.collection_removal.is_none());
app.key(KeyEvent::new(KeyCode::F(9), KeyModifiers::NONE));
assert!(app.collection_removal.is_some());
app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
assert!(
app.video_state
.videos(CollectionKind::WatchLater)
.is_empty()
);
assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
assert!(!app.video_state.is_watched("jNQXAC9IVRw"));
}
#[test]
fn saved_green_precedes_watch_later_magenta_without_changing_creator_or_selection_colors() {
let mut app = app(&["tubular"]);
app.config.categories.insert(
"Tagged".into(),
vec![config::normalize_channel("@creator").unwrap()],
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Saved title","channel":"Creator","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Later title","channel":"Other","uploader_id":"@other"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
for row in 0..2 {
app.views[0].selection.select(Some(row));
app.save_collection(CollectionKind::WatchLater);
}
app.views[0].selection.select(Some(0));
app.save_collection(CollectionKind::Saved);
app.views[0].selection.select(None);
let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(120, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
assert!(
buffer
.content
.iter()
.any(|cell| cell.symbol() == "S" && cell.fg == Color::Green)
);
assert!(
buffer
.content
.iter()
.any(|cell| cell.symbol() == "L" && cell.fg == Color::Magenta)
);
assert!(
buffer
.content
.iter()
.any(|cell| cell.symbol() == "C" && cell.fg == Color::Cyan)
);
app.views[0].selection.select(Some(0));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert!(
terminal
.backend()
.buffer()
.content
.iter()
.any(|cell| cell.symbol() == "S" && cell.fg == Color::Black && cell.bg == Color::Cyan)
);
app.browse_collection(CollectionKind::Saved);
app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
app.switch_view(0);
app.views[0].selection.select(None);
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert!(
terminal
.backend()
.buffer()
.content
.iter()
.any(|cell| cell.symbol() == "S" && cell.fg == Color::Magenta)
);
}
#[test]
fn paste_targets_only_active_inputs_and_refilters_without_executing_shortcuts() {
let mut app = app(&["tubular"]);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
app.paste("Haru 日本語\r\ns\t\x1b[31m");
assert_eq!(app.views[0].query, "Haru 日本語 s [31m");
assert_eq!(app.mode, Mode::Insert);
assert!(app.views[0].submitted_query.is_empty());
assert!(app.job.is_none(), "paste must not submit a search");
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.paste("i\nq");
assert_eq!(app.views[0].query, "Haru 日本語 s [31m");
assert_eq!(app.mode, Mode::Normal);
app.config.categories = [("Alpha".into(), vec![]), ("日本語".into(), vec![])].into();
app.config.channels = [
(
"@Alpha".into(),
config::normalize_channel("@Alpha").unwrap(),
),
(
"@日本語".into(),
config::normalize_channel("@日本語").unwrap(),
),
]
.into();
for kind in [BrowserKind::Categories, BrowserKind::Channels] {
app.open_browser(kind);
app.paste("Alpha");
assert!(app.browser.as_ref().unwrap().query.is_empty());
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
app.paste("日本語");
let browser = app.browser.as_ref().unwrap();
assert_eq!(browser.matches, [1]);
assert_eq!(browser.selection.selected(), Some(0));
assert!(browser.choices[browser.matches[0]].0.contains("日本語"));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
}
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@a".into(),
channel: String::new(),
},
"Creator".into(),
[("Alpha".into(), true), ("日本語".into(), false)].into(),
));
app.paste("i\n ");
assert!(app.category_dialog.as_ref().unwrap().tags["Alpha"]);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
app.paste("日本語");
assert_eq!(app.category_dialog.as_ref().unwrap().matches, [1]);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().tags["日本語"]);
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
app.paste("New\nTag\t?");
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("New Tag ?")
);
assert!(
app.help_popup.is_none(),
"pasted ? must remain literal text"
);
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().tags["New Tag ?"]);
assert!(
!app.config.categories.contains_key("New Tag ?"),
"paste must not save tags"
);
app.key(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE));
app.paste("n\nq");
assert!(app.category_dialog.as_ref().unwrap().name.is_none());
assert!(
app.help_popup.is_some(),
"paste must not close help or operate on its dialog"
);
}
fn loaded_channel_views(app: &mut App) {
let videos = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#;
for (label, identity) in app.config.saved_channels() {
let mut view = View::new(label, ViewSource::Channel(identity));
view.videos = feed_fixture(videos).unwrap().videos;
view.loaded = true;
view.next_start = 41;
view.selection.select(Some(1));
app.views.push(view);
}
}
fn browse_channel(app: &mut App, filter: &str) {
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
for c in filter.chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
}
#[test]
fn video_channel_colors_follow_category_membership_and_preserve_selection_contrast() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
let tagged_id = "UC4QobU6STFB0P71PMvOGN5A";
let registered_id = "UCaYhcUwRBNscFNUKTjgPFiA";
app.config.channels.insert(
"@mapped".into(),
config::normalize_channel(tagged_id).unwrap(),
);
app.config.channels.insert(
"@registered".into(),
config::normalize_channel(registered_id).unwrap(),
);
app.config.categories.insert(
"Favorites".into(),
vec![
config::normalize_channel(tagged_id).unwrap(),
config::normalize_channel("@direct").unwrap(),
],
);
let cases = [
("TaggedID", Some(tagged_id), None, true),
("TaggedHandle", None, Some("@direct"), true),
("MappedHandle", None, Some("@mapped"), true),
(
"Registered",
Some(registered_id),
Some("@registered"),
false,
),
("TaggedID", Some(registered_id), None, false),
("Unknown", None, None, false),
];
app.views[0].videos = youtube::search_results(
&serde_json::json!({
"entries": cases.iter().map(|(channel, id, handle, _)| serde_json::json!({
"id": "jNQXAC9IVRw", "title": "Video title", "channel": channel,
"channel_id": id, "uploader_id": handle, "upload_date": "20261011",
"duration": 3723.5
})).collect::<Vec<_>>()
})
.to_string(),
)
.unwrap()
.videos;
app.views[0].selection.select(None);
let mut terminal = Terminal::new(TestBackend::new(120, 24)).unwrap();
for cleared in [false, true] {
if cleared {
app.config.categories.clear();
}
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
// One tab row, three search rows, then the results border and two-line entries.
for (index, (label, _, _, tagged)) in cases.iter().enumerate() {
let y = 6 + 2 * index as u16;
let row: String = (0..120).map(|x| buffer[(x, y)].symbol()).collect();
let x = row.find(label).expect("channel label is visible") as u16;
assert_eq!(
buffer[(x, y)].fg,
if *tagged && !cleared {
Color::Cyan
} else {
Color::Reset
},
"{label} in row {index}, cleared={cleared}"
);
let title: String = (0..120).map(|x| buffer[(x, y - 1)].symbol()).collect();
assert!(title.contains("Video title"));
let date_x = row.find("2026-10-11").expect("date follows channel") as u16;
assert!(row.contains(&format!("{label} · 2026-10-11")));
assert!(
row.contains(" · 1:02:03"),
"duration is visible in metadata"
);
assert_eq!(buffer[(3, y - 1)].fg, Color::Reset, "title stays uncolored");
assert_eq!(buffer[(date_x, y)].fg, Color::Reset, "date stays uncolored");
assert!(
buffer[(x, y)]
.modifier
.contains(ratatui::style::Modifier::DIM)
);
}
if !cleared {
app.views[0].selection.select(Some(0));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let row: String = (0..120).map(|x| buffer[(x, 6)].symbol()).collect();
let x = row.find("TaggedID").unwrap() as u16;
assert_eq!(buffer[(x, 6)].fg, Color::Black);
assert_eq!(buffer[(x, 6)].bg, Color::Cyan);
app.views[0].selection.select(None);
}
}
}
#[test]
fn remapped_preview_and_input_actions_survive_key_only_config_reload() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#,
).unwrap().videos;
// Invalid IDs avoid curl; full descriptions exercise the real preview without extraction.
for (index, id) in ["first", "second"].into_iter().enumerate() {
app.views[0].videos[index].id = id.into();
app.remember_description(id.into(), "A long description paragraph.\n\n".repeat(40));
}
app.views[0].loaded = true;
app.views[0].selection.select(Some(0));
app.views[0].next_start = 41;
let document = r#"[keys]
video.info.overview = "I"
video.info.hide = "x"
view.collection.remove.selected = []
search.edit = "f2"
input.delete.word = "ctrl+backspace"
input.delete.line = "ctrl+l"
"#
.parse::<toml_edit::DocumentMut>()
.unwrap();
app.apply_config(config::Config {
keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
..Default::default()
});
let press = |app: &mut App, code, modifiers| app.key(KeyEvent::new(code, modifiers));
press(&mut app, KeyCode::Char('d'), KeyModifiers::NONE);
assert_eq!(app.preview, Some(PreviewMode::Description));
let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
press(&mut app, KeyCode::Char('j'), KeyModifiers::CONTROL);
assert_eq!(app.description_scroll, 1);
press(&mut app, KeyCode::Char('I'), KeyModifiers::SHIFT);
assert_eq!(app.preview, Some(PreviewMode::Info));
press(&mut app, KeyCode::Char('x'), KeyModifiers::NONE);
assert_eq!(app.preview, None);
assert!(app.description_job.is_none());
let remap = "[keys]\nvideo.select.next = 'n'\n"
.parse::<toml_edit::DocumentMut>()
.unwrap();
app.apply_config(config::Config {
keys: keys::Bindings::from_toml(remap.get("keys")).unwrap(),
..Default::default()
});
assert_eq!(app.views[0].next_start, 41);
assert_eq!(app.views[0].videos[0].title, "First");
press(&mut app, KeyCode::Char('j'), KeyModifiers::NONE);
assert_eq!(app.views[0].selection.selected(), Some(0));
press(&mut app, KeyCode::Char('n'), KeyModifiers::NONE);
assert_eq!(app.views[0].selection.selected(), Some(1));
app.apply_config(config::Config {
keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
..Default::default()
});
press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
assert_eq!(app.mode, Mode::Normal);
press(&mut app, KeyCode::F(2), KeyModifiers::NONE);
for character in "red blue I d?".chars() {
press(&mut app, KeyCode::Char(character), KeyModifiers::NONE);
}
assert_eq!(app.views[0].query, "red blue I d?");
assert_eq!(app.preview, None);
press(&mut app, KeyCode::Backspace, KeyModifiers::CONTROL);
assert_eq!(app.views[0].query, "red blue I ");
press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
assert_eq!(app.views[0].query, "red blue I ");
press(&mut app, KeyCode::Char('l'), KeyModifiers::CONTROL);
assert_eq!(app.views[0].query, "");
press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
assert_eq!(app.mode, Mode::Normal);
}
#[test]
fn remapped_selector_and_tag_keys_keep_input_and_modal_navigation_separate() {
let mut app = app(&["tubular"]);
let document = r#"[keys]
selector.select.next = "l"
selector.edit = "f3"
selector.close = "z"
input.submit = "ctrl+e"
input.cancel = "ctrl+b"
tags.new = "f4"
tags.cancel = "z"
"#
.parse::<toml_edit::DocumentMut>()
.unwrap();
app.apply_config(config::Config {
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
..Default::default()
});
loaded_channel_views(&mut app);
let press = |app: &mut App, code, modifiers| app.key(KeyEvent::new(code, modifiers));
app.open_browser(BrowserKind::Channels);
press(&mut app, KeyCode::Char('j'), KeyModifiers::NONE);
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
press(&mut app, KeyCode::Char('l'), KeyModifiers::NONE);
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
press(&mut app, KeyCode::F(3), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('l'), KeyModifiers::NONE);
assert_eq!(app.browser.as_ref().unwrap().query, "l");
assert_eq!(app.browser.as_ref().unwrap().matches, [0]);
press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
press(&mut app, KeyCode::Char('j'), KeyModifiers::CONTROL);
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
assert!(app.browser.is_some());
press(&mut app, KeyCode::Char('e'), KeyModifiers::CONTROL);
assert!(app.browser.is_none());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
assert_eq!(app.views[app.view_index].next_start, 41);
let history = app.view_history.clone();
app.category_dialog = Some(CategoryDialog {
name: None,
..CategoryDialog::new(
CategoryTarget::Channel {
handle: "@Beta".into(),
channel: "beta".into(),
},
"@Beta".into(),
BTreeMap::new(),
)
});
press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
assert_eq!(app.view_history, history);
assert!(app.category_dialog.is_some());
press(&mut app, KeyCode::F(4), KeyModifiers::NONE);
for character in "lI?".chars() {
press(&mut app, KeyCode::Char(character), KeyModifiers::NONE);
}
press(&mut app, KeyCode::Char('e'), KeyModifiers::CONTROL);
assert_eq!(
app.category_dialog.as_ref().unwrap().tags.get("lI?"),
Some(&true)
);
press(&mut app, KeyCode::Char('z'), KeyModifiers::NONE);
assert!(app.category_dialog.is_none());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
}
#[test]
fn help_scrolls_without_navigating_and_closes_to_the_same_preview() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
..Default::default()
});
loaded_channel_views(&mut app);
browse_channel(&mut app, "Alpha");
browse_channel(&mut app, "Beta");
let history = app.view_history.clone();
let selected = app.views[app.view_index].selection.selected();
let press = |app: &mut App, code| app.key(KeyEvent::new(code, KeyModifiers::NONE));
app.views[app.view_index].has_more = true;
app.views[app.view_index].prefetch_requested = true;
assert!(app.can_prefetch());
press(&mut app, KeyCode::Char('?'));
assert!(!app.can_prefetch());
app.preview = Some(PreviewMode::Info);
let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
press(&mut app, KeyCode::Char('j'));
assert_eq!(app.help_popup.as_ref().unwrap().scroll, 1);
for code in [
KeyCode::Enter,
KeyCode::Tab,
KeyCode::Char('-'),
KeyCode::Char('+'),
] {
press(&mut app, code);
}
assert_eq!(app.view_history, history);
assert!(app.forward_history.is_empty());
assert!(app.player_launch.is_none());
assert_eq!(app.views[app.view_index].selection.selected(), selected);
for _ in 0..100 {
press(&mut app, KeyCode::PageDown);
}
let help = app.help_popup.as_ref().unwrap();
assert_eq!(help.scroll, help.max_scroll);
let previous_max = help.max_scroll;
app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
assert_eq!(app.help_popup.as_ref().unwrap().scroll, previous_max - 1);
let mut larger = Terminal::new(TestBackend::new(120, 40)).unwrap();
larger
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let help = app.help_popup.as_ref().unwrap();
assert_eq!(help.scroll, help.max_scroll);
for _ in 0..100 {
press(&mut app, KeyCode::PageUp);
}
assert_eq!(app.help_popup.as_ref().unwrap().scroll, 0);
press(&mut app, KeyCode::Esc);
assert!(app.help_popup.is_none());
assert_eq!(app.preview, Some(PreviewMode::Info));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
press(&mut app, KeyCode::Char('-'));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("alpha".into())
);
press(&mut app, KeyCode::Char('+'));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
}
#[test]
fn help_preserves_selector_state_and_question_mark_is_literal_in_every_input() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [("@Alpha".into(), "alpha".into())].into(),
..Default::default()
});
let press = |app: &mut App, code| app.key(KeyEvent::new(code, KeyModifiers::NONE));
app.open_browser(BrowserKind::Channels);
press(&mut app, KeyCode::Char('?'));
assert!(app.help_popup.is_some());
press(&mut app, KeyCode::Char('?'));
assert!(app.help_popup.is_none());
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
press(&mut app, KeyCode::Char('i'));
press(&mut app, KeyCode::Char('?'));
assert!(app.help_popup.is_none());
assert_eq!(app.browser.as_ref().unwrap().query, "?");
assert!(app.browser.as_ref().unwrap().matches.is_empty());
press(&mut app, KeyCode::Esc);
press(&mut app, KeyCode::Esc);
press(&mut app, KeyCode::Char('i'));
press(&mut app, KeyCode::Char('?'));
assert!(app.help_popup.is_none());
assert_eq!(app.views[0].query, "?");
press(&mut app, KeyCode::Esc);
app.category_dialog = Some(CategoryDialog {
name: Some(String::new()),
..CategoryDialog::new(
CategoryTarget::Channel {
handle: "@Alpha".into(),
channel: "alpha".into(),
},
"@Alpha".into(),
BTreeMap::new(),
)
});
press(&mut app, KeyCode::Char('?'));
assert!(app.help_popup.is_none());
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("?")
);
press(&mut app, KeyCode::Esc);
press(&mut app, KeyCode::Char('?'));
assert!(app.help_popup.is_some());
press(&mut app, KeyCode::Esc);
assert!(app.category_dialog.is_some());
assert!(app.help_popup.is_none());
}
#[test]
fn plus_restores_forward_views_and_new_navigation_discards_the_forward_branch() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
..Default::default()
});
loaded_channel_views(&mut app);
for view in &mut app.views {
view.loaded = true;
}
browse_channel(&mut app, "Alpha");
browse_channel(&mut app, "Beta");
let press = |app: &mut App, c| {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
};
press(&mut app, '-');
press(&mut app, '-');
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
press(&mut app, '+');
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("alpha".into())
);
assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
assert_eq!(app.views[app.view_index].next_start, 41);
app.switch_view(app.view_index); // Refocusing does not discard forward history.
press(&mut app, '+');
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
press(&mut app, '+'); // End of history is a no-op.
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
press(&mut app, '-');
app.switch_view(1);
press(&mut app, '+');
assert_eq!(app.views[app.view_index].source, ViewSource::Feed);
app.mode = Mode::Insert;
press(&mut app, '+');
assert_eq!(app.views[0].query, "+");
assert_eq!(app.views[app.view_index].source, ViewSource::Feed);
assert!(app.job.is_none());
}
#[test]
fn forward_navigation_skips_unsubscribed_views() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
..Default::default()
});
loaded_channel_views(&mut app);
app.views[0].loaded = true;
browse_channel(&mut app, "Alpha");
browse_channel(&mut app, "Beta");
app.back_view();
app.back_view();
app.apply_config(config::Config {
channels: [("@Beta".into(), "beta".into())].into(),
..Default::default()
});
app.key(KeyEvent::new(KeyCode::Char('+'), KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
assert_eq!(app.temporary_view, Some(ViewSource::Channel("beta".into())));
assert!(app.job.is_none());
}
#[test]
fn minus_restores_view_history_without_consuming_modal_escape() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
categories: [("Category".into(), Vec::new())].into(),
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
..Default::default()
});
loaded_channel_views(&mut app);
for view in &mut app.views {
view.loaded = true;
}
app.switch_view(2);
browse_channel(&mut app, "Alpha");
browse_channel(&mut app, "Beta");
app.switch_view(app.view_index); // Refocusing must not add a history entry.
app.preview = Some(PreviewMode::Info);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.preview.is_none());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
app.mode = Mode::Insert;
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.views[0].query, "-");
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
app.open_browser(BrowserKind::Channels);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.browser.is_none());
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("beta".into())
);
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("alpha".into())
);
assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
assert_eq!(app.views[app.view_index].next_start, 41);
assert_eq!(
app.temporary_view,
Some(ViewSource::Channel("alpha".into()))
);
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Category".into())
);
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
assert!(app.job.is_none());
}
#[test]
fn back_history_uses_source_identity_after_config_reorders_or_removes_views() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
categories: [("Earlier".into(), Vec::new()), ("Keep".into(), Vec::new())].into(),
channels: [("@Alpha".into(), "alpha".into())].into(),
..Default::default()
});
loaded_channel_views(&mut app);
for view in &mut app.views {
view.loaded = true;
}
app.switch_view(3); // Keep initially follows Earlier.
browse_channel(&mut app, "Alpha");
app.apply_config(config::Config {
categories: [("Keep".into(), Vec::new())].into(),
channels: [("@Alpha".into(), "alpha".into())].into(),
..Default::default()
});
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Keep".into())
);
browse_channel(&mut app, "Alpha");
app.apply_config(config::Config {
channels: [("@Alpha".into(), "alpha".into())].into(),
..Default::default()
});
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
assert!(app.job.is_none());
}
#[test]
fn video_channel_shortcut_reuses_saved_views_and_requires_valid_identity() {
let mut app = app(&["tubular"]);
let identity = "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A";
app.apply_config(config::Config {
channels: [("@Saved".into(), identity.into())].into(),
..Default::default()
});
loaded_channel_views(&mut app);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Search result","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@Saved"}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(0));
app.preview = Some(PreviewMode::Description);
let press = |app: &mut App| {
app.key(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::SHIFT));
};
press(&mut app);
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel(identity.into())
);
assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
assert_eq!(app.views[app.view_index].next_start, 41);
assert_eq!(app.views[app.view_index].videos[1].title, "Second");
assert!(app.preview.is_none());
assert!(app.job.is_none());
let count = app.views.len();
press(&mut app);
assert_eq!(app.views.len(), count);
app.switch_view(0);
app.views[0].videos[0].channel_id = None;
press(&mut app); // A handle-only row resolves through the saved mapping.
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel(identity.into())
);
app.switch_view(0);
app.views[0].videos[0].uploader_id = Some("@invalid/handle".into());
press(&mut app);
assert_eq!(app.view_index, 0);
assert_eq!(app.views.len(), count);
assert!(app.job.is_none());
app.views[0].videos[0].uploader_id = None;
press(&mut app);
assert_eq!(app.view_index, 0);
app.mode = Mode::Insert;
press(&mut app);
assert_eq!(app.views[0].query, "U");
assert_eq!(app.view_index, 0);
}
#[test]
fn unsaved_video_channels_survive_config_changes_without_subscribing() {
let mut app = app(&["tubular"]);
let identity = "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A";
let mut channel = View::new("@Unsaved".into(), ViewSource::Channel(identity.into()));
channel.loaded = true;
app.views.push(channel);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Search result","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@Unsaved"}]}"#,
).unwrap().videos;
app.views[0].selection.select(Some(0));
app.views[0].loaded = true;
app.key(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::SHIFT));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel(identity.into())
);
assert!(app.config.subscriptions().is_empty());
app.apply_config(config::Config {
categories: [("Unrelated".into(), Vec::new())].into(),
..Default::default()
});
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel(identity.into())
);
assert!(app.views[app.view_index].loaded);
assert_eq!(
app.temporary_view,
Some(ViewSource::Channel(identity.into()))
);
app.apply_config(config::Config {
channels: [("@Registered".into(), identity.into())].into(),
..Default::default()
});
assert_eq!(app.views[app.view_index].name, "@Registered");
assert!(app.views[app.view_index].loaded);
app.apply_config(config::Config::default());
assert_eq!(app.view_index, 0);
assert!(
app.views
.iter()
.all(|view| view.source != ViewSource::Channel(identity.into()))
);
}
#[test]
fn channels_filter_in_both_modes_without_pinning_or_running_modal_shortcuts() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [
("@jazz".into(), "jazz identity".into()),
("@jokes".into(), "jokes identity".into()),
]
.into(),
..config::Config::default()
});
loaded_channel_views(&mut app);
app.views[0].query = "untouched".into();
app.views[0].loaded = true;
app.views[0].has_more = true;
app.preview = Some(PreviewMode::Info);
assert!(!app.can_prefetch());
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
assert!(app.preview.is_none());
assert!(!app.can_prefetch());
app.key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
assert!(app.config.pinned_categories.is_empty());
assert!(app.browser.as_ref().unwrap().error.is_none());
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
for c in "jkp".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
assert_eq!(app.browser.as_ref().unwrap().query, "jkp");
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), None);
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.view_index, 0);
assert!(app.browser.is_some());
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
app.key(KeyEvent::new(KeyCode::Char('J'), KeyModifiers::NONE));
for (code, modifiers, row) in [
(KeyCode::Char('j'), KeyModifiers::CONTROL, 1),
(KeyCode::Char('k'), KeyModifiers::CONTROL, 0),
(KeyCode::Down, KeyModifiers::NONE, 1),
(KeyCode::Up, KeyModifiers::NONE, 0),
] {
app.key(KeyEvent::new(code, modifiers));
assert_eq!(
app.browser.as_ref().unwrap().selection.selected(),
Some(row)
);
}
assert_eq!(app.browser.as_ref().unwrap().query, "J");
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.browser.as_ref().unwrap().mode, Mode::Normal);
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel("jazz identity".into())
);
assert_eq!(
app.views[app.view_index].source.channels(
&app.config,
&app.feed_channels,
&app.views[app.view_index].group_channels
),
["jazz identity"]
);
assert_eq!(app.views[0].query, "untouched");
assert!(app.browser.is_none());
assert!(app.job.is_none());
}
#[test]
fn channel_and_category_share_temporary_tab_and_cached_history() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
keys: Default::default(),
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
categories: [
("@Alpha".into(), vec!["beta".into()]),
("Temporary".into(), vec![]),
]
.into(),
pinned_categories: vec!["@Alpha".into()],
});
loaded_channel_views(&mut app);
app.views[2].loaded = true;
app.switch_view(3);
browse_channel(&mut app, "Alpha");
let alpha_source = ViewSource::Channel("alpha".into());
assert_eq!(app.views[app.view_index].source, alpha_source);
assert_eq!(
app.views[app.view_index].source.channels(
&app.config,
&app.feed_channels,
&app.views[app.view_index].group_channels
),
["alpha"]
);
app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
assert!(app.category_dialog.is_none());
assert_eq!(app.views[app.view_index].source, alpha_source);
browse_channel(&mut app, "Beta");
let visible: Vec<_> = app
.visible_views()
.map(|(_, view)| view.source.clone())
.collect();
assert_eq!(
visible,
[
ViewSource::Search,
ViewSource::Feed,
ViewSource::Category("@Alpha".into()),
ViewSource::Channel("beta".into())
]
);
assert!(app.views.iter().any(|view| view.source == alpha_source));
browse_channel(&mut app, "Alpha");
let view = &app.views[app.view_index];
assert_eq!(view.source, alpha_source);
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.next_start, 41);
assert_eq!(view.videos.len(), 2);
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(
app.views[app.view_index].source,
ViewSource::Category("Temporary".into())
);
assert!(
!app.visible_views()
.any(|(_, view)| matches!(view.source, ViewSource::Channel(_)))
);
browse_channel(&mut app, "Alpha");
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
assert_eq!(app.views[app.view_index].source, alpha_source);
assert!(app.job.is_none());
}
#[test]
fn channel_refresh_matches_identities_relabels_caches_and_removes_unsubscribed_views() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [
("@Alpha".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
categories: [("@Alpha".into(), vec!["beta".into()])].into(),
..config::Config::default()
});
loaded_channel_views(&mut app);
browse_channel(&mut app, "Alpha");
app.views[app.view_index].has_more = true;
app.views[app.view_index].feed_requests =
app.views[app.view_index].feed_cursor.plan(1).unwrap();
app.views[app.view_index].prefetch_requested = true;
app.views[app.view_index].page_error = Some("kept".into());
app.apply_config(config::Config {
keys: Default::default(),
channels: [
("@Renamed".into(), "alpha".into()),
("@Beta".into(), "beta".into()),
]
.into(),
categories: [
("New tag".into(), vec!["alpha".into()]),
("@Alpha".into(), vec![]),
]
.into(),
pinned_categories: vec!["@Alpha".into()],
});
let view = &app.views[app.view_index];
assert_eq!(view.source, ViewSource::Channel("alpha".into()));
assert_eq!(view.name, "@Renamed");
assert_eq!(view.title, " @Renamed ");
assert!(view.loaded && view.has_more);
assert_eq!(view.next_start, 41);
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.feed_requests.len(), 1);
assert!(view.prefetch_requested);
assert_eq!(view.page_error.as_deref(), Some("kept"));
let beta = app
.views
.iter()
.find(|view| view.source == ViewSource::Channel("beta".into()))
.unwrap();
assert_eq!(beta.next_start, 41);
assert_eq!(beta.selection.selected(), Some(1));
app.apply_config(config::Config {
keys: Default::default(),
channels: [("@Beta".into(), "beta".into())].into(),
categories: [("@Alpha".into(), vec!["beta".into()])].into(),
pinned_categories: vec!["@Alpha".into()],
});
assert_eq!(app.views[app.view_index].source, ViewSource::Search);
assert!(app.temporary_view.is_none());
assert!(
!app.views
.iter()
.any(|view| view.source == ViewSource::Channel("alpha".into()))
);
browse_channel(&mut app, "Beta");
assert_eq!(app.views[app.view_index].next_start, 41);
app.apply_config(config::Config::default());
assert_eq!(app.view_index, 0);
assert_eq!(app.views.len(), 2);
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
for code in [KeyCode::Down, KeyCode::Enter, KeyCode::Char('p')] {
app.key(KeyEvent::new(code, KeyModifiers::NONE));
}
assert!(app.browser.as_ref().unwrap().choices.is_empty());
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), None);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.browser.is_none());
assert!(app.job.is_none());
}
#[test]
fn channel_labels_cannot_alias_builtin_or_category_sources() {
let mut app = app(&["tubular"]);
// Raw fixture identities exercise equal labels without invoking an extractor.
app.apply_config(config::Config {
categories: [
("Feed".into(), vec!["Feed".into(), "Search".into()]),
("Search".into(), vec![]),
]
.into(),
pinned_categories: vec!["Feed".into(), "Search".into()],
..config::Config::default()
});
loaded_channel_views(&mut app);
for label in ["Feed", "Search"] {
browse_channel(&mut app, label);
assert_eq!(
app.views[app.view_index].source,
ViewSource::Channel(label.into())
);
assert_eq!(
app.views[app.view_index].source.channels(
&app.config,
&app.feed_channels,
&app.views[app.view_index].group_channels
),
[label]
);
assert_eq!(
app.visible_views()
.filter(|(_, view)| view.name == label)
.count(),
3
);
app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
assert!(app.category_dialog.is_none());
}
assert!(app.job.is_none());
}
#[test]
fn channel_selector_renders_plain_labels_modes_empty_states_and_filter_cursor() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
channels: [("@Alpha".into(), "alpha".into())].into(),
..config::Config::default()
});
let mut terminal = Terminal::new(TestBackend::new(180, 40)).unwrap();
let text = |terminal: &Terminal<TestBackend>| -> String {
terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect()
};
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let rendered = text(&terminal);
assert!(rendered.contains("@Alpha"));
assert!(!rendered.contains("[p]") && !rendered.contains("[ ]"));
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::NONE));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let popup = preview_area(Rect::new(0, 0, 180, 40));
assert_eq!(
terminal.get_cursor_position().unwrap(),
(popup.x + 3, popup.y + 2).into()
);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.apply_config(config::Config::default());
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert!(app.job.is_none());
}
#[test]
fn filtered_tagging_saves_visible_changes_without_losing_hidden_memberships() {
use ratatui::{Terminal, backend::TestBackend};
for bulk in [false, true] {
let path = std::env::temp_dir().join(format!(
"tubular-filtered-tags-{}-{bulk}.toml",
std::process::id()
));
let original = "[channels]\n'@a' = 'UC4QobU6STFB0P71PMvOGN5A'\n'@b' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n[categories]\nAlpha = ['@a', '@b']\nGamma = []\nZebra = ['@a', '@b']\n";
std::fs::write(&path, original).unwrap();
let mut app = App::new(
Options::parse_from(["tubular"]),
path.clone(),
config::load(&path).unwrap(),
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Creator video","channel":"Creator","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@a"}]}"#
).unwrap().videos;
app.views[0].selection.select(Some(0));
if bulk {
app.view_index = app
.views
.iter()
.position(|view| view.name == "Alpha")
.unwrap();
}
app.views[app.view_index].loaded = true;
let press = |app: &mut App, code, modifiers| {
app.key(KeyEvent::new(code, modifiers));
};
press(
&mut app,
KeyCode::Char(if bulk { 'S' } else { 's' }),
KeyModifiers::NONE,
);
press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
for c in "missing".chars() {
press(&mut app, KeyCode::Char(c), KeyModifiers::NONE);
}
let mut terminal = Terminal::new(TestBackend::new(120, 30)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let text: String = terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect();
assert!(text.contains("No matching tags."));
press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
for c in "GA".chars() {
press(&mut app, KeyCode::Char(c), KeyModifiers::SHIFT);
}
press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
assert!(app.category_dialog.is_some(), "filter Enter must not save");
assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let text: String = terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect();
assert!(text.contains("[x] Gamma"));
assert!(!text.contains("[x] Alpha") && !text.contains("[x] Zebra"));
press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
assert!(app.category_dialog.is_none());
let saved = config::load(&path).unwrap();
let a = config::normalize_channel("UC4QobU6STFB0P71PMvOGN5A").unwrap();
let b = config::normalize_channel("UCaYhcUwRBNscFNUKTjgPFiA").unwrap();
assert_eq!(saved.categories["Alpha"], [a.clone(), b.clone()]);
assert_eq!(saved.categories["Zebra"], [a.clone(), b.clone()]);
assert_eq!(
saved.categories["Gamma"],
if bulk { vec![a, b] } else { vec![a] }
);
std::fs::remove_file(path).unwrap();
}
}
#[test]
fn tag_filter_preserves_selection_and_stages_new_tags_outside_the_filter() {
let mut app = app(&["tubular"]);
app.category_dialog = Some(CategoryDialog::new(
CategoryTarget::Channel {
handle: "@a".into(),
channel: String::new(),
},
"Creator".into(),
[
("Alpha".into(), false),
("Gamma".into(), true),
("Zebra".into(), false),
]
.into(),
));
let press = |app: &mut App, code, modifiers| {
app.key(KeyEvent::new(code, modifiers));
};
press(&mut app, KeyCode::Char('j'), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('a'), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('j'), KeyModifiers::CONTROL);
press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
assert!(app.category_dialog.as_ref().unwrap().tags["Zebra"]);
assert!(!app.category_dialog.as_ref().unwrap().tags["Alpha"]);
press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
for c in "gamma".chars() {
press(&mut app, KeyCode::Char(c), KeyModifiers::NONE);
}
press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
press(&mut app, KeyCode::Char('n'), KeyModifiers::NONE);
for c in "New".chars() {
press(&mut app, KeyCode::Char(c), KeyModifiers::NONE);
}
press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
let dialog = app.category_dialog.as_ref().unwrap();
assert!(dialog.tags["New"]);
assert!(dialog.query.is_empty(), "new tag must be visible");
press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
assert!(
!app.category_dialog.as_ref().unwrap().tags["New"],
"new tag is selected"
);
press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
assert!(app.category_dialog.is_none());
assert!(
app.config.categories.is_empty(),
"cancel discards staged changes"
);
}
#[test]
fn bulk_picker_uses_all_saved_channels_and_commits_or_cancels_the_whole_group() {
let path =
std::env::temp_dir().join(format!("tubular-bulk-picker-{}.toml", std::process::id()));
let original = "[settings]\npinned_categories = ['Source']\n[channels]\n'@a' = 'UC4QobU6STFB0P71PMvOGN5A'\n'@b' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n'@other' = 'UCBR8-60-B28hp2BmDPdntcQ'\n[categories]\nEmpty = []\nMixed = ['@a', '@other']\nShared = ['@a', '@b', '@other']\nSource = ['@a', '@b']\n";
std::fs::write(&path, original).unwrap();
let mut app = App::new(
Options::parse_from(["tubular"]),
path.clone(),
config::load(&path).unwrap(),
);
loaded_channel_views(&mut app);
app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
assert!(app.category_dialog.is_none());
app.view_index = app
.views
.iter()
.position(|view| view.name == "Source")
.unwrap();
app.views[app.view_index].loaded = true;
app.views[1].loaded = true;
app.views[1].next_start = 41;
let subscriptions = app.feed_channels.clone();
app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
let dialog = app.category_dialog.as_ref().unwrap();
assert!(dialog.tags["Shared"] && dialog.tags["Source"]);
assert!(!dialog.tags["Mixed"] && !dialog.tags["Empty"]);
assert!(
matches!(&dialog.target, CategoryTarget::Category { channels, .. } if channels.len() == 2)
);
assert!(app.views[app.view_index].videos.is_empty());
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
for c in "Staged".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
assert!(!app.config.categories.contains_key("Staged"));
app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.is_none());
let saved = config::load(&path).unwrap();
assert!(saved.categories["Source"].is_empty());
assert_eq!(
saved.categories["Mixed"],
["https://www.youtube.com/channel/UCBR8-60-B28hp2BmDPdntcQ"]
);
assert_eq!(saved.categories["Shared"].len(), 3);
assert_eq!(saved.pinned_categories, ["Source"]);
assert_eq!(app.feed_channels, subscriptions);
assert!(app.views[1].loaded);
assert_eq!(app.views[1].next_start, 41);
browse_channel(&mut app, "@a");
let channel_source = app.views[app.view_index].source.clone();
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
let channel = &app.views[app.view_index];
assert_eq!(channel.source, channel_source);
assert!(channel.loaded);
assert_eq!(channel.videos.len(), 2);
assert_eq!(channel.selection.selected(), Some(1));
assert_eq!(channel.next_start, 41);
assert!(app.job.is_none());
app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
assert!(app.category_dialog.is_none());
std::fs::remove_file(path).unwrap();
}
#[test]
fn filtering_preserves_selected_categories_and_browses_the_filtered_row() {
let mut app = app(&["tubular"]);
app.views[0].query = "main search untouched".into();
app.apply_config(config::Config {
categories: [
("Alpha".into(), vec![]),
("Japanese immersion".into(), vec![]),
("Japanese news".into(), vec![]),
]
.into(),
..config::Config::default()
});
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
for c in "JAPANESE".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
for c in " news".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.browser.as_ref().unwrap().mode, Mode::Normal);
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].name, "Japanese news");
assert_eq!(app.views[0].query, "main search untouched");
assert!(app.browser.is_none());
}
#[test]
fn insert_filter_types_jk_handles_empty_matches_and_navigates_without_editing() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
categories: [
("Alpha".into(), vec![]),
("Jazz".into(), vec![]),
("Jokes".into(), vec![]),
("日本語だけで".into(), vec![]),
]
.into(),
..config::Config::default()
});
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
for c in "jk".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
assert!(app.browser.as_ref().unwrap().selection.selected().is_none());
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.browser.is_some());
assert_eq!(app.view_index, 0);
app.key(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
for (code, modifiers, row) in [
(KeyCode::Char('j'), KeyModifiers::CONTROL, 1),
(KeyCode::Char('k'), KeyModifiers::CONTROL, 0),
(KeyCode::Down, KeyModifiers::NONE, 1),
(KeyCode::Up, KeyModifiers::NONE, 0),
] {
app.key(KeyEvent::new(code, modifiers));
assert_eq!(
app.browser.as_ref().unwrap().selection.selected(),
Some(row)
);
}
assert_eq!(app.browser.as_ref().unwrap().query, "j");
app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::CONTROL));
for c in "日本".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].name, "日本語だけで");
assert_eq!(app.mode, Mode::Normal);
}
#[test]
fn category_browser_replaces_the_temporary_tab_and_cycles_only_visible_views() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
categories: [
("Alpha".into(), vec![]),
("Beta".into(), vec![]),
("Gamma".into(), vec![]),
]
.into(),
..config::Config::default()
});
let visible = |app: &App| {
app.visible_views()
.map(|(_, view)| view.name.clone())
.collect::<Vec<_>>()
};
assert_eq!(visible(&app), ["Search", "Feed"]);
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.view_index, 0);
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(app.views[app.view_index].name, "Beta");
assert_eq!(visible(&app), ["Search", "Feed", "Beta"]);
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(visible(&app), ["Search", "Feed", "Gamma"]);
app.apply_config(config::Config {
categories: app.config.categories.clone(),
pinned_categories: vec!["Beta".into()],
..config::Config::default()
});
assert_eq!(visible(&app), ["Search", "Feed", "Beta", "Gamma"]);
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.view_index, 0);
app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
assert_eq!(app.views[app.view_index].name, "Gamma");
app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
assert_eq!(app.views[app.view_index].name, "Beta");
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(visible(&app), ["Search", "Feed", "Beta"]);
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(visible(&app), ["Search", "Feed", "Beta"]);
assert!(app.browser.is_none());
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
assert!(app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)));
}
#[test]
fn categories_named_search_or_feed_are_distinct_from_permanent_views() {
let mut app = app(&["tubular"]);
app.apply_config(config::Config {
categories: [
("Alpha".into(), vec![]),
("Feed".into(), vec![]),
("Search".into(), vec![]),
]
.into(),
..config::Config::default()
});
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(app.view_index, 3);
assert_eq!(app.views[app.view_index].name, "Feed");
app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
}
#[test]
fn descriptions_are_shared_across_views_and_evict_least_recently_used_entries() {
let mut app = app(&["tubular"]);
let output = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Shared video"}]}"#;
for view in &mut app.views {
view.videos = youtube::search_results(output).unwrap().videos;
view.selection.select(Some(0));
view.loaded = true;
}
app.remember_description("jNQXAC9IVRw".into(), "Shared full description".into());
for index in 1..DESCRIPTION_CACHE_SIZE {
app.remember_description(format!("video{index:06}"), format!("Description {index}"));
}
app.switch_view(1);
app.load_description(); // A hit in Feed promotes the Search video's description.
assert!(app.description_job.is_none());
app.remember_description("new00000000".into(), "New description".into());
assert_eq!(
cached_description(&app.descriptions, "jNQXAC9IVRw"),
Some("Shared full description")
);
assert_eq!(cached_description(&app.descriptions, "video000001"), None);
assert_eq!(
cached_description(&app.descriptions, "video000002"),
Some("Description 2")
);
// Updating an existing entry, including a known empty description, must not evict another.
app.remember_description("jNQXAC9IVRw".into(), String::new());
app.load_description();
assert!(app.description_job.is_none());
assert_eq!(
cached_description(&app.descriptions, "jNQXAC9IVRw"),
Some("")
);
assert_eq!(
cached_description(&app.descriptions, "video000002"),
Some("Description 2")
);
}
#[test]
fn thumbnail_ellipsis_marks_only_hidden_content_and_preserves_wide_characters() {
use ratatui::{Terminal, backend::TestBackend, style::Modifier};
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Heading","channel":"Creator","upload_date":"20050423"}]}"#,
).unwrap().videos;
app.views[0].selection.select(Some(0));
app.preview = Some(PreviewMode::Info);
for (last_line, hidden) in [
("line", false),
("line", true),
("abcdefghijklmnopqrs", true),
("a界界界界界界界界界", true),
("", true),
] {
app.remember_description(
"jNQXAC9IVRw".into(),
format!(
"{}{last_line}{}",
"line\n".repeat(6),
if hidden { "\nhidden content" } else { "" },
),
);
let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let popup = preview_area(buffer.area);
let text_x = (popup.x + 1..popup.right() - 1)
.find(|&x| {
let cell = &buffer[(x, popup.y + 1)];
cell.symbol() == "H" && cell.modifier.contains(Modifier::BOLD)
})
.expect("title is visible");
let row: String = (text_x..popup.right() - 3)
.map(|x| buffer[(x, popup.bottom() - 2)].symbol())
.collect();
if hidden {
assert!(row.trim_end().ends_with('…'), "{row}");
if last_line.starts_with("a界") {
assert!(row.starts_with("a界"));
for x in text_x..popup.right() - 3 {
if buffer[(x, popup.bottom() - 2)].symbol() == "界" {
assert_eq!(buffer[(x + 1, popup.bottom() - 2)].symbol(), " ");
}
}
}
} else {
assert_eq!(row.trim_end(), "line");
}
}
}
#[test]
fn thumbnail_text_has_contrast_a_right_gutter_and_a_clipped_excerpt() {
use ratatui::{Terminal, backend::TestBackend, style::Modifier};
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First second third fourth fifth","channel":"Creator","upload_date":"20050423"}]}"#,
).unwrap().videos;
app.remember_description(
"jNQXAC9IVRw".into(),
format!("{}CLIPPED SENTINEL", "Excerpt line\n".repeat(30)),
);
app.views[0].selection.select(Some(0));
app.preview = Some(PreviewMode::Info);
for (width, height) in [(80, 24), (120, 40), (20, 10)] {
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let popup = preview_area(Rect::new(0, 0, width, height));
let mut excerpt_rows = Vec::new();
for y in popup.y + 1..popup.bottom() - 1 {
for x in popup.right() - 3..popup.right() - 1 {
assert_eq!(buffer.cell((x, y)).unwrap().symbol(), " ");
}
let row: String = (popup.x + popup.width / 2..popup.right() - 3)
.map(|x| buffer.cell((x, y)).unwrap().symbol())
.collect();
assert!(!row.contains("CLIPPED SENTINEL"));
if row.contains("Excerpt line") {
excerpt_rows.push(y);
}
}
if width == 20 {
assert!(excerpt_rows.is_empty()); // Heading takes all available height.
continue;
}
let text_x = (popup.x + 1..popup.right() - 1)
.find(|&x| {
let cell = &buffer[(x, popup.y + 1)];
cell.symbol() == "F" && cell.modifier.contains(Modifier::BOLD)
})
.expect("title is visible");
let title = &buffer[(text_x, popup.y + 1)];
assert!(title.modifier.contains(Modifier::BOLD));
assert!(!title.modifier.contains(Modifier::DIM));
let excerpt_y = *excerpt_rows
.last()
.expect("description fills remaining space");
assert_eq!(excerpt_y, popup.bottom() - 2);
let excerpt = &buffer[(text_x, excerpt_y)];
assert!(!excerpt.modifier.contains(Modifier::DIM));
assert!(!excerpt.modifier.contains(Modifier::BOLD));
}
}
#[test]
fn view_tabs_wrap_whole_labels_and_keep_the_selected_row_visible() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
app.views = ["Search", "Feed", "Language immersion", "日本語だけ", "中文"]
.into_iter()
.enumerate()
.map(|(index, name)| {
View::new(
name.into(),
match index {
0 => ViewSource::Search,
1 => ViewSource::Feed,
_ => ViewSource::Category(name.into()),
},
)
})
.collect();
app.config.pinned_categories = app
.views
.iter()
.skip(2)
.map(|view| view.name.clone())
.collect();
app.view_index = 4;
app.mode = Mode::Insert;
for (width, height) in [(30, 20), (56, 20), (55, 20), (9, 20), (30, 12)] {
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let tab_height = terminal.get_cursor_position().unwrap().y - 1;
let buffer = terminal.backend().buffer();
let locate = |symbol: &str| {
(0..tab_height)
.flat_map(|y| (0..width).map(move |x| (x, y)))
.find(|&position| buffer.cell(position).unwrap().symbol() == symbol)
};
let chinese = locate("中").expect("selected category remains visible");
assert_eq!(buffer.cell(chinese).unwrap().fg, Color::Cyan);
assert_eq!(
buffer.cell((chinese.0 + 2, chinese.1)).unwrap().symbol(),
"文"
);
if width >= 16 {
let japanese = locate("日").expect("neighboring category remains visible");
for (offset, character) in "日本語だけ".chars().enumerate() {
assert_eq!(
buffer
.cell((japanese.0 + offset as u16 * 2, japanese.1))
.unwrap()
.symbol(),
character.to_string(),
"category label must not split across rows"
);
}
assert_ne!(buffer.cell(japanese).unwrap().fg, Color::Cyan);
}
if width >= 24 {
assert!(
(0..tab_height).any(|y| {
(0..width)
.map(|x| buffer.cell((x, y)).unwrap().symbol())
.collect::<String>()
.contains("Language immersion")
}),
"whole category label must fit after wrapping"
);
}
}
}
#[test]
fn search_pages_preserve_relevance_and_selection() {
let mut view = View::new("Search".into(), ViewSource::Search);
let mut first = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","timestamp":100},{"id":"rQ_J9WH6CGk","title":"Second","timestamp":200}]}"#,
)
.unwrap();
first.has_more = true;
view.accept_page(first, false).unwrap();
view.selection.select(Some(1));
let mut next = youtube::search_results(
r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Duplicate"},{"id":"l-GaaivVJCE","title":"Relevant","timestamp":50},{"id":"l-GaaivVJCE","title":"Repeated"},{"id":"aaaaaaaaaaa","title":"Later","timestamp":300}]}"#,
)
.unwrap();
next.has_more = true;
view.accept_page(next, false).unwrap();
assert_eq!(
view.videos
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["jNQXAC9IVRw", "rQ_J9WH6CGk", "l-GaaivVJCE", "aaaaaaaaaaa"]
);
assert_eq!(view.videos[1].title, "Second");
assert_eq!(view.selection.selected(), Some(1));
assert_eq!(view.next_start, PAGE_SIZE * 2 + 1);
assert!(view.has_more);
}
#[test]
fn many_channel_feed_consumes_only_sixty_requested_rows() {
let mut app = app(&["tubular"]);
app.view_index = 1;
app.feed_channels = (0..75)
.map(|index| format!("https://www.youtube.com/@creator{index}"))
.collect();
let view = &mut app.views[1];
view.feed_requests = view.feed_cursor.plan(app.feed_channels.len()).unwrap();
assert_eq!(
view.feed_requests
.iter()
.map(|request| request.count)
.sum::<usize>(),
PAGE_SIZE
);
assert_eq!(view.feed_requests.len(), PAGE_SIZE);
let output = view
.feed_requests
.iter()
.map(|request| {
serde_json::json!({"entries":[{
"id":format!("channel{:04}", request.channel),
"title":"Upload",
"timestamp":request.channel,
}]})
.to_string()
})
.collect::<Vec<_>>()
.join("\n");
app.finish_page(Ok(output));
assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
assert!(app.views[1].has_more);
assert!(!app.can_prefetch());
let next = app.views[1]
.feed_cursor
.plan(app.feed_channels.len())
.unwrap();
assert!(
next.iter()
.any(|request| request.channel >= PAGE_SIZE && request.start == 1)
);
assert_eq!(
next.iter().map(|request| request.count).sum::<usize>(),
PAGE_SIZE
);
app.views[1].feed_requests = next.clone();
app.views[1].prefetch_requested = true;
app.finish_page(Ok(r#"{"entries":[]}"#.into()));
assert!(app.views[1].page_error.is_some());
assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
assert_eq!(
app.views[1]
.feed_cursor
.plan(app.feed_channels.len())
.unwrap(),
next
);
assert!(app.views[1].prefetch_requested);
}
#[test]
fn refresh_keeps_rows_until_a_valid_replacement_arrives() {
let mut app = app(&["tubular"]);
app.view_index = 1;
// Duplicate URLs fail request creation before any extractor is spawned.
app.feed_channels = vec!["fixture".into(), "fixture".into()];
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old"},{"id":"rQ_J9WH6CGk","title":"Selected"}]}
{"entries":[]}"#,
false,
);
app.views[1].selection.select(Some(1));
app.load_view();
assert_eq!(app.views[1].videos[1].title, "Selected");
assert_eq!(app.views[1].selection.selected(), Some(1));
assert!(app.views[1].page_error.is_some());
assert_eq!(app.views[1].next_start, 1);
app.finish_page(Ok("not JSON".into()));
assert_eq!(app.views[1].videos[1].title, "Selected");
assert_eq!(app.views[1].selection.selected(), Some(1));
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Updated"}]}
{"entries":[]}"#,
true,
);
assert_eq!(app.views[1].videos.len(), 1);
assert_eq!(app.views[1].videos[0].title, "Updated");
assert_eq!(app.views[1].selection.selected(), Some(0));
assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Next page"}]}
{"entries":[]}"#,
false,
);
assert_eq!(app.views[1].videos[0].title, "Updated");
assert_eq!(app.views[1].videos[1].title, "Next page");
app.load_view();
assert_eq!(app.views[1].videos[0].title, "Updated");
finish_feed_fixture(&mut app, "{\"entries\":[]}\n{\"entries\":[]}", false);
assert!(app.views[1].videos.is_empty());
assert_eq!(app.views[1].selection.selected(), None);
}
#[test]
fn loaded_feed_rows_are_visible_sorted_and_keep_selection_and_description_identity() {
let mut app = app(&["tubular"]);
app.view_index = 1;
app.feed_channels = vec![
"https://www.youtube.com/@one".into(),
"https://www.youtube.com/@two".into(),
];
// Keep both channels active despite a short visible page.
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old","timestamp":100},{"id":"rQ_J9WH6CGk","title":"Undated"}]}
{"entries":[{"id":"l-GaaivVJCE","title":"Middle","timestamp":200}]}"#,
true,
);
assert_eq!(
app.views[1]
.videos
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["l-GaaivVJCE", "jNQXAC9IVRw", "rQ_J9WH6CGk"]
);
app.views[1].selection.select(Some(1));
let description_id = app.views[1].videos[1].id.clone();
app.preview = Some(PreviewMode::Info);
app.remember_description("l-GaaivVJCE".into(), "Keep cached preview".into());
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Newer","timestamp":300}]}
{"entries":[]}"#,
false,
);
assert_eq!(
app.views[1]
.videos
.iter()
.map(|video| video.id.as_str())
.collect::<Vec<_>>(),
["SLV9AJxnb1U", "l-GaaivVJCE", "jNQXAC9IVRw", "rQ_J9WH6CGk"]
);
assert_eq!(app.views[1].selection.selected(), Some(2));
assert_eq!(app.views[1].videos[2].title, "Old");
app.finish_description(
description_id,
Ok(r#"{"id":"jNQXAC9IVRw","description":"Selected upload description"}"#.into()),
);
assert_eq!(
cached_description(&app.descriptions, "jNQXAC9IVRw"),
Some("Selected upload description")
);
assert_eq!(
cached_description(&app.descriptions, "l-GaaivVJCE"),
Some("Keep cached preview")
);
assert_eq!(cached_description(&app.descriptions, "SLV9AJxnb1U"), None);
assert_eq!(app.preview, Some(PreviewMode::Info));
assert!(!app.views[1].has_more);
}
#[test]
fn short_undated_or_invalid_feed_pages_require_new_forward_navigation() {
for visible in [0, 1, 19] {
let mut app = app(&["tubular"]);
app.view_index = 1;
app.feed_channels
.push("https://www.youtube.com/@jawed".into());
let mut entries: Vec<_> = (0..visible)
.map(|index| {
serde_json::json!({
"id":format!("unknown{index:04}"), "title":"Undated",
})
})
.collect();
entries.resize(PAGE_SIZE - 1, serde_json::Value::Null);
entries.push(serde_json::json!({"id":"bad", "title":"Invalid ID"}));
finish_feed_fixture(
&mut app,
&serde_json::json!({"entries":entries}).to_string(),
false,
);
assert_eq!(app.views[1].videos.len(), visible);
assert!(app.views[1].has_more);
assert!(!app.can_prefetch());
app.update();
assert!(app.job.is_none());
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
assert!(app.can_prefetch());
assert_eq!(
app.views[1].selection.selected(),
if visible == 0 {
None
} else {
Some((visible - 1).min(1))
}
);
finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
assert!(app.views[1].has_more);
assert!(!app.can_prefetch());
app.key(KeyEvent::new(KeyCode::Char('G'), KeyModifiers::SHIFT));
assert!(app.views[1].prefetch_requested);
let next = app.views[1].feed_cursor.plan(1).unwrap();
app.finish_page(Err("Continuation failed".into()));
assert_eq!(app.views[1].feed_cursor.plan(1).unwrap(), next);
assert!(!app.can_prefetch());
app.views[1].reset();
assert!(app.views[1].feed_requests.is_empty());
assert!(!app.views[1].prefetch_requested);
assert_eq!(app.views[1].feed_cursor.plan(1).unwrap()[0].start, 1);
}
}
#[test]
fn feed_cursors_and_staged_requests_survive_cancellation_and_history_independently() {
let mut app = app(&["tubular"]);
app.feed_channels
.push("https://www.youtube.com/@one".into());
app.config
.categories
.insert("Two".into(), vec!["https://www.youtube.com/@two".into()]);
app.views
.push(View::new("Two".into(), ViewSource::Category("Two".into())));
let category = app.views.len() - 1;
app.views[0].loaded = true;
for index in [1, category] {
app.view_index = index;
finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
}
app.view_index = 1;
app.views[1].prefetch_requested = true;
app.views[1].feed_requests = app.views[1].feed_cursor.plan(1).unwrap();
let cancelled = app.views[1].feed_requests.clone();
app.switch_view(category);
finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
assert_eq!(
app.views[category].feed_cursor.plan(1).unwrap()[0].start,
PAGE_SIZE * 2 + 1
);
app.back_view();
assert_eq!(app.view_index, 1);
assert_eq!(app.views[1].feed_requests, cancelled);
assert_eq!(app.views[1].feed_cursor.plan(1).unwrap(), cancelled);
assert!(app.views[1].prefetch_requested);
app.forward_view();
assert_eq!(app.view_index, category);
assert!(!app.views[category].prefetch_requested);
assert_eq!(
app.views[category].feed_cursor.plan(1).unwrap()[0].start,
PAGE_SIZE * 2 + 1
);
}
#[test]
fn category_membership_reordering_keeps_cursor_request_intent_and_cache() {
let mut app = App::new(
Options::parse_from(["tubular"]),
PathBuf::new(),
config::Config {
categories: [(
"Creators".into(),
vec![
"https://www.youtube.com/@two".into(),
"https://www.youtube.com/@one".into(),
],
)]
.into(),
..Default::default()
},
);
app.view_index = 2;
finish_feed_fixture(
&mut app,
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
true,
);
app.views[2].query = " draft robotics ".into();
app.views[2].submitted_query = "robotics".into();
app.remember_description("jNQXAC9IVRw".into(), "Retained".into());
app.views[2].feed_requests = app.views[2].feed_cursor.plan(2).unwrap();
app.views[2].prefetch_requested = true;
let requests = app.views[2].feed_requests.clone();
let mut categories = app.config.categories.clone();
categories.get_mut("Creators").unwrap().reverse();
app.apply_config(config::Config {
categories,
..Default::default()
});
assert_eq!(app.views[2].feed_requests, requests);
assert_eq!(app.views[2].feed_cursor.plan(2).unwrap(), requests);
assert!(app.views[2].prefetch_requested);
assert_eq!(app.views[2].videos[0].id, "jNQXAC9IVRw");
assert_eq!(app.views[2].selection.selected(), Some(0));
assert_eq!(app.views[2].query, " draft robotics ");
assert_eq!(app.views[2].submitted_query, "robotics");
assert_eq!(
cached_description(&app.descriptions, "jNQXAC9IVRw"),
Some("Retained")
);
let mut categories = app.config.categories.clone();
categories
.get_mut("Creators")
.unwrap()
.push("https://www.youtube.com/@three".into());
app.apply_config(config::Config {
categories,
..Default::default()
});
assert!(!app.views[2].loaded);
assert_eq!(app.views[2].videos[0].id, "jNQXAC9IVRw");
assert!(app.views[2].feed_requests.is_empty());
assert!(!app.views[2].prefetch_requested);
assert_eq!(app.views[2].next_start, 1);
assert_eq!(app.views[2].query, " draft robotics ");
assert_eq!(app.views[2].submitted_query, "robotics");
assert!(
app.views[2]
.feed_cursor
.plan(3)
.unwrap()
.iter()
.all(|request| request.start == 1)
);
}
#[test]
fn page_failures_and_view_switches_preserve_the_successful_cursor_until_reset() {
let mut app = app(&["tubular", "rust"]);
app.views[0].submitted_query = "rust".into();
app.finish_page(Err("First request failed".into()));
assert_eq!(app.views[0].next_start, 1);
assert!(!app.views[0].loaded);
assert!(app.views[0].page_error.is_some());
app.switch_view(0);
app.update();
assert!(app.job.is_none());
app.views[0].reset();
let entries: Vec<_> = (0..PAGE_SIZE)
.map(|index| {
serde_json::json!({
"id": format!("search{index:05}"),
"title": "Result",
})
})
.collect();
app.finish_page(Ok(serde_json::json!({"entries": entries}).to_string()));
assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
app.views[0].selection.select(Some(17));
app.remember_description(app.views[0].videos[17].id.clone(), "Cached.".into());
app.switch_view(1);
app.switch_view(0);
assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
assert_eq!(app.views[0].selection.selected(), Some(17));
app.finish_page(Ok("not JSON".into()));
app.update();
assert!(app.job.is_none());
assert_eq!(app.views[0].videos.len(), PAGE_SIZE);
assert_eq!(
cached_description(&app.descriptions, &app.views[0].videos[17].id),
Some("Cached.")
);
assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
assert!(!app.views[0].needs_page());
let view = &mut app.views[0];
view.feed_requests = view.feed_cursor.plan(1).unwrap();
view.prefetch_requested = true;
view.reset();
assert!(view.feed_requests.is_empty());
assert!(!view.feed_cursor.has_more());
assert!(!view.prefetch_requested);
assert_eq!(view.next_start, 1);
assert!(!view.loaded);
assert!(!view.has_more);
assert!(view.page_error.is_none());
}
#[test]
fn prefetch_only_runs_near_the_end_in_an_unobstructed_normal_view() {
let mut app = app(&["tubular"]);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
let mut page =
youtube::search_results(r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Result"}]}"#).unwrap();
page.has_more = true;
app.views[0].accept_page(page, false).unwrap();
assert!(!app.can_prefetch());
app.mode = Mode::Normal;
assert!(!app.can_prefetch());
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
assert!(app.can_prefetch());
app.preview = Some(PreviewMode::Description);
assert!(!app.can_prefetch());
app.preview = Some(PreviewMode::Info);
assert!(!app.can_prefetch());
app.preview = None;
app.category_dialog = Some(CategoryDialog {
name: None,
..CategoryDialog::new(
CategoryTarget::Channel {
channel: String::new(),
handle: String::new(),
},
String::new(),
BTreeMap::new(),
)
});
assert!(!app.can_prefetch());
app.category_dialog = None;
let entries: Vec<_> = (0..PAGE_SIZE)
.map(|index| {
serde_json::json!({
"id": format!("search{index:05}"),
"title": "Next result",
})
})
.collect();
app.views[0].reset();
app.views[0]
.accept_page(
youtube::search_results(&serde_json::json!({"entries": entries}).to_string()).unwrap(),
false,
)
.unwrap();
assert_eq!(app.views[0].selection.selected(), Some(0));
assert!(!app.can_prefetch());
let threshold = app.views[0].videos.len() - PAGE_SIZE / 3;
app.views[0].selection.select(Some(threshold - 1));
assert!(!app.can_prefetch());
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
assert!(app.can_prefetch());
assert!(app.job.is_none());
assert_eq!(app.views[0].selection.selected(), Some(threshold));
app.views[0].loaded = false;
assert!(!app.can_prefetch());
app.views[0].loaded = true;
app.views[0].has_more = false;
assert!(!app.can_prefetch());
app.views[0].has_more = true;
app.help_popup = Some(HelpPopup::default());
assert!(!app.can_prefetch());
app.help_popup = None;
app.views[0].selection.select(None);
assert!(!app.can_prefetch());
app.views[0].selection.select(Some(threshold));
app.views[0].page_error = Some("Stop retrying".into());
assert!(!app.can_prefetch());
app.views[0].page_error = None;
app.views[0].videos.clear();
app.views[0].selection.select(None);
assert!(app.can_prefetch());
}
#[test]
fn input_cursor_tracks_display_width_and_stays_inside_scrolled_fields() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
let mut terminal = Terminal::new(TestBackend::new(24, 20)).unwrap();
for (text, x) in [
("", 1),
("ab", 3),
("日本語", 7),
("e\u{301}", 2),
("abcdefghijklmnopqrstuvwxyz", 22),
] {
app.views[0].query = text.into();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert_eq!(terminal.get_cursor_position().unwrap(), (x, 2).into());
}
app.category_dialog = Some(CategoryDialog {
name: Some(String::new()),
..CategoryDialog::new(
CategoryTarget::Channel {
channel: String::new(),
handle: String::new(),
},
String::new(),
BTreeMap::new(),
)
});
for (text, x) in [("", 3), ("日本語", 9), ("abcdefghijklmnopqrstuvwxyz", 20)] {
app.category_dialog.as_mut().unwrap().name = Some(text.into());
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert_eq!(terminal.get_cursor_position().unwrap(), (x, 7).into());
}
}
#[test]
fn deletion_shortcuts_edit_search_and_tag_names_without_submitting() {
for tag_input in [false, true] {
for (input, code, modifiers, expected) in [
(
"first 日本語 ",
KeyCode::Backspace,
KeyModifiers::ALT,
"first ",
),
(
"first\u{3000}cafe\u{301} ",
KeyCode::Char('w'),
KeyModifiers::CONTROL,
"first\u{3000}",
),
("word", KeyCode::Backspace, KeyModifiers::ALT, ""),
(" \u{3000} ", KeyCode::Backspace, KeyModifiers::ALT, ""),
("", KeyCode::Backspace, KeyModifiers::ALT, ""),
("first 日本語", KeyCode::Backspace, KeyModifiers::SUPER, ""),
(
"first 日本語",
KeyCode::Backspace,
KeyModifiers::SUPER | KeyModifiers::ALT,
"",
),
(
"first 日本語",
KeyCode::Char('u'),
KeyModifiers::CONTROL,
"",
),
(
"first 日本語",
KeyCode::Backspace,
KeyModifiers::NONE,
"first 日本",
),
] {
let mut app = app(&["tubular"]);
if tag_input {
app.mode = Mode::Normal;
app.category_dialog = Some(CategoryDialog {
name: Some(input.into()),
..CategoryDialog::new(
CategoryTarget::Channel {
channel: "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A"
.into(),
handle: "@jawed".into(),
},
"jawed".into(),
BTreeMap::new(),
)
});
} else {
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
app.views[0].query = input.into();
}
app.key(KeyEvent::new(code, modifiers));
let edited = app
.category_dialog
.as_ref()
.and_then(|dialog| dialog.name.as_deref())
.unwrap_or(&app.views[0].query);
assert_eq!(
edited, expected,
"{tag_input}: {input:?} {code:?} {modifiers:?}"
);
assert!(app.job.is_none());
assert_eq!(
app.mode,
if tag_input {
Mode::Normal
} else {
Mode::Insert
}
);
}
}
let mut app = app(&["tubular"]);
app.views[0].query = "keep this query".into();
app.mode = Mode::Normal;
for (code, modifiers) in [
(KeyCode::Backspace, KeyModifiers::ALT),
(KeyCode::Backspace, KeyModifiers::SUPER),
(KeyCode::Char('w'), KeyModifiers::CONTROL),
] {
app.key(KeyEvent::new(code, modifiers));
assert_eq!(app.views[0].query, "keep this query");
}
}
#[test]
fn modal_keys_edit_or_navigate_without_submitting_on_escape() {
let mut app = app(&["tubular"]);
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
app.views[0].videos = vec![
Video {
id: "jNQXAC9IVRw".into(),
title: "Me at the zoo".into(),
channel: None,
channel_id: None,
uploader_id: None,
timestamp: None,
duration: None,
publication_date: None,
availability: None,
},
Video {
id: "rQ_J9WH6CGk".into(),
title: "Rust course".into(),
channel: None,
channel_id: None,
uploader_id: None,
timestamp: None,
duration: None,
publication_date: None,
availability: None,
},
];
app.views[0].selection.select(Some(0));
for c in ['j', 'k', 'q'] {
assert!(!app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE)));
}
app.update();
assert_eq!(app.views[0].query, "jkq");
assert_eq!(app.views[0].selection.selected(), Some(0));
assert!(app.job.is_none());
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.mode, Mode::Normal);
assert!(app.job.is_none());
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
assert_eq!(app.views[0].selection.selected(), Some(1));
app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::NONE));
assert_eq!(app.views[0].selection.selected(), Some(0));
app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
assert_eq!(app.mode, Mode::Insert);
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(app.mode, Mode::Normal);
assert!(app.views[0].query.is_empty());
assert!(app.job.is_none());
}
#[test]
fn category_dialog_is_modal_and_views_keep_independent_selections() {
let mut app = app(&["tubular", "rust"]);
let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"Rust video","channel":"Rust","channel_id":"UCaYhcUwRBNscFNUKTjgPFiA","uploader_id":"@RustVideos"},{"id":"rQ_J9WH6CGk","title":"Another video"}]}"#;
app.views[0].videos = youtube::search_results(videos).unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(1));
// The selected channel is unavailable; do not save a guessed display-name identity.
app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
assert!(app.category_dialog.is_none());
app.views[0].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().error.is_some());
for c in ['j', 'k', 'q', 'i', 't', 'd', ' '] {
assert!(!app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE)));
}
assert_eq!(
app.category_dialog.as_ref().unwrap().name.as_deref(),
Some("jkqitd ")
);
assert_eq!(app.views[0].query, "rust");
assert_eq!(app.views[0].selection.selected(), Some(0));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().name.is_none());
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('A'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().name.is_none());
assert!(app.category_dialog.as_ref().unwrap().tags["A"]);
assert!(app.config.categories.is_empty());
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert!(!app.category_dialog.as_ref().unwrap().tags["A"]);
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(!app.category_dialog.as_ref().unwrap().tags["A"]);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.category_dialog.is_none());
assert_eq!(app.mode, Mode::Normal);
assert!(app.config.categories.is_empty());
let rust = vec!["https://www.youtube.com/@RustVideos".into()];
app.apply_config(config::Config {
keys: Default::default(),
categories: [("Rust".into(), rust.clone())].into(),
channels: BTreeMap::new(),
pinned_categories: vec!["Rust".into()],
});
app.views[0].selection.select(Some(1));
app.views[1].videos = feed_fixture(videos).unwrap().videos;
app.views[1].loaded = true;
app.views[1].selection.select(Some(0));
app.views[2].videos = feed_fixture(videos).unwrap().videos;
app.views[2].loaded = true;
app.views[2].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.view_index, 1);
assert_eq!(app.views[1].name, "Feed");
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.view_index, 2);
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
assert_eq!(app.views[2].selection.selected(), Some(1));
assert_eq!(app.views[1].selection.selected(), Some(0));
app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
assert_eq!(app.view_index, 1);
assert_eq!(app.views[1].selection.selected(), Some(0));
app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
assert_eq!(app.view_index, 0);
assert_eq!(app.views[0].selection.selected(), Some(1));
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
app.apply_config(config::Config {
keys: Default::default(),
categories: [
(
"Books".into(),
vec!["https://www.youtube.com/@example".into()],
),
("Rust".into(), rust),
]
.into(),
channels: BTreeMap::new(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 3);
assert_eq!(app.views[3].name, "Rust");
assert_eq!(app.views[3].selection.selected(), Some(1));
assert!(app.views[3].loaded);
app.apply_config(config::Config {
keys: Default::default(),
categories: [("Rust".into(), vec![])].into(),
channels: BTreeMap::new(),
pinned_categories: Vec::new(),
});
assert_eq!(app.views[app.view_index].name, "Rust");
assert!(!app.views[app.view_index].loaded);
assert!(app.job.is_none());
app.load_page();
assert!(app.views[app.view_index].videos.is_empty());
assert!(app.views[app.view_index].selection.selected().is_none());
assert!(app.views[app.view_index].loaded);
}
#[test]
fn feed_cache_tracks_subscriptions_not_tag_memberships() {
let registered = "https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA";
let direct = "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A";
let added = "https://www.youtube.com/channel/UCBR8-60-B28hp2BmDPdntcQ";
let mut app = App::new(
Options::parse_from(["tubular", "rust"]),
PathBuf::new(),
config::Config {
keys: Default::default(),
channels: [("@RustVideos".into(), registered.into())].into(),
categories: [
("Direct".into(), vec![direct.into()]),
("Tagged".into(), vec![registered.into()]),
]
.into(),
pinned_categories: Vec::new(),
},
);
let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"New","timestamp":200},{"id":"rQ_J9WH6CGk","title":"Old","timestamp":100}]}"#;
assert_eq!(app.feed_channels, vec![direct, registered]);
app.views[1].videos = feed_fixture(videos).unwrap().videos;
app.views[1].selection.select(Some(1));
app.views[1].loaded = true;
app.views[1].next_start = 41;
app.views[1].has_more = true;
app.views[1].feed_requests = app.views[1].feed_cursor.plan(2).unwrap();
app.views[1].prefetch_requested = true;
app.views[1].page_error = Some("Retained page error".into());
app.remember_description(
app.views[1].videos[1].id.clone(),
"Retained description".into(),
);
app.views[3].videos = feed_fixture(videos).unwrap().videos;
app.views[3].selection.select(Some(0));
app.views[3].loaded = true;
app.views[3].next_start = 61;
app.views[3].has_more = true;
app.views[3].feed_requests = app.views[3].feed_cursor.plan(1).unwrap();
app.views[3].prefetch_requested = true;
app.views[3].page_error = Some("Tag page failed".into());
app.switch_view(1);
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [
("Direct".into(), vec![direct.into()]),
("Renamed".into(), vec![registered.into()]),
("Tagged".into(), vec![]),
]
.into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 1);
assert!(app.views[1].loaded);
assert_eq!(app.views[1].videos[1].id, "rQ_J9WH6CGk");
assert_eq!(app.views[1].selection.selected(), Some(1));
assert_eq!(app.views[1].next_start, 41);
assert!(app.views[1].has_more);
assert_eq!(app.views[1].feed_requests.len(), 2);
assert!(app.views[1].prefetch_requested);
assert_eq!(
app.views[1].page_error.as_deref(),
Some("Retained page error")
);
assert_eq!(
cached_description(&app.descriptions, &app.views[1].videos[1].id),
Some("Retained description")
);
assert!(!app.views[4].loaded);
assert_eq!(app.views[4].next_start, 1);
assert!(!app.views[4].has_more);
assert!(app.views[4].feed_requests.is_empty());
assert!(!app.views[4].prefetch_requested);
assert!(app.views[4].page_error.is_none());
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [
("Direct".into(), vec![direct.into()]),
("Renamed".into(), vec![]),
("Tagged".into(), vec![]),
]
.into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.feed_channels, vec![direct, registered]);
assert!(app.views[1].loaded);
assert_eq!(app.views[1].videos.len(), 2);
assert_eq!(app.views[1].selection.selected(), Some(1));
assert_eq!(app.views[1].next_start, 41);
assert!(app.views[1].has_more);
assert_eq!(app.views[1].feed_requests.len(), 2);
assert!(app.views[1].prefetch_requested);
assert!(app.views[1].page_error.is_some());
let mut channels = app.config.channels.clone();
channels.insert("@YouTube".into(), added.into());
app.apply_config(config::Config {
keys: Default::default(),
channels,
categories: app.config.categories.clone(),
pinned_categories: Vec::new(),
});
assert_eq!(app.feed_channels, vec![direct, added, registered]);
assert!(!app.views[1].loaded);
assert_eq!(app.views[1].next_start, 1);
assert!(!app.views[1].has_more);
assert!(app.views[1].feed_requests.is_empty());
assert!(!app.views[1].prefetch_requested);
assert!(app.views[1].page_error.is_none());
assert_eq!(app.view_index, 1);
assert!(app.job.is_none());
app.views[1].videos = feed_fixture(videos).unwrap().videos;
app.views[1].selection.select(Some(1));
app.views[1].loaded = true;
let mut channels = app.config.channels.clone();
channels.remove("@YouTube");
app.apply_config(config::Config {
keys: Default::default(),
channels,
categories: app.config.categories.clone(),
pinned_categories: Vec::new(),
});
assert_eq!(app.feed_channels, vec![direct, registered]);
assert!(!app.views[1].loaded);
assert_eq!(app.view_index, 1);
assert!(app.job.is_none());
}
#[test]
fn builtins_and_same_named_tags_keep_distinct_identities() {
let mut app = app(&["tubular", "rust"]);
app.apply_config(config::Config {
keys: Default::default(),
channels: [(
"@RustVideos".into(),
"https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA".into(),
)]
.into(),
categories: [("Feed".into(), vec![]), ("Search".into(), vec![])].into(),
pinned_categories: Vec::new(),
});
let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#;
for (index, view) in app.views.iter_mut().enumerate() {
view.videos = feed_fixture(videos).unwrap().videos;
view.loaded = true;
view.selection.select(Some(usize::from(index % 2 == 0)));
}
app.switch_view(1);
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [
("Alpha".into(), vec![]),
("Feed".into(), vec![]),
("Search".into(), vec![]),
]
.into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 1);
assert_eq!(app.views[1].selection.selected(), Some(0));
assert_eq!(app.views[3].name, "Feed");
assert_eq!(app.views[3].selection.selected(), Some(1));
assert_eq!(app.views[0].selection.selected(), Some(1));
assert_eq!(app.views[4].selection.selected(), Some(0));
app.switch_view(0);
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [("Feed".into(), vec![]), ("Search".into(), vec![])].into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 0);
app.switch_view(2);
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [
("Alpha".into(), vec![]),
("Feed".into(), vec![]),
("Search".into(), vec![]),
]
.into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 3);
assert_eq!(app.views[3].selection.selected(), Some(1));
app.switch_view(4);
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [
("Alpha".into(), vec![]),
("Beta".into(), vec![]),
("Feed".into(), vec![]),
("Search".into(), vec![]),
]
.into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 5);
assert_eq!(app.views[5].selection.selected(), Some(0));
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [
("Alpha".into(), vec![]),
("Beta".into(), vec![]),
("Feed".into(), vec![]),
]
.into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 0);
assert_eq!(app.views[0].selection.selected(), Some(1));
app.switch_view(4);
app.apply_config(config::Config {
keys: Default::default(),
channels: app.config.channels.clone(),
categories: [("Alpha".into(), vec![]), ("Beta".into(), vec![])].into(),
pinned_categories: Vec::new(),
});
assert_eq!(app.view_index, 0);
assert_eq!(app.views[1].name, "Feed");
assert_eq!(app.views[1].selection.selected(), Some(0));
assert!(app.job.is_none());
}
#[test]
fn empty_feed_is_informative_and_navigation_wraps_without_extraction() {
let mut app = app(&["tubular"]);
assert_eq!(app.views.len(), 2);
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::CONTROL));
assert_eq!(app.view_index, 1);
assert!(app.views[1].loaded);
assert!(app.views[1].videos.is_empty());
assert_eq!(app.views[1].selection.selected(), None);
assert!(app.job.is_none());
app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
assert_eq!(app.view_index, 0);
app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
assert_eq!(app.views[app.view_index].source, ViewSource::Feed);
assert!(app.job.is_none());
}
#[test]
fn channel_tags_stage_memberships_and_commit_only_from_the_list() {
let path = std::env::temp_dir().join(format!(
"tubular-tag-editor-test-{}.toml",
std::process::id()
));
struct TestFile(PathBuf);
impl Drop for TestFile {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.0);
}
}
std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
.unwrap();
let _file = TestFile(path.clone());
let original = "[categories]\nAlias = [\"@RustVideos\"]\nCanonical = [\"UCaYhcUwRBNscFNUKTjgPFiA\"]\nEmpty = []\n";
std::fs::write(&path, original).unwrap();
let mut app = app(&["tubular", "rust"]);
app.config_path = path.clone();
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"l-GaaivVJCE","title":"Rust video","channel_id":"UCaYhcUwRBNscFNUKTjgPFiA","uploader_id":"@RustVideos"}]}"#,
)
.unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
assert_eq!(
app.category_dialog.as_ref().unwrap().tags,
[
("Alias".into(), true),
("Canonical".into(), true),
("Empty".into(), false),
]
.into()
);
app.key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().tags["Alias"]);
app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
for c in "Empty".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().error.is_some());
app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
for c in " Added ".chars() {
app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
}
app.key(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert_eq!(
app.category_dialog.as_ref().unwrap().selection.selected(),
Some(0)
);
assert!(app.category_dialog.as_ref().unwrap().tags["Added"]);
assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
app.category_dialog.as_mut().unwrap().error = Some("Previous save failed".into());
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
assert!(app.category_dialog.as_ref().unwrap().error.is_none());
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.is_none());
let saved = config::load(&path).unwrap();
let canonical = vec!["https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA".to_owned()];
assert!(saved.categories["Alias"].is_empty());
assert!(saved.categories["Added"].is_empty());
assert_eq!(saved.categories["Canonical"], canonical);
assert_eq!(saved.categories["Empty"], canonical);
let committed = std::fs::read_to_string(&path).unwrap();
app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(std::fs::read_to_string(&path).unwrap(), committed);
std::fs::write(&path, "[categories]\n").unwrap();
app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
assert!(
app.category_dialog
.as_ref()
.unwrap()
.selection
.selected()
.is_none()
);
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
assert!(app.category_dialog.is_none());
assert!(config::load(&path).unwrap().categories.is_empty());
}
#[test]
fn preview_cycles_without_reloading_and_selection_resets_scrolling() {
use ratatui::{Terminal, backend::TestBackend};
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"9bZkp7q19f0","title":"Second"}]}"#,
).unwrap().videos;
// Invalid fixture IDs keep thumbnail failure deterministic without invoking curl.
app.views[0].videos[0].id = "first".into();
app.views[0].videos[1].id = "second".into();
app.remember_description("first".into(), "First paragraph\n\n".repeat(40));
app.remember_description("second".into(), "Second paragraph\n\n".repeat(40));
app.views[0].selection.select(Some(0));
app.views[0].loaded = true;
let mut terminal = Terminal::new(TestBackend::new(120, 40)).unwrap();
let press = |app: &mut App, code| {
app.key(KeyEvent::new(code, KeyModifiers::NONE));
};
press(&mut app, KeyCode::Char('t'));
assert_eq!(app.preview, None);
press(&mut app, KeyCode::Char('d'));
assert_eq!(app.preview, Some(PreviewMode::Info));
assert!(app.description_job.is_none());
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let info = terminal.backend().buffer().clone();
press(&mut app, KeyCode::Char('d'));
assert_eq!(app.preview, Some(PreviewMode::Description));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
press(&mut app, KeyCode::PageDown);
assert!(app.description_scroll > 0);
let scroll = app.description_scroll;
press(&mut app, KeyCode::Char('d'));
assert_eq!(app.preview, Some(PreviewMode::Info));
assert_eq!(app.description_scroll, scroll);
assert!(app.description_job.is_none());
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
// Includes the failed thumbnail text: cancellation would remove that image state.
assert_eq!(terminal.backend().buffer(), &info);
press(&mut app, KeyCode::Char('d'));
press(&mut app, KeyCode::Char('j'));
assert_eq!(app.preview, Some(PreviewMode::Description));
assert_eq!(app.views[0].selection.selected(), Some(1));
assert_eq!(app.description_scroll, 0);
assert_eq!(app.description_viewport, None);
assert!(app.description_error.is_none());
assert!(app.description_job.is_none());
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let buffer = terminal.backend().buffer();
let popup = preview_area(buffer.area);
let title = &buffer[(popup.x + 2, popup.y + 2)];
assert_eq!(title.symbol(), "S");
assert!(title.modifier.contains(ratatui::style::Modifier::BOLD));
press(&mut app, KeyCode::Down);
assert_eq!(app.description_scroll, 1);
assert_eq!(app.views[0].selection.selected(), Some(1));
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
assert_eq!(app.description_scroll, 2);
assert_eq!(app.views[0].selection.selected(), Some(1));
app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
assert_eq!(app.description_scroll, 1);
app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
assert_eq!(app.description_scroll, 0);
app.description_scroll = app.description_max_scroll;
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
assert_eq!(app.description_scroll, app.description_max_scroll);
assert_eq!(app.views[0].selection.selected(), Some(1));
press(&mut app, KeyCode::Char('d'));
press(&mut app, KeyCode::Up);
assert_eq!(app.views[0].selection.selected(), Some(0));
assert_eq!(app.description_scroll, 0);
press(&mut app, KeyCode::Esc);
assert_eq!(app.preview, None);
assert_eq!(
cached_description(&app.descriptions, "first"),
Some("First paragraph\n\n".repeat(40).as_str())
);
press(&mut app, KeyCode::Char('i'));
press(&mut app, KeyCode::Char('t'));
press(&mut app, KeyCode::Char('d'));
assert_eq!(app.views[0].query, "td");
assert_eq!(app.preview, None);
}
#[test]
fn full_description_scrolls_padded_metadata_and_body_together() {
use ratatui::{Terminal, backend::TestBackend, style::Modifier};
let mut app = app(&["tubular"]);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Selected video","channel":"Creator","upload_date":"20050423"}]}"#,
).unwrap().videos;
app.views[0].selection.select(Some(0));
app.preview = Some(PreviewMode::Description);
app.remember_description(
"jNQXAC9IVRw".into(),
(0..100).map(|i| format!("Body line {i:03}\n")).collect(),
);
let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let before = terminal.backend().buffer().clone();
let popup = preview_area(before.area);
let x = popup.x + 2;
let title_y = popup.y + 2;
let body_y = (title_y..popup.bottom() - 1)
.find(|&y| before[(x, y)].symbol() == "B")
.expect("description is visible below metadata");
for x in popup.x + 1..popup.right() - 1 {
assert_eq!(before[(x, popup.y + 1)].symbol(), " ");
}
assert!(before[(x, title_y)].modifier.contains(Modifier::BOLD));
assert!(before[(x, title_y + 2)].modifier.contains(Modifier::DIM));
assert!(!before[(x, body_y)].modifier.contains(Modifier::DIM));
assert_eq!(
app.description_viewport,
Some((popup.width - 4, popup.height - 2))
);
app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
terminal
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let after = terminal.backend().buffer();
assert_eq!(after[(x, title_y - 1)].symbol(), "S");
assert!(after[(x, title_y - 1)].modifier.contains(Modifier::BOLD));
assert_eq!(after[(x, title_y + 1)].symbol(), "C");
assert!(after[(x, title_y + 1)].modifier.contains(Modifier::DIM));
let row = |buffer: &ratatui::buffer::Buffer, y| -> String {
(x..popup.right() - 2)
.map(|x| buffer[(x, y)].symbol())
.collect()
};
assert_eq!(row(&before, body_y).trim_end(), "Body line 000");
assert_eq!(row(after, body_y).trim_end(), "Body line 001");
for y in popup.y + 1..popup.bottom() - 1 {
assert_eq!(after[(popup.x + 1, y)].symbol(), " ");
assert_eq!(after[(popup.right() - 2, y)].symbol(), " ");
}
// A wrapped title cannot prevent reaching the description in a small pane.
let mut narrow = Terminal::new(TestBackend::new(12, 8)).unwrap();
narrow
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
assert!(app.description_max_scroll > 0);
app.description_scroll = app.description_max_scroll;
narrow
.draw(|frame| app.draw(frame, Duration::ZERO))
.unwrap();
let narrow_popup = preview_area(narrow.backend().buffer().area);
let narrow_buffer = narrow.backend().buffer();
let tail: String = (narrow_popup.y + 1..narrow_popup.bottom() - 1)
.flat_map(|y| {
(narrow_popup.x + 2..narrow_popup.right() - 2)
.map(move |x| narrow_buffer[(x, y)].symbol())
})
.collect();
assert!(tail.contains("099"), "{tail}");
}
#[test]
fn search_without_a_handle_can_tag_a_registered_channel() {
let path = std::env::temp_dir().join(format!(
"tubular-missing-handle-{}.toml",
std::process::id()
));
let original =
"[channels]\n'@ch.1676' = 'UChAQQ9at2MDlXjvQX3vL3Yw'\n[categories]\nJapanese = []\n";
std::fs::write(&path, original).unwrap();
let mut app = App::new(
Options::parse_from(["tubular"]),
path.clone(),
config::load(&path).unwrap(),
);
app.views[0].videos = youtube::search_results(
r#"{"entries":[{"id":"nwxkg84mADI","title":"Hokkaido Vlog","channel":"敷嶋てとらch.","channel_id":"UChAQQ9at2MDlXjvQX3vL3Yw","uploader_id":null}]}"#,
).unwrap().videos;
app.views[0].loaded = true;
app.views[0].selection.select(Some(0));
app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
assert!(app.category_dialog.is_some(), "{}", app.status);
app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
let saved = config::load(&path).unwrap();
assert_eq!(
saved.categories["Japanese"],
["https://www.youtube.com/channel/UChAQQ9at2MDlXjvQX3vL3Yw"]
);
std::fs::remove_file(path).unwrap();
}
#[test]
fn escape_discards_checks_without_consuming_view_history() {
let mut app = app(&["tubular"]);
app.views[0].loaded = true;
app.views[1].loaded = true;
app.switch_view(1);
app.views[1].checked.insert("jNQXAC9IVRw".into());
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.views[1].checked.is_empty());
assert_eq!(app.view_index, 1);
app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.view_index, 1);
app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
assert_eq!(app.view_index, 0);
}
Reference in New Issue View Git Blame Copy Permalink