vibesonic/internal/scanner/scanner_test.go

package scanner

import (
	"context"
	"io"
	"log/slog"
	"os"
	"os/exec"
	"path/filepath"
	"testing"
	"time"

	"git.noroutes.net/NoRoutes/vibetunes/internal/database"
	"git.noroutes.net/NoRoutes/vibetunes/internal/metadata"
)

func testLogger() *slog.Logger {
	return slog.New(slog.NewTextHandler(io.Discard, nil))
}

func genFile(t *testing.T, dir, name, title, artist string) string {
	t.Helper()
	if _, err := exec.LookPath("ffmpeg"); err != nil {
		t.Skip("ffmpeg not installed, skipping scanner integration test")
	}
	out := filepath.Join(dir, name)
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	cmd := exec.CommandContext(ctx, "ffmpeg",
		"-f", "lavfi", "-i", "sine=frequency=440:duration=1",
		"-metadata", "title="+title,
		"-metadata", "artist="+artist,
		"-metadata", "album=Scan Test Album",
		"-codec:a", "libmp3lame", "-b:a", "64k",
		out,
	)
	if combined, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("ffmpeg failed: %v\n%s", err, combined)
	}
	return out
}

func newTestScanner(t *testing.T) (*Scanner, *database.MusicFolder, string) {
	t.Helper()
	if _, err := exec.LookPath("ffprobe"); err != nil {
		t.Skip("ffprobe not installed, skipping scanner integration test")
	}
	dbPath := filepath.Join(t.TempDir(), "test.db")
	db, err := database.Open(dbPath)
	if err != nil {
		t.Fatalf("database.Open: %v", err)
	}
	t.Cleanup(func() { db.Close() })

	musicDir := t.TempDir()
	folder, err := database.CreateMusicFolder(db, "Test Music", musicDir, "music")
	if err != nil {
		t.Fatalf("CreateMusicFolder: %v", err)
	}

	s := New(db, &metadata.Prober{}, testLogger())
	return s, folder, musicDir
}

func TestScanFolderAddsNewFiles(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	genFile(t, dir, "song1.mp3", "Song One", "Artist One")
	genFile(t, dir, "song2.mp3", "Song Two", "Artist One")

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder: %v", err)
	}

	files, err := database.ListMediaFilesForFolder(s.DB, folder.ID)
	if err != nil {
		t.Fatalf("ListMediaFilesForFolder: %v", err)
	}
	if len(files) != 2 {
		t.Fatalf("got %d media files, want 2", len(files))
	}

	state, err := database.GetScanState(s.DB, folder.ID)
	if err != nil {
		t.Fatalf("GetScanState: %v", err)
	}
	if state.FilesAdded != 2 {
		t.Errorf("FilesAdded = %d, want 2", state.FilesAdded)
	}
	if state.Status != "idle" {
		t.Errorf("Status = %q, want idle", state.Status)
	}
}

func TestScanFolderIncrementalNoReprobe(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	genFile(t, dir, "song1.mp3", "Song One", "Artist One")

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder (1st): %v", err)
	}
	files1, _ := database.ListMediaFilesForFolder(s.DB, folder.ID)
	id1 := files1[0].ID

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder (2nd): %v", err)
	}
	files2, _ := database.ListMediaFilesForFolder(s.DB, folder.ID)
	if len(files2) != 1 {
		t.Fatalf("got %d media files after rescan, want 1 (no duplicates)", len(files2))
	}
	if files2[0].ID != id1 {
		t.Errorf("media file ID changed across rescan: %s -> %s", id1, files2[0].ID)
	}

	state, err := database.GetScanState(s.DB, folder.ID)
	if err != nil {
		t.Fatalf("GetScanState: %v", err)
	}
	if state.FilesAdded != 0 || state.FilesUpdated != 0 {
		t.Errorf("second scan should add/update nothing, got added=%d updated=%d", state.FilesAdded, state.FilesUpdated)
	}
}

func TestScanFolderMarksDeletedFilesMissing(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	path := genFile(t, dir, "song1.mp3", "Song One", "Artist One")

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder (1st): %v", err)
	}
	if err := os.Remove(path); err != nil {
		t.Fatalf("os.Remove: %v", err)
	}
	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder (2nd): %v", err)
	}

	files, err := database.ListMediaFilesForFolder(s.DB, folder.ID)
	if err != nil {
		t.Fatalf("ListMediaFilesForFolder: %v", err)
	}
	if len(files) != 1 {
		t.Fatalf("got %d media files, want 1 (row kept, not deleted)", len(files))
	}
	if !files[0].Missing {
		t.Error("expected the removed file's row to be marked missing")
	}

	state, err := database.GetScanState(s.DB, folder.ID)
	if err != nil {
		t.Fatalf("GetScanState: %v", err)
	}
	if state.FilesRemoved != 1 {
		t.Errorf("FilesRemoved = %d, want 1", state.FilesRemoved)
	}
}

