sonda/internal/auth/service_test.go
tgiachi 96ad8b1f62 feat(auth): accounts are identified by an email address
Registration, login and the admin's create-user call take `email` instead of
`username`, and the user object returns `email`. The address is checked for its
shape (a plain address, no display name, at most 254 bytes), trimmed, lowercased
and unique. Sonda sends no mail and does not verify it.

- Migration 0018 renames the users column (and the PostgreSQL index); values are
  kept, so an account made before keeps its plain name and still logs in with it
  (login does not check the shape).
- Error code username_taken becomes email_taken; the JWT claim is now `email`,
  so access tokens issued before the upgrade are refused once and clients refresh.
- OpenAPI spec, README, the web login form (type email), strings (en, it) and
  the generated API types follow.

Closes #65
2026-11-12 14:40:33 +01:00

521 lines
16 KiB
Go

package auth
import (
"context"
"errors"
"strings"
"testing"
"time"
)
// ---- fake stores ----
type fakeUserRow struct {
u User
hash string
}
type fakeRefreshRow struct {
userID int64
expires time.Time
revoked bool
revokedAt time.Time
}
// fakeStore implements UserStore and RefreshStore in memory, following the
// same rules as the real repositories.
type fakeStore struct {
users map[int64]*fakeUserRow
tokens map[string]*fakeRefreshRow // by hash
nextID int64
}
func newFakeStore() *fakeStore {
return &fakeStore{users: map[int64]*fakeUserRow{}, tokens: map[string]*fakeRefreshRow{}}
}
func (f *fakeStore) find(email string) *fakeUserRow {
for _, r := range f.users {
if strings.EqualFold(r.u.Email, email) {
return r
}
}
return nil
}
func (f *fakeStore) CountUsers(context.Context) (int, error) { return len(f.users), nil }
func (f *fakeStore) CountAdmins(context.Context) (int, error) {
n := 0
for _, r := range f.users {
if r.u.IsAdmin {
n++
}
}
return n, nil
}
func (f *fakeStore) CreateUser(_ context.Context, email, hash string, isAdmin bool) (User, error) {
if f.find(email) != nil {
return User{}, ErrEmailTaken
}
f.nextID++
u := User{ID: f.nextID, Email: email, IsAdmin: isAdmin, CreatedAt: time.Now()}
f.users[u.ID] = &fakeUserRow{u: u, hash: hash}
return u, nil
}
func (f *fakeStore) UserByEmail(_ context.Context, email string) (User, string, error) {
r := f.find(email)
if r == nil {
return User{}, "", ErrUserNotFound
}
return r.u, r.hash, nil
}
func (f *fakeStore) UserByID(_ context.Context, id int64) (User, string, error) {
r, ok := f.users[id]
if !ok {
return User{}, "", ErrUserNotFound
}
return r.u, r.hash, nil
}
func (f *fakeStore) ListUsers(context.Context) ([]User, error) {
var out []User
for id := int64(1); id <= f.nextID; id++ {
if r, ok := f.users[id]; ok {
out = append(out, r.u)
}
}
return out, nil
}
func (f *fakeStore) SetAdmin(_ context.Context, id int64, isAdmin bool) error {
r, ok := f.users[id]
if !ok {
return ErrUserNotFound
}
r.u.IsAdmin = isAdmin
return nil
}
func (f *fakeStore) SetPasswordHash(_ context.Context, id int64, hash string, now time.Time) error {
r, ok := f.users[id]
if !ok {
return ErrUserNotFound
}
r.hash = hash
f.revokeUser(id, now) // same transaction in the real store
return nil
}
func (f *fakeStore) DeleteUser(_ context.Context, id int64) error {
if _, ok := f.users[id]; !ok {
return ErrUserNotFound
}
delete(f.users, id)
for h, t := range f.tokens { // cascade
if t.userID == id {
delete(f.tokens, h)
}
}
return nil
}
func (f *fakeStore) SaveRefreshToken(_ context.Context, t RefreshToken) error {
f.tokens[t.TokenHash] = &fakeRefreshRow{userID: t.UserID, expires: t.ExpiresAt}
return nil
}
func (f *fakeStore) revokeUser(userID int64, now time.Time) {
for _, t := range f.tokens {
if t.userID == userID && !t.revoked {
t.revoked, t.revokedAt = true, now
}
}
}
func (f *fakeStore) RotateRefreshToken(_ context.Context, oldHash string, next RefreshToken, now time.Time) (int64, error) {
t, ok := f.tokens[oldHash]
if !ok {
return 0, ErrInvalidRefreshToken
}
if t.revoked {
if now.Sub(t.revokedAt) > RefreshReuseGrace {
f.revokeUser(t.userID, now) // reuse after the grace window: assume theft
}
return 0, ErrInvalidRefreshToken
}
if !now.Before(t.expires) {
return 0, ErrInvalidRefreshToken
}
t.revoked, t.revokedAt = true, now
f.tokens[next.TokenHash] = &fakeRefreshRow{userID: t.userID, expires: next.ExpiresAt}
return t.userID, nil
}
func (f *fakeStore) RevokeRefreshToken(_ context.Context, hash string, now time.Time) error {
if t, ok := f.tokens[hash]; ok && !t.revoked {
t.revoked, t.revokedAt = true, now
}
return nil
}
func newTestService() (*Service, *fakeStore) {
st := newFakeStore()
return NewService(st, st, NewTokenIssuer(testSecret, 15*time.Minute), 24*time.Hour), st
}
// bootstrap registers the first (admin) user and returns the service.
func bootstrap(t *testing.T) (*Service, *fakeStore, User) {
t.Helper()
s, st := newTestService()
u, err := s.Register(context.Background(), "alice@example.org", "longenough")
if err != nil {
t.Fatal(err)
}
return s, st, u
}
// ---- register / login ----
func TestRegisterFirstUserIsAdminThenClosed(t *testing.T) {
s, _, u := bootstrap(t)
if !u.IsAdmin {
t.Error("the first user must be an admin")
}
if _, err := s.Register(context.Background(), "bob@example.org", "longenough"); !errors.Is(err, ErrRegistrationClosed) {
t.Fatalf("err = %v, want ErrRegistrationClosed", err)
}
}
func TestRegisterValidation(t *testing.T) {
tests := []struct {
name, user, pass string
}{
{"no address", "", "longenough"},
{"a name, not an address", "alice", "longenough"},
{"no domain", "alice@", "longenough"},
{"no name", "@example.org", "longenough"},
{"two at signs", "a@b@example.org", "longenough"},
{"a space", "al ice@example.org", "longenough"},
{"a display name", "Alice <alice@example.org>", "longenough"},
{"too long", strings.Repeat("a", 250) + "@example.org", "longenough"},
{"short password", "alice@example.org", "short"},
{"huge password", "alice@example.org", strings.Repeat("x", 300)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s, _ := newTestService()
if _, err := s.Register(context.Background(), tt.user, tt.pass); !errors.Is(err, ErrInvalidInput) {
t.Fatalf("err = %v, want ErrInvalidInput", err)
}
})
}
}
func TestLoginIssuesBothTokens(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
sess, err := s.Login(ctx, "ALICE@Example.org", "longenough") // addresses are case-insensitive
if err != nil {
t.Fatal(err)
}
if sess.AccessToken == "" || sess.RefreshToken == "" || sess.User.Email != "alice@example.org" || !sess.User.IsAdmin {
t.Fatalf("session = %+v", sess)
}
if !sess.RefreshExpiresAt.After(sess.AccessExpiresAt) {
t.Error("refresh token must outlive the access token")
}
if _, err := NewTokenIssuer(testSecret, time.Hour).Parse(sess.AccessToken); err != nil {
t.Errorf("access token does not verify: %v", err)
}
if _, err := s.Login(ctx, "alice@example.org", "wrongpass1"); !errors.Is(err, ErrInvalidCredentials) {
t.Errorf("wrong password: err = %v", err)
}
if _, err := s.Login(ctx, "nobody", "longenough"); !errors.Is(err, ErrInvalidCredentials) {
t.Errorf("unknown user: err = %v", err)
}
}
func TestRefreshTokenIsStoredHashed(t *testing.T) {
s, st, _ := bootstrap(t)
sess, _ := s.Login(context.Background(), "alice@example.org", "longenough")
if _, ok := st.tokens[sess.RefreshToken]; ok {
t.Fatal("the raw refresh token is stored; only its hash may be")
}
if _, ok := st.tokens[hashRefreshToken(sess.RefreshToken)]; !ok {
t.Fatal("hash of the refresh token not stored")
}
}
// ---- refresh ----
func TestRefreshRotates(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
first, _ := s.Login(ctx, "alice@example.org", "longenough")
second, err := s.Refresh(ctx, first.RefreshToken)
if err != nil {
t.Fatal(err)
}
if second.RefreshToken == first.RefreshToken || second.AccessToken == "" || second.User.Email != "alice@example.org" {
t.Fatalf("second = %+v", second)
}
// The new token works.
if _, err := s.Refresh(ctx, second.RefreshToken); err != nil {
t.Fatalf("refreshing with the new token: %v", err)
}
}
func TestReusedRefreshTokenRevokesEverySession(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
first, _ := s.Login(ctx, "alice@example.org", "longenough")
second, _ := s.Refresh(ctx, first.RefreshToken)
// Well after the grace window, presenting the rotated token looks like theft.
s.now = func() time.Time { return time.Now().Add(RefreshReuseGrace + time.Minute) }
if _, err := s.Refresh(ctx, first.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("reuse: err = %v, want ErrInvalidRefreshToken", err)
}
// ...so the legitimate newer token is dead too.
if _, err := s.Refresh(ctx, second.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("after reuse the newer token must be revoked: err = %v", err)
}
}
// Two tabs, or a client retrying in parallel, present the same token almost
// at once. The loser fails but must not log the winner out.
func TestReplayInsideTheGraceWindowKeepsTheNewToken(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
first, _ := s.Login(ctx, "alice@example.org", "longenough")
second, err := s.Refresh(ctx, first.RefreshToken)
if err != nil {
t.Fatal(err)
}
if _, err := s.Refresh(ctx, first.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("the replay itself must still fail: err = %v", err)
}
if _, err := s.Refresh(ctx, second.RefreshToken); err != nil {
t.Fatalf("a replay inside the grace window must not revoke the new token: %v", err)
}
}
func TestRefreshRejectsExpiredUnknownAndEmpty(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
sess, _ := s.Login(ctx, "alice@example.org", "longenough")
for _, tok := range []string{"", "not-a-token", strings.Repeat("a", 43)} {
if _, err := s.Refresh(ctx, tok); !errors.Is(err, ErrInvalidRefreshToken) {
t.Errorf("token %q: err = %v", tok, err)
}
}
s.now = func() time.Time { return time.Now().Add(48 * time.Hour) }
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Errorf("expired token: err = %v", err)
}
}
func TestRefreshFailsForDeletedUser(t *testing.T) {
s, _, admin := bootstrap(t)
ctx := context.Background()
bob, err := s.CreateUser(ctx, "bob@example.org", "longenough", false)
if err != nil {
t.Fatal(err)
}
bobSess, _ := s.Login(ctx, "bob@example.org", "longenough")
if err := s.DeleteUser(ctx, bob.ID); err != nil {
t.Fatal(err)
}
if _, err := s.Refresh(ctx, bobSess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("err = %v", err)
}
_ = admin
}
// ---- logout / password ----
func TestLogoutRevokesTheToken(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
sess, _ := s.Login(ctx, "alice@example.org", "longenough")
if err := s.Logout(ctx, sess.RefreshToken); err != nil {
t.Fatal(err)
}
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("after logout: err = %v", err)
}
// Logging out twice, or with garbage, is not an error.
if err := s.Logout(ctx, sess.RefreshToken); err != nil {
t.Errorf("second logout: %v", err)
}
if err := s.Logout(ctx, "garbage"); err != nil {
t.Errorf("garbage logout: %v", err)
}
}
func TestChangePassword(t *testing.T) {
s, _, u := bootstrap(t)
ctx := context.Background()
sess, _ := s.Login(ctx, "alice@example.org", "longenough")
if err := s.ChangePassword(ctx, u.ID, "wrong-current", "brandnewpass"); !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("wrong current: err = %v", err)
}
if err := s.ChangePassword(ctx, u.ID, "longenough", "short"); !errors.Is(err, ErrInvalidInput) {
t.Fatalf("weak new password: err = %v", err)
}
if err := s.ChangePassword(ctx, u.ID, "longenough", "brandnewpass"); err != nil {
t.Fatal(err)
}
if _, err := s.Login(ctx, "alice@example.org", "longenough"); !errors.Is(err, ErrInvalidCredentials) {
t.Error("old password still works")
}
if _, err := s.Login(ctx, "alice@example.org", "brandnewpass"); err != nil {
t.Errorf("new password: %v", err)
}
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Error("a password change must revoke existing sessions")
}
}
// ---- admin ----
func TestAdminCreateAndListUsers(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
bob, err := s.CreateUser(ctx, "bob@example.org", "longenough", false)
if err != nil || bob.IsAdmin {
t.Fatalf("bob = %+v err=%v", bob, err)
}
if _, err := s.CreateUser(ctx, "BOB@example.org", "longenough", false); !errors.Is(err, ErrEmailTaken) {
t.Errorf("duplicate: err = %v", err)
}
if _, err := s.CreateUser(ctx, "x", "longenough", false); !errors.Is(err, ErrInvalidInput) {
t.Errorf("bad email: err = %v", err)
}
users, err := s.ListUsers(ctx)
if err != nil || len(users) != 2 || users[0].Email != "alice@example.org" || users[1].Email != "bob@example.org" {
t.Fatalf("users = %+v err=%v", users, err)
}
}
func TestSetAdminAndLastAdminGuard(t *testing.T) {
s, _, alice := bootstrap(t)
ctx := context.Background()
bob, _ := s.CreateUser(ctx, "bob@example.org", "longenough", false)
// The only admin cannot be demoted.
if _, err := s.SetAdmin(ctx, alice.ID, false); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("demoting the last admin: err = %v", err)
}
got, err := s.SetAdmin(ctx, bob.ID, true)
if err != nil || !got.IsAdmin {
t.Fatalf("promote: %+v err=%v", got, err)
}
// With two admins, one can step down.
if got, err = s.SetAdmin(ctx, alice.ID, false); err != nil || got.IsAdmin {
t.Fatalf("demote with two admins: %+v err=%v", got, err)
}
// Now bob is the last one.
if _, err := s.SetAdmin(ctx, bob.ID, false); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("demoting the new last admin: err = %v", err)
}
if _, err := s.SetAdmin(ctx, 999, true); !errors.Is(err, ErrUserNotFound) {
t.Errorf("unknown user: err = %v", err)
}
}
func TestDeleteUserGuards(t *testing.T) {
s, _, alice := bootstrap(t)
ctx := context.Background()
bob, _ := s.CreateUser(ctx, "bob@example.org", "longenough", false)
if err := s.DeleteUser(ctx, alice.ID); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("deleting the last admin: err = %v", err)
}
if err := s.DeleteUser(ctx, bob.ID); err != nil {
t.Fatal(err)
}
if err := s.DeleteUser(ctx, bob.ID); !errors.Is(err, ErrUserNotFound) {
t.Errorf("deleting twice: err = %v", err)
}
}
func TestResetPasswordRevokesSessions(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
bob, _ := s.CreateUser(ctx, "bob@example.org", "longenough", false)
sess, _ := s.Login(ctx, "bob@example.org", "longenough")
if err := s.ResetPassword(ctx, bob.ID, "short"); !errors.Is(err, ErrInvalidInput) {
t.Fatalf("weak password: err = %v", err)
}
if err := s.ResetPassword(ctx, bob.ID, "resetpassword"); err != nil {
t.Fatal(err)
}
if _, err := s.Login(ctx, "bob@example.org", "resetpassword"); err != nil {
t.Errorf("login with the reset password: %v", err)
}
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Error("a reset must revoke the user's sessions")
}
if err := s.ResetPassword(ctx, 999, "resetpassword"); !errors.Is(err, ErrUserNotFound) {
t.Errorf("unknown user: err = %v", err)
}
}
func TestUserLookup(t *testing.T) {
s, _, alice := bootstrap(t)
u, err := s.User(context.Background(), alice.ID)
if err != nil || u.Email != "alice@example.org" || !u.IsAdmin {
t.Fatalf("u = %+v err=%v", u, err)
}
if _, err := s.User(context.Background(), 999); !errors.Is(err, ErrUserNotFound) {
t.Errorf("err = %v", err)
}
}
func TestAnAddressIsTrimmedAndLowercased(t *testing.T) {
s, _ := newTestService()
ctx := context.Background()
u, err := s.Register(ctx, " Alice@Example.ORG ", "longenough")
if err != nil || u.Email != "alice@example.org" {
t.Fatalf("user = %+v err = %v", u, err)
}
if _, err := s.Login(ctx, " ALICE@example.org", "longenough"); err != nil {
t.Errorf("login with another spelling: %v", err)
}
if _, err := s.CreateUser(ctx, "alice@EXAMPLE.org", "longenough", false); !errors.Is(err, ErrEmailTaken) {
t.Errorf("same address, other case: err = %v", err)
}
}
// Accounts made before addresses were asked for have a plain name: it stays their login.
func TestAnOldAccountNameStillLogsIn(t *testing.T) {
s, st := newTestService()
hash, err := HashPassword("longenough")
if err != nil {
t.Fatal(err)
}
if _, err := st.CreateUser(context.Background(), "olduser", hash, true); err != nil {
t.Fatal(err)
}
if _, err := s.Login(context.Background(), "OldUser", "longenough"); err != nil {
t.Errorf("an old name no longer logs in: %v", err)
}
}