mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-18 02:52:36 +03:00
* chore(lint): ban context.Background in tests, flag unused nolints Add a forbidigo rule that rejects context.Background and context.TODO in _test.go files. The lint message points to the right fix: the spec's ctx from GinkgoT().Context(), or t.Context() and b.Context() in plain tests and benchmarks. AGENTS.md already asks for this, but nothing enforced it, so new tests kept adding Background calls. All 465 existing calls are replaced, with one ctx per top-level Describe set at the top of its BeforeEach. The migration forbidigo rules keep their old scope through an exclusion matched on their message text. Also enable nolintlint with require-specific and allow-unused: false. It found 41 //nolint directives that suppressed nothing, or named no linter, or had a leading space that made them inert. They are removed or fixed. The sweep also fixed a middleware test that wrote a user with a nil ctx before ctx was set. * test: keep cleanup ROLLBACKs and the scanner singleton off the spec ctx The ROLLBACK cleanups in the library, plugin and initial setup tests must run even if the spec context is already cancelled, so they use context.WithoutCancel. The same goes for the context handed to the process-wide scanner singleton in the GetInstance test. Also document that the forbidigo exclusions are scoped by message text. * test: pass the caller's ctx to tests.ClearDB ClearDB was the last context.Background call in shared test code. It now takes a ctx, and every caller passes its spec ctx. The forbidigo rule for tests also covers the tests/ helper package now, so new helpers there cannot add Background calls either.
264 lines
8.6 KiB
Go
264 lines
8.6 KiB
Go
package persistence
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"github.com/Masterminds/squirrel"
|
|
"github.com/deluan/rest"
|
|
"github.com/navidrome/navidrome/conf"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("sqlRestful", func() {
|
|
var ctx context.Context
|
|
|
|
BeforeEach(func() {
|
|
ctx = GinkgoT().Context()
|
|
})
|
|
|
|
Describe("parseRestFilters", func() {
|
|
var r sqlRepository
|
|
var options rest.QueryOptions
|
|
|
|
BeforeEach(func() {
|
|
r = sqlRepository{}
|
|
})
|
|
|
|
It("returns nil if filters is empty", func() {
|
|
options.Filters = nil
|
|
Expect(r.parseRestFilters(ctx, options)).To(BeNil())
|
|
})
|
|
|
|
It(`returns nil if tries a filter with legacySearchExpr("'")`, func() {
|
|
conf.Update(func(c *conf.Options) { c.Search.Backend = "legacy" })
|
|
r.filterMappings = map[string]filterFunc{
|
|
"name": fullTextFilter("table"),
|
|
}
|
|
options.Filters = map[string]any{"name": "'"}
|
|
Expect(r.parseRestFilters(ctx, options)).To(BeEmpty())
|
|
})
|
|
|
|
It("does not add nill filters", func() {
|
|
r.filterMappings = map[string]filterFunc{
|
|
"name": func(string, any) squirrel.Sqlizer {
|
|
return nil
|
|
},
|
|
}
|
|
options.Filters = map[string]any{"name": "joe"}
|
|
Expect(r.parseRestFilters(ctx, options)).To(BeEmpty())
|
|
})
|
|
|
|
It("returns a '=' condition for 'id' filter", func() {
|
|
options.Filters = map[string]any{"id": "123"}
|
|
Expect(r.parseRestFilters(ctx, options)).To(Equal(squirrel.And{squirrel.Eq{"id": "123"}}))
|
|
})
|
|
|
|
It("returns a 'in' condition for multiples 'id' filters", func() {
|
|
options.Filters = map[string]any{"id": []string{"123", "456"}}
|
|
Expect(r.parseRestFilters(ctx, options)).To(Equal(squirrel.And{squirrel.Eq{"id": []string{"123", "456"}}}))
|
|
})
|
|
|
|
It("returns a 'like' condition for other filters", func() {
|
|
options.Filters = map[string]any{"name": "joe"}
|
|
Expect(r.parseRestFilters(ctx, options)).To(Equal(squirrel.And{squirrel.Like{"name": "joe%"}}))
|
|
})
|
|
|
|
It("uses the custom filter", func() {
|
|
r.filterMappings = map[string]filterFunc{
|
|
"test": func(field string, value any) squirrel.Sqlizer {
|
|
return squirrel.Gt{field: value}
|
|
},
|
|
}
|
|
options.Filters = map[string]any{"test": 100}
|
|
Expect(r.parseRestFilters(ctx, options)).To(Equal(squirrel.And{squirrel.Gt{"test": 100}}))
|
|
})
|
|
})
|
|
|
|
Describe("fullTextFilter function", func() {
|
|
var filter filterFunc
|
|
var tableName string
|
|
var mbidFields []string
|
|
|
|
BeforeEach(func() {
|
|
conf.Update(func(c *conf.Options) { c.Search.Backend = "legacy" })
|
|
tableName = "test_table"
|
|
mbidFields = []string{"mbid", "artist_mbid"}
|
|
filter = fullTextFilter(tableName, mbidFields...)
|
|
})
|
|
|
|
Context("when value is a valid UUID", func() {
|
|
It("returns only the mbid filter (precedence over full text)", func() {
|
|
uuid := "550e8400-e29b-41d4-a716-446655440000"
|
|
result := filter("search", uuid)
|
|
|
|
expected := squirrel.Or{
|
|
squirrel.Eq{"test_table.mbid": uuid},
|
|
squirrel.Eq{"test_table.artist_mbid": uuid},
|
|
}
|
|
Expect(result).To(Equal(expected))
|
|
})
|
|
|
|
It("falls back to full text when no mbid fields are provided", func() {
|
|
noMbidFilter := fullTextFilter(tableName)
|
|
uuid := "550e8400-e29b-41d4-a716-446655440000"
|
|
result := noMbidFilter("search", uuid)
|
|
|
|
// mbidExpr with no fields returns nil, so cmp.Or falls back to search strategy
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(ContainElement("% 550e8400-e29b-41d4-a716-446655440000%"))
|
|
})
|
|
})
|
|
|
|
Context("when value is not a valid UUID", func() {
|
|
It("returns full text search condition only", func() {
|
|
result := filter("search", "beatles")
|
|
|
|
// mbidExpr returns nil for non-UUIDs, so search strategy result is returned directly
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(ContainElement("% beatles%"))
|
|
})
|
|
|
|
It("handles multi-word search terms", func() {
|
|
result := filter("search", "the beatles abbey road")
|
|
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
// All words should be present as LIKE conditions
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(HaveLen(4))
|
|
Expect(args).To(ContainElement("% the%"))
|
|
Expect(args).To(ContainElement("% beatles%"))
|
|
Expect(args).To(ContainElement("% abbey%"))
|
|
Expect(args).To(ContainElement("% road%"))
|
|
})
|
|
})
|
|
|
|
Context("when SearchFullString config changes behavior", func() {
|
|
It("uses different separator with SearchFullString=false", func() {
|
|
conf.Update(func(c *conf.Options) { c.Search.FullString = false })
|
|
result := filter("search", "test query")
|
|
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(HaveLen(2))
|
|
Expect(args).To(ContainElement("% test%"))
|
|
Expect(args).To(ContainElement("% query%"))
|
|
})
|
|
|
|
It("uses no separator with SearchFullString=true", func() {
|
|
conf.Update(func(c *conf.Options) { c.Search.FullString = true })
|
|
result := filter("search", "test query")
|
|
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(HaveLen(2))
|
|
Expect(args).To(ContainElement("%test%"))
|
|
Expect(args).To(ContainElement("%query%"))
|
|
})
|
|
})
|
|
|
|
Context("single-character queries (regression: must not be rejected)", func() {
|
|
It("returns valid filter for single-char query with legacy backend", func() {
|
|
conf.Update(func(c *conf.Options) { c.Search.Backend = "legacy" })
|
|
result := filter("search", "a")
|
|
Expect(result).ToNot(BeNil(), "single-char REST filter must not be dropped")
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("LIKE"))
|
|
Expect(args).ToNot(BeEmpty())
|
|
})
|
|
|
|
It("returns valid filter for single-char query with FTS backend", func() {
|
|
conf.Update(func(c *conf.Options) {
|
|
c.Search.Backend = "fts"
|
|
c.Search.FullString = false
|
|
})
|
|
ftsFilter := fullTextFilter(tableName, mbidFields...)
|
|
result := ftsFilter("search", "a")
|
|
Expect(result).ToNot(BeNil(), "single-char REST filter must not be dropped")
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("MATCH"))
|
|
Expect(args).ToNot(BeEmpty())
|
|
})
|
|
})
|
|
|
|
Context("edge cases", func() {
|
|
It("returns nil for empty string", func() {
|
|
result := filter("search", "")
|
|
Expect(result).To(BeNil())
|
|
})
|
|
|
|
It("returns nil for string with only whitespace", func() {
|
|
result := filter("search", " ")
|
|
Expect(result).To(BeNil())
|
|
})
|
|
|
|
It("handles special characters that are sanitized", func() {
|
|
result := filter("search", "don't")
|
|
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(ContainElement("% dont%"))
|
|
})
|
|
|
|
It("returns nil for single quote (SQL injection protection)", func() {
|
|
result := filter("search", "'")
|
|
Expect(result).To(BeNil())
|
|
})
|
|
|
|
It("handles mixed case UUIDs", func() {
|
|
uuid := "550E8400-E29B-41D4-A716-446655440000"
|
|
result := filter("search", uuid)
|
|
|
|
// Should return only mbid filter (uppercase UUID should work)
|
|
expected := squirrel.Or{
|
|
squirrel.Eq{"test_table.mbid": strings.ToLower(uuid)},
|
|
squirrel.Eq{"test_table.artist_mbid": strings.ToLower(uuid)},
|
|
}
|
|
Expect(result).To(Equal(expected))
|
|
})
|
|
|
|
It("handles invalid UUID format gracefully", func() {
|
|
result := filter("search", "550e8400-invalid-uuid")
|
|
|
|
// Should return full text filter since UUID is invalid
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(ContainElement("% 550e8400-invalid-uuid%"))
|
|
})
|
|
|
|
It("handles empty mbid fields array", func() {
|
|
emptyMbidFilter := fullTextFilter(tableName, []string{}...)
|
|
result := emptyMbidFilter("search", "test")
|
|
|
|
// mbidExpr with empty fields returns nil, so search strategy result is returned directly
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(ContainElement("% test%"))
|
|
})
|
|
|
|
It("converts value to lowercase before processing", func() {
|
|
result := filter("search", "TEST")
|
|
|
|
sql, args, err := result.ToSql()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(sql).To(ContainSubstring("test_table.full_text LIKE"))
|
|
Expect(args).To(ContainElement("% test%"))
|
|
})
|
|
})
|
|
})
|
|
|
|
})
|