- Asking whether Lidarr has an artist keeps the answer for a minute, asks once however many ask at once, and has at most four questions on their way; what cannot be answered is not kept, and a send forgets what was kept. - An id that is not a MusicBrainz id (one that a provider named and that was only cleaned) is no id: it is refused or shown as no_id instead of becoming a 500. - A send that waits for its turn gives up when its request does. - A bad answer after the add also says the artist may have been added; a canceled send ends like the other canceled requests. - The README says which artists can be sent.
281 lines
12 KiB
Go
281 lines
12 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/uptrace/bun"
|
|
|
|
"codeberg.org/squidd/sonda/internal/discovery"
|
|
"codeberg.org/squidd/sonda/internal/providers/lidarr"
|
|
)
|
|
|
|
const lidarrAPIKey = "fedcba9876543210fedcba9876543210"
|
|
|
|
type fakeLidarr struct {
|
|
options lidarr.Options
|
|
err error
|
|
asked int
|
|
}
|
|
|
|
func (f *fakeLidarr) Options(context.Context) (lidarr.Options, error) {
|
|
f.asked++
|
|
return f.options, f.err
|
|
}
|
|
|
|
func newLidarrAPI(t *testing.T) (http.Handler, *fakeLidarr, string, string) {
|
|
t.Helper()
|
|
fake := &fakeLidarr{options: lidarr.Options{
|
|
QualityProfiles: []lidarr.Profile{{ID: 1, Name: "Any"}, {ID: 2, Name: "Lossless"}},
|
|
MetadataProfiles: []lidarr.Profile{{ID: 1, Name: "Standard"}},
|
|
RootFolders: []lidarr.RootFolder{{Path: "/music", Accessible: true}},
|
|
}}
|
|
h, _ := newTestEnvDB(t, func(d *Deps, _ *bun.DB) { d.Lidarr = fake })
|
|
admin := registerAndLogin(t, h)
|
|
_, bob := addUser(t, h, admin, "bob", false)
|
|
return h, fake, admin, bob
|
|
}
|
|
|
|
func TestLidarrIsListedLastWithItsAddressAndOptions(t *testing.T) {
|
|
h, _, admin, _ := newLidarrAPI(t)
|
|
list := do(t, h, "GET", "/api/v1/providers", admin, nil).Body["providers"].([]any)
|
|
if len(list) != 6 {
|
|
t.Fatalf("providers = %v", list)
|
|
}
|
|
for _, it := range list[:5] {
|
|
p := it.(map[string]any)
|
|
if p["needs_url"] != false || p["url"] != "" || p["lidarr"] != nil {
|
|
t.Errorf("%v has an address or Lidarr options: %v", p["name"], p)
|
|
}
|
|
}
|
|
l := list[5].(map[string]any)
|
|
sameKeys(t, "lidarr", l, "name", "enabled", "needs_api_key", "needs_url", "has_api_key", "contact", "url", "lidarr", "sends", "notes", "updated_at")
|
|
opts, _ := l["lidarr"].(map[string]any)
|
|
sameKeys(t, "lidarr options", opts, "quality_profile_id", "metadata_profile_id", "root_folder_path", "monitor", "search_missing")
|
|
if l["name"] != "lidarr" || l["enabled"] != false || l["needs_api_key"] != true || l["needs_url"] != true ||
|
|
opts["monitor"] != "all" || opts["search_missing"] != true || opts["quality_profile_id"] != float64(0) {
|
|
t.Errorf("lidarr = %v", l)
|
|
}
|
|
}
|
|
|
|
func TestSettingLidarrUp(t *testing.T) {
|
|
h, _, admin, _ := newLidarrAPI(t)
|
|
put := func(body map[string]any) resp { return do(t, h, "PUT", "/api/v1/providers/lidarr", admin, body) }
|
|
|
|
if r := put(map[string]any{"enabled": true}); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
|
t.Fatalf("enabled with nothing: %d %v", r.Code, r.Body)
|
|
}
|
|
r := put(map[string]any{"api_key": lidarrAPIKey, "url": "http://orion:8686/"})
|
|
if r.Code != http.StatusOK || r.Body["url"] != "http://orion:8686" || r.Body["has_api_key"] != true || r.Body["enabled"] != false {
|
|
t.Fatalf("key and address: %d %v", r.Code, r.Body)
|
|
}
|
|
if raw, _ := json.Marshal(r.Body); strings.Contains(string(raw), lidarrAPIKey) {
|
|
t.Fatal("the response carries the API key")
|
|
}
|
|
// What is not said in the options is the default; what is said replaces all of them.
|
|
r = put(map[string]any{"lidarr": map[string]any{"quality_profile_id": 2, "metadata_profile_id": 1, "root_folder_path": "/music"}})
|
|
opts, _ := r.Body["lidarr"].(map[string]any)
|
|
if r.Code != http.StatusOK || opts["quality_profile_id"] != float64(2) || opts["root_folder_path"] != "/music" ||
|
|
opts["monitor"] != "all" || opts["search_missing"] != true {
|
|
t.Fatalf("options: %d %v", r.Code, r.Body)
|
|
}
|
|
r = put(map[string]any{"lidarr": map[string]any{"quality_profile_id": 2, "metadata_profile_id": 1, "root_folder_path": "/music", "monitor": "latest", "search_missing": false}})
|
|
opts, _ = r.Body["lidarr"].(map[string]any)
|
|
if opts["monitor"] != "latest" || opts["search_missing"] != false {
|
|
t.Fatalf("options: %v", r.Body)
|
|
}
|
|
if r := put(map[string]any{"enabled": true}); r.Code != http.StatusOK || r.Body["enabled"] != true {
|
|
t.Fatalf("enable: %d %v", r.Code, r.Body)
|
|
}
|
|
for name, body := range map[string]map[string]any{
|
|
"an address that is not http": {"url": "ftp://orion"},
|
|
"an address with a secret": {"url": "http://orion/?apikey=x"},
|
|
"a short key": {"api_key": "abc"},
|
|
"a monitor that is not one": {"lidarr": map[string]any{"monitor": "everything"}},
|
|
} {
|
|
if r := put(body); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
|
t.Errorf("%s: %d %v", name, r.Code, r.Body)
|
|
}
|
|
}
|
|
// Clearing the address turns it off.
|
|
if r := put(map[string]any{"url": ""}); r.Code != http.StatusOK || r.Body["enabled"] != false || r.Body["url"] != "" {
|
|
t.Errorf("clear the address: %d %v", r.Code, r.Body)
|
|
}
|
|
// Other providers have neither.
|
|
if r := do(t, h, "PUT", "/api/v1/providers/musicbrainz", admin, map[string]any{"url": "http://orion"}); r.Code != http.StatusBadRequest {
|
|
t.Errorf("an address for MusicBrainz: %d %v", r.Code, r.Body)
|
|
}
|
|
}
|
|
|
|
func TestOnlyAnAdminReadsWhatLidarrOffers(t *testing.T) {
|
|
h, fake, admin, bob := newLidarrAPI(t)
|
|
if r := do(t, h, "GET", "/api/v1/providers/lidarr/options", "", nil); r.Code != http.StatusUnauthorized {
|
|
t.Errorf("without a token: %d", r.Code)
|
|
}
|
|
if r := do(t, h, "GET", "/api/v1/providers/lidarr/options", bob, nil); r.Code != http.StatusForbidden || errCode(r) != "admin_required" {
|
|
t.Errorf("as a user: %d %v", r.Code, r.Body)
|
|
}
|
|
if fake.asked != 0 {
|
|
t.Error("Lidarr was asked on behalf of someone who is not an admin")
|
|
}
|
|
r := do(t, h, "GET", "/api/v1/providers/lidarr/options", admin, nil)
|
|
if r.Code != http.StatusOK {
|
|
t.Fatalf("%d %v", r.Code, r.Body)
|
|
}
|
|
sameKeys(t, "options", r.Body, "quality_profiles", "metadata_profiles", "root_folders")
|
|
q := r.Body["quality_profiles"].([]any)
|
|
if len(q) != 2 || q[1].(map[string]any)["id"] != float64(2) || q[1].(map[string]any)["name"] != "Lossless" {
|
|
t.Errorf("quality profiles = %v", q)
|
|
}
|
|
sameKeys(t, "profile", q[0].(map[string]any), "id", "name")
|
|
f := r.Body["root_folders"].([]any)[0].(map[string]any)
|
|
sameKeys(t, "root folder", f, "path", "accessible")
|
|
if f["path"] != "/music" || f["accessible"] != true {
|
|
t.Errorf("root folder = %v", f)
|
|
}
|
|
}
|
|
|
|
func TestWhatGoesWrongAskingLidarrIsSaidPlainly(t *testing.T) {
|
|
h, fake, admin, _ := newLidarrAPI(t)
|
|
for _, c := range []struct {
|
|
err error
|
|
status int
|
|
code string
|
|
}{
|
|
{lidarr.ErrNotConfigured, http.StatusConflict, "lidarr_not_configured"},
|
|
{lidarr.ErrKeyRefused, http.StatusBadGateway, "lidarr_key_refused"},
|
|
{lidarr.ErrUnreachable, http.StatusBadGateway, "lidarr_unavailable"},
|
|
{lidarr.ErrBadResponse, http.StatusBadGateway, "lidarr_unavailable"},
|
|
{context.DeadlineExceeded, http.StatusBadGateway, "lidarr_unavailable"},
|
|
} {
|
|
fake.err = c.err
|
|
if r := do(t, h, "GET", "/api/v1/providers/lidarr/options", admin, nil); r.Code != c.status || errCode(r) != c.code {
|
|
t.Errorf("%v: %d %v, want %d %s", c.err, r.Code, r.Body, c.status, c.code)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- sending an artist ----
|
|
|
|
type fakeSender struct {
|
|
outcome lidarr.Outcome
|
|
err error
|
|
sent []int64
|
|
presence lidarr.Presence
|
|
perr error
|
|
}
|
|
|
|
func (f *fakeSender) Send(_ context.Context, id int64) (lidarr.Outcome, error) {
|
|
if f.err != nil {
|
|
return "", f.err
|
|
}
|
|
f.sent = append(f.sent, id)
|
|
return f.outcome, nil
|
|
}
|
|
|
|
func (f *fakeSender) Presence(context.Context, int64) (lidarr.Presence, error) {
|
|
return f.presence, f.perr
|
|
}
|
|
|
|
func newSenderAPI(t *testing.T) (http.Handler, *fakeSender, string, string) {
|
|
t.Helper()
|
|
fake := &fakeSender{outcome: lidarr.Added}
|
|
h, _ := newTestEnvDB(t, func(d *Deps, _ *bun.DB) { d.LidarrArtists = fake })
|
|
admin := registerAndLogin(t, h)
|
|
_, bob := addUser(t, h, admin, "bob", false)
|
|
return h, fake, admin, bob
|
|
}
|
|
|
|
func TestOnlyAnAdminSendsAnArtistToLidarr(t *testing.T) {
|
|
h, fake, admin, bob := newSenderAPI(t)
|
|
if r := do(t, h, "POST", "/api/v1/artists/7/lidarr", "", nil); r.Code != http.StatusUnauthorized {
|
|
t.Errorf("without a token: %d", r.Code)
|
|
}
|
|
if r := do(t, h, "POST", "/api/v1/artists/7/lidarr", bob, nil); r.Code != http.StatusForbidden || errCode(r) != "admin_required" {
|
|
t.Errorf("as a user: %d %v", r.Code, r.Body)
|
|
}
|
|
if len(fake.sent) != 0 {
|
|
t.Fatal("an artist was sent on behalf of someone who is not an admin")
|
|
}
|
|
r := do(t, h, "POST", "/api/v1/artists/7/lidarr", admin, nil)
|
|
if r.Code != http.StatusOK || r.Body["status"] != "added" || len(fake.sent) != 1 || fake.sent[0] != 7 {
|
|
t.Fatalf("%d %v sent %v", r.Code, r.Body, fake.sent)
|
|
}
|
|
sameKeys(t, "sent", r.Body, "status")
|
|
fake.outcome = lidarr.AlreadyAdded
|
|
if r := do(t, h, "POST", "/api/v1/artists/7/lidarr", admin, nil); r.Code != http.StatusOK || r.Body["status"] != "already_added" {
|
|
t.Errorf("again: %d %v", r.Code, r.Body)
|
|
}
|
|
if r := do(t, h, "POST", "/api/v1/artists/abc/lidarr", admin, nil); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
|
t.Errorf("a bad id: %d %v", r.Code, r.Body)
|
|
}
|
|
}
|
|
|
|
func TestWhatStopsAnArtistFromBeingSentIsSaid(t *testing.T) {
|
|
h, fake, admin, _ := newSenderAPI(t)
|
|
for _, c := range []struct {
|
|
err error
|
|
status int
|
|
code string
|
|
}{
|
|
{discovery.ErrNotFound, http.StatusNotFound, "artist_not_found"},
|
|
{lidarr.ErrNoID, http.StatusUnprocessableEntity, "no_musicbrainz_id"},
|
|
{lidarr.ErrDisabled, http.StatusConflict, "lidarr_disabled"},
|
|
{lidarr.ErrNotSetUp, http.StatusConflict, "lidarr_not_configured"},
|
|
{lidarr.ErrNotConfigured, http.StatusConflict, "lidarr_not_configured"},
|
|
{lidarr.ErrNotFound, http.StatusUnprocessableEntity, "lidarr_unknown_artist"},
|
|
{lidarr.ErrKeyRefused, http.StatusBadGateway, "lidarr_key_refused"},
|
|
{lidarr.ErrUnreachable, http.StatusBadGateway, "lidarr_unavailable"},
|
|
{lidarr.ErrBadResponse, http.StatusBadGateway, "lidarr_unavailable"},
|
|
{context.DeadlineExceeded, http.StatusBadGateway, "lidarr_unavailable"},
|
|
} {
|
|
fake.err = c.err
|
|
if r := do(t, h, "POST", "/api/v1/artists/7/lidarr", admin, nil); r.Code != c.status || errCode(r) != c.code {
|
|
t.Errorf("%v: %d %v, want %d %s", c.err, r.Code, r.Body, c.status, c.code)
|
|
}
|
|
}
|
|
// A refusal carries Lidarr's reason, which the admin needs; a timeout says the artist may be there.
|
|
fake.err = fmt.Errorf("%w: Root folder does not exist", lidarr.ErrRejected)
|
|
r := do(t, h, "POST", "/api/v1/artists/7/lidarr", admin, nil)
|
|
msg, _ := r.Body["error"].(map[string]any)["message"].(string)
|
|
if r.Code != http.StatusUnprocessableEntity || errCode(r) != "lidarr_rejected" || !strings.Contains(msg, "Root folder does not exist") {
|
|
t.Errorf("rejected: %d %v", r.Code, r.Body)
|
|
}
|
|
for _, cause := range []error{lidarr.ErrUnreachable, lidarr.ErrBadResponse, context.DeadlineExceeded} {
|
|
fake.err = cause
|
|
r = do(t, h, "POST", "/api/v1/artists/7/lidarr", admin, nil)
|
|
msg, _ = r.Body["error"].(map[string]any)["message"].(string)
|
|
if !strings.Contains(msg, "may have been added") {
|
|
t.Errorf("%v: %q, want it to say the artist may have been added", cause, msg)
|
|
}
|
|
}
|
|
fake.err = context.Canceled
|
|
if r := do(t, h, "POST", "/api/v1/artists/7/lidarr", admin, nil); r.Code != 499 {
|
|
t.Errorf("a request that left: %d", r.Code)
|
|
}
|
|
}
|
|
|
|
func TestAnyUserSeesWhetherLidarrHasAnArtist(t *testing.T) {
|
|
h, fake, _, bob := newSenderAPI(t)
|
|
if r := do(t, h, "GET", "/api/v1/artists/7/lidarr", "", nil); r.Code != http.StatusUnauthorized {
|
|
t.Errorf("without a token: %d", r.Code)
|
|
}
|
|
fake.presence = lidarr.Presence{Status: "ok", InLidarr: true, Monitored: true}
|
|
r := do(t, h, "GET", "/api/v1/artists/7/lidarr", bob, nil)
|
|
sameKeys(t, "presence", r.Body, "provider_status", "in_lidarr", "monitored")
|
|
if r.Code != http.StatusOK || r.Body["provider_status"] != "ok" || r.Body["in_lidarr"] != true || r.Body["monitored"] != true {
|
|
t.Errorf("%d %v", r.Code, r.Body)
|
|
}
|
|
fake.presence = lidarr.Presence{Status: "disabled"}
|
|
if r := do(t, h, "GET", "/api/v1/artists/7/lidarr", bob, nil); r.Body["provider_status"] != "disabled" || r.Body["in_lidarr"] != false {
|
|
t.Errorf("off: %v", r.Body)
|
|
}
|
|
fake.perr = discovery.ErrNotFound
|
|
if r := do(t, h, "GET", "/api/v1/artists/7/lidarr", bob, nil); r.Code != http.StatusNotFound || errCode(r) != "artist_not_found" {
|
|
t.Errorf("unknown: %d %v", r.Code, r.Body)
|
|
}
|
|
}
|