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) } } }