1 files changed, 65 insertions, 47 deletions

diff --git a/tests/database.rs b/tests/database.rs
index adbf535..84eb663 100644
--- a/tests/database.rs
+++ b/tests/database.rs
@@ -114,115 +114,131 @@ fn seed_test_db(db: &Database) {
 fn test_complete_artists_prefix() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_artists("M").unwrap();
-    assert_eq!(results.len(), 2);
-    assert!(results.contains(&"Metallica".to_string()));
-    assert!(results.contains(&"Miles Davis".to_string()));
+    let results = db.complete("M").unwrap();
+    assert!(results.contains(&"Metallica/".to_string()));
+    assert!(results.contains(&"Miles Davis/".to_string()));
 }
 
 #[test]
 fn test_complete_artists_prefix_lowercase() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_artists("m").unwrap();
+    let results = db.complete("m").unwrap();
     assert!(
-        results.contains(&"Metallica".to_string()),
+        results.contains(&"Metallica/".to_string()),
         "LIKE should be case-insensitive"
     );
 }
 
 #[test]
-fn test_complete_artists_no_match() {
+fn test_complete_no_match() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_artists("Z").unwrap();
+    let results = db.complete("Z").unwrap();
     assert!(results.is_empty());
 }
 
 #[test]
-fn test_complete_artists_empty_prefix() {
+fn test_complete_empty_prefix() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_artists("").unwrap();
+    let results = db.complete("").unwrap();
     assert_eq!(results.len(), 3);
+    assert!(results.contains(&"Metallica/".to_string()));
+    assert!(results.contains(&"Miles Davis/".to_string()));
+    assert!(results.contains(&"Aphex Twin/".to_string()));
 }
 
 #[test]
-fn test_complete_albums_with_artist_prefix() {
+fn test_complete_albums_for_artist() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_albums("Metallica/").unwrap();
+    let results = db.complete("Metallica/").unwrap();
     assert_eq!(results.len(), 2);
-    assert!(results.contains(&"Master of Puppets".to_string()));
-    assert!(results.contains(&"Ride the Lightning".to_string()));
+    assert!(results.contains(&"Metallica/Master of Puppets/".to_string()));
+    assert!(results.contains(&"Metallica/Ride the Lightning/".to_string()));
+}
+
+#[test]
+fn test_complete_albums_artist_lowercase() {
+    let db = Database::open_in_memory().unwrap();
+    seed_test_db(&db);
+    let results = db.complete("metallica/").unwrap();
+    assert_eq!(results.len(), 2, "artist match should be case-insensitive");
+    assert!(results.contains(&"metallica/Master of Puppets/".to_string()));
 }
 
 #[test]
 fn test_complete_albums_with_album_prefix() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_albums("Metallica/R").unwrap();
-    assert_eq!(results.len(), 1);
-    assert_eq!(results[0], "Ride the Lightning");
+    // "R" matches "Ride the Lightning" (prefix) and "Master of Puppets" (contains 'r')
+    let results = db.complete("Metallica/R").unwrap();
+    assert_eq!(results.len(), 2);
+    assert_eq!(results[0], "Metallica/Ride the Lightning/");
+    assert_eq!(results[1], "Metallica/Master of Puppets/");
 }
 
 #[test]
-fn test_complete_albums_unknown_artist() {
+fn test_complete_albums_substring_match() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_albums("Unknown/").unwrap();
-    assert!(results.is_empty());
+    // "ind" matches "Kind of Blue" (contains "ind")
+    let results = db.complete("Miles Davis/ind").unwrap();
+    assert_eq!(results.len(), 1);
+    assert_eq!(results[0], "Miles Davis/Kind of Blue/");
 }
 
 #[test]
-fn test_complete_albums_no_slash() {
+fn test_complete_artists_substring_match() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_albums("Metallica").unwrap();
-    assert!(results.is_empty(), "needs trailing slash");
+    // "x" matches "Aphex Twin" (contains 'x')
+    let results = db.complete("x").unwrap();
+    assert!(results.contains(&"Aphex Twin/".to_string()));
 }
 
 #[test]
