From 5f2d1897b245fbee12d17b5910eaf5233ca6802b Mon Sep 17 00:00:00 2001 From: salmonik Date: Tue, 5 May 2026 23:29:39 +0200 Subject: Add unit tests in /tests directory for config, database, playback, and scrobbler modules --- Cargo.lock | 133 +++++++++++++++++++++++++++++++++++----- Cargo.toml | 6 ++ src/audio.rs | 1 + src/database.rs | 4 +- src/lib.rs | 7 +++ src/playback.rs | 13 ++-- src/scrobbler.rs | 8 +-- tests/config.rs | 133 ++++++++++++++++++++++++++++++++++++++++ tests/database.rs | 85 ++++++++++++++++++++++++++ tests/playback.rs | 175 +++++++++++++++++++++++++++++++++++++++++++++++++++++ tests/scrobbler.rs | 77 +++++++++++++++++++++++ 11 files changed, 615 insertions(+), 27 deletions(-) create mode 100644 src/lib.rs create mode 100644 tests/config.rs create mode 100644 tests/database.rs create mode 100644 tests/playback.rs create mode 100644 tests/scrobbler.rs diff --git a/Cargo.lock b/Cargo.lock index 1baedf3..82ef060 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -491,6 +491,12 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a" +[[package]] +name = "fastrand" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" + [[package]] name = "find-msvc-tools" version = "0.1.9" @@ -919,16 +925,6 @@ version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2" -[[package]] -name = "iri-string" -version = "0.7.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20" -dependencies = [ - "memchr", - "serde", -] - [[package]] name = "is_terminal_polyfill" version = "1.70.2" @@ -1075,6 +1071,12 @@ dependencies = [ "vcpkg", ] +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + [[package]] name = "litemap" version = "0.8.2" @@ -1470,7 +1472,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.52.0", + "windows-sys 0.60.2", ] [[package]] @@ -1631,6 +1633,7 @@ dependencies = [ "serde", "serde_json", "symphonia", + "tempfile", "tokio", "toml", ] @@ -1675,6 +1678,19 @@ dependencies = [ "semver", ] +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags 2.11.1", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + [[package]] name = "rustls" version = "0.23.40" @@ -2192,6 +2208,19 @@ dependencies = [ "libc", ] +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.4.2", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + [[package]] name = "thiserror" version = "1.0.69" @@ -2376,20 +2405,20 @@ dependencies = [ [[package]] name = "tower-http" -version = "0.6.8" +version = "0.6.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" +checksum = "a28f0d049ccfaa566e14e9663d304d8577427b368cb4710a20528690287a738b" dependencies = [ "bitflags 2.11.1", "bytes", "futures-util", "http", "http-body", - "iri-string", "pin-project-lite", "tower", "tower-layer", "tower-service", + "url", ] [[package]] @@ -2777,6 +2806,15 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + [[package]] name = "windows-sys" version = "0.61.2" @@ -2810,13 +2848,30 @@ dependencies = [ "windows_aarch64_gnullvm 0.52.6", "windows_aarch64_msvc 0.52.6", "windows_i686_gnu 0.52.6", - "windows_i686_gnullvm", + "windows_i686_gnullvm 0.52.6", "windows_i686_msvc 0.52.6", "windows_x86_64_gnu 0.52.6", "windows_x86_64_gnullvm 0.52.6", "windows_x86_64_msvc 0.52.6", ] +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + [[package]] name = "windows-threading" version = "0.2.1" @@ -2838,6 +2893,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + [[package]] name = "windows_aarch64_msvc" version = "0.42.2" @@ -2850,6 +2911,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + [[package]] name = "windows_i686_gnu" version = "0.42.2" @@ -2862,12 +2929,24 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + [[package]] name = "windows_i686_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + [[package]] name = "windows_i686_msvc" version = "0.42.2" @@ -2880,6 +2959,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + [[package]] name = "windows_x86_64_gnu" version = "0.42.2" @@ -2892,6 +2977,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + [[package]] name = "windows_x86_64_gnullvm" version = "0.42.2" @@ -2904,6 +2995,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + [[package]] name = "windows_x86_64_msvc" version = "0.42.2" @@ -2916,6 +3013,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + [[package]] name = "winnow" version = "1.0.2" diff --git a/Cargo.toml b/Cargo.toml index 0ceee6f..21614c5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,9 @@ name = "rsp" version = "0.1.0" edition = "2021" +[lib] +path = "src/lib.rs" + [dependencies] clap = { version = "4.6.1", features = ["derive", "string"] } rusqlite = { version = "0.39", features = ["bundled"] } @@ -19,3 +22,6 @@ dirs = "6.0" libc = "0.2.186" ctrlc = "3.5.2" rand = "0.10.1" + +[dev-dependencies] +tempfile = "3.17" diff --git a/src/audio.rs b/src/audio.rs index 93eb8e6..d716a23 100644 --- a/src/audio.rs +++ b/src/audio.rs @@ -21,6 +21,7 @@ pub struct AudioEngine { volume: Arc>, } +#[allow(clippy::new_without_default)] impl AudioEngine { pub fn new() -> Self { let (tx, rx) = mpsc::channel(); diff --git a/src/database.rs b/src/database.rs index 9d1d5f2..b7b8e88 100644 --- a/src/database.rs +++ b/src/database.rs @@ -220,7 +220,7 @@ impl Database { } } -fn is_audio_file(path: &Path) -> bool { +pub fn is_audio_file(path: &Path) -> bool { path.extension() .and_then(|ext| ext.to_str()) .map(|ext| { @@ -232,7 +232,7 @@ fn is_audio_file(path: &Path) -> bool { .unwrap_or(false) } -fn extract_metadata(path: &Path) -> (String, String, String, Option, Option) { +pub fn extract_metadata(path: &Path) -> (String, String, String, Option, Option) { let file_stem = path .file_stem() .and_then(|s| s.to_str()) diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..9317bcd --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,7 @@ +pub mod audio; +pub mod cli; +pub mod config; +pub mod daemon; +pub mod database; +pub mod playback; +pub mod scrobbler; diff --git a/src/playback.rs b/src/playback.rs index 76c0f44..d9dd1f9 100644 --- a/src/playback.rs +++ b/src/playback.rs @@ -18,7 +18,7 @@ pub struct Track { pub duration: Option, } -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq)] #[allow(dead_code)] pub enum ShuffleMode { None, @@ -28,14 +28,15 @@ pub enum ShuffleMode { #[allow(dead_code)] pub struct Player { - state: PlaybackState, - current_track: Option, - queue: Vec, - volume: u8, - shuffle: ShuffleMode, + pub state: PlaybackState, + pub current_track: Option, + pub queue: Vec, + pub volume: u8, + pub shuffle: ShuffleMode, } #[allow(dead_code)] +#[allow(clippy::new_without_default)] impl Player { pub fn new() -> Self { Player { diff --git a/src/scrobbler.rs b/src/scrobbler.rs index 09a7f55..ddcbed9 100644 --- a/src/scrobbler.rs +++ b/src/scrobbler.rs @@ -2,10 +2,10 @@ use reqwest::Client; #[allow(dead_code)] pub struct Scrobbler { - lastfm_api_key: Option, - lastfm_api_secret: Option, - lastfm_session_key: Option, - listenbrainz_token: Option, + pub lastfm_api_key: Option, + pub lastfm_api_secret: Option, + pub lastfm_session_key: Option, + pub listenbrainz_token: Option, client: Client, } diff --git a/tests/config.rs b/tests/config.rs new file mode 100644 index 0000000..70c5034 --- /dev/null +++ b/tests/config.rs @@ -0,0 +1,133 @@ +use rsp::config::Config; +use std::path::PathBuf; + +#[test] +fn test_config_get_scan_interval() { + let config = Config { + config_path: PathBuf::from("/test/config.toml"), + music_paths: vec![], + scan_interval: Some(3600), + socket_path: None, + lastfm_api_key: None, + lastfm_api_secret: None, + lastfm_session_key: None, + listenbrainz_token: None, + volume: None, + shuffle: None, + }; + assert_eq!(config.get("scan_interval").unwrap(), "3600"); +} + +#[test] +fn test_config_get_not_set() { + let config = Config { + config_path: PathBuf::from("/test/config.toml"), + ..Default::default() + }; + assert_eq!(config.get("scan_interval").unwrap(), "not set"); +} + +#[test] +fn test_config_get_volume() { + let config = Config { + config_path: PathBuf::from("/test/config.toml"), + music_paths: vec![], + scan_interval: None, + socket_path: None, + lastfm_api_key: None, + lastfm_api_secret: None, + lastfm_session_key: None, + listenbrainz_token: None, + volume: Some(75), + shuffle: None, + }; + assert_eq!(config.get("volume").unwrap(), "75"); +} + +#[test] +fn test_config_get_unknown_key() { + let config = Config::default(); + let result = config.get("unknown_key"); + assert!(result.is_err()); +} + +#[test] +fn test_config_set_scan_interval() { + let mut config = Config::default(); + config.set("scan_interval", "7200").unwrap(); + assert_eq!(config.scan_interval, Some(7200)); +} + +#[test] +fn test_config_set_invalid_scan_interval() { + let mut config = Config::default(); + let result = config.set("scan_interval", "invalid"); + assert!(result.is_err()); +} + +#[test] +fn test_config_set_volume() { + let mut config = Config::default(); + config.set("volume", "50").unwrap(); + assert_eq!(config.volume, Some(50)); +} + +#[test] +fn test_config_set_invalid_volume() { + let mut config = Config::default(); + let result = config.set("volume", "256"); + assert!(result.is_err()); +} + +#[test] +fn test_config_set_shuffle_valid() { + let mut config = Config::default(); + config.set("shuffle", "all").unwrap(); + assert_eq!(config.shuffle, Some("all".to_string())); +} + +#[test] +fn test_config_set_shuffle_off() { + let mut config = Config::default(); + config.set("shuffle", "off").unwrap(); + assert_eq!(config.shuffle, None); +} + +#[test] +fn test_config_set_shuffle_invalid() { + let mut config = Config::default(); + let result = config.set("shuffle", "invalid"); + assert!(result.is_err()); +} + +#[test] +fn test_config_set_unknown_key() { + let mut config = Config::default(); + let result = config.set("unknown_key", "value"); + assert!(result.is_err()); +} + +#[test] +fn test_config_unset_volume() { + let mut config = Config { + config_path: PathBuf::from("/test/config.toml"), + music_paths: vec![], + scan_interval: None, + socket_path: None, + lastfm_api_key: None, + lastfm_api_secret: None, + lastfm_session_key: None, + listenbrainz_token: None, + volume: Some(50), + shuffle: None, + }; + config.unset("volume").unwrap(); + assert_eq!(config.volume, None); +} + +#[test] +fn test_config_unset_unknown_key() { + let mut config = Config::default(); + let result = config.unset("unknown_key"); + assert!(result.is_err()); +} diff --git a/tests/database.rs b/tests/database.rs new file mode 100644 index 0000000..67fe0ed --- /dev/null +++ b/tests/database.rs @@ -0,0 +1,85 @@ +use rsp::database::{extract_metadata, is_audio_file}; +use std::path::PathBuf; + +#[test] +fn test_is_audio_file_mp3() { + let path = PathBuf::from("/music/song.mp3"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_flac() { + let path = PathBuf::from("/music/song.flac"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_ogg() { + let path = PathBuf::from("/music/song.ogg"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_m4a() { + let path = PathBuf::from("/music/song.m4a"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_wav() { + let path = PathBuf::from("/music/song.wav"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_opus() { + let path = PathBuf::from("/music/song.opus"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_uppercase() { + let path = PathBuf::from("/music/song.MP3"); + assert!(is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_non_audio() { + let path = PathBuf::from("/music/song.txt"); + assert!(!is_audio_file(&path)); +} + +#[test] +fn test_is_audio_file_no_extension() { + let path = PathBuf::from("/music/songfile"); + assert!(!is_audio_file(&path)); +} + +#[test] +fn test_extract_metadata_standard_path() { + let path = PathBuf::from("/music/Artist/Album/Track.mp3"); + let (artist, album, title, track_num, duration) = extract_metadata(&path); + assert_eq!(artist, "Artist"); + assert_eq!(album, "Album"); + assert_eq!(title, "Track"); + assert_eq!(track_num, None); + assert_eq!(duration, None); +} + +#[test] +fn test_extract_metadata_deep_path() { + let path = PathBuf::from("/music/Artist/Album/Disc1/Track.mp3"); + let (artist, album, title, _, _) = extract_metadata(&path); + assert_eq!(artist, "Album"); + assert_eq!(album, "Disc1"); + assert_eq!(title, "Track"); +} + +#[test] +fn test_extract_metadata_no_parent() { + let path = PathBuf::from("/song.mp3"); + let (artist, album, title, _, _) = extract_metadata(&path); + assert_eq!(artist, "Unknown"); + assert_eq!(album, "Unknown"); + assert_eq!(title, "song"); +} diff --git a/tests/playback.rs b/tests/playback.rs new file mode 100644 index 0000000..80ecf58 --- /dev/null +++ b/tests/playback.rs @@ -0,0 +1,175 @@ +use rsp::playback::{PlaybackState, Player, ShuffleMode, Track}; +use std::path::PathBuf; + +fn dummy_track(title: &str) -> Track { + Track { + path: PathBuf::from(format!("/music/{}", title)), + title: title.to_string(), + artist: "Test Artist".to_string(), + album: "Test Album".to_string(), + duration: Some(180000), + } +} + +#[test] +fn test_player_default_state() { + let player = Player::new(); + assert_eq!(player.state(), &PlaybackState::Stopped); + assert_eq!(player.volume(), 70); +} + +#[test] +fn test_player_play_with_track_in_queue() { + let mut player = Player::new(); + player.queue_track(dummy_track("Test Track"), "last"); + player.play(); + assert_eq!(player.state(), &PlaybackState::Playing); + assert!(player.current_track.is_some()); + assert!(player.queue.is_empty()); +} + +#[test] +fn test_player_play_with_no_track() { + let mut player = Player::new(); + player.play(); + assert_eq!(player.state(), &PlaybackState::Stopped); +} + +#[test] +fn test_player_play_track() { + let mut player = Player::new(); + player.play_track(dummy_track("Test Track")); + assert_eq!(player.state(), &PlaybackState::Playing); + assert!(player.current_track.is_some()); +} + +#[test] +fn test_player_pause() { + let mut player = Player::new(); + player.play_track(dummy_track("Test Track")); + player.pause(); + assert_eq!(player.state(), &PlaybackState::Paused); +} + +#[test] +fn test_player_pause_when_stopped() { + let mut player = Player::new(); + player.pause(); + assert_eq!(player.state(), &PlaybackState::Stopped); +} + +#[test] +fn test_player_resume() { + let mut player = Player::new(); + player.play_track(dummy_track("Test Track")); + player.pause(); + player.resume(); + assert_eq!(player.state(), &PlaybackState::Playing); +} + +#[test] +fn test_player_resume_when_stopped() { + let mut player = Player::new(); + player.resume(); + assert_eq!(player.state(), &PlaybackState::Stopped); +} + +#[test] +fn test_player_stop() { + let mut player = Player::new(); + player.play_track(dummy_track("Test Track")); + player.stop(); + assert_eq!(player.state(), &PlaybackState::Stopped); + assert!(player.current_track.is_none()); +} + +#[test] +fn test_player_next_with_queue() { + let mut player = Player::new(); + player.queue_track(dummy_track("Track 1"), "last"); + player.queue_track(dummy_track("Track 2"), "last"); + player.next(); + assert_eq!(player.current_track.as_ref().unwrap().title, "Track 1"); +} + +#[test] +fn test_player_next_empty_queue() { + let mut player = Player::new(); + player.next(); + assert_eq!(player.state(), &PlaybackState::Stopped); + assert!(player.current_track.is_none()); +} + +#[test] +fn test_player_previous() { + let mut player = Player::new(); + player.play_track(dummy_track("Test Track")); + player.previous(); + assert_eq!(player.state(), &PlaybackState::Playing); +} + +#[test] +fn test_player_set_volume() { + let mut player = Player::new(); + player.set_volume(50); + assert_eq!(player.volume(), 50); +} + +#[test] +fn test_player_set_volume_caps_at_100() { + let mut player = Player::new(); + player.set_volume(150); + assert_eq!(player.volume(), 100); +} + +#[test] +fn test_player_set_shuffle() { + let mut player = Player::new(); + player.set_shuffle(ShuffleMode::All); + assert_eq!(player.shuffle, ShuffleMode::All); +} + +#[test] +fn test_player_queue_track_now() { + let mut player = Player::new(); + player.queue_track(dummy_track("Track 1"), "now"); + assert_eq!(player.queue.len(), 1); + assert_eq!(player.queue[0].title, "Track 1"); +} + +#[test] +fn test_player_queue_track_next() { + let mut player = Player::new(); + player.queue_track(dummy_track("Track 1"), "last"); + player.queue_track(dummy_track("Track 2"), "next"); + assert_eq!(player.queue.len(), 2); + assert_eq!(player.queue[0].title, "Track 1"); + assert_eq!(player.queue[1].title, "Track 2"); +} + +#[test] +fn test_player_queue_track_last() { + let mut player = Player::new(); + player.queue_track(dummy_track("Track 1"), "last"); + player.queue_track(dummy_track("Track 2"), "last"); + assert_eq!(player.queue.len(), 2); + assert_eq!(player.queue[0].title, "Track 1"); + assert_eq!(player.queue[1].title, "Track 2"); +} + +#[test] +fn test_player_dequeue_next() { + let mut player = Player::new(); + player.queue_track(dummy_track("Track 1"), "last"); + let track = player.dequeue_next(); + assert!(track.is_some()); + assert_eq!(track.unwrap().title, "Track 1"); + assert!(player.queue.is_empty()); +} + +#[test] +fn test_player_dequeue_next_empty() { + let mut player = Player::new(); + let track = player.dequeue_next(); + assert!(track.is_none()); +} diff --git a/tests/scrobbler.rs b/tests/scrobbler.rs new file mode 100644 index 0000000..f326250 --- /dev/null +++ b/tests/scrobbler.rs @@ -0,0 +1,77 @@ +use rsp::scrobbler::Scrobbler; + +#[test] +fn test_scrobbler_new_with_all_params() { + let scrobbler = Scrobbler::new( + Some("api_key".to_string()), + Some("secret".to_string()), + Some("session".to_string()), + Some("token".to_string()), + ); + assert!(scrobbler.lastfm_api_key.is_some()); + assert!(scrobbler.lastfm_api_secret.is_some()); + assert!(scrobbler.lastfm_session_key.is_some()); + assert!(scrobbler.listenbrainz_token.is_some()); +} + +#[test] +fn test_scrobbler_new_with_none() { + let scrobbler = Scrobbler::new(None, None, None, None); + assert!(scrobbler.lastfm_api_key.is_none()); + assert!(scrobbler.lastfm_api_secret.is_none()); + assert!(scrobbler.lastfm_session_key.is_none()); + assert!(scrobbler.listenbrainz_token.is_none()); +} + +#[test] +fn test_scrobbler_now_playing_no_api_key() { + let scrobbler = Scrobbler::new(None, None, None, None); + scrobbler.now_playing("Artist", "Track", Some("Album")); +} + +#[test] +fn test_scrobbler_now_playing_with_api_key() { + let scrobbler = Scrobbler::new(Some("api_key".to_string()), None, None, None); + scrobbler.now_playing("Artist", "Track", Some("Album")); +} + +#[test] +fn test_scrobbler_scrobble_no_keys() { + let scrobbler = Scrobbler::new(None, None, None, None); + scrobbler.scrobble("Artist", "Track", Some("Album"), 1234567890); +} + +#[test] +fn test_scrobbler_scrobble_with_lastfm() { + let scrobbler = Scrobbler::new(Some("api_key".to_string()), None, None, None); + scrobbler.scrobble("Artist", "Track", Some("Album"), 1234567890); +} + +#[test] +fn test_scrobbler_scrobble_with_listenbrainz() { + let scrobbler = Scrobbler::new(None, None, None, Some("token".to_string())); + scrobbler.scrobble("Artist", "Track", Some("Album"), 1234567890); +} + +#[test] +fn test_scrobbler_scrobble_with_both() { + let scrobbler = Scrobbler::new( + Some("api_key".to_string()), + None, + None, + Some("token".to_string()), + ); + scrobbler.scrobble("Artist", "Track", Some("Album"), 1234567890); +} + +#[test] +fn test_scrobbler_now_playing_no_album() { + let scrobbler = Scrobbler::new(Some("api_key".to_string()), None, None, None); + scrobbler.now_playing("Artist", "Track", None); +} + +#[test] +fn test_scrobbler_scrobble_no_album() { + let scrobbler = Scrobbler::new(Some("api_key".to_string()), None, None, None); + scrobbler.scrobble("Artist", "Track", None, 1234567890); +} -- cgit v1.2.3