convert to Ginkgo

Signed-off-by: Deluan <deluan@navidrome.org>

core/external_metadata_simple_test.go

@@ -6,7 +6,6 @@ import (
 	"log"
 	"reflect"
 	"strings"
-	"testing"
 	"unsafe"
 
 	"github.com/Masterminds/squirrel"
@@ -15,7 +14,8 @@ import (
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
 	"github.com/navidrome/navidrome/utils/str"
-	"github.com/stretchr/testify/assert"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 )
 
 // Custom implementation of ArtistRepository for testing
@@ -285,178 +285,190 @@ func setStructField(obj interface{}, fieldName string, value interface{}) {
 	rf.Set(reflect.ValueOf(value))
 }
 
-// Direct implementation of ExternalMetadata for testing that avoids agents registration issues
+var _ = Describe("CustomExternalMetadata", func() {
-func TestDirectTopSongs(t *testing.T) {
+	var ctx context.Context
-	// Setup
-	ctx := context.Background()
 
-	// Create custom mock repositories
+	BeforeEach(func() {
-	mockArtistRepo := newCustomArtistRepo()
+		ctx = context.Background()
-	mockMediaFileRepo := newCustomMediaFileRepo()
+	})
 
-	// Configure mock data
+	Describe("DirectTopSongs", func() {
-	artist := model.Artist{ID: "artist-1", Name: "Artist One"}
+		var mockArtistRepo *customArtistRepo
-	mockArtistRepo.SetData(model.Artists{artist})
+		var mockMediaFileRepo *customMediaFileRepo
+		var mockDS *tests.MockDataStore
+		var mockAgent *MockAgent
+		var agentsImpl *agents.Agents
+		var em ExternalMetadata
 
-	log.Printf("Test: Set up artist: %s (ID: %s)", artist.Name, artist.ID)
+		BeforeEach(func() {
+			// Create custom mock repositories
+			mockArtistRepo = newCustomArtistRepo()
+			mockMediaFileRepo = newCustomMediaFileRepo()
 
-	mediaFiles := []model.MediaFile{
+			// Configure mock data
-		{
+			artist := model.Artist{ID: "artist-1", Name: "Artist One"}
-			ID:                "song-1",
+			mockArtistRepo.SetData(model.Artists{artist})
-			Title:             "Song One",
-			Artist:            "Artist One",
-			ArtistID:          "artist-1",
-			MbzReleaseTrackID: "mbid-1",
-			Missing:           false,
-		},
-		{
-			ID:                "song-2",
-			Title:             "Song Two",
-			Artist:            "Artist One",
-			ArtistID:          "artist-1",
-			MbzReleaseTrackID: "mbid-2",
-			Missing:           false,
-		},
-	}
-	mockMediaFileRepo.SetData(model.MediaFiles(mediaFiles))
 
-	for _, mf := range mediaFiles {
+			log.Printf("Test: Set up artist: %s (ID: %s)", artist.Name, artist.ID)
-		log.Printf("Test: Set up media file: %s (ID: %s, MBID: %s, ArtistID: %s)",
-			mf.Title, mf.ID, mf.MbzReleaseTrackID, mf.ArtistID)
-	}
 
-	// Create mock datastore
+			mediaFiles := []model.MediaFile{
-	mockDS := &tests.MockDataStore{
+				{
-		MockedArtist:    mockArtistRepo,
+					ID:                "song-1",
-		MockedMediaFile: mockMediaFileRepo,
+					Title:             "Song One",
-	}
+					Artist:            "Artist One",
+					ArtistID:          "artist-1",
+					MbzReleaseTrackID: "mbid-1",
+					Missing:           false,
+				},
+				{
+					ID:                "song-2",
+					Title:             "Song Two",
+					Artist:            "Artist One",
+					ArtistID:          "artist-1",
+					MbzReleaseTrackID: "mbid-2",
+					Missing:           false,
+				},
+			}
+			mockMediaFileRepo.SetData(model.MediaFiles(mediaFiles))
 
-	// Create mock agent
+			for _, mf := range mediaFiles {
-	mockAgent := &MockAgent{
+				log.Printf("Test: Set up media file: %s (ID: %s, MBID: %s, ArtistID: %s)",
-		topSongs: []agents.Song{
+					mf.Title, mf.ID, mf.MbzReleaseTrackID, mf.ArtistID)
-			{Name: "Song One", MBID: "mbid-1"},
+			}
-			{Name: "Song Two", MBID: "mbid-2"},
-		},
-	}
 
-	// Use the real agents.Agents implementation but with our mock agent
+			// Create mock datastore
-	agentsImpl := &agents.Agents{}
+			mockDS = &tests.MockDataStore{
+				MockedArtist:    mockArtistRepo,
+				MockedMediaFile: mockMediaFileRepo,
+			}
 
-	// Set unexported fields using reflection and unsafe
+			// Create mock agent
-	setStructField(agentsImpl, "ds", mockDS)
+			mockAgent = &MockAgent{
-	setStructField(agentsImpl, "agents", []agents.Interface{mockAgent})
+				topSongs: []agents.Song{
+					{Name: "Song One", MBID: "mbid-1"},
+					{Name: "Song Two", MBID: "mbid-2"},
+				},
+			}
 
-	// Create our service under test
+			// Use the real agents.Agents implementation but with our mock agent
-	em := NewExternalMetadata(mockDS, agentsImpl)
+			agentsImpl = &agents.Agents{}
 
-	// Test
+			// Set unexported fields using reflection and unsafe
-	log.Printf("Test: Calling TopSongs for artist: %s", "Artist One")
+			setStructField(agentsImpl, "ds", mockDS)
-	songs, err := em.TopSongs(ctx, "Artist One", 5)
+			setStructField(agentsImpl, "agents", []agents.Interface{mockAgent})
 
-	log.Printf("Test: Result: error=%v, songs=%v", err, songs)
+			// Create our service under test
+			em = NewExternalMetadata(mockDS, agentsImpl)
+		})
 
-	// Assertions
+		It("returns matching songs from the artist results", func() {
-	assert.NoError(t, err)
+			log.Printf("Test: Calling TopSongs for artist: %s", "Artist One")
-	assert.Len(t, songs, 2)
+			songs, err := em.TopSongs(ctx, "Artist One", 5)
-	if len(songs) > 0 {
-		assert.Equal(t, "song-1", songs[0].ID)
-	}
-	if len(songs) > 1 {
-		assert.Equal(t, "song-2", songs[1].ID)
-	}
-}
 
-func TestTopSongs(t *testing.T) {
+			log.Printf("Test: Result: error=%v, songs=%v", err, songs)
-	// Setup
-	ctx := context.Background()
 
-	// Store the original config to restore it later
+			Expect(err).ToNot(HaveOccurred())
-	originalAgentsConfig := conf.Server.Agents
+			Expect(songs).To(HaveLen(2))
+			Expect(songs[0].ID).To(Equal("song-1"))
+			Expect(songs[1].ID).To(Equal("song-2"))
+		})
+	})
 
-	// Set our mock agent as the only agent
+	Describe("TopSongs with agent registration", func() {
-	conf.Server.Agents = "mock"
+		var mockArtistRepo *customArtistRepo
-	defer func() {
+		var mockMediaFileRepo *customMediaFileRepo
-		conf.Server.Agents = originalAgentsConfig
+		var mockDS *tests.MockDataStore
-	}()
+		var mockAgent *MockAgent
+		var em ExternalMetadata
+		var originalAgentsConfig string
 
-	// Clear the agents map to prevent interference
+		BeforeEach(func() {
-	agents.Map = nil
+			// Store the original config to restore it later
+			originalAgentsConfig = conf.Server.Agents
 
-	// Create custom mock repositories
+			// Set our mock agent as the only agent
-	mockArtistRepo := newCustomArtistRepo()
+			conf.Server.Agents = "mock"
-	mockMediaFileRepo := newCustomMediaFileRepo()
 
-	// Configure mock data
+			// Clear the agents map to prevent interference
-	artist := model.Artist{ID: "artist-1", Name: "Artist One"}
+			agents.Map = nil
-	mockArtistRepo.SetData(model.Artists{artist})
 
-	log.Printf("Test: Set up artist: %s (ID: %s)", artist.Name, artist.ID)
+			// Create custom mock repositories
+			mockArtistRepo = newCustomArtistRepo()
+			mockMediaFileRepo = newCustomMediaFileRepo()
 
-	mediaFiles := []model.MediaFile{
+			// Configure mock data
-		{
+			artist := model.Artist{ID: "artist-1", Name: "Artist One"}
-			ID:                "song-1",
+			mockArtistRepo.SetData(model.Artists{artist})
-			Title:             "Song One",
-			Artist:            "Artist One",
-			ArtistID:          "artist-1",
-			MbzReleaseTrackID: "mbid-1",
-			Missing:           false,
-		},
-		{
-			ID:                "song-2",
-			Title:             "Song Two",
-			Artist:            "Artist One",
-			ArtistID:          "artist-1",
-			MbzReleaseTrackID: "mbid-2",
-			Missing:           false,
-		},
-	}
-	mockMediaFileRepo.SetData(model.MediaFiles(mediaFiles))
 
-	for _, mf := range mediaFiles {
+			log.Printf("Test: Set up artist: %s (ID: %s)", artist.Name, artist.ID)
-		log.Printf("Test: Set up media file: %s (ID: %s, MBID: %s, ArtistID: %s)",
-			mf.Title, mf.ID, mf.MbzReleaseTrackID, mf.ArtistID)
-	}
 
-	// Create mock datastore
+			mediaFiles := []model.MediaFile{
-	mockDS := &tests.MockDataStore{
+				{
-		MockedArtist:    mockArtistRepo,
+					ID:                "song-1",
-		MockedMediaFile: mockMediaFileRepo,
+					Title:             "Song One",
-	}
+					Artist:            "Artist One",
+					ArtistID:          "artist-1",
+					MbzReleaseTrackID: "mbid-1",
+					Missing:           false,
+				},
+				{
+					ID:                "song-2",
+					Title:             "Song Two",
+					Artist:            "Artist One",
+					ArtistID:          "artist-1",
+					MbzReleaseTrackID: "mbid-2",
+					Missing:           false,
+				},
+			}
+			mockMediaFileRepo.SetData(model.MediaFiles(mediaFiles))
 
-	// Create and register a mock agent
+			for _, mf := range mediaFiles {
-	mockAgent := &MockAgent{
+				log.Printf("Test: Set up media file: %s (ID: %s, MBID: %s, ArtistID: %s)",
-		topSongs: []agents.Song{
+					mf.Title, mf.ID, mf.MbzReleaseTrackID, mf.ArtistID)
-			{Name: "Song One", MBID: "mbid-1"},
+			}
-			{Name: "Song Two", MBID: "mbid-2"},
-		},
-	}
 
-	// Register our mock agent - this is key to making it available
+			// Create mock datastore
-	agents.Register("mock", func(model.DataStore) agents.Interface { return mockAgent })
+			mockDS = &tests.MockDataStore{
+				MockedArtist:    mockArtistRepo,
+				MockedMediaFile: mockMediaFileRepo,
+			}
 
-	// Dump the registered agents for debugging
+			// Create and register a mock agent
-	log.Printf("Test: Registered agents:")
+			mockAgent = &MockAgent{
-	for name := range agents.Map {
+				topSongs: []agents.Song{
-		log.Printf("  - %s", name)
+					{Name: "Song One", MBID: "mbid-1"},
-	}
+					{Name: "Song Two", MBID: "mbid-2"},
+				},
+			}
 
-	// Create the service to test
+			// Register our mock agent - this is key to making it available
-	log.Printf("Test: Creating ExternalMetadata with conf.Server.Agents=%s", conf.Server.Agents)
+			agents.Register("mock", func(model.DataStore) agents.Interface { return mockAgent })
-	em := NewExternalMetadata(mockDS, agents.GetAgents(mockDS))
 
-	// Test
+			// Dump the registered agents for debugging
-	log.Printf("Test: Calling TopSongs for artist: %s", "Artist One")
+			log.Printf("Test: Registered agents:")
-	songs, err := em.TopSongs(ctx, "Artist One", 5)
+			for name := range agents.Map {
+				log.Printf("  - %s", name)
+			}
 
-	log.Printf("Test: Result: error=%v, songs=%v", err, songs)
+			// Create the service to test
+			log.Printf("Test: Creating ExternalMetadata with conf.Server.Agents=%s", conf.Server.Agents)
+			em = NewExternalMetadata(mockDS, agents.GetAgents(mockDS))
+		})
 
-	// Assertions
+		AfterEach(func() {
-	assert.NoError(t, err)
+			conf.Server.Agents = originalAgentsConfig
-	assert.Len(t, songs, 2)
+		})
-	if len(songs) > 0 {
+
-		assert.Equal(t, "song-1", songs[0].ID)
+		It("returns matching songs from the registered agent", func() {
-	}
+			log.Printf("Test: Calling TopSongs for artist: %s", "Artist One")
-	if len(songs) > 1 {
+			songs, err := em.TopSongs(ctx, "Artist One", 5)
-		assert.Equal(t, "song-2", songs[1].ID)
+
-	}
+			log.Printf("Test: Result: error=%v, songs=%v", err, songs)
-}
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(songs).To(HaveLen(2))
+			Expect(songs[0].ID).To(Equal("song-1"))
+			Expect(songs[1].ID).To(Equal("song-2"))
+		})
+	})
+})