package httpapi import ( "net/http" "net/http/httptest" "strconv" "strings" "testing" ) func str(m map[string]any, key string) string { v, _ := m[key].(string) return v } func sub(m map[string]any, key string) map[string]any { v, _ := m[key].(map[string]any) return v } // loginSession logs in and returns the whole session body. func loginSession(t *testing.T, h http.Handler, user, pass string) map[string]any { t.Helper() r := do(t, h, "POST", "/api/v1/auth/login", "", map[string]string{"email": address(user), "password": pass}) if r.Code != http.StatusOK { t.Fatalf("login %s: %d %v", user, r.Code, r.Body) } return r.Body } // addUser has the admin create an account and returns that account's access token. func addUser(t *testing.T, h http.Handler, adminTok, name string, admin bool) (id float64, token string) { t.Helper() r := do(t, h, "POST", "/api/v1/users", adminTok, map[string]any{"email": address(name), "password": "longenough", "is_admin": admin}) if r.Code != http.StatusCreated { t.Fatalf("create %s: %d %v", name, r.Code, r.Body) } id, _ = r.Body["id"].(float64) return id, str(loginSession(t, h, name, "longenough"), "access_token") } func userPath(id float64) string { return "/api/v1/users/" + strconv.FormatInt(int64(id), 10) } // ---- login, me ---- func TestLoginReturnsSessionWithRoles(t *testing.T) { h := newTestAPI(t) registerAndLogin(t, h) s := loginSession(t, h, "alice", "longenough") for _, k := range []string{"access_token", "refresh_token", "access_expires_at", "refresh_expires_at"} { if str(s, k) == "" { t.Errorf("%s missing from %v", k, s) } } u := sub(s, "user") if u["email"] != "alice@example.org" || u["is_admin"] != true { t.Errorf("user = %v, want alice as admin", u) } } func TestMe(t *testing.T) { h := newTestAPI(t) tok := registerAndLogin(t, h) if r := do(t, h, "GET", "/api/v1/auth/me", "", nil); r.Code != http.StatusUnauthorized { t.Errorf("no token: %d", r.Code) } r := do(t, h, "GET", "/api/v1/auth/me", tok, nil) if r.Code != http.StatusOK || r.Body["email"] != "alice@example.org" || r.Body["is_admin"] != true { t.Fatalf("me: %d %v", r.Code, r.Body) } if _, leaked := r.Body["password_hash"]; leaked { t.Error("password hash leaked") } } // ---- refresh, logout ---- func TestRefreshRotatesAndOldTokenCannotBeReplayed(t *testing.T) { h := newTestAPI(t) registerAndLogin(t, h) first := loginSession(t, h, "alice", "longenough") r := do(t, h, "POST", "/api/v1/auth/refresh", "", map[string]string{"refresh_token": str(first, "refresh_token")}) if r.Code != http.StatusOK || str(r.Body, "access_token") == "" { t.Fatalf("refresh: %d %v", r.Code, r.Body) } second := str(r.Body, "refresh_token") if second == "" || second == str(first, "refresh_token") { t.Fatal("refresh token was not rotated") } // The new access token works. if r := do(t, h, "GET", "/api/v1/auth/me", str(r.Body, "access_token"), nil); r.Code != http.StatusOK { t.Errorf("new access token: %d", r.Code) } // Replaying the spent token fails. Right after a rotation that is treated as // a race (two tabs), so the newer token keeps working; reuse long after the // rotation revoking every session is covered in the auth and storage tests. r = do(t, h, "POST", "/api/v1/auth/refresh", "", map[string]string{"refresh_token": str(first, "refresh_token")}) if r.Code != http.StatusUnauthorized || errCode(r) != "invalid_refresh_token" { t.Fatalf("replay: %d %v", r.Code, r.Body) } r = do(t, h, "POST", "/api/v1/auth/refresh", "", map[string]string{"refresh_token": second}) if r.Code != http.StatusOK { t.Fatalf("the newer token must survive a replay inside the grace window: %d", r.Code) } } func TestRefreshRejectsBadRequests(t *testing.T) { h := newTestAPI(t) for name, body := range map[string]any{ "empty": map[string]string{}, "unknown": map[string]string{"refresh_token": "nope"}, "malformed": "{oops", } { r := do(t, h, "POST", "/api/v1/auth/refresh", "", body) want := http.StatusUnauthorized if name == "malformed" { want = http.StatusBadRequest } if r.Code != want { t.Errorf("%s: %d %v, want %d", name, r.Code, r.Body, want) } } } func TestAccessTokenCannotBeUsedAsRefreshToken(t *testing.T) { h := newTestAPI(t) registerAndLogin(t, h) s := loginSession(t, h, "alice", "longenough") r := do(t, h, "POST", "/api/v1/auth/refresh", "", map[string]string{"refresh_token": str(s, "access_token")}) if r.Code != http.StatusUnauthorized { t.Fatalf("access token accepted as refresh token: %d", r.Code) } } func TestLogout(t *testing.T) { h := newTestAPI(t) registerAndLogin(t, h) s := loginSession(t, h, "alice", "longenough") body := map[string]string{"refresh_token": str(s, "refresh_token")} if r := do(t, h, "POST", "/api/v1/auth/logout", "", body); r.Code != http.StatusNoContent { t.Fatalf("logout: %d", r.Code) } if r := do(t, h, "POST", "/api/v1/auth/refresh", "", body); r.Code != http.StatusUnauthorized { t.Errorf("refresh after logout: %d", r.Code) } // Idempotent, and it never reveals whether the token existed. if r := do(t, h, "POST", "/api/v1/auth/logout", "", body); r.Code != http.StatusNoContent { t.Errorf("second logout: %d", r.Code) } if r := do(t, h, "POST", "/api/v1/auth/logout", "", map[string]string{"refresh_token": "junk"}); r.Code != http.StatusNoContent { t.Errorf("junk logout: %d", r.Code) } } // ---- password ---- func TestChangePassword(t *testing.T) { h := newTestAPI(t) tok := registerAndLogin(t, h) s := loginSession(t, h, "alice", "longenough") if r := do(t, h, "POST", "/api/v1/auth/password", "", map[string]string{"current_password": "x", "new_password": "y"}); r.Code != http.StatusUnauthorized { t.Errorf("no token: %d", r.Code) } r := do(t, h, "POST", "/api/v1/auth/password", tok, map[string]string{"current_password": "wrongwrong", "new_password": "brandnewpass"}) if r.Code != http.StatusForbidden || errCode(r) != "invalid_credentials" { t.Fatalf("wrong current: %d %v", r.Code, r.Body) } r = do(t, h, "POST", "/api/v1/auth/password", tok, map[string]string{"current_password": "longenough", "new_password": "short"}) if r.Code != http.StatusBadRequest { t.Fatalf("weak new password: %d %v", r.Code, r.Body) } r = do(t, h, "POST", "/api/v1/auth/password", tok, map[string]string{"current_password": "longenough", "new_password": "brandnewpass"}) if r.Code != http.StatusNoContent { t.Fatalf("change: %d %v", r.Code, r.Body) } if r := do(t, h, "POST", "/api/v1/auth/login", "", map[string]string{"email": "alice@example.org", "password": "longenough"}); r.Code != http.StatusUnauthorized { t.Errorf("old password still works: %d", r.Code) } loginSession(t, h, "alice", "brandnewpass") if r := do(t, h, "POST", "/api/v1/auth/refresh", "", map[string]string{"refresh_token": str(s, "refresh_token")}); r.Code != http.StatusUnauthorized { t.Errorf("old session survived a password change: %d", r.Code) } } // ---- admin ---- func TestAdminEndpointsRejectNonAdmins(t *testing.T) { h := newTestAPIWithScan(t, &fakeScan{}) admin := registerAndLogin(t, h) bobID, bob := addUser(t, h, admin, "bob", false) calls := []struct{ method, path string }{ {"GET", "/api/v1/users"}, {"POST", "/api/v1/users"}, {"PATCH", userPath(bobID)}, {"PUT", userPath(bobID) + "/password"}, {"DELETE", userPath(bobID)}, {"POST", "/api/v1/library/scan"}, } for _, c := range calls { if r := do(t, h, c.method, c.path, "", nil); r.Code != http.StatusUnauthorized { t.Errorf("%s %s without token: %d", c.method, c.path, r.Code) } r := do(t, h, c.method, c.path, bob, map[string]any{"email": "x", "password": "longenough", "is_admin": true}) if r.Code != http.StatusForbidden || errCode(r) != "admin_required" { t.Errorf("%s %s as non-admin: %d %v", c.method, c.path, r.Code, r.Body) } } // Reading the scan status stays open to every signed-in user. if r := do(t, h, "GET", "/api/v1/library/scan", bob, nil); r.Code != http.StatusOK { t.Errorf("scan status as user: %d", r.Code) } } func TestAdminUserLifecycle(t *testing.T) { h := newTestAPI(t) admin := registerAndLogin(t, h) bobID, bob := addUser(t, h, admin, "bob", false) r := do(t, h, "GET", "/api/v1/users", admin, nil) users, _ := r.Body["users"].([]any) if r.Code != http.StatusOK || len(users) != 2 { t.Fatalf("list: %d %v", r.Code, r.Body) } for _, u := range users { if _, leaked := u.(map[string]any)["password_hash"]; leaked { t.Error("password hash leaked in the user list") } } if r := do(t, h, "POST", "/api/v1/users", admin, map[string]any{"email": "BOB@example.org", "password": "longenough"}); r.Code != http.StatusConflict || errCode(r) != "email_taken" { t.Errorf("duplicate: %d %v", r.Code, r.Body) } if r := do(t, h, "POST", "/api/v1/users", admin, map[string]any{"email": "x", "password": "longenough"}); r.Code != http.StatusBadRequest { t.Errorf("invalid: %d", r.Code) } // Promote bob: his existing token now passes the admin check. r = do(t, h, "PATCH", userPath(bobID), admin, map[string]any{"is_admin": true}) if r.Code != http.StatusOK || r.Body["is_admin"] != true { t.Fatalf("promote: %d %v", r.Code, r.Body) } if r := do(t, h, "GET", "/api/v1/users", bob, nil); r.Code != http.StatusOK { t.Errorf("promoted user cannot list users: %d", r.Code) } // Reset bob's password: the new one works, his sessions are gone. bobSession := loginSession(t, h, "bob", "longenough") if r := do(t, h, "PUT", userPath(bobID)+"/password", admin, map[string]string{"password": "resetpassword"}); r.Code != http.StatusNoContent { t.Fatalf("reset: %d %v", r.Code, r.Body) } loginSession(t, h, "bob", "resetpassword") if r := do(t, h, "POST", "/api/v1/auth/refresh", "", map[string]string{"refresh_token": str(bobSession, "refresh_token")}); r.Code != http.StatusUnauthorized { t.Errorf("session survived a password reset: %d", r.Code) } // Delete bob: his still-valid access token stops working on admin routes. if r := do(t, h, "DELETE", userPath(bobID), admin, nil); r.Code != http.StatusNoContent { t.Fatalf("delete: %d %v", r.Code, r.Body) } if r := do(t, h, "GET", "/api/v1/users", bob, nil); r.Code != http.StatusUnauthorized { t.Errorf("deleted admin's token: %d, want 401", r.Code) } if r := do(t, h, "DELETE", userPath(bobID), admin, nil); r.Code != http.StatusNotFound || errCode(r) != "user_not_found" { t.Errorf("delete twice: %d %v", r.Code, r.Body) } } func TestLastAdminCannotBeRemoved(t *testing.T) { h := newTestAPI(t) admin := registerAndLogin(t, h) me := do(t, h, "GET", "/api/v1/auth/me", admin, nil) id, _ := me.Body["id"].(float64) r := do(t, h, "PATCH", userPath(id), admin, map[string]any{"is_admin": false}) if r.Code != http.StatusConflict || errCode(r) != "last_admin" { t.Errorf("demote last admin: %d %v", r.Code, r.Body) } r = do(t, h, "DELETE", userPath(id), admin, nil) if r.Code != http.StatusConflict || errCode(r) != "last_admin" { t.Errorf("delete last admin: %d %v", r.Code, r.Body) } } func TestAdminRoutesValidateInput(t *testing.T) { h := newTestAPI(t) admin := registerAndLogin(t, h) if r := do(t, h, "PATCH", "/api/v1/users/abc", admin, map[string]any{"is_admin": true}); r.Code != http.StatusBadRequest { t.Errorf("non-numeric id: %d", r.Code) } if r := do(t, h, "PATCH", "/api/v1/users/1", admin, map[string]any{}); r.Code != http.StatusBadRequest { t.Errorf("missing is_admin: %d", r.Code) } if r := do(t, h, "PATCH", "/api/v1/users/999", admin, map[string]any{"is_admin": true}); r.Code != http.StatusNotFound { t.Errorf("unknown user: %d", r.Code) } if r := do(t, h, "PUT", "/api/v1/users/999/password", admin, map[string]string{"password": "longenough"}); r.Code != http.StatusNotFound { t.Errorf("reset unknown: %d", r.Code) } } func TestAdminCanStartScan(t *testing.T) { scan := &fakeScan{} h := newTestAPIWithScan(t, scan) admin := registerAndLogin(t, h) if r := do(t, h, "POST", "/api/v1/library/scan", admin, nil); r.Code != http.StatusAccepted { t.Fatalf("admin scan: %d %v", r.Code, r.Body) } if scan.starts != 1 { t.Errorf("starts = %d", scan.starts) } } // Only "Authorization: Bearer " is accepted. A bare token must not pass. func TestAuthorizationHeaderMustUseTheBearerScheme(t *testing.T) { h := newTestAPI(t) tok := registerAndLogin(t, h) for name, header := range map[string]string{ "bare token": tok, "basic scheme": "Basic " + tok, "token scheme": "Token " + tok, "empty bearer": "Bearer ", "bearer no gap": "Bearer" + tok, } { req := httptest.NewRequest("GET", "/api/v1/auth/me", nil) req.Header.Set("Authorization", header) rec := httptest.NewRecorder() h.ServeHTTP(rec, req) if rec.Code != http.StatusUnauthorized { t.Errorf("%s: status %d, want 401", name, rec.Code) } } req := httptest.NewRequest("GET", "/api/v1/auth/me", nil) req.Header.Set("Authorization", "Bearer "+tok) rec := httptest.NewRecorder() h.ServeHTTP(rec, req) if rec.Code != http.StatusOK { t.Errorf("proper Bearer header: %d", rec.Code) } } // RFC 7235: the name of the authentication scheme is case-insensitive. func TestBearerSchemeIsCaseInsensitive(t *testing.T) { h := newTestAPI(t) tok := registerAndLogin(t, h) for _, scheme := range []string{"Bearer", "bearer", "BEARER", "bEaReR"} { req := httptest.NewRequest("GET", "/api/v1/auth/me", nil) req.Header.Set("Authorization", scheme+" "+tok) rec := httptest.NewRecorder() h.ServeHTTP(rec, req) if rec.Code != http.StatusOK { t.Errorf("scheme %q: status %d, want 200", scheme, rec.Code) } } } // An access token outlives a deleted account for a few minutes. Reporting a // listen with it must be a 401, not a database error. func TestListenWithADeletedAccountsTokenIsUnauthorized(t *testing.T) { h := newTestAPI(t) admin := registerAndLogin(t, h) bobID, bob := addUser(t, h, admin, "bob", false) if r := do(t, h, "DELETE", userPath(bobID), admin, nil); r.Code != http.StatusNoContent { t.Fatalf("delete: %d", r.Code) } // Whatever else is wrong with the request, the deleted account is told // "unauthorized" first. for name, body := range map[string]map[string]any{ "a valid event": {"track_id": 1, "event_type": "play", "idempotency_key": "k"}, "an unknown track": {"track_id": 999, "event_type": "play", "idempotency_key": "k"}, "an absurd length": {"track_id": 1, "event_type": "play", "duration_played_ms": 1, "idempotency_key": "k2"}, } { r := do(t, h, "POST", "/api/v1/listens", bob, body) if r.Code != http.StatusUnauthorized || errCode(r) != "unauthorized" { t.Errorf("%s after the account was deleted: %d %v", name, r.Code, r.Body) } } } // address makes an email of a short test name: "bob" is "bob@example.org". func address(name string) string { if strings.Contains(name, "@") { return name } return name + "@example.org" }