-fn test_complete_tracks_full_path() {
+fn test_complete_albums_unknown_artist() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_tracks("Metallica/Master of Puppets/").unwrap();
-    assert_eq!(results.len(), 2);
-    assert!(results.contains(&"Battery".to_string()));
-    assert!(results.contains(&"Master of Puppets".to_string()));
+    let results = db.complete("Unknown/").unwrap();
+    assert!(results.is_empty());
 }
 
 #[test]
-fn test_complete_tracks_with_prefix() {
+fn test_complete_tracks_for_album() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_tracks("Metallica/Master of Puppets/B").unwrap();
-    assert_eq!(results.len(), 1);
-    assert_eq!(results[0], "Battery");
+    let results = db.complete("Metallica/Master of Puppets/").unwrap();
+    assert_eq!(results.len(), 2);
+    assert!(results.contains(&"Metallica/Master of Puppets/Battery".to_string()));
+    assert!(results.contains(&"Metallica/Master of Puppets/Master of Puppets".to_string()));
 }
 
 #[test]
-fn test_complete_tracks_unknown_album() {
+fn test_complete_tracks_with_prefix() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_tracks("Metallica/Nonexistent/").unwrap();
-    assert!(results.is_empty());
+    let results = db.complete("Metallica/Master of Puppets/B").unwrap();
+    assert_eq!(results.len(), 1);
+    assert_eq!(results[0], "Metallica/Master of Puppets/Battery");
 }
 
 #[test]
-fn test_complete_tracks_too_few_parts() {
+fn test_complete_tracks_unknown_album() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    let results = db.complete_tracks("Metallica").unwrap();
+    let results = db.complete("Metallica/Nonexistent/").unwrap();
     assert!(results.is_empty());
 }
 
 #[test]
 fn test_complete_empty_db() {
     let db = Database::open_in_memory().unwrap();
-    assert!(db.complete_artists("").unwrap().is_empty());
-    assert!(db.complete_albums("x/").unwrap().is_empty());
-    assert!(db.complete_tracks("x/y/").unwrap().is_empty());
+    assert!(db.complete("").unwrap().is_empty());
+    assert!(db.complete("x/").unwrap().is_empty());
+    assert!(db.complete("x/y/").unwrap().is_empty());
 }
 
 // --- find_tracks_by_album tests ---
@@ -271,17 +287,18 @@ fn test_find_tracks_by_album_unknown_album() {
 }
 
 #[test]
-fn test_find_tracks_by_album_case_sensitive_artist() {
+fn test_find_tracks_by_album_case_insensitive_artist() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
-    // SQLite = is case-sensitive for TEXT (unless NOCASE collation)
     let tracks = db
         .find_tracks_by_album("metallica", "Master of Puppets")
         .unwrap();
-    assert!(
-        tracks.is_empty(),
-        "artist name match should be case-sensitive"
+    assert_eq!(
+        tracks.len(),
+        2,
+        "artist name match should be case-insensitive"
     );
+    assert_eq!(tracks[0].title, "Battery");
 }
 
 #[test]
@@ -353,13 +370,14 @@ fn test_find_track_by_parts_no_match_artist() {
 }
 
 #[test]
-fn test_find_track_by_parts_case_sensitive() {
+fn test_find_track_by_parts_case_insensitive() {
     let db = Database::open_in_memory().unwrap();
     seed_test_db(&db);
     let track = db
         .find_track_by_parts("metallica", "Master of Puppets", "Battery")
         .unwrap();
-    assert!(track.is_none(), "artist match should be case-sensitive");
+    assert!(track.is_some(), "artist match should be case-insensitive");
+    assert_eq!(track.unwrap().title, "Battery");
 }
 
 // --- resolve_path tests ---