forked from Furumi/furumi-tui
The tab opens the FRID podcast store (podcasts.sqlite3, migrating a prototype database in place; newer or foreign files are reported and left unchanged) off the UI thread and shows subscriptions with unplayed counts and check status, podcast -> seasons -> episodes navigation, and episodes with saved position, played state, duration and date. Episode search, played filter and order run as paged store queries with request sequence numbers. Adding a feed, checking one or all feeds, marking played and unsubscribing (with a confirmation that progress is kept) go through Effect/AppEvent; a scheduler refreshes due feeds in the background. New actions are bound in the podcasts keymap context and listed in a Podcasts help section. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1838 lines
60 KiB
Rust
1838 lines
60 KiB
Rust
use super::*;
|
|
use crate::library::models::{ArtistCard, ArtistDetail, TrackItem};
|
|
|
|
#[test]
|
|
fn additional_settings_preserve_main_navigation_and_child_dialog_parent() {
|
|
use crate::app::state::{FedInputField, Popup, SettingsRow, additional_settings_rows};
|
|
let mut state = AppState {
|
|
active_tab: Tab::Federation,
|
|
..AppState::default()
|
|
};
|
|
let main_rows = settings_rows(&state);
|
|
assert!(!main_rows.contains(&SettingsRow::MusicDirectory));
|
|
assert!(!main_rows.contains(&SettingsRow::CheckUpdate));
|
|
assert!(!main_rows.contains(&SettingsRow::VisualizationClock));
|
|
state.settings_cursor = main_rows
|
|
.iter()
|
|
.position(|r| *r == SettingsRow::AdditionalSettings)
|
|
.unwrap();
|
|
let main_cursor = state.settings_cursor;
|
|
update(&mut state, Action::Select);
|
|
assert!(state.additional_settings_open);
|
|
update(&mut state, Action::Select);
|
|
assert!(matches!(
|
|
state.popup,
|
|
Some(Popup::FedInput {
|
|
field: FedInputField::MusicDirectory,
|
|
..
|
|
})
|
|
));
|
|
// Child dialogs own their input; closing one leaves the parent window intact.
|
|
state.popup = None;
|
|
assert!(state.additional_settings_open);
|
|
update(&mut state, Action::SelectLast);
|
|
assert_eq!(
|
|
state.additional_settings_cursor,
|
|
additional_settings_rows(&state).len() - 1
|
|
);
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(
|
|
state.additional_settings_cursor,
|
|
additional_settings_rows(&state).len() - 1
|
|
);
|
|
update(&mut state, Action::ToggleHelp);
|
|
update(&mut state, Action::Back);
|
|
assert!(!state.help_visible);
|
|
assert!(state.additional_settings_open);
|
|
update(&mut state, Action::Back);
|
|
assert!(!state.additional_settings_open);
|
|
assert!(!state.should_quit);
|
|
assert_eq!(state.settings_cursor, main_cursor);
|
|
}
|
|
|
|
#[test]
|
|
fn manual_update_check_is_single_flight_and_disabled_after_install() {
|
|
let mut state = AppState::default();
|
|
state.additional_settings_cursor = crate::app::state::additional_settings_rows(&state)
|
|
.iter()
|
|
.position(|row| *row == crate::app::state::SettingsRow::CheckUpdate)
|
|
.unwrap();
|
|
assert_eq!(
|
|
update_additional_settings(&mut state, Action::Select),
|
|
Some(Effect::CheckUpdate)
|
|
);
|
|
assert!(state.updater.busy);
|
|
assert_eq!(update_additional_settings(&mut state, Action::Select), None);
|
|
state.updater.busy = false;
|
|
state.updater.installed = true;
|
|
assert_eq!(update_additional_settings(&mut state, Action::Select), None);
|
|
state.updater.installed = false;
|
|
state.additional_settings_cursor = crate::app::state::additional_settings_rows(&state)
|
|
.iter()
|
|
.position(|row| *row == crate::app::state::SettingsRow::InstallUpdate)
|
|
.unwrap();
|
|
assert_eq!(update_additional_settings(&mut state, Action::Select), None);
|
|
}
|
|
|
|
fn with_artists(n: usize) -> AppState {
|
|
let mut state = AppState::default();
|
|
state.global.artists = (0..n)
|
|
.map(|i| ArtistCard {
|
|
id: i as i64,
|
|
name: format!("artist {i}"),
|
|
image_path: None,
|
|
release_count: 1,
|
|
track_count: 2,
|
|
availability: crate::library::models::Availability::Local,
|
|
})
|
|
.collect();
|
|
state
|
|
}
|
|
|
|
#[test]
|
|
fn listening_history_popup_requests_a_background_load() {
|
|
let mut state = AppState::default();
|
|
assert_eq!(
|
|
update(&mut state, Action::OpenListenHistory),
|
|
Some(Effect::LoadListenHistory)
|
|
);
|
|
assert!(matches!(
|
|
state.popup,
|
|
Some(crate::app::state::Popup::ListenHistory { cursor: 0 })
|
|
));
|
|
assert!(matches!(
|
|
state.listen_history,
|
|
Some(crate::app::state::Loadable::Loading)
|
|
));
|
|
}
|
|
|
|
fn test_track(id: i64) -> TrackItem {
|
|
TrackItem {
|
|
id,
|
|
title: format!("t{id}"),
|
|
track_number: None,
|
|
disc_number: None,
|
|
duration_seconds: 1.0,
|
|
artists: vec![],
|
|
featured_artists: vec![],
|
|
release_id: 1,
|
|
release_title: "r".into(),
|
|
release_year: None,
|
|
cover_path: None,
|
|
file_path: format!("/s/{id}"),
|
|
content_id: Some(format!("b3:{id:064x}")),
|
|
audio_format: None,
|
|
audio_bitrate: None,
|
|
audio_sample_rate: None,
|
|
audio_bit_depth: None,
|
|
file_size_bytes: None,
|
|
play_count: 0,
|
|
fed: None,
|
|
podcast: None,
|
|
}
|
|
}
|
|
|
|
fn pending_fed_track(id: i64) -> TrackItem {
|
|
crate::federation::pending_track(&crate::federation::FedTrack {
|
|
item_id: format!("fed-{id}"),
|
|
owner: "peer".into(),
|
|
own: false,
|
|
title: format!("remote-{id}"),
|
|
artist_names: vec!["remote artist".into()],
|
|
featured_artist_names: vec![],
|
|
year: None,
|
|
duration_seconds: Some(1),
|
|
content_id: Some(format!("b3:{id:064x}")),
|
|
release_title: Some("remote release".into()),
|
|
track_number: None,
|
|
disc_number: None,
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn quit_needs_double_press() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::Quit);
|
|
assert!(!state.should_quit);
|
|
assert_eq!(state.status_message.as_deref(), Some(QUIT_CONFIRM_HINT));
|
|
update(&mut state, Action::Quit);
|
|
assert!(state.should_quit);
|
|
}
|
|
|
|
#[test]
|
|
fn other_action_disarms_quit() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::Quit);
|
|
update(&mut state, Action::NextTab);
|
|
update(&mut state, Action::Quit);
|
|
assert!(!state.should_quit);
|
|
}
|
|
|
|
#[test]
|
|
fn expired_quit_confirmation_rearms() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::Quit);
|
|
state.quit_armed_until = Some(Instant::now() - Duration::from_secs(1));
|
|
update(&mut state, Action::Quit);
|
|
assert!(!state.should_quit);
|
|
assert_eq!(state.status_message.as_deref(), Some(QUIT_CONFIRM_HINT));
|
|
}
|
|
|
|
#[test]
|
|
fn tab_cycling_wraps() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::PrevTab);
|
|
assert_eq!(state.active_tab, Tab::Logs);
|
|
update(&mut state, Action::NextTab);
|
|
assert_eq!(state.active_tab, Tab::Global);
|
|
}
|
|
|
|
#[test]
|
|
fn tabs_follow_the_documented_order() {
|
|
use crate::config::keymap::KeyContext;
|
|
|
|
assert_eq!(
|
|
Tab::ALL,
|
|
[
|
|
Tab::Global,
|
|
Tab::Playlists,
|
|
Tab::Queue,
|
|
Tab::Podcasts,
|
|
Tab::Federation,
|
|
Tab::Logs,
|
|
]
|
|
);
|
|
let titles: Vec<_> = Tab::ALL.iter().map(|tab| tab.title()).collect();
|
|
assert_eq!(
|
|
titles,
|
|
[
|
|
"Library",
|
|
"Playlists",
|
|
"Queue",
|
|
"Podcasts",
|
|
"Settings",
|
|
"Logs"
|
|
]
|
|
);
|
|
for (index, tab) in Tab::ALL.iter().enumerate() {
|
|
assert_eq!(tab.index(), index);
|
|
assert_eq!(Tab::from_index(index), Some(*tab));
|
|
}
|
|
assert_eq!(Tab::from_index(Tab::ALL.len()), None);
|
|
assert_eq!(Tab::Podcasts.key_context(), KeyContext::Podcasts);
|
|
assert_eq!(Tab::Federation.key_context(), KeyContext::Federation);
|
|
}
|
|
|
|
#[test]
|
|
fn next_and_prev_tab_visit_every_tab_in_order() {
|
|
let mut state = AppState::default();
|
|
for expected in Tab::ALL.iter().cycle().skip(1).take(Tab::ALL.len()) {
|
|
update(&mut state, Action::NextTab);
|
|
assert_eq!(state.active_tab, *expected);
|
|
}
|
|
assert_eq!(state.active_tab, Tab::Global);
|
|
for expected in Tab::ALL.iter().rev() {
|
|
update(&mut state, Action::PrevTab);
|
|
assert_eq!(state.active_tab, *expected);
|
|
}
|
|
assert_eq!(state.active_tab, Tab::Global);
|
|
}
|
|
|
|
#[test]
|
|
fn go_to_tab_uses_the_new_numbering() {
|
|
let mut state = AppState::default();
|
|
for (index, tab) in [
|
|
(3, Tab::Podcasts),
|
|
(4, Tab::Federation),
|
|
(5, Tab::Logs),
|
|
(2, Tab::Queue),
|
|
] {
|
|
update(&mut state, Action::GoToTab(index));
|
|
assert_eq!(state.active_tab, tab);
|
|
}
|
|
// Out-of-range indices are ignored.
|
|
update(&mut state, Action::GoToTab(6));
|
|
assert_eq!(state.active_tab, Tab::Queue);
|
|
// Re-selecting the placeholder tab is a harmless reset.
|
|
update(&mut state, Action::GoToTab(3));
|
|
update(&mut state, Action::GoToTab(3));
|
|
assert_eq!(state.active_tab, Tab::Podcasts);
|
|
}
|
|
|
|
#[test]
|
|
fn help_names_tabs_for_go_to_tab() {
|
|
let labels: Vec<_> = (0..Tab::ALL.len())
|
|
.map(|index| Action::GoToTab(index).describe())
|
|
.collect();
|
|
assert_eq!(
|
|
labels,
|
|
[
|
|
"Go to Library",
|
|
"Go to Playlists",
|
|
"Go to Queue",
|
|
"Go to Podcasts",
|
|
"Go to Settings",
|
|
"Go to Logs",
|
|
]
|
|
);
|
|
assert_eq!(Action::GoToTab(6).describe(), "Go to tab 7");
|
|
}
|
|
|
|
#[test]
|
|
fn volume_clamps() {
|
|
let mut state = AppState::default();
|
|
for _ in 0..30 {
|
|
update(&mut state, Action::VolumeUp);
|
|
}
|
|
assert_eq!(state.player.volume, 100);
|
|
for _ in 0..30 {
|
|
update(&mut state, Action::VolumeDown);
|
|
}
|
|
assert_eq!(state.player.volume, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn library_filters_popup_opens_on_library_screens() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::OpenLibraryFilters);
|
|
assert!(matches!(
|
|
state.popup,
|
|
Some(crate::app::state::Popup::LibraryFilters { .. })
|
|
));
|
|
|
|
state.popup = None;
|
|
state.global.stack.push(GlobalView::Search { cursor: 0 });
|
|
update(&mut state, Action::OpenLibraryFilters);
|
|
assert!(matches!(
|
|
state.popup,
|
|
Some(crate::app::state::Popup::LibraryFilters { .. })
|
|
));
|
|
|
|
state.popup = None;
|
|
state.active_tab = Tab::Queue;
|
|
update(&mut state, Action::OpenLibraryFilters);
|
|
assert!(state.popup.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn source_mode_cycles_on_library_playlists_and_queue_tabs() {
|
|
use crate::config::settings::LibrarySourceMode;
|
|
|
|
let mut state = AppState::default();
|
|
assert_eq!(
|
|
update(&mut state, Action::CycleSourceMode),
|
|
Some(Effect::SourceModeChanged)
|
|
);
|
|
assert_eq!(state.global.filters.source_mode, LibrarySourceMode::Local);
|
|
|
|
state.active_tab = Tab::Playlists;
|
|
assert_eq!(
|
|
update(&mut state, Action::CycleSourceMode),
|
|
Some(Effect::SourceModeChanged)
|
|
);
|
|
assert_eq!(state.global.filters.source_mode, LibrarySourceMode::My);
|
|
|
|
state.active_tab = Tab::Queue;
|
|
assert_eq!(
|
|
update(&mut state, Action::CycleSourceMode),
|
|
Some(Effect::SourceModeChanged)
|
|
);
|
|
assert_eq!(state.global.filters.source_mode, LibrarySourceMode::Global);
|
|
|
|
state.active_tab = Tab::Federation;
|
|
assert_eq!(update(&mut state, Action::CycleSourceMode), None);
|
|
assert_eq!(state.global.filters.source_mode, LibrarySourceMode::Global);
|
|
}
|
|
|
|
#[test]
|
|
fn back_closes_help_first() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::ToggleHelp);
|
|
assert!(state.help_visible);
|
|
update(&mut state, Action::Back);
|
|
assert!(!state.help_visible);
|
|
}
|
|
|
|
#[test]
|
|
fn grid_movement_clamps_and_wraps_rows() {
|
|
let mut state = with_artists(10);
|
|
let cols = grid_columns();
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(state.global.selected, cols.min(9));
|
|
update(&mut state, Action::MoveUp);
|
|
assert_eq!(state.global.selected, 0);
|
|
update(&mut state, Action::MoveLeft);
|
|
assert_eq!(state.global.selected, 0);
|
|
update(&mut state, Action::MoveRight);
|
|
assert_eq!(state.global.selected, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn table_mode_moves_one_row() {
|
|
let mut state = with_artists(10);
|
|
state.global.view = ViewMode::Table;
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(state.global.selected, 1);
|
|
// Left/right are meaningless in the table.
|
|
update(&mut state, Action::MoveRight);
|
|
assert_eq!(state.global.selected, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn page_down_moves_a_page_and_clamps() {
|
|
let mut state = with_artists(200);
|
|
let cols = grid_columns() as isize;
|
|
let expected = (page_step(&state) * cols).min(199) as usize;
|
|
update(&mut state, Action::PageDown);
|
|
assert_eq!(state.global.selected, expected);
|
|
update(&mut state, Action::PageUp);
|
|
assert_eq!(state.global.selected, 0);
|
|
|
|
state.global.view = ViewMode::Table;
|
|
update(&mut state, Action::PageDown);
|
|
assert_eq!(state.global.selected, page_step(&state).min(199) as usize);
|
|
}
|
|
|
|
#[test]
|
|
fn jump_first_last() {
|
|
let mut state = with_artists(10);
|
|
update(&mut state, Action::SelectLast);
|
|
assert_eq!(state.global.selected, 9);
|
|
update(&mut state, Action::SelectFirst);
|
|
assert_eq!(state.global.selected, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn artist_tiles_move_by_visual_rows_across_groups() {
|
|
use crate::library::models::{ArtistDetail, ReleaseCard};
|
|
|
|
let release = |id: i64, kind: &str| ReleaseCard {
|
|
id,
|
|
title: format!("r{id}"),
|
|
release_type: kind.to_string(),
|
|
year: None,
|
|
cover_path: None,
|
|
track_count: 1,
|
|
availability: crate::library::models::Availability::Local,
|
|
};
|
|
let columns = grid_columns();
|
|
// The terminal size can be visible to tests. Build enough albums to
|
|
// force a short second album row for whichever width this run has.
|
|
let detail = ArtistDetail {
|
|
id: 1,
|
|
name: "a".into(),
|
|
image_path: None,
|
|
total_track_count: 0,
|
|
total_play_count: 0,
|
|
top_tracks: vec![],
|
|
featured_tracks: vec![],
|
|
releases: (0..=columns)
|
|
.map(|index| release(10 + index as i64, "album"))
|
|
.chain((0..2).map(|index| release(100 + index, "compilation")))
|
|
.collect(),
|
|
};
|
|
let mut state = AppState::default();
|
|
state.artist_views.insert(1, Loadable::Ready(detail));
|
|
state.global.stack.push(GlobalView::Artist {
|
|
id: 1,
|
|
cursor: columns + 1,
|
|
});
|
|
|
|
// Up from the first compilation lands on the album row directly
|
|
// above, not one flat grid-width jump back.
|
|
update(&mut state, Action::MoveUp);
|
|
assert_eq!(
|
|
state.global.stack.last(),
|
|
Some(&GlobalView::Artist {
|
|
id: 1,
|
|
cursor: columns
|
|
})
|
|
);
|
|
// And back down returns to the compilation row, same column.
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(
|
|
state.global.stack.last(),
|
|
Some(&GlobalView::Artist {
|
|
id: 1,
|
|
cursor: columns + 1
|
|
})
|
|
);
|
|
// Up from the second compilation clamps to the single tile above.
|
|
state.global.stack.pop();
|
|
state.global.stack.push(GlobalView::Artist {
|
|
id: 1,
|
|
cursor: columns + 2,
|
|
});
|
|
update(&mut state, Action::MoveUp);
|
|
assert_eq!(
|
|
state.global.stack.last(),
|
|
Some(&GlobalView::Artist {
|
|
id: 1,
|
|
cursor: columns
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn select_opens_artist_and_back_returns() {
|
|
let mut state = with_artists(3);
|
|
state.global.selected = 2;
|
|
update(&mut state, Action::Select);
|
|
assert_eq!(
|
|
state.global.stack.last(),
|
|
Some(&GlobalView::Artist { id: 2, cursor: 0 })
|
|
);
|
|
update(&mut state, Action::Back);
|
|
assert!(state.global.stack.is_empty());
|
|
assert_eq!(state.global.selected, 2);
|
|
}
|
|
|
|
#[test]
|
|
fn back_from_search_resets_search_state() {
|
|
let mut state = AppState::default();
|
|
state.global.stack.push(GlobalView::Search { cursor: 0 });
|
|
state.search.query = "abc".to_string();
|
|
update(&mut state, Action::Back);
|
|
assert!(state.global.stack.is_empty());
|
|
assert!(state.search.query.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn queue_advances_and_respects_repeat() {
|
|
use crate::app::state::RepeatMode;
|
|
use crate::library::models::TrackItem;
|
|
|
|
let track = |id: i64| TrackItem {
|
|
id,
|
|
title: format!("t{id}"),
|
|
track_number: None,
|
|
disc_number: None,
|
|
duration_seconds: 1.0,
|
|
artists: vec![],
|
|
featured_artists: vec![],
|
|
release_id: 1,
|
|
release_title: "r".into(),
|
|
release_year: None,
|
|
cover_path: None,
|
|
file_path: format!("/api/player/stream/{id}"),
|
|
content_id: None,
|
|
audio_format: None,
|
|
audio_bitrate: None,
|
|
audio_sample_rate: None,
|
|
audio_bit_depth: None,
|
|
file_size_bytes: None,
|
|
play_count: 0,
|
|
fed: None,
|
|
podcast: None,
|
|
};
|
|
let mut state = AppState::default();
|
|
state.player.queue = vec![track(1), track(2)];
|
|
state.player.playing = true;
|
|
|
|
// Track 1 finishes → play track 2.
|
|
assert_eq!(advance_after_finish(&mut state), Some(Effect::PlayCurrent));
|
|
assert_eq!(state.player.queue_pos, 1);
|
|
// Last track, repeat off → stop.
|
|
assert_eq!(advance_after_finish(&mut state), Some(Effect::StopPlayback));
|
|
assert!(!state.player.playing);
|
|
// Repeat all wraps to the start.
|
|
state.player.playing = true;
|
|
state.player.repeat = RepeatMode::All;
|
|
assert_eq!(advance_after_finish(&mut state), Some(Effect::PlayCurrent));
|
|
assert_eq!(state.player.queue_pos, 0);
|
|
// Repeat one replays the same position.
|
|
state.player.repeat = RepeatMode::One;
|
|
assert_eq!(advance_after_finish(&mut state), Some(Effect::PlayCurrent));
|
|
assert_eq!(state.player.queue_pos, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn same_tab_number_resets_to_root() {
|
|
let mut state = with_artists(3);
|
|
update(&mut state, Action::Select);
|
|
assert!(!state.global.stack.is_empty());
|
|
update(&mut state, Action::GoToTab(0));
|
|
assert!(state.global.stack.is_empty());
|
|
|
|
state.playlists.opened = Some(OpenedPlaylist {
|
|
id: crate::app::state::LIKES_PLAYLIST_ID,
|
|
cursor: 0,
|
|
});
|
|
update(&mut state, Action::GoToTab(1));
|
|
assert_eq!(state.active_tab, Tab::Playlists);
|
|
assert!(state.playlists.opened.is_some());
|
|
update(&mut state, Action::GoToTab(1));
|
|
assert!(state.playlists.opened.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn queue_tab_select_and_clear() {
|
|
use crate::library::models::TrackItem;
|
|
let track = |id: i64| TrackItem {
|
|
id,
|
|
title: format!("t{id}"),
|
|
track_number: None,
|
|
disc_number: None,
|
|
duration_seconds: 1.0,
|
|
artists: vec![],
|
|
featured_artists: vec![],
|
|
release_id: 1,
|
|
release_title: "r".into(),
|
|
release_year: None,
|
|
cover_path: None,
|
|
file_path: format!("/s/{id}"),
|
|
content_id: None,
|
|
audio_format: None,
|
|
audio_bitrate: None,
|
|
audio_sample_rate: None,
|
|
audio_bit_depth: None,
|
|
file_size_bytes: None,
|
|
play_count: 0,
|
|
fed: None,
|
|
podcast: None,
|
|
};
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
state.player.queue = vec![track(1), track(2), track(3)];
|
|
state.player.queue_pos = 2;
|
|
|
|
// Cursor moves independently; enter rewinds playback to that track
|
|
// without dropping anything from the queue.
|
|
update(&mut state, Action::MoveUp);
|
|
update(&mut state, Action::MoveUp);
|
|
assert_eq!(state.queue_tab.cursor, 0);
|
|
assert_eq!(
|
|
update(&mut state, Action::Select),
|
|
Some(Effect::PlayCurrent)
|
|
);
|
|
assert_eq!(state.player.queue_pos, 0);
|
|
assert_eq!(state.player.queue.len(), 3);
|
|
|
|
assert_eq!(
|
|
update(&mut state, Action::ClearQueue),
|
|
Some(Effect::StopPlayback)
|
|
);
|
|
assert!(state.player.queue.is_empty());
|
|
assert!(!state.player.playing);
|
|
}
|
|
|
|
#[test]
|
|
fn local_mode_hides_pending_federation_tracks_from_playlists_and_playback() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Playlists,
|
|
..AppState::default()
|
|
};
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::Local;
|
|
state.playlists.opened = Some(OpenedPlaylist { id: 7, cursor: 1 });
|
|
state.playlist_views.insert(
|
|
7,
|
|
Loadable::Ready(crate::library::models::PlaylistDetail {
|
|
id: 7,
|
|
title: "mixed".into(),
|
|
description: None,
|
|
tracks: vec![test_track(1), pending_fed_track(2), test_track(3)],
|
|
}),
|
|
);
|
|
|
|
assert_eq!(
|
|
playlist_tracks(&state, 7)
|
|
.unwrap()
|
|
.iter()
|
|
.map(|track| track.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![1, 3]
|
|
);
|
|
assert_eq!(
|
|
update(&mut state, Action::Select),
|
|
Some(Effect::PlayCurrent)
|
|
);
|
|
assert_eq!(
|
|
state
|
|
.player
|
|
.queue
|
|
.iter()
|
|
.map(|track| track.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![1, 3]
|
|
);
|
|
assert_eq!(state.player.queue_pos, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn network_modes_show_pending_federation_playlist_tracks() {
|
|
let mut state = AppState::default();
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::My;
|
|
state.playlist_views.insert(
|
|
7,
|
|
Loadable::Ready(crate::library::models::PlaylistDetail {
|
|
id: 7,
|
|
title: "mixed".into(),
|
|
description: None,
|
|
tracks: vec![test_track(1), pending_fed_track(2)],
|
|
}),
|
|
);
|
|
|
|
assert_eq!(playlist_tracks(&state, 7).unwrap().len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn local_mode_rejects_async_federation_queue_additions() {
|
|
let mut state = AppState::default();
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::Local;
|
|
|
|
enqueue_tracks(
|
|
&mut state,
|
|
vec![test_track(1), pending_fed_track(2), test_track(3)],
|
|
false,
|
|
);
|
|
|
|
assert_eq!(
|
|
state
|
|
.player
|
|
.queue
|
|
.iter()
|
|
.map(|track| track.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![1, 3]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn switching_to_local_mode_removes_pending_federation_queue_tracks() {
|
|
let mut state = AppState::default();
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::My;
|
|
state.player.queue = vec![test_track(1), pending_fed_track(2), test_track(3)];
|
|
state.player.queue_pos = 1;
|
|
state.player.current = Some(state.player.queue[1].clone());
|
|
state.player.playing = true;
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::Local;
|
|
|
|
let effect = apply_library_filter_change(&mut state);
|
|
|
|
assert!(matches!(
|
|
effect,
|
|
Some(Effect::RemoveQueueIndices {
|
|
indices,
|
|
restart_paused: Some(false),
|
|
stop: false,
|
|
}) if indices == vec![1]
|
|
));
|
|
assert_eq!(
|
|
state
|
|
.player
|
|
.queue
|
|
.iter()
|
|
.map(|track| track.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![1, 3]
|
|
);
|
|
assert_eq!(state.player.queue_pos, 1);
|
|
assert_eq!(state.player.current.as_ref().map(|track| track.id), Some(3));
|
|
}
|
|
|
|
#[test]
|
|
fn current_track_info_uses_now_playing_track() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
let mut complete = test_track(2);
|
|
complete.audio_format = Some("flac".into());
|
|
complete.audio_bitrate = Some(921);
|
|
state.player.queue = vec![test_track(1), complete];
|
|
state.player.queue_pos = 1;
|
|
state.queue_tab.cursor = 0;
|
|
let mut lightweight = test_track(2);
|
|
lightweight.file_path.clear();
|
|
state.player.current = Some(lightweight);
|
|
|
|
assert_eq!(update(&mut state, Action::OpenCurrentTrackInfo), None);
|
|
match &state.popup {
|
|
Some(crate::app::state::Popup::TrackInfo { tracks, .. }) => {
|
|
assert_eq!(
|
|
tracks.iter().map(|track| track.id).collect::<Vec<_>>(),
|
|
vec![2]
|
|
);
|
|
assert_eq!(tracks[0].file_path, "/s/2");
|
|
assert_eq!(tracks[0].audio_format.as_deref(), Some("flac"));
|
|
assert_eq!(tracks[0].audio_bitrate, Some(921));
|
|
}
|
|
other => panic!("expected track info popup, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn visualizer_requires_current_track() {
|
|
let mut state = AppState::default();
|
|
|
|
assert_eq!(update(&mut state, Action::ToggleVisualizer), None);
|
|
|
|
assert!(!state.visualizer.active);
|
|
assert_eq!(
|
|
state.status_message.as_deref(),
|
|
Some("nothing playing — start a track first")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn visualizer_toggles_and_back_closes_it() {
|
|
let mut state = AppState::default();
|
|
state.player.current = Some(test_track(7));
|
|
state.help_visible = true;
|
|
|
|
assert_eq!(update(&mut state, Action::ToggleVisualizer), None);
|
|
assert!(state.visualizer.active);
|
|
assert!(state.visualizer.started_at.is_some());
|
|
assert!(!state.help_visible);
|
|
|
|
assert_eq!(update(&mut state, Action::Back), None);
|
|
assert!(!state.visualizer.active);
|
|
assert!(state.visualizer.started_at.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn add_to_playlist_from_release_carries_selected_track() {
|
|
use crate::app::state::{PlaylistAddTarget, Popup};
|
|
use crate::library::models::ReleaseDetail;
|
|
|
|
let mut state = AppState::default();
|
|
state
|
|
.global
|
|
.stack
|
|
.push(GlobalView::Release { id: 1, cursor: 1 });
|
|
state.release_views.insert(
|
|
1,
|
|
Loadable::Ready(ReleaseDetail {
|
|
id: 1,
|
|
title: "r".into(),
|
|
release_type: "album".into(),
|
|
year: None,
|
|
cover_path: None,
|
|
artists: vec![],
|
|
tracks: vec![test_track(1), test_track(2)],
|
|
}),
|
|
);
|
|
|
|
assert_eq!(update(&mut state, Action::AddToPlaylist), None);
|
|
match &state.popup {
|
|
Some(Popup::AddToPlaylist {
|
|
target: PlaylistAddTarget::Local(tracks),
|
|
..
|
|
}) => {
|
|
assert_eq!(
|
|
tracks.iter().map(|track| track.id).collect::<Vec<_>>(),
|
|
vec![2]
|
|
);
|
|
}
|
|
other => panic!("expected add-to-playlist popup with selected track, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn add_to_playlist_from_non_track_view_uses_current_track() {
|
|
use crate::app::state::{PlaylistAddTarget, Popup};
|
|
|
|
let mut state = AppState {
|
|
active_tab: Tab::Logs,
|
|
..AppState::default()
|
|
};
|
|
state.player.current = Some(test_track(7));
|
|
|
|
assert_eq!(update(&mut state, Action::AddToPlaylist), None);
|
|
match &state.popup {
|
|
Some(Popup::AddToPlaylist {
|
|
target: PlaylistAddTarget::Local(tracks),
|
|
..
|
|
}) => {
|
|
assert_eq!(
|
|
tracks.iter().map(|track| track.id).collect::<Vec<_>>(),
|
|
vec![7]
|
|
);
|
|
}
|
|
other => panic!("expected add-to-playlist popup with current track, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn visual_selection_removes_queue_range() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
state.player.queue = (1..=4).map(test_track).collect();
|
|
state.queue_tab.cursor = 1;
|
|
|
|
assert_eq!(update(&mut state, Action::ToggleTrackSelection), None);
|
|
update(&mut state, Action::MoveDown);
|
|
|
|
let selected: Vec<i64> = selected_tracks(&state)
|
|
.into_iter()
|
|
.map(|track| track.id)
|
|
.collect();
|
|
assert_eq!(selected, vec![2, 3]);
|
|
assert_eq!(
|
|
update(&mut state, Action::RemoveFromQueue),
|
|
Some(Effect::RemoveQueueIndices {
|
|
indices: vec![1, 2],
|
|
restart_paused: None,
|
|
stop: false,
|
|
})
|
|
);
|
|
let remaining: Vec<i64> = state.player.queue.iter().map(|track| track.id).collect();
|
|
assert_eq!(remaining, vec![1, 4]);
|
|
assert!(!state.track_selection.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn artist_top_track_selection_queues_all_selected_tracks() {
|
|
let mut state = AppState::default();
|
|
state
|
|
.global
|
|
.stack
|
|
.push(GlobalView::Artist { id: 9, cursor: 0 });
|
|
state.artist_views.insert(
|
|
9,
|
|
Loadable::Ready(ArtistDetail {
|
|
id: 9,
|
|
name: "artist".into(),
|
|
image_path: None,
|
|
total_track_count: 3,
|
|
total_play_count: 0,
|
|
top_tracks: (1..=3).map(test_track).collect(),
|
|
releases: vec![],
|
|
featured_tracks: vec![],
|
|
}),
|
|
);
|
|
|
|
update(&mut state, Action::ToggleTrackSelection);
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(
|
|
update(&mut state, Action::QueueAddLast),
|
|
Some(Effect::QueueOrderChanged {
|
|
restart_current: false,
|
|
}),
|
|
);
|
|
let queued: Vec<i64> = state.player.queue.iter().map(|track| track.id).collect();
|
|
assert_eq!(queued, vec![1, 2]);
|
|
assert!(!state.track_selection.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn sequential_queue_next_additions_keep_their_order_as_one_block() {
|
|
let mut state = AppState::default();
|
|
state.player.queue = (10..=13).map(test_track).collect();
|
|
state.player.queue_pos = 0;
|
|
state.player.current = Some(test_track(10));
|
|
|
|
assert!(!enqueue_tracks(&mut state, vec![test_track(1)], true));
|
|
assert!(!enqueue_tracks(&mut state, vec![test_track(2)], true));
|
|
assert!(!enqueue_tracks(&mut state, vec![test_track(3)], true));
|
|
|
|
assert_eq!(
|
|
state
|
|
.player
|
|
.queue
|
|
.iter()
|
|
.map(|track| track.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![10, 1, 2, 3, 11, 12, 13]
|
|
);
|
|
assert_eq!(state.player.play_next_end, Some(4));
|
|
}
|
|
|
|
#[test]
|
|
fn queue_selection_moves_as_a_group_and_preserves_current_track() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
state.player.queue = (1..=5).map(test_track).collect();
|
|
state.player.queue_pos = 0;
|
|
state.player.current = Some(test_track(1));
|
|
state.queue_tab.cursor = 2;
|
|
state.track_selection.start(TrackSelectionScope::Queue, 2);
|
|
state
|
|
.track_selection
|
|
.set_cursor(TrackSelectionScope::Queue, 3);
|
|
|
|
assert_eq!(
|
|
update(&mut state, Action::MoveQueueUp),
|
|
Some(Effect::QueueOrderChanged {
|
|
restart_current: false,
|
|
})
|
|
);
|
|
assert_eq!(
|
|
state
|
|
.player
|
|
.queue
|
|
.iter()
|
|
.map(|track| track.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![1, 3, 4, 2, 5]
|
|
);
|
|
assert_eq!(state.player.queue_pos, 0);
|
|
assert_eq!(state.queue_tab.cursor, 1);
|
|
assert_eq!(
|
|
state
|
|
.track_selection
|
|
.indices(&TrackSelectionScope::Queue, 5),
|
|
Some(vec![1, 2])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn removing_current_queue_track_requests_paused_restart() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
state.player.queue = (1..=3).map(test_track).collect();
|
|
state.player.queue_pos = 1;
|
|
state.queue_tab.cursor = 1;
|
|
state.player.current = Some(test_track(2));
|
|
state.player.playing = true;
|
|
state.player.paused = true;
|
|
|
|
assert_eq!(
|
|
update(&mut state, Action::RemoveFromQueue),
|
|
Some(Effect::RemoveQueueIndices {
|
|
indices: vec![1],
|
|
restart_paused: Some(true),
|
|
stop: false,
|
|
})
|
|
);
|
|
let remaining: Vec<i64> = state.player.queue.iter().map(|track| track.id).collect();
|
|
assert_eq!(remaining, vec![1, 3]);
|
|
assert_eq!(state.player.queue_pos, 1);
|
|
assert_eq!(state.player.current.as_ref().map(|track| track.id), Some(3));
|
|
}
|
|
|
|
#[test]
|
|
fn bulk_like_targets_only_tracks_that_need_toggle() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
state.player.queue = (1..=3).map(test_track).collect();
|
|
state.likes.insert(format!("b3:{:064x}", 1));
|
|
|
|
update(&mut state, Action::ToggleTrackSelection);
|
|
update(&mut state, Action::SelectLast);
|
|
assert_eq!(
|
|
update(&mut state, Action::ToggleLike),
|
|
Some(Effect::ToggleLikes {
|
|
track_ids: vec![2, 3],
|
|
fed_tracks: vec![],
|
|
})
|
|
);
|
|
|
|
state.likes = [1, 2, 3]
|
|
.into_iter()
|
|
.map(|id| format!("b3:{id:064x}"))
|
|
.collect();
|
|
assert_eq!(
|
|
update(&mut state, Action::ToggleLike),
|
|
Some(Effect::ToggleLikes {
|
|
track_ids: vec![1, 2, 3],
|
|
fed_tracks: vec![],
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn shuffle_reorders_tail_and_restores() {
|
|
use crate::library::models::TrackItem;
|
|
let track = |id: i64| TrackItem {
|
|
id,
|
|
title: format!("t{id}"),
|
|
track_number: None,
|
|
disc_number: None,
|
|
duration_seconds: 1.0,
|
|
artists: vec![],
|
|
featured_artists: vec![],
|
|
release_id: 1,
|
|
release_title: "r".into(),
|
|
release_year: None,
|
|
cover_path: None,
|
|
file_path: format!("/s/{id}"),
|
|
content_id: None,
|
|
audio_format: None,
|
|
audio_bitrate: None,
|
|
audio_sample_rate: None,
|
|
audio_bit_depth: None,
|
|
file_size_bytes: None,
|
|
play_count: 0,
|
|
fed: None,
|
|
podcast: None,
|
|
};
|
|
let mut state = AppState::default();
|
|
state.player.queue = (1..=8).map(track).collect();
|
|
state.player.queue_pos = 2;
|
|
state.player.current = Some(track(3));
|
|
|
|
update(&mut state, Action::ToggleShuffle);
|
|
assert!(state.player.shuffle);
|
|
// Played part and the current track stay in place.
|
|
let ids: Vec<i64> = state.player.queue.iter().map(|t| t.id).collect();
|
|
assert_eq!(&ids[..3], &[1, 2, 3]);
|
|
// The tail is a permutation of the original tail.
|
|
let mut tail = ids[3..].to_vec();
|
|
tail.sort_unstable();
|
|
assert_eq!(tail, vec![4, 5, 6, 7, 8]);
|
|
|
|
update(&mut state, Action::ToggleShuffle);
|
|
assert!(!state.player.shuffle);
|
|
let restored: Vec<i64> = state.player.queue.iter().map(|t| t.id).collect();
|
|
assert_eq!(restored, vec![1, 2, 3, 4, 5, 6, 7, 8]);
|
|
assert!(state.player.original_order.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn shift_j_opens_release_from_queue() {
|
|
use crate::library::models::{ReleaseDetail, TrackItem};
|
|
let track = |id: i64, release_id: i64| TrackItem {
|
|
id,
|
|
title: format!("t{id}"),
|
|
track_number: None,
|
|
disc_number: None,
|
|
duration_seconds: 1.0,
|
|
artists: vec![],
|
|
featured_artists: vec![],
|
|
release_id,
|
|
release_title: "r".into(),
|
|
release_year: None,
|
|
cover_path: None,
|
|
file_path: format!("/s/{id}"),
|
|
content_id: None,
|
|
audio_format: None,
|
|
audio_bitrate: None,
|
|
audio_sample_rate: None,
|
|
audio_bit_depth: None,
|
|
file_size_bytes: None,
|
|
play_count: 0,
|
|
fed: None,
|
|
podcast: None,
|
|
};
|
|
let mut state = AppState {
|
|
active_tab: Tab::Queue,
|
|
..AppState::default()
|
|
};
|
|
state.player.queue = vec![track(1, 7), track(2, 7)];
|
|
state.queue_tab.cursor = 1;
|
|
|
|
// Release not loaded yet → jump queued as pending focus.
|
|
update(&mut state, Action::GoToRelease);
|
|
assert_eq!(state.active_tab, Tab::Global);
|
|
assert_eq!(
|
|
state.global.stack.last(),
|
|
Some(&GlobalView::Release { id: 7, cursor: 0 })
|
|
);
|
|
assert_eq!(state.pending_release_focus, Some((7, 2)));
|
|
|
|
// Esc returns to the origin tab, not to the Global grid.
|
|
update(&mut state, Action::Back);
|
|
assert_eq!(state.active_tab, Tab::Queue);
|
|
assert!(state.global.stack.is_empty());
|
|
assert!(state.jump_origin.is_none());
|
|
|
|
// With the release cached, the cursor lands on the track directly.
|
|
state.global.stack.clear();
|
|
state.pending_release_focus = None;
|
|
state.release_views.insert(
|
|
7,
|
|
Loadable::Ready(ReleaseDetail {
|
|
id: 7,
|
|
title: "r".into(),
|
|
release_type: "album".into(),
|
|
year: None,
|
|
cover_path: None,
|
|
artists: vec![],
|
|
tracks: vec![track(1, 7), track(2, 7)],
|
|
}),
|
|
);
|
|
state.active_tab = Tab::Queue;
|
|
update(&mut state, Action::GoToRelease);
|
|
assert_eq!(
|
|
state.global.stack.last(),
|
|
Some(&GlobalView::Release { id: 7, cursor: 1 })
|
|
);
|
|
assert!(state.pending_release_focus.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn view_toggle() {
|
|
let mut state = AppState::default();
|
|
update(&mut state, Action::ToggleViewMode);
|
|
assert_eq!(state.global.view, ViewMode::Table);
|
|
update(&mut state, Action::ToggleViewMode);
|
|
assert_eq!(state.global.view, ViewMode::Tiles);
|
|
}
|
|
|
|
fn enrichment_state(release: bool) -> AppState {
|
|
use crate::library::models::{ArtistRef, ReleaseDetail};
|
|
let mut state = AppState::default();
|
|
state.federation.settings.enabled = true;
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::Global;
|
|
state.artist_views.insert(
|
|
1,
|
|
Loadable::Ready(ArtistDetail {
|
|
id: 1,
|
|
name: "Artist".into(),
|
|
image_path: None,
|
|
total_track_count: 1,
|
|
total_play_count: 0,
|
|
top_tracks: vec![test_track(1)],
|
|
featured_tracks: vec![],
|
|
releases: vec![],
|
|
}),
|
|
);
|
|
state.release_views.insert(
|
|
1,
|
|
Loadable::Ready(ReleaseDetail {
|
|
id: 1,
|
|
title: "Release".into(),
|
|
release_type: "album".into(),
|
|
year: None,
|
|
cover_path: None,
|
|
artists: vec![ArtistRef {
|
|
id: 1,
|
|
name: "Artist".into(),
|
|
}],
|
|
tracks: vec![test_track(1)],
|
|
}),
|
|
);
|
|
state.global.stack.push(if release {
|
|
GlobalView::Release { id: 1, cursor: 0 }
|
|
} else {
|
|
GlobalView::Artist { id: 1, cursor: 0 }
|
|
});
|
|
state
|
|
}
|
|
|
|
#[test]
|
|
fn card_enrichment_retries_startup_failure_without_reopening() {
|
|
use crate::app::enrichment::{self, Card, Request};
|
|
use std::time::{Duration, Instant};
|
|
for release in [false, true] {
|
|
let mut state = enrichment_state(release);
|
|
let now = Instant::now();
|
|
let request = enrichment::prepare(&mut state, now).unwrap();
|
|
let card = match request {
|
|
Request::Artist { id: 1, ref name } if name == "Artist" => Card::Artist(1),
|
|
Request::Release {
|
|
id: 1,
|
|
ref title,
|
|
ref artists,
|
|
} if title == "Release" && artists == &["Artist"] => Card::Release(1),
|
|
_ => panic!("wrong enrichment request: {request:?}"),
|
|
};
|
|
// Slow requests are never duplicated, even after the refresh interval.
|
|
assert!(enrichment::prepare(&mut state, now + Duration::from_secs(60)).is_none());
|
|
let completed = now + Duration::from_secs(60);
|
|
state.card_enrichment.complete(card, completed);
|
|
if release {
|
|
enrichment::store_result(
|
|
&mut state.release_fed_views,
|
|
1,
|
|
Err("federation is not running".into()),
|
|
);
|
|
} else {
|
|
enrichment::store_result(
|
|
&mut state.artist_fed_views,
|
|
1,
|
|
Err("federation is not running".into()),
|
|
);
|
|
}
|
|
assert!(enrichment::prepare(&mut state, completed + Duration::from_secs(1)).is_none());
|
|
assert_eq!(
|
|
enrichment::prepare(&mut state, completed + Duration::from_secs(30)),
|
|
Some(request)
|
|
);
|
|
assert!(matches!(
|
|
state.artist_views.get(&1),
|
|
Some(Loadable::Ready(_))
|
|
));
|
|
assert!(matches!(
|
|
state.release_views.get(&1),
|
|
Some(Loadable::Ready(_))
|
|
));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn card_enrichment_reopens_cached_cards_and_keeps_success_during_failed_refresh() {
|
|
use crate::app::enrichment::{self, Card};
|
|
use std::time::{Duration, Instant};
|
|
for release in [false, true] {
|
|
let mut state = enrichment_state(release);
|
|
let now = Instant::now();
|
|
let request = enrichment::prepare(&mut state, now).unwrap();
|
|
state.card_enrichment.complete(
|
|
if release {
|
|
Card::Release(1)
|
|
} else {
|
|
Card::Artist(1)
|
|
},
|
|
now,
|
|
);
|
|
if release {
|
|
enrichment::store_result(
|
|
&mut state.release_fed_views,
|
|
1,
|
|
Ok(crate::federation::FedRelease {
|
|
title: "Release".into(),
|
|
..Default::default()
|
|
}),
|
|
);
|
|
} else {
|
|
enrichment::store_result(
|
|
&mut state.artist_fed_views,
|
|
1,
|
|
Ok(crate::federation::FedArtistCard {
|
|
name: "Artist".into(),
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
// Successful but local-only/empty snapshots must also be refreshed.
|
|
assert!(enrichment::prepare(&mut state, now).is_none());
|
|
let view = state.global.stack.pop().unwrap();
|
|
assert!(enrichment::prepare(&mut state, now).is_none());
|
|
state.global.stack.push(view);
|
|
assert_eq!(
|
|
enrichment::prepare(&mut state, now + Duration::from_secs(1)),
|
|
Some(request)
|
|
);
|
|
if release {
|
|
assert!(matches!(
|
|
state.release_fed_views.get(&1),
|
|
Some(Loadable::Ready(_))
|
|
));
|
|
enrichment::store_result(&mut state.release_fed_views, 1, Err("offline".into()));
|
|
assert!(
|
|
matches!(state.release_fed_views.get(&1), Some(Loadable::Ready(card)) if card.title == "Release")
|
|
);
|
|
} else {
|
|
assert!(matches!(
|
|
state.artist_fed_views.get(&1),
|
|
Some(Loadable::Ready(_))
|
|
));
|
|
enrichment::store_result(&mut state.artist_fed_views, 1, Err("offline".into()));
|
|
assert!(
|
|
matches!(state.artist_fed_views.get(&1), Some(Loadable::Ready(card)) if card.name == "Artist")
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn card_enrichment_respects_network_mode_and_deduplicates_navigation() {
|
|
use crate::app::enrichment;
|
|
use crate::config::settings::LibrarySourceMode;
|
|
use std::time::Instant;
|
|
for release in [false, true] {
|
|
let mut state = enrichment_state(release);
|
|
let now = Instant::now();
|
|
state.federation.settings.enabled = false;
|
|
assert!(enrichment::prepare(&mut state, now).is_none());
|
|
state.federation.settings.enabled = true;
|
|
state.global.filters.source_mode = LibrarySourceMode::Local;
|
|
assert!(enrichment::prepare(&mut state, now).is_none());
|
|
state.global.filters.source_mode = LibrarySourceMode::Global;
|
|
assert!(enrichment::prepare(&mut state, now).is_some());
|
|
state.active_tab = Tab::Queue;
|
|
assert!(enrichment::prepare(&mut state, now).is_none());
|
|
state.active_tab = Tab::Global;
|
|
assert!(enrichment::prepare(&mut state, now).is_none());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn card_enrichment_refreshes_local_only_success_while_still_open() {
|
|
use crate::app::enrichment::{self, Card};
|
|
use std::time::{Duration, Instant};
|
|
for release in [false, true] {
|
|
let mut state = enrichment_state(release);
|
|
let now = Instant::now();
|
|
let request = enrichment::prepare(&mut state, now).unwrap();
|
|
state.card_enrichment.complete(
|
|
if release {
|
|
Card::Release(1)
|
|
} else {
|
|
Card::Artist(1)
|
|
},
|
|
now,
|
|
);
|
|
if release {
|
|
enrichment::store_result(&mut state.release_fed_views, 1, Ok(Default::default()));
|
|
} else {
|
|
enrichment::store_result(&mut state.artist_fed_views, 1, Ok(Default::default()));
|
|
}
|
|
assert!(enrichment::prepare(&mut state, now + Duration::from_secs(29)).is_none());
|
|
assert_eq!(
|
|
enrichment::prepare(&mut state, now + Duration::from_secs(30)),
|
|
Some(request)
|
|
);
|
|
}
|
|
}
|
|
|
|
fn render_enrichment_card(state: &AppState) -> String {
|
|
use ratatui::{Terminal, backend::TestBackend};
|
|
let mut terminal = Terminal::new(TestBackend::new(160, 40)).unwrap();
|
|
terminal
|
|
.draw(|frame| crate::ui::global::draw(frame, frame.area(), state))
|
|
.unwrap();
|
|
terminal
|
|
.backend()
|
|
.buffer()
|
|
.content
|
|
.iter()
|
|
.map(|cell| cell.symbol())
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn local_card_explains_source_filter_instead_of_waiting_for_a_request() {
|
|
use crate::app::enrichment;
|
|
let mut state = enrichment_state(false);
|
|
state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::Local;
|
|
assert!(enrichment::prepare(&mut state, std::time::Instant::now()).is_none());
|
|
let text = render_enrichment_card(&state);
|
|
assert!(
|
|
!text.contains("federation: pending"),
|
|
"Local mode must not promise a request that is disabled"
|
|
);
|
|
assert!(
|
|
text.contains("Local"),
|
|
"the card must explain why network results are hidden"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn card_refresh_animates_while_previous_results_stay_visible() {
|
|
use crate::app::enrichment::{self, Card};
|
|
use std::time::{Duration, Instant};
|
|
for release in [false, true] {
|
|
let mut state = enrichment_state(release);
|
|
let now = Instant::now();
|
|
assert!(enrichment::prepare(&mut state, now).is_some());
|
|
let card = if release {
|
|
Card::Release(1)
|
|
} else {
|
|
Card::Artist(1)
|
|
};
|
|
state.card_enrichment.complete(card, now);
|
|
if release {
|
|
enrichment::store_result(&mut state.release_fed_views, 1, Ok(Default::default()));
|
|
} else {
|
|
enrichment::store_result(&mut state.artist_fed_views, 1, Ok(Default::default()));
|
|
}
|
|
assert!(enrichment::prepare(&mut state, now + Duration::from_secs(30)).is_some());
|
|
let first = render_enrichment_card(&state);
|
|
assert!(first.contains(&format!("{} searching peers", state.spinner())));
|
|
state.advance_spinner();
|
|
let next = render_enrichment_card(&state);
|
|
assert!(next.contains(&format!("{} searching peers", state.spinner())));
|
|
assert_ne!(first, next);
|
|
state
|
|
.card_enrichment
|
|
.complete(card, now + Duration::from_secs(31));
|
|
assert!(!render_enrichment_card(&state).contains("searching peers"));
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Podcasts tab
|
|
|
|
mod podcast_tab {
|
|
use furumi_library::podcasts::{EpisodeSort, PlayedFilter, SeasonFilter};
|
|
use music_dht::podcast::{FeedUrl, PodcastId, ProgressStatus};
|
|
|
|
use super::*;
|
|
use crate::app::podcast_fixtures::{self as fx, podcast_id};
|
|
use crate::app::state::{
|
|
FedInputField, PODCAST_ACTION_ROWS, PODCAST_EPISODE_PAGE, PodcastStoreStatus, Popup,
|
|
};
|
|
use crate::app::update::podcasts;
|
|
use crate::podcasts::refresh::{RefreshReport, SubscribeReport};
|
|
|
|
fn ready(rows: Vec<crate::app::state::PodcastRow>) -> AppState {
|
|
let mut state = fx::ready_state(rows);
|
|
state.podcasts.selected = PODCAST_ACTION_ROWS;
|
|
state
|
|
}
|
|
|
|
fn other_id() -> PodcastId {
|
|
PodcastId::from_feed_url(&FeedUrl::parse("https://other.test/feed.xml").unwrap())
|
|
}
|
|
|
|
fn episode_request(effect: Option<Effect>) -> (u64, furumi_library::podcasts::EpisodeQuery) {
|
|
match effect {
|
|
Some(Effect::PodcastLoadEpisodes { seq, query }) => (seq, query),
|
|
other => panic!("expected an episode load, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
fn page(count: u32) -> Vec<furumi_library::podcasts::EpisodeListItem> {
|
|
(1..=count)
|
|
.map(|n| fx::episode(n, &format!("Episode {n}"), None))
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn podcast_actions_wait_for_the_store() {
|
|
let mut state = AppState {
|
|
active_tab: Tab::Podcasts,
|
|
..AppState::default()
|
|
};
|
|
assert_eq!(update(&mut state, Action::AddPodcast), None);
|
|
assert!(state.popup.is_none());
|
|
assert!(
|
|
state
|
|
.status_message
|
|
.as_deref()
|
|
.is_some_and(|m| m.contains("still opening"))
|
|
);
|
|
state.podcasts.store = PodcastStoreStatus::Failed("newer schema".into());
|
|
assert_eq!(update(&mut state, Action::RefreshAllPodcasts), None);
|
|
assert!(
|
|
state
|
|
.status_message
|
|
.as_deref()
|
|
.is_some_and(|m| m.contains("unavailable: newer schema"))
|
|
);
|
|
// Opening the store loads the list.
|
|
assert_eq!(
|
|
podcasts::store_opened(&mut state, Ok(())),
|
|
Some(Effect::PodcastsReload)
|
|
);
|
|
assert_eq!(state.podcasts.store, PodcastStoreStatus::Ready);
|
|
}
|
|
|
|
#[test]
|
|
fn podcast_actions_outside_the_tab_only_explain() {
|
|
let mut state = fx::ready_state(vec![fx::row("Show", 0, 1, 0)]);
|
|
state.active_tab = Tab::Global;
|
|
assert_eq!(update(&mut state, Action::RefreshAllPodcasts), None);
|
|
assert!(state.podcasts.refreshing.is_empty());
|
|
assert!(
|
|
state
|
|
.status_message
|
|
.as_deref()
|
|
.is_some_and(|m| m.contains("Podcasts tab (4)"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn podcast_opens_seasons_then_a_season_then_goes_back() {
|
|
let mut state = ready(vec![fx::row("Show", 1, 5, 1)]);
|
|
assert_eq!(
|
|
update(&mut state, Action::Select),
|
|
Some(Effect::PodcastLoadSeasons(podcast_id()))
|
|
);
|
|
assert!(!state.podcasts.showing_episodes());
|
|
podcasts::seasons_loaded(&mut state, podcast_id(), Ok(fx::seasons()));
|
|
// Rows: All, Season 1, Without a season.
|
|
assert_eq!(state.podcasts.season_rows().len(), 3);
|
|
update(&mut state, Action::MoveDown);
|
|
let (seq, query) = episode_request(update(&mut state, Action::Select));
|
|
assert_eq!(query.season, SeasonFilter::Season(1));
|
|
assert_eq!(query.limit, Some(PODCAST_EPISODE_PAGE));
|
|
assert_eq!(query.offset, 0);
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(page(3)));
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(
|
|
state
|
|
.podcasts
|
|
.selected_episode()
|
|
.map(|item| item.episode.title.as_str()),
|
|
Some("Episode 2")
|
|
);
|
|
|
|
// Esc: episodes -> seasons (cursor kept) -> list (on the podcast).
|
|
update(&mut state, Action::Back);
|
|
let opened = state.podcasts.opened.as_ref().unwrap();
|
|
assert_eq!((opened.season, opened.season_cursor), (None, Some(1)));
|
|
update(&mut state, Action::Back);
|
|
assert!(state.podcasts.opened.is_none());
|
|
assert_eq!(state.podcasts.selected, PODCAST_ACTION_ROWS);
|
|
// A late seasons result for the closed podcast is ignored.
|
|
podcasts::seasons_loaded(&mut state, podcast_id(), Ok(Vec::new()));
|
|
assert!(state.podcasts.opened_seasons().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn podcast_without_seasons_opens_its_episodes_and_tab_key_resets() {
|
|
let mut state = ready(vec![fx::row("Show", 1, 2, 0)]);
|
|
let (_, query) = episode_request(update(&mut state, Action::Select));
|
|
assert_eq!(query.season, SeasonFilter::Any);
|
|
assert!(state.podcasts.showing_episodes());
|
|
// Pressing the tab's number again returns to the list.
|
|
update(&mut state, Action::GoToTab(Tab::Podcasts.index()));
|
|
assert!(state.podcasts.opened.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn live_search_drops_stale_pages_and_keeps_the_rows_meanwhile() {
|
|
let mut state = ready(vec![fx::row("Show", 1, 3, 0)]);
|
|
let (first, _) = episode_request(update(&mut state, Action::Select));
|
|
podcasts::episodes_loaded(&mut state, first, 0, Ok(page(3)));
|
|
|
|
update(&mut state, Action::SearchEpisodes);
|
|
assert!(matches!(
|
|
state.popup,
|
|
Some(Popup::FedInput {
|
|
field: FedInputField::PodcastSearch,
|
|
..
|
|
})
|
|
));
|
|
let (second, query) = episode_request(podcasts::set_search(&mut state, "pilot".into()));
|
|
assert_eq!(query.search.as_deref(), Some("pilot"));
|
|
assert!(second > first);
|
|
// The old rows stay visible while the search runs.
|
|
let list = state.podcasts.opened_episodes().unwrap();
|
|
assert!(list.loading);
|
|
assert_eq!(list.items.len(), 3);
|
|
// Typing on: the previous request's result arrives late and is dropped.
|
|
let (third, _) = episode_request(podcasts::set_search(&mut state, "pilot 2".into()));
|
|
podcasts::episodes_loaded(&mut state, second, 0, Ok(page(2)));
|
|
assert_eq!(state.podcasts.opened_episodes().unwrap().items.len(), 3);
|
|
podcasts::episodes_loaded(&mut state, third, 0, Ok(page(1)));
|
|
let list = state.podcasts.opened_episodes().unwrap();
|
|
assert_eq!(list.items.len(), 1);
|
|
assert!(!list.loading && list.complete);
|
|
// An unchanged search requests nothing.
|
|
assert_eq!(podcasts::set_search(&mut state, "pilot 2".into()), None);
|
|
// Search, filter and sort are per opened podcast view.
|
|
update(&mut state, Action::Back);
|
|
assert!(state.podcasts.search.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn sort_and_played_filter_reload_from_the_top() {
|
|
let mut state = ready(vec![fx::row("Show", 1, 3, 0)]);
|
|
let (seq, _) = episode_request(update(&mut state, Action::Select));
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(page(3)));
|
|
update(&mut state, Action::SelectLast);
|
|
let (_, query) = episode_request(update(&mut state, Action::CycleEpisodeSort));
|
|
assert_eq!(query.sort, EpisodeSort::OldestFirst);
|
|
assert_eq!(state.podcasts.opened.as_ref().unwrap().episode_cursor, 0);
|
|
let (_, query) = episode_request(update(&mut state, Action::CycleEpisodeFilter));
|
|
assert_eq!(query.played, PlayedFilter::Unplayed);
|
|
assert_eq!(query.sort, EpisodeSort::OldestFirst);
|
|
}
|
|
|
|
#[test]
|
|
fn long_episode_lists_load_page_by_page() {
|
|
let mut state = ready(vec![fx::row("Show", 600, 600, 0)]);
|
|
let (seq, _) = episode_request(update(&mut state, Action::Select));
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(page(PODCAST_EPISODE_PAGE as u32)));
|
|
assert!(!state.podcasts.opened_episodes().unwrap().complete);
|
|
let (more_seq, query) = episode_request(update(&mut state, Action::SelectLast));
|
|
assert_eq!(more_seq, seq);
|
|
assert_eq!(query.offset, PODCAST_EPISODE_PAGE);
|
|
// No duplicate request while the page is in flight.
|
|
assert_eq!(update(&mut state, Action::MoveUp), None);
|
|
podcasts::episodes_loaded(&mut state, seq, PODCAST_EPISODE_PAGE, Ok(page(100)));
|
|
let list = state.podcasts.opened_episodes().unwrap();
|
|
assert_eq!(list.items.len(), PODCAST_EPISODE_PAGE + 100);
|
|
assert!(list.complete);
|
|
assert_eq!(update(&mut state, Action::SelectLast), None);
|
|
}
|
|
|
|
#[test]
|
|
fn manual_and_scheduled_refreshes_are_deduplicated() {
|
|
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
|
let url = FeedUrl::parse("https://example.test/feed.xml").unwrap();
|
|
assert_eq!(
|
|
update(&mut state, Action::RefreshPodcast),
|
|
Some(Effect::PodcastRefresh {
|
|
targets: vec![(podcast_id(), url.clone())],
|
|
manual: true,
|
|
})
|
|
);
|
|
assert!(state.podcasts.refreshing.contains(&podcast_id()));
|
|
assert_eq!(update(&mut state, Action::RefreshPodcast), None);
|
|
assert_eq!(update(&mut state, Action::RefreshAllPodcasts), None);
|
|
// The scheduler skips feeds already in flight.
|
|
let due = vec![(podcast_id(), url.clone()), (other_id(), url.clone())];
|
|
assert_eq!(
|
|
podcasts::refresh_due(&mut state, due),
|
|
Some(Effect::PodcastRefresh {
|
|
targets: vec![(other_id(), url)],
|
|
manual: false,
|
|
})
|
|
);
|
|
let effects = podcasts::refreshed(
|
|
&mut state,
|
|
podcast_id(),
|
|
Ok(RefreshReport {
|
|
new_episodes: 2,
|
|
..RefreshReport::default()
|
|
}),
|
|
true,
|
|
);
|
|
assert_eq!(effects, vec![Effect::PodcastsReload]);
|
|
assert!(!state.podcasts.refreshing.contains(&podcast_id()));
|
|
assert!(
|
|
state
|
|
.status_message
|
|
.as_deref()
|
|
.is_some_and(|m| m.contains("2 new episode(s) in \"Show\""))
|
|
);
|
|
// A background failure stays out of the status bar.
|
|
state.status_message = None;
|
|
podcasts::refreshed(&mut state, other_id(), Err("HTTP 500".into()), false);
|
|
assert!(state.status_message.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn refreshing_the_opened_podcast_reloads_it_on_the_same_episode() {
|
|
let mut state = ready(vec![fx::row("Show", 0, 3, 0)]);
|
|
let (seq, _) = episode_request(update(&mut state, Action::Select));
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(page(3)));
|
|
update(&mut state, Action::MoveDown);
|
|
let effects = podcasts::refreshed(
|
|
&mut state,
|
|
podcast_id(),
|
|
Ok(RefreshReport {
|
|
new_episodes: 1,
|
|
..RefreshReport::default()
|
|
}),
|
|
false,
|
|
);
|
|
assert_eq!(effects.len(), 2);
|
|
let (seq, _) = episode_request(effects.into_iter().nth(1));
|
|
// A new episode arrived on top: the cursor follows "Episode 2".
|
|
let mut rows = vec![fx::episode(9, "Newest", None)];
|
|
rows.extend(page(3));
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(rows));
|
|
assert_eq!(
|
|
state
|
|
.podcasts
|
|
.selected_episode()
|
|
.map(|item| item.episode.title.as_str()),
|
|
Some("Episode 2")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn adding_a_feed_validates_the_url_then_selects_the_new_podcast() {
|
|
let mut state = ready(Vec::new());
|
|
state.podcasts.selected = 0;
|
|
update(&mut state, Action::Select);
|
|
assert!(matches!(
|
|
state.popup,
|
|
Some(Popup::FedInput {
|
|
field: FedInputField::PodcastFeedUrl,
|
|
..
|
|
})
|
|
));
|
|
state.popup = None;
|
|
assert_eq!(podcasts::submit_feed_url(&mut state, " "), None);
|
|
assert_eq!(
|
|
podcasts::submit_feed_url(&mut state, "ftp://example.test/feed"),
|
|
None
|
|
);
|
|
assert!(!state.podcasts.subscribing);
|
|
assert_eq!(
|
|
podcasts::submit_feed_url(&mut state, "example.test/feed.xml"),
|
|
Some(Effect::PodcastSubscribe("example.test/feed.xml".into()))
|
|
);
|
|
assert!(state.podcasts.subscribing);
|
|
// A second add while one is running is refused.
|
|
update(&mut state, Action::AddPodcast);
|
|
assert!(state.popup.is_none());
|
|
|
|
let effect = podcasts::subscribed(
|
|
&mut state,
|
|
Ok(SubscribeReport {
|
|
podcast_id: podcast_id(),
|
|
title: "Show".into(),
|
|
already_subscribed: false,
|
|
new_episodes: 4,
|
|
}),
|
|
);
|
|
assert_eq!(effect, Some(Effect::PodcastsReload));
|
|
assert!(!state.podcasts.subscribing);
|
|
assert!(
|
|
state
|
|
.status_message
|
|
.as_deref()
|
|
.is_some_and(|m| m.contains("subscribed to \"Show\" (4 episode(s); private)"))
|
|
);
|
|
let mut other = fx::row("Another", 0, 1, 0);
|
|
other.summary.podcast_id = other_id();
|
|
podcasts::list_loaded(&mut state, Ok(vec![other, fx::row("Show", 4, 4, 0)]));
|
|
assert_eq!(state.podcasts.selected, PODCAST_ACTION_ROWS + 1);
|
|
assert_eq!(
|
|
state.podcasts.current_podcast().map(|row| row.title()),
|
|
Some("Show")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unsubscribing_asks_first_and_keeps_progress() {
|
|
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
|
let (seq, _) = episode_request(update(&mut state, Action::Select));
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(page(1)));
|
|
update(&mut state, Action::UnsubscribePodcast);
|
|
assert!(matches!(
|
|
&state.popup,
|
|
Some(Popup::ConfirmPodcastUnsubscribe { podcast_id: id, title })
|
|
if *id == podcast_id() && title == "Show"
|
|
));
|
|
state.popup = None;
|
|
let effect = podcasts::unsubscribed(&mut state, podcast_id(), "Show".into(), Ok(()));
|
|
assert_eq!(effect, Some(Effect::PodcastsReload));
|
|
assert!(state.podcasts.opened.is_none());
|
|
assert!(
|
|
state
|
|
.status_message
|
|
.as_deref()
|
|
.is_some_and(|m| m.contains("progress and history are kept"))
|
|
);
|
|
// Unsubscribed elsewhere: the reloaded list closes an open view.
|
|
let mut state = ready(vec![fx::row("Show", 0, 1, 0)]);
|
|
update(&mut state, Action::Select);
|
|
podcasts::list_loaded(&mut state, Ok(Vec::new()));
|
|
assert!(state.podcasts.opened.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn marking_played_toggles_by_status() {
|
|
let mut state = ready(vec![fx::row("Show", 1, 2, 0)]);
|
|
let (seq, _) = episode_request(update(&mut state, Action::Select));
|
|
let items = vec![
|
|
fx::episode(1, "Done", Some((ProgressStatus::Completed, 0))),
|
|
fx::episode(2, "Half", Some((ProgressStatus::InProgress, 60_000))),
|
|
];
|
|
let done = items[0].episode.episode_id.clone();
|
|
let half = items[1].episode.episode_id.clone();
|
|
podcasts::episodes_loaded(&mut state, seq, 0, Ok(items));
|
|
assert_eq!(
|
|
update(&mut state, Action::ToggleEpisodePlayed),
|
|
Some(Effect::PodcastSetPlayed {
|
|
episode_id: done,
|
|
played: false,
|
|
})
|
|
);
|
|
update(&mut state, Action::MoveDown);
|
|
assert_eq!(
|
|
update(&mut state, Action::ToggleEpisodePlayed),
|
|
Some(Effect::PodcastSetPlayed {
|
|
episode_id: half,
|
|
played: true,
|
|
})
|
|
);
|
|
let effects = podcasts::played_set(&mut state, true, Ok(()));
|
|
assert_eq!(effects[0], Effect::PodcastsReload);
|
|
assert!(matches!(
|
|
effects.last(),
|
|
Some(Effect::PodcastLoadEpisodes { .. })
|
|
));
|
|
}
|
|
}
|