update

persistence/genre_repository_test.go

@@ -0,0 +1,329 @@
+package persistence
+
+import (
+	"context"
+	"slices"
+	"strings"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/deluan/rest"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/id"
+	"github.com/navidrome/navidrome/model/request"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("GenreRepository", func() {
+	var repo model.GenreRepository
+	var restRepo model.ResourceRepository
+	var tagRepo model.TagRepository
+	var ctx context.Context
+
+	BeforeEach(func() {
+		ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "userid", UserName: "johndoe", IsAdmin: true})
+		genreRepo := NewGenreRepository(ctx, GetDBXBuilder())
+		repo = genreRepo
+		restRepo = genreRepo.(model.ResourceRepository)
+		tagRepo = NewTagRepository(ctx, GetDBXBuilder())
+
+		// Clear any existing tags to ensure test isolation
+		db := GetDBXBuilder()
+		_, err := db.NewQuery("DELETE FROM tag").Execute()
+		Expect(err).ToNot(HaveOccurred())
+
+		// Ensure library 1 exists and user has access to it
+		_, err = db.NewQuery("INSERT OR IGNORE INTO library (id, name, path, default_new_users) VALUES (1, 'Test Library', '/test', true)").Execute()
+		Expect(err).ToNot(HaveOccurred())
+		_, err = db.NewQuery("INSERT OR IGNORE INTO user_library (user_id, library_id) VALUES ('userid', 1)").Execute()
+		Expect(err).ToNot(HaveOccurred())
+
+		// Add comprehensive test data that covers all test scenarios
+		newTag := func(name, value string) model.Tag {
+			return model.Tag{ID: id.NewTagID(name, value), TagName: model.TagName(name), TagValue: value}
+		}
+
+		err = tagRepo.Add(1,
+			newTag("genre", "rock"),
+			newTag("genre", "pop"),
+			newTag("genre", "jazz"),
+			newTag("genre", "electronic"),
+			newTag("genre", "classical"),
+			newTag("genre", "ambient"),
+			newTag("genre", "techno"),
+			newTag("genre", "house"),
+			newTag("genre", "trance"),
+			newTag("genre", "Alternative Rock"),
+			newTag("genre", "Blues"),
+			newTag("genre", "Country"),
+			// These should not be counted as genres
+			newTag("mood", "happy"),
+			newTag("mood", "ambient"),
+		)
+		Expect(err).ToNot(HaveOccurred())
+	})
+
+	Describe("GetAll", func() {
+		It("should return all genres", func() {
+			genres, err := repo.GetAll()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(genres).To(HaveLen(12))
+
+			// Verify that all returned items are genres (TagName = "genre")
+			genreNames := make([]string, len(genres))
+			for i, genre := range genres {
+				genreNames[i] = genre.Name
+			}
+			Expect(genreNames).To(ContainElement("rock"))
+			Expect(genreNames).To(ContainElement("pop"))
+			Expect(genreNames).To(ContainElement("jazz"))
+			// Should not contain mood tags
+			Expect(genreNames).ToNot(ContainElement("happy"))
+		})
+
+		It("should support query options", func() {
+			// Test with limiting results
+			genres, err := repo.GetAll(model.QueryOptions{Max: 1})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(genres).To(HaveLen(1))
+		})
+
+		It("should handle empty results gracefully", func() {
+			// Clear all genre tags
+			_, err := GetDBXBuilder().NewQuery("DELETE FROM tag WHERE tag_name = 'genre'").Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			genres, err := repo.GetAll()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(genres).To(BeEmpty())
+		})
+		Describe("filtering and sorting", func() {
+			It("should filter by name using like match", func() {
+				// Test filtering by partial name match using the "name" filter which maps to containsFilter("tag_value")
+				options := model.QueryOptions{
+					Filters: squirrel.Like{"tag_value": "%rock%"}, // Direct field access
+				}
+				genres, err := repo.GetAll(options)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(genres).To(HaveLen(2)) // Should match "rock" and "Alternative Rock"
+
+				// Verify all returned genres contain "rock" in their name
+				for _, genre := range genres {
+					Expect(strings.ToLower(genre.Name)).To(ContainSubstring("rock"))
+				}
+			})
+
+			It("should sort by name in ascending order", func() {
+				// Test sorting by name with the fixed mapping
+				options := model.QueryOptions{
+					Filters: squirrel.Like{"tag_value": "%e%"}, // Should match genres containing "e"
+					Sort:    "name",
+				}
+				genres, err := repo.GetAll(options)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(genres).To(HaveLen(7))
+
+				Expect(slices.IsSortedFunc(genres, func(a, b model.Genre) int {
+					return strings.Compare(b.Name, a.Name) // Inverted to check descending order
+				}))
+			})
+
+			It("should sort by name in descending order", func() {
+				// Test sorting by name in descending order
+				options := model.QueryOptions{
+					Filters: squirrel.Like{"tag_value": "%e%"}, // Should match genres containing "e"
+					Sort:    "name",
+					Order:   "desc",
+				}
+				genres, err := repo.GetAll(options)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(genres).To(HaveLen(7))
+
+				Expect(slices.IsSortedFunc(genres, func(a, b model.Genre) int {
+					return strings.Compare(a.Name, b.Name)
+				}))
+			})
+		})
+	})
+
+	Describe("Count", func() {
+		It("should return correct count of genres", func() {
+			count, err := restRepo.Count()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(int64(12))) // We have 12 genre tags
+		})
+
+		It("should handle zero count", func() {
+			// Clear all genre tags
+			_, err := GetDBXBuilder().NewQuery("DELETE FROM tag WHERE tag_name = 'genre'").Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err := restRepo.Count()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(BeZero())
+		})
+
+		It("should only count genre tags", func() {
+			// Add a non-genre tag
+			nonGenreTag := model.Tag{
+				ID:       id.NewTagID("mood", "energetic"),
+				TagName:  "mood",
+				TagValue: "energetic",
+			}
+			err := tagRepo.Add(1, nonGenreTag)
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err := restRepo.Count()
+			Expect(err).ToNot(HaveOccurred())
+			// Count should not include the mood tag
+			Expect(count).To(Equal(int64(12))) // Should still be 12 genre tags
+		})
+
+		It("should filter by name using like match", func() {
+			// Test filtering by partial name match using the "name" filter which maps to containsFilter("tag_value")
+			options := rest.QueryOptions{
+				Filters: map[string]interface{}{"name": "%rock%"},
+			}
+			count, err := restRepo.Count(options)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(BeNumerically("==", 2))
+		})
+	})
+
+	Describe("Read", func() {
+		It("should return existing genre", func() {
+			// Use one of the existing genres from our consolidated dataset
+			genreID := id.NewTagID("genre", "rock")
+			result, err := restRepo.Read(genreID)
+			Expect(err).ToNot(HaveOccurred())
+			genre := result.(*model.Genre)
+			Expect(genre.ID).To(Equal(genreID))
+			Expect(genre.Name).To(Equal("rock"))
+		})
+
+		It("should return error for non-existent genre", func() {
+			_, err := restRepo.Read("non-existent-id")
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("should not return non-genre tags", func() {
+			moodID := id.NewTagID("mood", "happy") // This exists as a mood tag, not genre
+			_, err := restRepo.Read(moodID)
+			Expect(err).To(HaveOccurred()) // Should not find it as a genre
+		})
+	})
+
+	Describe("ReadAll", func() {
+		It("should return all genres through ReadAll", func() {
+			result, err := restRepo.ReadAll()
+			Expect(err).ToNot(HaveOccurred())
+			genres := result.(model.Genres)
+			Expect(genres).To(HaveLen(12)) // We have 12 genre tags
+
+			genreNames := make([]string, len(genres))
+			for i, genre := range genres {
+				genreNames[i] = genre.Name
+			}
+			// Check for some of our consolidated dataset genres
+			Expect(genreNames).To(ContainElement("rock"))
+			Expect(genreNames).To(ContainElement("pop"))
+			Expect(genreNames).To(ContainElement("jazz"))
+		})
+
+		It("should support rest query options", func() {
+			result, err := restRepo.ReadAll()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result).ToNot(BeNil())
+		})
+	})
+
+	Describe("Library Filtering", func() {
+		Context("Headless Processes (No User Context)", func() {
+			var headlessRepo model.GenreRepository
+			var headlessRestRepo model.ResourceRepository
+
+			BeforeEach(func() {
+				// Create a repository with no user context (headless)
+				headlessGenreRepo := NewGenreRepository(context.Background(), GetDBXBuilder())
+				headlessRepo = headlessGenreRepo
+				headlessRestRepo = headlessGenreRepo.(model.ResourceRepository)
+
+				// Add genres to different libraries
+				db := GetDBXBuilder()
+				_, err := db.NewQuery("INSERT OR IGNORE INTO library (id, name, path) VALUES (2, 'Test Library 2', '/test2')").Execute()
+				Expect(err).ToNot(HaveOccurred())
+
+				// Add tags to different libraries
+				newTag := func(name, value string) model.Tag {
+					return model.Tag{ID: id.NewTagID(name, value), TagName: model.TagName(name), TagValue: value}
+				}
+
+				err = tagRepo.Add(2, newTag("genre", "jazz"))
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("should see all genres from all libraries when no user is in context", func() {
+				// Headless processes should see all genres regardless of library
+				genres, err := headlessRepo.GetAll()
+				Expect(err).ToNot(HaveOccurred())
+
+				// Should see genres from all libraries
+				var genreNames []string
+				for _, genre := range genres {
+					genreNames = append(genreNames, genre.Name)
+				}
+
+				// Should include both rock (library 1) and jazz (library 2)
+				Expect(genreNames).To(ContainElement("rock"))
+				Expect(genreNames).To(ContainElement("jazz"))
+			})
+
+			It("should count all genres from all libraries when no user is in context", func() {
+				count, err := headlessRestRepo.Count()
+				Expect(err).ToNot(HaveOccurred())
+
+				// Should count all genres from all libraries
+				Expect(count).To(BeNumerically(">=", 2))
+			})
+
+			It("should allow headless processes to apply explicit library_id filters", func() {
+				// Filter by specific library
+				genres, err := headlessRestRepo.ReadAll(rest.QueryOptions{
+					Filters: map[string]interface{}{"library_id": 2},
+				})
+				Expect(err).ToNot(HaveOccurred())
+
+				genreList := genres.(model.Genres)
+				// Should see only genres from library 2
+				Expect(genreList).To(HaveLen(1))
+				Expect(genreList[0].Name).To(Equal("jazz"))
+			})
+
+			It("should get individual genres when no user is in context", func() {
+				// Get all genres first to find an ID
+				genres, err := headlessRepo.GetAll()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(genres).ToNot(BeEmpty())
+
+				// Headless process should be able to get the genre
+				genre, err := headlessRestRepo.Read(genres[0].ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(genre).ToNot(BeNil())
+			})
+		})
+	})
+
+	Describe("EntityName", func() {
+		It("should return correct entity name", func() {
+			name := restRepo.EntityName()
+			Expect(name).To(Equal("tag")) // Genre repository uses tag table
+		})
+	})
+
+	Describe("NewInstance", func() {
+		It("should return new genre instance", func() {
+			instance := restRepo.NewInstance()
+			Expect(instance).To(BeAssignableToTypeOf(&model.Genre{}))
+		})
+	})
+})