Every 15 minutes (library.auto_scan_minutes, SONDA_AUTO_SCAN_MINUTES, 0 turns it off) Sonda takes the signature of each library, a hash of the names of everything in it folder by folder, which costs only the names of the files and so suits a NAS that sleeps. A library whose signature changed (a song or a folder came, went or was renamed) is scanned the usual way; every library is also scanned at least once a day, to find a song tagged again where it stands. It does not scan while another scan runs, tries again at the next look when a scan failed, leaves alone a folder that cannot be read (a NAS that is not mounted), and ignores the housekeeping folders of a NAS.
366 lines
13 KiB
Go
366 lines
13 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func writeFile(t *testing.T, dir, content string) string {
|
|
t.Helper()
|
|
p := filepath.Join(dir, "sonda.toml")
|
|
if err := os.WriteFile(p, []byte(content), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return p
|
|
}
|
|
|
|
func TestLoadEmptyPathReturnsDefaults(t *testing.T) {
|
|
cfg, err := Load("")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Server.Listen != "127.0.0.1:8080" {
|
|
t.Errorf("listen = %q", cfg.Server.Listen)
|
|
}
|
|
if cfg.Database.Path != "sonda.db" {
|
|
t.Errorf("db path = %q", cfg.Database.Path)
|
|
}
|
|
if cfg.Database.Driver != "sqlite" {
|
|
t.Errorf("db driver = %q", cfg.Database.Driver)
|
|
}
|
|
if cfg.Log.Env != "production" {
|
|
t.Errorf("env = %q", cfg.Log.Env)
|
|
}
|
|
if cfg.Library.ScanWorkers != 4 {
|
|
t.Errorf("scan workers = %d", cfg.Library.ScanWorkers)
|
|
}
|
|
if cfg.Library.AutoScanMinutes != 15 {
|
|
t.Errorf("auto scan = %d minutes, want 15", cfg.Library.AutoScanMinutes)
|
|
}
|
|
if cfg.Listening.MinListen() != 20*time.Second {
|
|
t.Errorf("min listen = %v, want 20s", cfg.Listening.MinListen())
|
|
}
|
|
if cfg.Auth.AccessTTL() != 15*time.Minute {
|
|
t.Errorf("access ttl = %v", cfg.Auth.AccessTTL())
|
|
}
|
|
if cfg.Auth.RefreshTTL() != 720*time.Hour {
|
|
t.Errorf("refresh ttl = %v", cfg.Auth.RefreshTTL())
|
|
}
|
|
}
|
|
|
|
func TestLoadFileOverridesDefaults(t *testing.T) {
|
|
dir := t.TempDir()
|
|
p := writeFile(t, dir, `
|
|
[server]
|
|
listen = "0.0.0.0:9000"
|
|
|
|
[library]
|
|
scan_workers = 9
|
|
|
|
`)
|
|
cfg, err := Load(p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Server.Listen != "0.0.0.0:9000" {
|
|
t.Errorf("listen = %q", cfg.Server.Listen)
|
|
}
|
|
if cfg.Library.ScanWorkers != 9 {
|
|
t.Errorf("scan workers = %d", cfg.Library.ScanWorkers)
|
|
}
|
|
// untouched keys keep their defaults
|
|
if cfg.Database.Path != "sonda.db" {
|
|
t.Errorf("db path = %q", cfg.Database.Path)
|
|
}
|
|
}
|
|
|
|
func TestLoadEnvOverridesFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
p := writeFile(t, dir, "[log]\nenv = \"production\"\n")
|
|
t.Setenv("SONDA_ENV", "dev")
|
|
t.Setenv("SONDA_LISTEN", "127.0.0.1:1")
|
|
t.Setenv("SONDA_DB_PATH", "x.db")
|
|
t.Setenv("SONDA_DB_DRIVER", "postgres")
|
|
t.Setenv("SONDA_DB_DSN", "postgres://u:p@h/db")
|
|
t.Setenv("SONDA_JWT_SECRET", "envsecret")
|
|
cfg, err := Load(p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Log.Env != "dev" || cfg.Server.Listen != "127.0.0.1:1" ||
|
|
cfg.Database.Path != "x.db" ||
|
|
cfg.Auth.JWTSecret != "envsecret" ||
|
|
cfg.Database.Driver != "postgres" || cfg.Database.DSN != "postgres://u:p@h/db" {
|
|
t.Errorf("env not applied: %+v", cfg)
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsUnknownField(t *testing.T) {
|
|
dir := t.TempDir()
|
|
p := writeFile(t, dir, "[server]\nlisten_addr = \"x\"\n")
|
|
if _, err := Load(p); err == nil {
|
|
t.Fatal("expected error for unknown field")
|
|
}
|
|
}
|
|
|
|
func TestLoadMissingFile(t *testing.T) {
|
|
if _, err := Load(filepath.Join(t.TempDir(), "nope.toml")); err == nil {
|
|
t.Fatal("expected error for missing file")
|
|
}
|
|
}
|
|
|
|
func TestValidate(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mutate func(*Config)
|
|
wantErr string
|
|
}{
|
|
{"ok", func(c *Config) {}, ""},
|
|
{"bad env", func(c *Config) { c.Log.Env = "staging" }, "log.env"},
|
|
{"empty listen", func(c *Config) { c.Server.Listen = "" }, "server.listen"},
|
|
{"empty db", func(c *Config) { c.Database.Path = "" }, "database.path"},
|
|
{"bad driver", func(c *Config) { c.Database.Driver = "mysql" }, "database.driver"},
|
|
{"postgres without dsn", func(c *Config) { c.Database.Driver = "postgres" }, "database.dsn"},
|
|
{"postgres ok", func(c *Config) {
|
|
c.Database.Driver = "postgres"
|
|
c.Database.Path = ""
|
|
c.Database.DSN = "postgres://u:p@localhost/db"
|
|
}, ""},
|
|
{"no secret", func(c *Config) { c.Auth.JWTSecret = "" }, "auth.jwt_secret"},
|
|
{"short secret", func(c *Config) { c.Auth.JWTSecret = "short" }, "auth.jwt_secret"},
|
|
{"zero min listen", func(c *Config) { c.Listening.MinListenSeconds = 0 }, "listening.min_listen_seconds"},
|
|
{"negative min listen", func(c *Config) { c.Listening.MinListenSeconds = -5 }, "listening.min_listen_seconds"},
|
|
{"absurd min listen", func(c *Config) { c.Listening.MinListenSeconds = 3601 }, "listening.min_listen_seconds"},
|
|
{"zero half life", func(c *Config) { c.Taste.HalfLifeDays = 0 }, "taste.half_life_days"},
|
|
{"negative half life", func(c *Config) { c.Taste.HalfLifeDays = -1 }, "taste.half_life_days"},
|
|
{"absurd half life", func(c *Config) { c.Taste.HalfLifeDays = 3651 }, "taste.half_life_days"},
|
|
{"negative weight", func(c *Config) { c.Scoring.WeightGenre = -0.1 }, "scoring.weight_genre"},
|
|
{"huge weight", func(c *Config) { c.Scoring.WeightAffinity = 11 }, "scoring.weight_affinity"},
|
|
{"all weights zero", func(c *Config) { c.Scoring = Scoring{} }, "scoring.weight"},
|
|
{"one weight is enough", func(c *Config) { c.Scoring = Scoring{WeightPreference: 1} }, ""},
|
|
{"no wikipedia language", func(c *Config) { c.Wikipedia.Languages = nil }, "wikipedia.languages"},
|
|
{"a bad wikipedia language", func(c *Config) { c.Wikipedia.Languages = []string{"it", "Italian"} }, "wikipedia.languages"},
|
|
{"a wikipedia language with a hyphen", func(c *Config) { c.Wikipedia.Languages = []string{"zh-yue"} }, "wikipedia.languages"},
|
|
{"a repeated wikipedia language", func(c *Config) { c.Wikipedia.Languages = []string{"it", "it"} }, "wikipedia.languages"},
|
|
{"too many wikipedia languages", func(c *Config) { c.Wikipedia.Languages = []string{"aa", "bb", "cc", "dd", "ee", "ff"} }, "wikipedia.languages"},
|
|
{"two wikipedia languages", func(c *Config) { c.Wikipedia.Languages = []string{"it", "en"} }, ""},
|
|
{"empty data dir", func(c *Config) { c.Storage.DataDir = "" }, "storage.data_dir"},
|
|
{"bad workers", func(c *Config) { c.Library.ScanWorkers = 0 }, "library.scan_workers"},
|
|
{"a negative auto scan", func(c *Config) { c.Library.AutoScanMinutes = -1 }, "library.auto_scan_minutes"},
|
|
{"an auto scan of a year", func(c *Config) { c.Library.AutoScanMinutes = 525600 }, "library.auto_scan_minutes"},
|
|
{"auto scan off", func(c *Config) { c.Library.AutoScanMinutes = 0 }, ""},
|
|
{"bad access ttl", func(c *Config) { c.Auth.AccessTTLMinutes = 0 }, "auth.access_ttl_minutes"},
|
|
{"bad refresh ttl", func(c *Config) { c.Auth.RefreshTTLHours = 0 }, "auth.refresh_ttl_hours"},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg, err := Load("")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg.Auth.JWTSecret = strings.Repeat("s", 32)
|
|
tt.mutate(&cfg)
|
|
err = cfg.Validate()
|
|
if tt.wantErr == "" {
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
return
|
|
}
|
|
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
|
|
t.Fatalf("err = %v, want containing %q", err, tt.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// library.roots moved into the database; an old config must fail with a hint,
|
|
// not with a bare "unknown key".
|
|
func TestLoadExplainsRemovedLibraryRoots(t *testing.T) {
|
|
p := writeFile(t, t.TempDir(), "[library]\nroots = [\"/music\"]\n")
|
|
_, err := Load(p)
|
|
if err == nil {
|
|
t.Fatal("expected an error for library.roots")
|
|
}
|
|
if !strings.Contains(err.Error(), "library.roots") || !strings.Contains(err.Error(), "/api/v1/libraries") {
|
|
t.Errorf("error = %v, want a pointer to the libraries API", err)
|
|
}
|
|
}
|
|
|
|
func TestListeningSettingIsReadFromTheFile(t *testing.T) {
|
|
p := writeFile(t, t.TempDir(), "[listening]\nmin_listen_seconds = 30\n")
|
|
cfg, err := Load(p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Listening.MinListen() != 30*time.Second {
|
|
t.Errorf("min listen = %v", cfg.Listening.MinListen())
|
|
}
|
|
}
|
|
|
|
func TestTasteSettingIsReadFromTheFile(t *testing.T) {
|
|
cfg, err := Load(writeFile(t, t.TempDir(), "[taste]\nhalf_life_days = 30\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Taste.HalfLife() != 30*24*time.Hour {
|
|
t.Errorf("half life = %v", cfg.Taste.HalfLife())
|
|
}
|
|
if def := Default().Taste.HalfLife(); def != 90*24*time.Hour {
|
|
t.Errorf("default half life = %v, want 90 days", def)
|
|
}
|
|
}
|
|
|
|
func TestScoringDefaultsAndFile(t *testing.T) {
|
|
def := Default().Scoring
|
|
if def.WeightAffinity != 0.40 || def.WeightGenre != 0.25 || def.WeightPreference != 0.25 || def.WeightDiscovery != 0.10 {
|
|
t.Errorf("default weights = %+v", def)
|
|
}
|
|
cfg, err := Load(writeFile(t, t.TempDir(), "[scoring]\nweight_affinity = 1\nweight_genre = 0\nweight_preference = 0\nweight_discovery = 0\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Scoring.WeightAffinity != 1 || cfg.Scoring.WeightGenre != 0 {
|
|
t.Errorf("weights = %+v", cfg.Scoring)
|
|
}
|
|
// A weight left out of the file keeps its default.
|
|
cfg, err = Load(writeFile(t, t.TempDir(), "[scoring]\nweight_genre = 0.5\n"))
|
|
if err != nil || cfg.Scoring.WeightAffinity != 0.40 || cfg.Scoring.WeightGenre != 0.5 {
|
|
t.Errorf("weights = %+v err=%v", cfg.Scoring, err)
|
|
}
|
|
}
|
|
|
|
func TestWikipediaLanguages(t *testing.T) {
|
|
if got := Default().Wikipedia.Languages; len(got) != 1 || got[0] != "en" {
|
|
t.Errorf("default languages = %v, want [en]", got)
|
|
}
|
|
cfg, err := Load(writeFile(t, t.TempDir(), "[wikipedia]\nlanguages = [\"it\", \"en\"]\n"))
|
|
if err != nil || len(cfg.Wikipedia.Languages) != 2 || cfg.Wikipedia.Languages[0] != "it" {
|
|
t.Errorf("languages = %v err = %v", cfg.Wikipedia.Languages, err)
|
|
}
|
|
}
|
|
|
|
func TestStorageDataDirDefaultsNextToTheDatabase(t *testing.T) {
|
|
for name, tt := range map[string]struct{ toml, want string }{
|
|
"default database": {"", "data"},
|
|
"database elsewhere": {"[database]\npath = \"/var/lib/sonda/sonda.db\"\n", "/var/lib/sonda/data"},
|
|
"relative database": {"[database]\npath = \"state/sonda.db\"\n", "state/data"},
|
|
"set explicitly": {"[database]\npath = \"/var/lib/sonda/sonda.db\"\n[storage]\ndata_dir = \"/srv/x\"\n", "/srv/x"},
|
|
"postgres": {"[database]\ndriver = \"postgres\"\ndsn = \"postgres://u:p@h/d\"\npath = \"\"\n", "data"},
|
|
} {
|
|
cfg, err := Load(writeFile(t, t.TempDir(), tt.toml))
|
|
if err != nil || cfg.Storage.DataDir != tt.want {
|
|
t.Errorf("%s: data dir = %q err=%v, want %q", name, cfg.Storage.DataDir, err, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStorageDataDir(t *testing.T) {
|
|
cfg, err := Load(writeFile(t, t.TempDir(), "[storage]\ndata_dir = \"/srv/sonda\"\n"))
|
|
if err != nil || cfg.Storage.DataDir != "/srv/sonda" {
|
|
t.Errorf("data dir = %q err=%v", cfg.Storage.DataDir, err)
|
|
}
|
|
t.Setenv("SONDA_DATA_DIR", "/var/lib/sonda")
|
|
if cfg, err = Load(""); err != nil || cfg.Storage.DataDir != "/var/lib/sonda" {
|
|
t.Errorf("from the environment: %q err=%v", cfg.Storage.DataDir, err)
|
|
}
|
|
}
|
|
|
|
// Provider settings moved into the database. An old config must fail with a
|
|
// hint, never be ignored in silence.
|
|
func TestLoadExplainsRemovedProviderSettings(t *testing.T) {
|
|
p := writeFile(t, t.TempDir(), "[providers.lastfm]\napi_key = \"0123456789abcdef0123456789abcdef\"\n")
|
|
_, err := Load(p)
|
|
if err == nil {
|
|
t.Fatal("expected an error for the providers section")
|
|
}
|
|
if !strings.Contains(err.Error(), "providers") || !strings.Contains(err.Error(), "/api/v1/providers") {
|
|
t.Errorf("error = %v, want a pointer to the providers API", err)
|
|
}
|
|
if strings.Contains(err.Error(), "0123456789abcdef") {
|
|
t.Errorf("the error repeats the key: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestLoadRefusesTheOldLastFMEnvironmentVariable(t *testing.T) {
|
|
t.Setenv("SONDA_LASTFM_API_KEY", "0123456789abcdef0123456789abcdef")
|
|
_, err := Load("")
|
|
if err == nil {
|
|
t.Fatal("expected an error: the variable is no longer read, so it must not be ignored silently")
|
|
}
|
|
if !strings.Contains(err.Error(), "SONDA_LASTFM_API_KEY") || !strings.Contains(err.Error(), "/api/v1/providers") {
|
|
t.Errorf("error = %v", err)
|
|
}
|
|
if strings.Contains(err.Error(), "0123456789abcdef") {
|
|
t.Errorf("the error repeats the key: %v", err)
|
|
}
|
|
}
|
|
|
|
// Deleting files from the music folders is the one thing Sonda does not do unless it is told to.
|
|
func TestDeletingIsOffByDefault(t *testing.T) {
|
|
cfg, err := Load("")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Library.AllowDelete {
|
|
t.Error("library.allow_delete is on by default")
|
|
}
|
|
}
|
|
|
|
func TestAllowDeleteIsReadFromTheFile(t *testing.T) {
|
|
cfg, err := Load(writeFile(t, t.TempDir(), "[library]\nallow_delete = true\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !cfg.Library.AllowDelete {
|
|
t.Error("allow_delete = true in the file was not read")
|
|
}
|
|
}
|
|
|
|
func TestAllowDeleteEnvironmentVariableWinsOverTheFile(t *testing.T) {
|
|
p := writeFile(t, t.TempDir(), "[library]\nallow_delete = true\n")
|
|
t.Setenv("SONDA_ALLOW_DELETE", "false")
|
|
cfg, err := Load(p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Library.AllowDelete {
|
|
t.Error("SONDA_ALLOW_DELETE=false did not turn it off")
|
|
}
|
|
t.Setenv("SONDA_ALLOW_DELETE", "true")
|
|
cfg, err = Load("")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !cfg.Library.AllowDelete {
|
|
t.Error("SONDA_ALLOW_DELETE=true did not turn it on")
|
|
}
|
|
}
|
|
|
|
// A typo in a setting that lets Sonda delete files must not be ignored in silence.
|
|
func TestAllowDeleteEnvironmentVariableMustBeABoolean(t *testing.T) {
|
|
t.Setenv("SONDA_ALLOW_DELETE", "yes please")
|
|
if _, err := Load(""); err == nil || !strings.Contains(err.Error(), "SONDA_ALLOW_DELETE") {
|
|
t.Errorf("got %v, want an error naming SONDA_ALLOW_DELETE", err)
|
|
}
|
|
}
|
|
|
|
func TestTheAutoScanComesFromTheFileOrTheEnvironment(t *testing.T) {
|
|
dir := t.TempDir()
|
|
p := writeFile(t, dir, "[library]\nauto_scan_minutes = 5\n")
|
|
cfg, err := Load(p)
|
|
if err != nil || cfg.Library.AutoScanMinutes != 5 {
|
|
t.Fatalf("file: %d %v", cfg.Library.AutoScanMinutes, err)
|
|
}
|
|
t.Setenv("SONDA_AUTO_SCAN_MINUTES", "0")
|
|
if cfg, err = Load(p); err != nil || cfg.Library.AutoScanMinutes != 0 {
|
|
t.Fatalf("environment over file: %d %v", cfg.Library.AutoScanMinutes, err)
|
|
}
|
|
t.Setenv("SONDA_AUTO_SCAN_MINUTES", "often")
|
|
if _, err = Load(""); err == nil {
|
|
t.Fatal("a value that is not a number was taken")
|
|
}
|
|
}
|