Migrating hosting from Codeberg to git.kmalloc.org. Renames the module path in go.mod, every internal import, and the OCI image source label in the Dockerfile. Build and full test suite verified green after the rename.
159 lines
6 KiB
Go
159 lines
6 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"git.kmalloc.org/squid/sonda/internal/auth"
|
|
)
|
|
|
|
type fakeParser struct {
|
|
claims auth.Claims
|
|
err error
|
|
}
|
|
|
|
func (f fakeParser) Parse(string) (auth.Claims, error) { return f.claims, f.err }
|
|
|
|
type fakeUsers struct {
|
|
user auth.User
|
|
err error
|
|
}
|
|
|
|
func (f fakeUsers) User(context.Context, int64) (auth.User, error) { return f.user, f.err }
|
|
|
|
func TestRequireAuthChecksWhoTheTokenWasIssuedFor(t *testing.T) {
|
|
issued := time.Unix(1_700_000_000, 0)
|
|
token := auth.Claims{UserID: 5, Email: "bob", IssuedAt: issued}
|
|
for _, tt := range []struct {
|
|
name string
|
|
users fakeUsers
|
|
want int
|
|
}{
|
|
{"the same account", fakeUsers{user: auth.User{ID: 5, Email: "bob", CreatedAt: issued.Add(-time.Hour)}}, http.StatusOK},
|
|
{"created in the same second as the token", fakeUsers{user: auth.User{ID: 5, Email: "bob", CreatedAt: issued}}, http.StatusOK},
|
|
{"the account is gone", fakeUsers{err: auth.ErrUserNotFound}, http.StatusUnauthorized},
|
|
{"the id now belongs to somebody else", fakeUsers{user: auth.User{ID: 5, Email: "carol", CreatedAt: issued.Add(-time.Hour)}}, http.StatusUnauthorized},
|
|
{"the id was reused for the same name, later", fakeUsers{user: auth.User{ID: 5, Email: "bob", CreatedAt: issued.Add(time.Minute)}}, http.StatusUnauthorized},
|
|
{"the database fails", fakeUsers{err: errors.New("boom")}, http.StatusInternalServerError},
|
|
} {
|
|
r := gin.New()
|
|
r.GET("/x", requireAuth(fakeParser{claims: token}, tt.users, false), func(c *gin.Context) {
|
|
if currentUserID(c) != 5 {
|
|
t.Errorf("%s: user id = %d", tt.name, currentUserID(c))
|
|
}
|
|
c.Status(http.StatusOK)
|
|
})
|
|
req := httptest.NewRequest("GET", "/x", nil)
|
|
req.Header.Set("Authorization", "Bearer anything")
|
|
rec := httptest.NewRecorder()
|
|
r.ServeHTTP(rec, req)
|
|
if rec.Code != tt.want {
|
|
t.Errorf("%s: status %d, want %d", tt.name, rec.Code, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRequireAuthDoesNotCallAClientThatLeftAnInternalError(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
r := gin.New()
|
|
var logged int
|
|
r.Use(func(c *gin.Context) { c.Next(); logged = len(c.Errors) })
|
|
r.GET("/x", requireAuth(fakeParser{claims: auth.Claims{UserID: 5, Email: "bob"}}, fakeUsers{err: context.Canceled}, false), func(c *gin.Context) {
|
|
t.Error("the handler ran for a client that left")
|
|
})
|
|
req := httptest.NewRequest("GET", "/x", nil).WithContext(ctx)
|
|
req.Header.Set("Authorization", "Bearer anything")
|
|
rec := httptest.NewRecorder()
|
|
r.ServeHTTP(rec, req)
|
|
if rec.Code == http.StatusInternalServerError || logged != 0 {
|
|
t.Errorf("status %d and %d logged errors: a client leaving is not an internal error", rec.Code, logged)
|
|
}
|
|
}
|
|
|
|
func TestAdminCheckReusesTheAccountAlreadyLookedUp(t *testing.T) {
|
|
calls := 0
|
|
users := countingUsers{user: auth.User{ID: 5, Email: "root", IsAdmin: true}, calls: &calls}
|
|
r := gin.New()
|
|
r.GET("/x", requireAuth(fakeParser{claims: auth.Claims{UserID: 5, Email: "root", IssuedAt: time.Now()}}, users, false),
|
|
requireAdmin(users), func(c *gin.Context) { c.Status(http.StatusOK) })
|
|
req := httptest.NewRequest("GET", "/x", nil)
|
|
req.Header.Set("Authorization", "Bearer anything")
|
|
rec := httptest.NewRecorder()
|
|
r.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusOK || calls != 1 {
|
|
t.Errorf("status %d after %d lookups, want 200 after 1", rec.Code, calls)
|
|
}
|
|
}
|
|
|
|
type countingUsers struct {
|
|
user auth.User
|
|
calls *int
|
|
}
|
|
|
|
func (f countingUsers) User(context.Context, int64) (auth.User, error) {
|
|
*f.calls++
|
|
return f.user, nil
|
|
}
|
|
|
|
func TestRequireAuthDoesNotLookUpWhenTheTokenIsBad(t *testing.T) {
|
|
r := gin.New()
|
|
r.GET("/x", requireAuth(fakeParser{err: errors.New("bad")}, fakeUsers{err: errors.New("must not be called")}, false), func(c *gin.Context) {
|
|
c.Status(http.StatusOK)
|
|
})
|
|
req := httptest.NewRequest("GET", "/x", nil)
|
|
req.Header.Set("Authorization", "Bearer anything")
|
|
rec := httptest.NewRecorder()
|
|
r.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Errorf("status %d, want 401", rec.Code)
|
|
}
|
|
}
|
|
|
|
// On SQLite the highest id is given again once its user is deleted. A token of the
|
|
// deleted user must not work as the new one.
|
|
func TestATokenOfADeletedUserDoesNotWorkAsWhoeverGetsTheSameId(t *testing.T) {
|
|
h := newTestAPI(t)
|
|
admin := registerAndLogin(t, h)
|
|
create := func(name string) (id int64, token string) {
|
|
cred := map[string]any{"email": address(name), "password": "longenough"}
|
|
r := do(t, h, "POST", "/api/v1/users", admin, cred)
|
|
if r.Code != http.StatusCreated {
|
|
t.Fatalf("create %s: %d %v", name, r.Code, r.Body)
|
|
}
|
|
token, _ = do(t, h, "POST", "/api/v1/auth/login", "", cred).Body["access_token"].(string)
|
|
return int64(r.Body["id"].(float64)), token
|
|
}
|
|
bobID, bob := create("bob")
|
|
if r := do(t, h, "DELETE", "/api/v1/users/"+strconv.FormatInt(bobID, 10), admin, nil); r.Code != http.StatusNoContent {
|
|
t.Fatalf("delete bob: %d %v", r.Code, r.Body)
|
|
}
|
|
carolID, carol := create("carol")
|
|
if carolID != bobID {
|
|
t.Skipf("the id was not reused (%d then %d): nothing to prove here", bobID, carolID)
|
|
}
|
|
|
|
// The streaming route also takes the token in the query. Track 999 does not
|
|
// exist: the right token gets "not found", the wrong one must not get that far.
|
|
if r := do(t, h, "GET", "/api/v1/tracks/999/stream?access_token="+bob, "", nil); r.Code != http.StatusUnauthorized {
|
|
t.Errorf("stream with bob's token: %d, want 401", r.Code)
|
|
}
|
|
if r := do(t, h, "GET", "/api/v1/tracks/999/stream?access_token="+carol, "", nil); r.Code != http.StatusNotFound {
|
|
t.Errorf("stream with carol's token: %d, want 404", r.Code)
|
|
}
|
|
for _, path := range []string{"/api/v1/me/settings", "/api/v1/me/taste", "/api/v1/listens", "/api/v1/auth/me"} {
|
|
if r := do(t, h, "GET", path, bob, nil); r.Code != http.StatusUnauthorized {
|
|
t.Errorf("GET %s with bob's token: %d %v, want 401", path, r.Code, r.Body)
|
|
}
|
|
if r := do(t, h, "GET", path, carol, nil); r.Code != http.StatusOK {
|
|
t.Errorf("GET %s with carol's own token: %d %v, want 200", path, r.Code, r.Body)
|
|
}
|
|
}
|
|
}
|