func TestScanFolderDetectsRename(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	oldPath := genFile(t, dir, "old_name.mp3", "Song One", "Artist One")

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder (1st): %v", err)
	}
	files1, _ := database.ListMediaFilesForFolder(s.DB, folder.ID)
	id1 := files1[0].ID

	newPath := filepath.Join(dir, "new_name.mp3")
	if err := os.Rename(oldPath, newPath); err != nil {
		t.Fatalf("os.Rename: %v", err)
	}
	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder (2nd): %v", err)
	}

	files2, err := database.ListMediaFilesForFolder(s.DB, folder.ID)
	if err != nil {
		t.Fatalf("ListMediaFilesForFolder: %v", err)
	}
	if len(files2) != 1 {
		t.Fatalf("got %d media files after rename, want 1 (matched by content, not duplicated)", len(files2))
	}
	if files2[0].ID != id1 {
		t.Errorf("media file ID changed across rename: %s -> %s (should reuse the same row)", id1, files2[0].ID)
	}
	if files2[0].RelativePath != "new_name.mp3" {
		t.Errorf("RelativePath = %q, want new_name.mp3", files2[0].RelativePath)
	}
	if files2[0].Missing {
		t.Error("renamed file should not be marked missing")
	}
}

func TestScanFolderIndexesLibraryTags(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	genFile(t, dir, "song1.mp3", "Song One", "Shared Artist")
	genFile(t, dir, "song2.mp3", "Song Two", "Shared Artist")

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder: %v", err)
	}

	artists, err := database.ListArtists(s.DB)
	if err != nil {
		t.Fatalf("ListArtists: %v", err)
	}
	if len(artists) != 1 {
		t.Fatalf("artists = %v, want 1 shared artist reused across both songs", artists)
	}

	albums, err := database.ListAlbumsByArtist(s.DB, artists[0].ID)
	if err != nil {
		t.Fatalf("ListAlbumsByArtist: %v", err)
	}
	if len(albums) != 1 {
		t.Fatalf("albums = %v, want 1", albums)
	}
	songs, err := database.ListSongsByAlbum(s.DB, albums[0].ID)
	if err != nil {
		t.Fatalf("ListSongsByAlbum: %v", err)
	}
	if len(songs) != 2 {
		t.Fatalf("songs = %v, want 2", songs)
	}
}

func TestScanFolderRejectsConcurrentScan(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	genFile(t, dir, "song1.mp3", "Song One", "Artist One")

	if !s.beginScan(folder.ID) {
		t.Fatal("beginScan should succeed the first time")
	}
	defer s.endScan(folder.ID)

	if err := s.ScanFolder(context.Background(), folder.ID); err == nil {
		t.Fatal("expected error scanning a folder that is already being scanned")
	}
}

func TestScanFolderIndexesSidecarLRC(t *testing.T) {
	s, folder, dir := newTestScanner(t)
	genFile(t, dir, "song1.mp3", "Song One", "Artist One")

	lrc := "[ar:Artist One]\n[00:01.00]Hello world\n[00:02.50]<00:02.50>Second <00:02.90>line\n"
	if err := os.WriteFile(filepath.Join(dir, "song1.lrc"), []byte(lrc), 0o644); err != nil {
		t.Fatalf("write sidecar lrc: %v", err)
	}

	if err := s.ScanFolder(context.Background(), folder.ID); err != nil {
		t.Fatalf("ScanFolder: %v", err)
	}

	songs, err := database.ListSongs(s.DB, 10, 0)
	if err != nil || len(songs) != 1 {
		t.Fatalf("ListSongs: %v %v", songs, err)
	}

	entries, err := database.GetSongStructuredLyrics(s.DB, songs[0].ID)
	if err != nil {
		t.Fatalf("GetSongStructuredLyrics: %v", err)
	}
	var synced *database.StructuredLyricsRow
	for i := range entries {
		if entries[i].Synced {
			synced = &entries[i]
		}
	}
	if synced == nil {
		t.Fatalf("expected a synced structuredLyrics entry from the sidecar .lrc, got %+v", entries)
	}
	if len(synced.Lines) != 2 || synced.Lines[0].Text != "Hello world" {
		t.Fatalf("lines = %+v", synced.Lines)
	}
	if synced.Lines[0].StartMs == nil || *synced.Lines[0].StartMs != 1000 {
		t.Errorf("line[0].StartMs = %v, want 1000", synced.Lines[0].StartMs)
	}
	if len(synced.Lines[1].Words) != 2 {
		t.Fatalf("expected word-level cues from Enhanced LRC line, got %+v", synced.Lines[1])
	}
}