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.
368 lines
13 KiB
Go
368 lines
13 KiB
Go
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/navidrome/navidrome/model"
|
|
"github.com/navidrome/navidrome/plugins"
|
|
"github.com/navidrome/navidrome/tests"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var samplePlugins = model.Plugins{
|
|
{ID: "alpha", Manifest: `{"name":"Alpha","version":"1.0.0","author":"me"}`, Enabled: true},
|
|
{ID: "beta", Manifest: `{"name":"Beta","version":"2.1.0","author":"me"}`, Enabled: false, LastError: "boom"},
|
|
}
|
|
|
|
var _ = Describe("plugin command format flags", func() {
|
|
// Regression: list and info must not share a format variable. Binding the
|
|
// same var on both commands makes the last init() registration clobber the
|
|
// other's default, breaking `plugin list` with no -f flag.
|
|
It("defaults `list -f` to table", func() {
|
|
Expect(pluginListCmd.Flags().Lookup("format").DefValue).To(Equal("table"))
|
|
})
|
|
|
|
It("defaults `info -f` to text", func() {
|
|
Expect(pluginInfoCmd.Flags().Lookup("format").DefValue).To(Equal("text"))
|
|
})
|
|
})
|
|
|
|
var _ = Describe("formatPluginList", func() {
|
|
It("renders csv with a header and one row per plugin", func() {
|
|
out, err := formatPluginList(samplePlugins, "csv")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
lines := strings.Split(strings.TrimSpace(out), "\n")
|
|
Expect(lines).To(HaveLen(3)) // header + 2 rows
|
|
Expect(lines[0]).To(ContainSubstring("id"))
|
|
Expect(out).To(ContainSubstring("alpha"))
|
|
Expect(out).To(ContainSubstring("beta"))
|
|
})
|
|
|
|
It("renders valid json", func() {
|
|
out, err := formatPluginList(samplePlugins, "json")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
var got []map[string]any
|
|
Expect(json.Unmarshal([]byte(out), &got)).To(Succeed())
|
|
Expect(got).To(HaveLen(2))
|
|
})
|
|
|
|
It("renders a human table by default", func() {
|
|
out, err := formatPluginList(samplePlugins, "table")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("Alpha"))
|
|
Expect(out).To(ContainSubstring("1.0.0"))
|
|
})
|
|
|
|
It("errors on an unknown format", func() {
|
|
_, err := formatPluginList(samplePlugins, "yaml")
|
|
Expect(err).To(HaveOccurred())
|
|
})
|
|
})
|
|
|
|
var _ = Describe("enable/disable plugin", func() {
|
|
var ctx context.Context
|
|
BeforeEach(func() {
|
|
ctx = GinkgoT().Context()
|
|
})
|
|
|
|
It("calls EnablePlugin on the manager", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
err := enablePlugin(ctx, mgr, "alpha")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.EnablePluginCalls).To(Equal([]string{"alpha"}))
|
|
})
|
|
|
|
It("calls DisablePlugin on the manager", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
err := disablePlugin(ctx, mgr, "beta")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.DisablePluginCalls).To(Equal([]string{"beta"}))
|
|
})
|
|
})
|
|
|
|
var _ = Describe("applyPluginEdit", func() {
|
|
var cur *model.Plugin
|
|
var ctx context.Context
|
|
BeforeEach(func() {
|
|
ctx = GinkgoT().Context()
|
|
cur = &model.Plugin{ID: "alpha", Users: `["bob"]`, Libraries: `[1,2]`, AllowWriteAccess: true}
|
|
})
|
|
|
|
It("validates then updates config when config is provided", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
cfg := `{"key":"val"}`
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{config: &cfg})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.ValidatePluginConfigCalls).To(HaveLen(1))
|
|
Expect(mgr.ValidatePluginConfigCalls[0].ConfigJSON).To(Equal(cfg))
|
|
Expect(mgr.UpdatePluginConfigCalls).To(HaveLen(1))
|
|
Expect(mgr.UpdatePluginConfigCalls[0].ConfigJSON).To(Equal(cfg))
|
|
})
|
|
|
|
It("updates users with allUsers flag", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
all := true
|
|
err := applyPluginEdit(ctx, mgr, cur,
|
|
pluginEditOptions{allUsers: &all})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginUsersCalls).To(HaveLen(1))
|
|
Expect(mgr.UpdatePluginUsersCalls[0].AllUsers).To(BeTrue())
|
|
})
|
|
|
|
It("updates libraries with allLibraries and write access", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
all := true
|
|
wr := true
|
|
err := applyPluginEdit(ctx, mgr, cur,
|
|
pluginEditOptions{allLibraries: &all, writeAccess: &wr})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginLibrariesCalls).To(HaveLen(1))
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].AllLibraries).To(BeTrue())
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].AllowWriteAccess).To(BeTrue())
|
|
})
|
|
|
|
It("preserves existing fields when only the write-access flag changes", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
no := false
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{writeAccess: &no})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginLibrariesCalls).To(HaveLen(1))
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].LibrariesJSON).To(Equal(`[1,2]`)) // not wiped
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].AllowWriteAccess).To(BeFalse())
|
|
})
|
|
|
|
It("preserves existing users when only the all-users flag changes", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
all := true
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{allUsers: &all})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginUsersCalls[0].UsersJSON).To(Equal(`["bob"]`)) // not wiped
|
|
})
|
|
|
|
It("parses a comma-separated users value into a JSON array", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
users := "alice, bob"
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{users: &users})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginUsersCalls[0].UsersJSON).To(Equal(`["alice","bob"]`))
|
|
})
|
|
|
|
It("passes a JSON-array users value through unchanged", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
users := `["alice","bob"]`
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{users: &users})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginUsersCalls[0].UsersJSON).To(Equal(`["alice","bob"]`))
|
|
})
|
|
|
|
It("rejects a malformed JSON-array users value", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
users := `["alice"`
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{users: &users})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(mgr.UpdatePluginUsersCalls).To(BeEmpty())
|
|
})
|
|
|
|
It("parses a comma-separated libraries value into a JSON array of ints", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
libs := "1, 2"
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{libraries: &libs})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].LibrariesJSON).To(Equal(`[1,2]`))
|
|
})
|
|
|
|
It("rejects a non-integer library ID", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
libs := "1,abc"
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{libraries: &libs})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(mgr.UpdatePluginLibrariesCalls).To(BeEmpty())
|
|
})
|
|
|
|
It("clears allUsers when an explicit users list is set", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
cur.AllUsers = true
|
|
users := "alice"
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{users: &users})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginUsersCalls[0].UsersJSON).To(Equal(`["alice"]`))
|
|
Expect(mgr.UpdatePluginUsersCalls[0].AllUsers).To(BeFalse())
|
|
})
|
|
|
|
It("clears allLibraries when an explicit libraries list is set", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
cur.AllLibraries = true
|
|
libs := "1"
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{libraries: &libs})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].LibrariesJSON).To(Equal(`[1]`))
|
|
Expect(mgr.UpdatePluginLibrariesCalls[0].AllLibraries).To(BeFalse())
|
|
})
|
|
|
|
It("does nothing and errors when no fields are set", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{})
|
|
Expect(err).To(HaveOccurred())
|
|
})
|
|
|
|
It("aborts the config update when validation fails", func() {
|
|
mgr := &tests.MockPluginManager{ValidateError: errors.New("bad config")}
|
|
cfg := `{"key":"val"}`
|
|
err := applyPluginEdit(ctx, mgr, cur, pluginEditOptions{config: &cfg})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(mgr.ValidatePluginConfigCalls).To(HaveLen(1))
|
|
Expect(mgr.UpdatePluginConfigCalls).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
var _ = Describe("isPackagePath", func() {
|
|
It("is true for any .ndp path", func() {
|
|
Expect(isPackagePath("/some/dir/x.ndp")).To(BeTrue())
|
|
})
|
|
It("is true for a non-existent .ndp path (so ReadManifest reports the error)", func() {
|
|
Expect(isPackagePath("/nope/x.ndp")).To(BeTrue())
|
|
})
|
|
It("is false for a bare plugin id", func() {
|
|
Expect(isPackagePath("my-plugin")).To(BeFalse())
|
|
})
|
|
})
|
|
|
|
var _ = Describe("formatPluginInfo", func() {
|
|
It("renders installed plugin details as text", func() {
|
|
p := &model.Plugin{ID: "alpha", Manifest: `{"name":"Alpha","version":"1.0.0","author":"me"}`, Enabled: true}
|
|
out, err := formatPluginInfo(p, "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("alpha"))
|
|
Expect(out).To(ContainSubstring("Alpha"))
|
|
})
|
|
It("renders json", func() {
|
|
p := &model.Plugin{ID: "alpha", Manifest: `{}`}
|
|
out, err := formatPluginInfo(p, "json")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("alpha"))
|
|
})
|
|
})
|
|
|
|
var _ = Describe("formatManifestInfo", func() {
|
|
It("renders text with name, version, author", func() {
|
|
m := &plugins.Manifest{Name: "My Plugin", Version: "2.0.0", Author: "me"}
|
|
out, err := formatManifestInfo(m, "abc123", "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("My Plugin"))
|
|
Expect(out).To(ContainSubstring("2.0.0"))
|
|
Expect(out).To(ContainSubstring("me"))
|
|
})
|
|
|
|
It("omits Description and Website when nil", func() {
|
|
m := &plugins.Manifest{Name: "X", Version: "1.0.0", Author: "a"}
|
|
out, err := formatManifestInfo(m, "abc123", "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).ToNot(ContainSubstring("Description:"))
|
|
Expect(out).ToNot(ContainSubstring("Website:"))
|
|
})
|
|
|
|
It("includes Description and Website when set", func() {
|
|
desc := "a cool plugin"
|
|
site := "https://example.com"
|
|
m := &plugins.Manifest{Name: "X", Version: "1.0.0", Author: "a", Description: &desc, Website: &site}
|
|
out, err := formatManifestInfo(m, "abc123", "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("a cool plugin"))
|
|
Expect(out).To(ContainSubstring("https://example.com"))
|
|
})
|
|
|
|
It("renders valid json", func() {
|
|
m := &plugins.Manifest{Name: "X", Version: "1.0.0", Author: "a"}
|
|
out, err := formatManifestInfo(m, "abc123", "json")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("\"name\""))
|
|
})
|
|
})
|
|
|
|
var _ = Describe("formatPluginInfo enriched text", func() {
|
|
var fixedTime time.Time
|
|
|
|
BeforeEach(func() {
|
|
fixedTime = time.Date(2025, 1, 15, 12, 0, 0, 0, time.UTC)
|
|
})
|
|
|
|
It("includes Users, Libraries, Permissions, Created, Updated in text output", func() {
|
|
p := &model.Plugin{
|
|
ID: "myplugin",
|
|
Manifest: `{"name":"My Plugin","version":"1.0.0","author":"me","permissions":{"users":{},"subsonicapi":{}}}`,
|
|
Enabled: true,
|
|
Users: "alice,bob",
|
|
Libraries: "1,2",
|
|
CreatedAt: fixedTime,
|
|
UpdatedAt: fixedTime.Add(time.Hour),
|
|
}
|
|
out, err := formatPluginInfo(p, "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("alice,bob"))
|
|
Expect(out).To(ContainSubstring("1,2"))
|
|
Expect(out).To(ContainSubstring("subsonicapi"))
|
|
Expect(out).To(ContainSubstring("users"))
|
|
Expect(out).To(ContainSubstring("2025-01-15T12:00:00Z"))
|
|
})
|
|
|
|
It("omits Users and Libraries lines when empty", func() {
|
|
p := &model.Plugin{
|
|
ID: "myplugin",
|
|
Manifest: `{"name":"X","version":"1.0.0","author":"me"}`,
|
|
CreatedAt: fixedTime,
|
|
UpdatedAt: fixedTime,
|
|
}
|
|
out, err := formatPluginInfo(p, "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).ToNot(ContainSubstring("Users:"))
|
|
Expect(out).ToNot(ContainSubstring("Libraries:"))
|
|
})
|
|
|
|
It("does not alter json output", func() {
|
|
p := &model.Plugin{ID: "x", Manifest: `{}`, Users: "alice"}
|
|
out, err := formatPluginInfo(p, "json")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring(`"x"`))
|
|
})
|
|
})
|
|
|
|
var _ = Describe("formatManifestInfo enriched text", func() {
|
|
It("includes Permissions when declared", func() {
|
|
p := &plugins.Permissions{Http: &plugins.HTTPPermission{}}
|
|
m := &plugins.Manifest{Name: "P", Version: "1.0.0", Author: "a", Permissions: p}
|
|
out, err := formatManifestInfo(m, "abc123", "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring("http"))
|
|
Expect(out).To(ContainSubstring("Permissions:"))
|
|
})
|
|
|
|
It("omits Permissions line when no permissions declared", func() {
|
|
m := &plugins.Manifest{Name: "P", Version: "1.0.0", Author: "a"}
|
|
out, err := formatManifestInfo(m, "abc123", "text")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).ToNot(ContainSubstring("Permissions:"))
|
|
})
|
|
|
|
It("does not alter json output", func() {
|
|
p := &plugins.Permissions{Http: &plugins.HTTPPermission{}}
|
|
m := &plugins.Manifest{Name: "P", Version: "1.0.0", Author: "a", Permissions: p}
|
|
out, err := formatManifestInfo(m, "abc123", "json")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(out).To(ContainSubstring(`"name"`))
|
|
})
|
|
})
|
|
|
|
var _ = Describe("rescanPlugins", func() {
|
|
It("calls RescanPlugins on the manager", func() {
|
|
mgr := &tests.MockPluginManager{}
|
|
err := rescanPlugins(GinkgoT().Context(), mgr)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(mgr.RescanPluginsCalls).To(Equal(1))
|
|
})
|
|
})
|