Add unit tests in /tests directory for config, database, playback, and scrobbler modules

11 files changed, 615 insertions, 27 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 1baedf3..82ef060 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -492,6 +492,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -920,16 +926,6 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1076,6 +1072,12 @@ dependencies = [
 ]
 
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -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",
 ]
@@ -1676,6 +1679,19 @@ dependencies = [
 ]
 
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2193,6 +2209,19 @@ dependencies = [
 ]
 
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -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]]
@@ -2779,6 +2808,15 @@ dependencies = [
 
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
@@ -2810,7 +2848,7 @@ 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",
@@ -2818,6 +2856,23 @@ dependencies = [
 ]
 
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2839,6 +2894,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2851,6 +2912,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2863,12 +2930,24 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2881,6 +2960,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2893,6 +2978,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2905,6 +2996,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2917,6 +3014,12 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
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<Mutex<f32>>,
 }
 
+#[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<i32>, Option<u64>) {
+pub fn extract_metadata(path: &Path) -> (String, String, String, Option<i32>, Option<u64>) {
     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<u64>,
 }
 
-#[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<Track>,
-    queue: Vec<Track>,
-    volume: u8,
-    shuffle: ShuffleMode,
+    pub state: PlaybackState,
+    pub current_track: Option<Track>,
+    pub queue: Vec<Track>,
+    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<String>,
-    lastfm_api_secret: Option<String>,
-    lastfm_session_key: Option<String>,
-    listenbrainz_token: Option<String>,
+    pub lastfm_api_key: Option<String>,
+    pub lastfm_api_secret: Option<String>,
+    pub lastfm_session_key: Option<String>,
+    pub listenbrainz_token: Option<String>,
     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);
+}