follow sql schema

This commit is contained in:
venture
2026-11-14 09:52:18 +01:00
parent f7649f24ef
commit 276a9fe320
23 changed files with 855 additions and 548 deletions
+35
View File
@@ -0,0 +1,35 @@
package auth
import (
"database/sql"
"errors"
"mediarr/ident"
"mediarr/identity"
)
type AuthenticatedUser struct {
Principal identity.Principal
Account Account
}
type Account struct {
PrincipalID ident.UUID
Login string
State string
MustChangePassword bool
FailedAttempts int64
LockedUntil sql.NullInt64
LastLoginAt sql.NullInt64
CreatedAt int64
}
var (
ErrInvalidCredentials = errors.New("identifiants invalides")
ErrAccountLocked = errors.New("compte verrouillé")
ErrAccountDisabled = errors.New("compte désactivé")
ErrLoginTaken = errors.New("login déjà utilisé")
ErrInvalidLogin = errors.New("login invalide")
ErrWeakPassword = errors.New("mot de passe trop faible")
ErrInvalidSession = errors.New("session invalide")
)
+42
View File
@@ -0,0 +1,42 @@
package auth
import (
"context"
"testing"
"mediarr/database"
)
func newTestService(t *testing.T) *Service {
t.Helper()
t.Chdir(t.TempDir())
err, db := database.NewDatabase(database.NewDatabaseParams{})
if err != nil {
t.Fatalf("NewDatabase : %v", err)
}
t.Cleanup(func() {
if err := db.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
return NewService(*db)
}
func mustCreateUser(t *testing.T, service *Service, login, password, role string) *AuthenticatedUser {
t.Helper()
created, err := service.CreateUser(context.Background(), CreateUserParams{
Login: login,
Password: password,
Role: role,
})
if err != nil {
t.Fatalf("CreateUser(%q) : %v", login, err)
}
return created
}
+1 -1
View File
@@ -1,4 +1,4 @@
package user
package auth
import (
"fmt"
+8 -8
View File
@@ -1,4 +1,4 @@
package user
package auth
import (
"crypto/rand"
@@ -32,7 +32,7 @@ func HashPassword(password string) (string, error) {
salt := make([]byte, argon2SaltLen)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("user: génération du sel : %w", err)
return "", fmt.Errorf("auth: génération du sel : %w", err)
}
key := argon2.IDKey([]byte(password), salt, argon2Time, argon2Memory, argon2Threads, argon2KeyLen)
@@ -64,23 +64,23 @@ func decodePasswordHash(encoded string) (argon2Params, []byte, []byte, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" {
return params, nil, nil, errors.New("user: hash Argon2id invalide")
return params, nil, nil, errors.New("auth: hash Argon2id invalide")
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
return params, nil, nil, errors.New("user: version Argon2id invalide")
return params, nil, nil, errors.New("auth: version Argon2id invalide")
}
var memory, iterations, threads uint32
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, &threads); err != nil {
return params, nil, nil, errors.New("user: paramètres Argon2id invalides")
return params, nil, nil, errors.New("auth: paramètres Argon2id invalides")
}
if memory < 8*1024 || memory > 1024*1024 ||
iterations < 1 || iterations > 10 ||
threads < 1 || threads > 16 {
return params, nil, nil, errors.New("user: paramètres Argon2id hors limites")
return params, nil, nil, errors.New("auth: paramètres Argon2id hors limites")
}
params = argon2Params{
@@ -91,12 +91,12 @@ func decodePasswordHash(encoded string) (argon2Params, []byte, []byte, error) {
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil || len(salt) < 8 || len(salt) > 64 {
return params, nil, nil, errors.New("user: sel Argon2id invalide")
return params, nil, nil, errors.New("auth: sel Argon2id invalide")
}
key, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil || len(key) < 16 || len(key) > 64 {
return params, nil, nil, errors.New("user: clé Argon2id invalide")
return params, nil, nil, errors.New("auth: clé Argon2id invalide")
}
return params, salt, key, nil
@@ -1,4 +1,4 @@
package user
package auth
import (
"errors"
+41
View File
@@ -0,0 +1,41 @@
package auth
import (
"context"
"strings"
"mediarr/database"
"mediarr/identity"
)
type Service struct {
db database.DatabaseClient
identity *identity.Service
}
func NewService(db database.DatabaseClient) *Service {
return &Service{
db: db,
identity: identity.NewService(db),
}
}
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer func() {
_ = tx.Rollback()
}()
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
return err
}
return tx.Commit()
}
func isUniqueViolation(err error) bool {
return err != nil && strings.Contains(strings.ToLower(err.Error()), "unique constraint failed")
}
+5 -5
View File
@@ -1,4 +1,4 @@
package user
package auth
import (
"context"
@@ -90,7 +90,7 @@ func (s *Service) CreateSession(ctx context.Context, params CreateSessionParams)
tokenBytes := make([]byte, sessionTokenBytes)
if _, err := rand.Read(tokenBytes); err != nil {
return nil, "", fmt.Errorf("user: génération du token de session : %w", err)
return nil, "", fmt.Errorf("auth: génération du token de session : %w", err)
}
token := base64.RawURLEncoding.EncodeToString(tokenBytes)
tokenHash := sha256.Sum256([]byte(token))
@@ -126,7 +126,7 @@ func (s *Service) CreateSession(ctx context.Context, params CreateSessionParams)
return sessionFromDB(session), token, nil
}
func (s *Service) ValidateSession(ctx context.Context, token string) (*Session, *User, error) {
func (s *Service) ValidateSession(ctx context.Context, token string) (*Session, *AuthenticatedUser, error) {
if token == "" {
return nil, nil, ErrInvalidSession
}
@@ -145,14 +145,14 @@ func (s *Service) ValidateSession(ctx context.Context, token string) (*Session,
return nil, nil, ErrInvalidSession
}
user, err := s.loadUser(ctx, session.PrincipalID)
user, err := s.loadAuthenticatedUser(ctx, session.PrincipalID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, ErrInvalidSession
}
return nil, nil, err
}
if user.Status != "active" || user.AccountState == "disabled" {
if user.Principal.Status != "active" || user.Account.State == "disabled" {
return nil, nil, ErrInvalidSession
}
+199
View File
@@ -0,0 +1,199 @@
package auth
import (
"context"
"errors"
"testing"
"time"
"mediarr/database"
"mediarr/identity"
)
func TestCreateAndValidateSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
session, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.Principal.ID,
Label: "test",
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if token == "" {
t.Fatal("token vide")
}
validated, authenticated, err := service.ValidateSession(ctx, token)
if err != nil {
t.Fatalf("ValidateSession : %v", err)
}
if validated.ID != session.ID {
t.Fatalf("id = %s, attendu %s", validated.ID, session.ID)
}
if authenticated.Principal.ID != created.Principal.ID {
t.Fatalf("principal = %s, attendu %s", authenticated.Principal.ID, created.Principal.ID)
}
_, _, err = service.ValidateSession(ctx, "mauvais-token")
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestRevokeSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
session, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.Principal.ID,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if err := service.RevokeSession(ctx, session.ID); err != nil {
t.Fatalf("RevokeSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestRevokeSessionByToken(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.Principal.ID,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if err := service.RevokeSessionByToken(ctx, token); err != nil {
t.Fatalf("RevokeSessionByToken : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestListAndDeleteExpiredSessions(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
if _, _, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.Principal.ID,
}); err != nil {
t.Fatalf("CreateSession : %v", err)
}
sessions, err := service.ListSessions(ctx, created.Principal.ID)
if err != nil {
t.Fatalf("ListSessions : %v", err)
}
if len(sessions) != 1 {
t.Fatalf("sessions = %d, attendu 1", len(sessions))
}
deleted, err := service.DeleteExpiredSessions(ctx)
if err != nil {
t.Fatalf("DeleteExpiredSessions : %v", err)
}
if deleted != 0 {
t.Fatalf("supprimées = %d, attendu 0", deleted)
}
}
func TestGuestSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
guest, err := identity.NewService(service.db).CreateGuest(ctx, "jean")
if err != nil {
t.Fatalf("CreateGuest : %v", err)
}
session, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: guest.ID,
Kind: "api",
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if session.Kind != "api" {
t.Fatalf("kind = %q, attendu api", session.Kind)
}
_, authenticated, err := service.ValidateSession(ctx, token)
if err != nil {
t.Fatalf("ValidateSession : %v", err)
}
if authenticated.Principal.ID != guest.ID {
t.Fatalf("principal = %s, attendu %s", authenticated.Principal.ID, guest.ID)
}
if authenticated.Account.Login != "jean" {
t.Fatalf("login = %q, attendu jean", authenticated.Account.Login)
}
if authenticated.Account.State != "active" {
t.Fatalf("state = %q, attendu active", authenticated.Account.State)
}
}
func TestCreateSessionRejectsInactivePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.db.WriteQueries.UpdatePrincipalStatus(ctx, database.UpdatePrincipalStatusParams{
Status: "disabled",
ID: created.Principal.ID,
})
if err != nil {
t.Fatalf("UpdatePrincipalStatus : %v", err)
}
_, _, err = service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.Principal.ID,
})
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestSessionExpiration(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.Principal.ID,
TTL: time.Millisecond,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
time.Sleep(2 * time.Millisecond)
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
+47 -54
View File
@@ -1,4 +1,4 @@
package user
package auth
import (
"context"
@@ -9,6 +9,7 @@ import (
"mediarr/database"
"mediarr/ident"
"mediarr/identity"
)
const (
@@ -16,30 +17,13 @@ const (
lockDuration = 15 * time.Minute
)
type User struct {
ID ident.UUID
Login string
Name string
Status string
AccountState string
MustChangePassword bool
CreatedAt int64
Groups []Group
}
type Group struct {
ID ident.UUID
Name string
Role string
}
type CreateUserParams struct {
Login string
Password string
Role string
}
func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*User, error) {
func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*AuthenticatedUser, error) {
display, key, err := normalizeLogin(params.Login)
if err != nil {
return nil, err
@@ -50,16 +34,22 @@ func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*Use
role := params.Role
if role == "" {
role = RoleMember
role = identity.RoleMember
}
groupName, err := groupNameForRole(role)
groupName, err := identity.GroupNameForRole(role)
if err != nil {
return nil, err
}
group, err := s.groupByName(ctx, groupName)
group, err := s.db.Queries.GetPrincipalByNameAndKind(ctx, database.GetPrincipalByNameAndKindParams{
Kind: identity.KindGroup,
Name: groupName,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", identity.ErrGroupNotFound, groupName)
}
return nil, err
}
@@ -78,7 +68,7 @@ func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*Use
err = s.withTx(ctx, func(q *database.Queries) error {
if _, err := q.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: userID,
Kind: "user",
Kind: identity.KindUser,
Name: display,
Status: "active",
CreatedAt: now,
@@ -109,7 +99,7 @@ func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*Use
_, err := q.CreateMembership(ctx, database.CreateMembershipParams{
GroupID: group.ID,
MemberID: userID,
Role: "member",
Role: identity.RoleMember,
CreatedAt: now,
})
return err
@@ -121,10 +111,10 @@ func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*Use
return nil, err
}
return s.loadUser(ctx, userID)
return s.loadAuthenticatedUser(ctx, userID)
}
func (s *Service) Authenticate(ctx context.Context, login, password string) (*User, error) {
func (s *Service) Authenticate(ctx context.Context, login, password string) (*AuthenticatedUser, error) {
_, key, err := normalizeLogin(login)
if err != nil {
return nil, ErrInvalidCredentials
@@ -203,7 +193,7 @@ func (s *Service) Authenticate(ctx context.Context, login, password string) (*Us
return nil, err
}
return s.loadUser(ctx, account.PrincipalID)
return s.loadAuthenticatedUser(ctx, account.PrincipalID)
}
func (s *Service) SetPassword(ctx context.Context, principalID ident.UUID, password string) error {
@@ -232,39 +222,42 @@ func (s *Service) SetPassword(ctx context.Context, principalID ident.UUID, passw
return err
}
func (s *Service) loadUser(ctx context.Context, id ident.UUID) (*User, error) {
principal, err := s.db.Queries.GetPrincipal(ctx, id)
func (s *Service) loadAuthenticatedUser(ctx context.Context, id ident.UUID) (*AuthenticatedUser, error) {
principal, err := s.identity.GetPrincipal(ctx, id)
if err != nil {
return nil, err
}
login := principal.Name
accountState := "active"
mustChangePassword := false
account, err := s.db.Queries.GetAccount(ctx, id)
switch {
case err == nil:
login = account.Login
accountState = account.State
mustChangePassword = account.MustChangePassword != 0
case !errors.Is(err, sql.ErrNoRows):
return nil, err
}
groups, err := s.ListGroups(ctx, id)
if err != nil {
return nil, err
}
return &User{
ID: principal.ID,
Login: login,
Name: principal.Name,
Status: principal.Status,
AccountState: accountState,
MustChangePassword: mustChangePassword,
CreatedAt: principal.CreatedAt,
Groups: groups,
return &AuthenticatedUser{
Principal: *principal,
Account: accountFromDB(account),
}, nil
case errors.Is(err, sql.ErrNoRows):
return &AuthenticatedUser{
Principal: *principal,
Account: Account{
PrincipalID: id,
Login: principal.Name,
State: "active",
},
}, nil
default:
return nil, err
}
}
func accountFromDB(account database.Account) Account {
return Account{
PrincipalID: account.PrincipalID,
Login: account.Login,
State: account.State,
MustChangePassword: account.MustChangePassword != 0,
FailedAttempts: account.FailedAttempts,
LockedUntil: account.LockedUntil,
LastLoginAt: account.LastLoginAt,
CreatedAt: account.CreatedAt,
}
}
+35 -34
View File
@@ -1,4 +1,4 @@
package user
package auth
import (
"context"
@@ -8,6 +8,7 @@ import (
"time"
"mediarr/database"
"mediarr/identity"
)
func TestCreateUser(t *testing.T) {
@@ -22,30 +23,30 @@ func TestCreateUser(t *testing.T) {
t.Fatalf("CreateUser : %v", err)
}
if created.ID.IsZero() {
if created.Principal.ID.IsZero() {
t.Fatal("identifiant utilisateur vide")
}
if created.Login != "Alice" {
t.Fatalf("login = %q, attendu Alice", created.Login)
if created.Account.Login != "Alice" {
t.Fatalf("login = %q, attendu Alice", created.Account.Login)
}
if created.Name != "Alice" {
t.Fatalf("name = %q, attendu Alice", created.Name)
if created.Principal.Name != "Alice" {
t.Fatalf("name = %q, attendu Alice", created.Principal.Name)
}
if created.Status != "active" {
t.Fatalf("status = %q, attendu active", created.Status)
if created.Principal.Status != "active" {
t.Fatalf("status = %q, attendu active", created.Principal.Status)
}
if created.AccountState != "active" {
t.Fatalf("état du compte = %q, attendu active", created.AccountState)
if created.Account.State != "active" {
t.Fatalf("état du compte = %q, attendu active", created.Account.State)
}
if len(created.Groups) != 1 || created.Groups[0].Name != "members" {
t.Fatalf("groupes = %+v, attendu members", created.Groups)
if len(created.Principal.Groups) != 1 || created.Principal.Groups[0].Name != "members" {
t.Fatalf("groupes = %+v, attendu members", created.Principal.Groups)
}
principal, err := service.db.Queries.GetPrincipal(ctx, created.ID)
principal, err := service.db.Queries.GetPrincipal(ctx, created.Principal.ID)
if err != nil {
t.Fatalf("GetPrincipal : %v", err)
}
if principal.Kind != "user" {
if principal.Kind != identity.KindUser {
t.Fatalf("kind = %q, attendu user", principal.Kind)
}
@@ -65,7 +66,7 @@ func TestCreateUserRejectsDuplicateLogin(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.CreateUser(ctx, CreateUserParams{
Login: "ALICE",
@@ -101,7 +102,7 @@ func TestCreateUserRejectsInvalidInput(t *testing.T) {
Password: "correct horse battery staple",
Role: "super-admin",
})
if !errors.Is(err, ErrInvalidRole) {
if !errors.Is(err, identity.ErrInvalidRole) {
t.Fatalf("rôle invalide : erreur = %v, attendu ErrInvalidRole", err)
}
}
@@ -109,10 +110,10 @@ func TestCreateUserRejectsInvalidInput(t *testing.T) {
func TestCreateUserAdmin(t *testing.T) {
service := newTestService(t)
created := mustCreateUser(t, service, "root", "correct horse battery staple", RoleAdmin)
created := mustCreateUser(t, service, "root", "correct horse battery staple", identity.RoleAdmin)
if len(created.Groups) != 1 || created.Groups[0].Name != "admins" {
t.Fatalf("groupes = %+v, attendu admins", created.Groups)
if len(created.Principal.Groups) != 1 || created.Principal.Groups[0].Name != "admins" {
t.Fatalf("groupes = %+v, attendu admins", created.Principal.Groups)
}
}
@@ -120,17 +121,17 @@ func TestAuthenticate(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
authenticated, err := service.Authenticate(ctx, "ALICE", "correct horse battery staple")
if err != nil {
t.Fatalf("Authenticate : %v", err)
}
if authenticated.ID != created.ID {
t.Fatalf("id = %s, attendu %s", authenticated.ID, created.ID)
if authenticated.Principal.ID != created.Principal.ID {
t.Fatalf("id = %s, attendu %s", authenticated.Principal.ID, created.Principal.ID)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
account, err := service.db.Queries.GetAccount(ctx, created.Principal.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
@@ -152,14 +153,14 @@ func TestAuthenticateRejectsWrongPassword(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.Authenticate(ctx, "alice", "mauvais mot de passe")
if !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("erreur = %v, attendu ErrInvalidCredentials", err)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
account, err := service.db.Queries.GetAccount(ctx, created.Principal.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
@@ -172,7 +173,7 @@ func TestAuthenticateLocksAccountAfterTooManyFailures(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
for attempt := 1; attempt <= maxFailedAttempts; attempt++ {
_, err := service.Authenticate(ctx, "alice", "mauvais mot de passe")
@@ -193,7 +194,7 @@ func TestAuthenticateLocksAccountAfterTooManyFailures(t *testing.T) {
t.Fatalf("erreur = %v, attendu ErrAccountLocked", err)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
account, err := service.db.Queries.GetAccount(ctx, created.Principal.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
@@ -209,14 +210,14 @@ func TestAuthenticateUnlocksExpiredAccount(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.db.WriteQueries.LockAccount(ctx, database.LockAccountParams{
LockedUntil: sql.NullInt64{
Int64: time.Now().Add(-time.Minute).UnixMilli(),
Valid: true,
},
PrincipalID: created.ID,
PrincipalID: created.Principal.ID,
})
if err != nil {
t.Fatalf("LockAccount : %v", err)
@@ -227,7 +228,7 @@ func TestAuthenticateUnlocksExpiredAccount(t *testing.T) {
t.Fatalf("Authenticate : %v", err)
}
account, err := service.db.Queries.GetAccount(ctx, created.ID)
account, err := service.db.Queries.GetAccount(ctx, created.Principal.ID)
if err != nil {
t.Fatalf("GetAccount : %v", err)
}
@@ -243,11 +244,11 @@ func TestAuthenticateRejectsDisabledAccount(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
_, err := service.db.WriteQueries.UpdateAccountState(ctx, database.UpdateAccountStateParams{
State: "disabled",
PrincipalID: created.ID,
PrincipalID: created.Principal.ID,
})
if err != nil {
t.Fatalf("UpdateAccountState : %v", err)
@@ -263,9 +264,9 @@ func TestSetPassword(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
created := mustCreateUser(t, service, "alice", "correct horse battery staple", identity.RoleMember)
if err := service.SetPassword(ctx, created.ID, "nouveau correct horse battery staple"); err != nil {
if err := service.SetPassword(ctx, created.Principal.ID, "nouveau correct horse battery staple"); err != nil {
t.Fatalf("SetPassword : %v", err)
}
+6 -13
View File
@@ -1,4 +1,4 @@
package user
package identity
import (
"context"
@@ -11,14 +11,7 @@ import (
"mediarr/ident"
)
type Member struct {
ID ident.UUID
Name string
Kind string
Role string
}
func groupNameForRole(role string) (string, error) {
func GroupNameForRole(role string) (string, error) {
switch role {
case RoleAdmin:
return "admins", nil
@@ -31,9 +24,9 @@ func groupNameForRole(role string) (string, error) {
func (s *Service) AddMember(ctx context.Context, groupID, memberID ident.UUID, role string) error {
if role == "" {
role = "member"
role = RoleMember
}
if role != "member" && role != "admin" {
if role != RoleAdmin && role != RoleMember {
return fmt.Errorf("%w: %q", ErrInvalidRole, role)
}
@@ -44,7 +37,7 @@ func (s *Service) AddMember(ctx context.Context, groupID, memberID ident.UUID, r
}
return err
}
if group.Kind != "group" {
if group.Kind != KindGroup {
return fmt.Errorf("%w: %s", ErrInvalidGroup, group.Kind)
}
@@ -55,7 +48,7 @@ func (s *Service) AddMember(ctx context.Context, groupID, memberID ident.UUID, r
}
return err
}
if member.Kind != "user" && member.Kind != "guest" {
if member.Kind != KindUser && member.Kind != KindGuest {
return fmt.Errorf("%w: %s", ErrInvalidMember, member.Kind)
}
+107
View File
@@ -0,0 +1,107 @@
package identity
import (
"context"
"errors"
"testing"
)
func TestAddAndRemoveMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
user := mustCreatePrincipal(t, service, KindUser, "alice")
members := mustGroup(t, service, "members")
admins := mustGroup(t, service, "admins")
if err := service.AddMember(ctx, members.ID, user.ID, RoleMember); err != nil {
t.Fatalf("AddMember(members) : %v", err)
}
if err := service.AddMember(ctx, admins.ID, user.ID, RoleAdmin); err != nil {
t.Fatalf("AddMember(admins) : %v", err)
}
groups, err := service.ListGroups(ctx, user.ID)
if err != nil {
t.Fatalf("ListGroups : %v", err)
}
if !hasGroup(groups, "members") || !hasGroup(groups, "admins") {
t.Fatalf("groupes = %+v, attendu members et admins", groups)
}
list, err := service.ListGroupMembers(ctx, admins.ID)
if err != nil {
t.Fatalf("ListGroupMembers : %v", err)
}
if len(list) != 1 || list[0].ID != user.ID || list[0].Role != RoleAdmin {
t.Fatalf("membres = %+v, attendu alice admin", list)
}
if err := service.RemoveMember(ctx, admins.ID, user.ID); err != nil {
t.Fatalf("RemoveMember : %v", err)
}
if err := service.RemoveMember(ctx, admins.ID, user.ID); !errors.Is(err, ErrNotMember) {
t.Fatalf("erreur = %v, attendu ErrNotMember", err)
}
}
func TestAddMemberRejectsDuplicate(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
user := mustCreatePrincipal(t, service, KindUser, "alice")
members := mustGroup(t, service, "members")
if err := service.AddMember(ctx, members.ID, user.ID, RoleMember); err != nil {
t.Fatalf("AddMember : %v", err)
}
err := service.AddMember(ctx, members.ID, user.ID, RoleMember)
if !errors.Is(err, ErrAlreadyMember) {
t.Fatalf("erreur = %v, attendu ErrAlreadyMember", err)
}
}
func TestAddMemberRejectsInvalidMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
user := mustCreatePrincipal(t, service, KindUser, "alice")
members := mustGroup(t, service, "members")
err := service.AddMember(ctx, members.ID, members.ID, RoleMember)
if !errors.Is(err, ErrInvalidMember) {
t.Fatalf("erreur = %v, attendu ErrInvalidMember", err)
}
err = service.AddMember(ctx, user.ID, user.ID, RoleMember)
if !errors.Is(err, ErrInvalidGroup) {
t.Fatalf("erreur = %v, attendu ErrInvalidGroup", err)
}
}
func TestGroupNameForRole(t *testing.T) {
name, err := GroupNameForRole(RoleAdmin)
if err != nil || name != "admins" {
t.Fatalf("admin : name = %q, err = %v", name, err)
}
name, err = GroupNameForRole(RoleMember)
if err != nil || name != "members" {
t.Fatalf("member : name = %q, err = %v", name, err)
}
if _, err := GroupNameForRole("super-admin"); !errors.Is(err, ErrInvalidRole) {
t.Fatalf("erreur = %v, attendu ErrInvalidRole", err)
}
}
func hasGroup(groups []Group, name string) bool {
for _, group := range groups {
if group.Name == name {
return true
}
}
return false
}
@@ -1,4 +1,4 @@
package user
package identity
import (
"context"
@@ -26,16 +26,15 @@ func newTestService(t *testing.T) *Service {
return NewService(*db)
}
func mustCreateUser(t *testing.T, service *Service, login, password, role string) *User {
func mustCreatePrincipal(t *testing.T, service *Service, kind, name string) *Principal {
t.Helper()
created, err := service.CreateUser(context.Background(), CreateUserParams{
Login: login,
Password: password,
Role: role,
created, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
Kind: kind,
Name: name,
})
if err != nil {
t.Fatalf("CreateUser(%q) : %v", login, err)
t.Fatalf("CreatePrincipal(%q) : %v", name, err)
}
return created
@@ -45,7 +44,7 @@ func mustGroup(t *testing.T, service *Service, name string) database.Principal {
t.Helper()
group, err := service.db.Queries.GetPrincipalByNameAndKind(context.Background(), database.GetPrincipalByNameAndKindParams{
Kind: "group",
Kind: KindGroup,
Name: name,
})
if err != nil {
+55
View File
@@ -0,0 +1,55 @@
package identity
import (
"errors"
"mediarr/ident"
)
const (
KindCluster = "cluster"
KindUser = "user"
KindGuest = "guest"
KindGroup = "group"
KindSystem = "system"
)
const (
RoleAdmin = "admin"
RoleMember = "member"
)
type Principal struct {
ID ident.UUID
Kind string
Name string
Status string
CreatedAt int64
Groups []Group
}
type Group struct {
ID ident.UUID
Name string
Role string
}
type Member struct {
ID ident.UUID
Name string
Kind string
Role string
}
var (
ErrInvalidRole = errors.New("rôle invalide")
ErrAlreadyMember = errors.New("membre déjà présent dans le groupe")
ErrNotMember = errors.New("membre absent du groupe")
ErrInvalidMember = errors.New("membre invalide : utilisateur ou invité attendu")
ErrInvalidGroup = errors.New("groupe invalide")
ErrGroupNotFound = errors.New("groupe introuvable")
ErrNameTaken = errors.New("nom déjà utilisé")
ErrInvalidKind = errors.New("type de principal invalide")
ErrInvalidName = errors.New("nom invalide")
ErrInvalidStatus = errors.New("statut de principal invalide")
)
+142
View File
@@ -0,0 +1,142 @@
package identity
import (
"context"
"fmt"
"strings"
"time"
"mediarr/database"
"mediarr/ident"
)
const maxNameLen = 255
type CreatePrincipalParams struct {
Kind string
Name string
PublicKey []byte
Status string
}
func (s *Service) CreatePrincipal(ctx context.Context, params CreatePrincipalParams) (*Principal, error) {
if !validKind(params.Kind) {
return nil, fmt.Errorf("%w: %q", ErrInvalidKind, params.Kind)
}
name := strings.TrimSpace(params.Name)
if name == "" || len(name) > maxNameLen {
return nil, fmt.Errorf("%w: %q", ErrInvalidName, params.Name)
}
status := params.Status
if status == "" {
status = "active"
}
if status != "active" && status != "disabled" && status != "revoked" {
return nil, fmt.Errorf("%w: %q", ErrInvalidStatus, status)
}
if params.Kind == KindCluster && len(params.PublicKey) == 0 {
return nil, fmt.Errorf("%w: clé publique requise pour un cluster", ErrInvalidKind)
}
id, err := ident.NewV7()
if err != nil {
return nil, err
}
_, err = s.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: id,
Kind: params.Kind,
Name: name,
PublicKey: params.PublicKey,
Status: status,
CreatedAt: time.Now().UnixMilli(),
})
if err != nil {
if isUniqueViolation(err) {
return nil, fmt.Errorf("%w: %s", ErrNameTaken, name)
}
return nil, err
}
return s.GetPrincipal(ctx, id)
}
func (s *Service) CreateGuest(ctx context.Context, name string) (*Principal, error) {
group, err := s.groupByName(ctx, "guests")
if err != nil {
return nil, err
}
name = strings.TrimSpace(name)
if name == "" || len(name) > maxNameLen {
return nil, fmt.Errorf("%w: %q", ErrInvalidName, name)
}
id, err := ident.NewV7()
if err != nil {
return nil, err
}
now := time.Now().UnixMilli()
err = s.withTx(ctx, func(q *database.Queries) error {
if _, err := q.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: id,
Kind: KindGuest,
Name: name,
Status: "active",
CreatedAt: now,
}); err != nil {
return err
}
_, err := q.CreateMembership(ctx, database.CreateMembershipParams{
GroupID: group.ID,
MemberID: id,
Role: RoleMember,
CreatedAt: now,
})
return err
})
if err != nil {
if isUniqueViolation(err) {
return nil, fmt.Errorf("%w: %s", ErrNameTaken, name)
}
return nil, err
}
return s.GetPrincipal(ctx, id)
}
func (s *Service) GetPrincipal(ctx context.Context, id ident.UUID) (*Principal, error) {
principal, err := s.db.Queries.GetPrincipal(ctx, id)
if err != nil {
return nil, err
}
groups, err := s.ListGroups(ctx, id)
if err != nil {
return nil, err
}
return &Principal{
ID: principal.ID,
Kind: principal.Kind,
Name: principal.Name,
Status: principal.Status,
CreatedAt: principal.CreatedAt,
Groups: groups,
}, nil
}
func validKind(kind string) bool {
switch kind {
case KindCluster, KindUser, KindGuest, KindGroup, KindSystem:
return true
default:
return false
}
}
+107
View File
@@ -0,0 +1,107 @@
package identity
import (
"context"
"errors"
"testing"
)
func TestCreatePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created, err := service.CreatePrincipal(ctx, CreatePrincipalParams{
Kind: KindUser,
Name: "alice",
})
if err != nil {
t.Fatalf("CreatePrincipal : %v", err)
}
if created.ID.IsZero() {
t.Fatal("identifiant vide")
}
if created.Kind != KindUser {
t.Fatalf("kind = %q, attendu %q", created.Kind, KindUser)
}
if created.Name != "alice" {
t.Fatalf("name = %q, attendu alice", created.Name)
}
if created.Status != "active" {
t.Fatalf("status = %q, attendu active", created.Status)
}
if len(created.Groups) != 0 {
t.Fatalf("groupes = %+v, attendu aucun", created.Groups)
}
}
func TestCreatePrincipalRejectsDuplicateName(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
mustCreatePrincipal(t, service, KindUser, "alice")
_, err := service.CreatePrincipal(ctx, CreatePrincipalParams{
Kind: KindUser,
Name: "alice",
})
if !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
}
func TestCreatePrincipalRejectsInvalidKind(t *testing.T) {
service := newTestService(t)
_, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
Kind: "robot",
Name: "r2d2",
})
if !errors.Is(err, ErrInvalidKind) {
t.Fatalf("erreur = %v, attendu ErrInvalidKind", err)
}
}
func TestCreatePrincipalRejectsInvalidName(t *testing.T) {
service := newTestService(t)
_, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
Kind: KindUser,
Name: " ",
})
if !errors.Is(err, ErrInvalidName) {
t.Fatalf("erreur = %v, attendu ErrInvalidName", err)
}
}
func TestCreateGuest(t *testing.T) {
service := newTestService(t)
guest, err := service.CreateGuest(context.Background(), "jean")
if err != nil {
t.Fatalf("CreateGuest : %v", err)
}
if guest.Kind != KindGuest {
t.Fatalf("kind = %q, attendu %q", guest.Kind, KindGuest)
}
if guest.Name != "jean" {
t.Fatalf("name = %q, attendu jean", guest.Name)
}
if len(guest.Groups) != 1 || guest.Groups[0].Name != "guests" {
t.Fatalf("groupes = %+v, attendu guests", guest.Groups)
}
}
func TestCreateGuestRejectsDuplicateName(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
if _, err := service.CreateGuest(ctx, "jean"); err != nil {
t.Fatalf("CreateGuest : %v", err)
}
if _, err := service.CreateGuest(ctx, "jean"); !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
}
+2 -2
View File
@@ -1,4 +1,4 @@
package user
package identity
import (
"context"
@@ -40,7 +40,7 @@ func isUniqueViolation(err error) bool {
func (s *Service) groupByName(ctx context.Context, name string) (database.Principal, error) {
group, err := s.db.Queries.GetPrincipalByNameAndKind(ctx, database.GetPrincipalByNameAndKindParams{
Kind: "group",
Kind: KindGroup,
Name: name,
})
if err != nil {
+8 -3
View File
@@ -1,9 +1,10 @@
package node
import (
"mediarr/auth"
"mediarr/cluster"
"mediarr/database"
"mediarr/user"
"mediarr/identity"
)
type Node struct {
@@ -51,6 +52,10 @@ func (n *Node) ClusterIdentity() cluster.Identity {
return n.cluster
}
func (n *Node) Users() *user.Service {
return user.NewService(n.db)
func (n *Node) Identity() *identity.Service {
return identity.NewService(n.db)
}
func (n *Node) Auth() *auth.Service {
return auth.NewService(n.db)
}
@@ -4,30 +4,34 @@ import (
"context"
"testing"
"mediarr/user"
"mediarr/auth"
)
func TestNodeUsers(t *testing.T) {
func TestNodeAuth(t *testing.T) {
t.Chdir(t.TempDir())
err, node := NewNode(NewNodeParams{DatabaseName: "users"})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() { _ = node.Close() })
t.Cleanup(func() {
if err := node.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
if err := node.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
created, err := node.Users().CreateUser(context.Background(), user.CreateUserParams{
created, err := node.Auth().CreateUser(context.Background(), auth.CreateUserParams{
Login: "alice",
Password: "correct horse battery staple",
})
if err != nil {
t.Fatalf("CreateUser : %v", err)
}
if created.Login != "alice" {
t.Fatalf("login = %q, attendu alice", created.Login)
if created.Account.Login != "alice" {
t.Fatalf("login = %q, attendu alice", created.Account.Login)
}
}
-19
View File
@@ -1,19 +0,0 @@
package user
import "errors"
var (
ErrInvalidCredentials = errors.New("identifiants invalides")
ErrAccountLocked = errors.New("compte verrouillé")
ErrAccountDisabled = errors.New("compte désactivé")
ErrLoginTaken = errors.New("login déjà utilisé")
ErrInvalidLogin = errors.New("login invalide")
ErrWeakPassword = errors.New("mot de passe trop faible")
ErrInvalidSession = errors.New("session invalide")
ErrInvalidRole = errors.New("rôle invalide")
ErrAlreadyMember = errors.New("membre déjà présent dans le groupe")
ErrNotMember = errors.New("membre absent du groupe")
ErrInvalidMember = errors.New("membre invalide : utilisateur ou invité attendu")
ErrInvalidGroup = errors.New("groupe invalide")
ErrGroupNotFound = errors.New("groupe introuvable")
)
-83
View File
@@ -1,83 +0,0 @@
package user
import (
"context"
"errors"
"testing"
)
func TestAddAndRemoveMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
admins := mustGroup(t, service, "admins")
if err := service.AddMember(ctx, admins.ID, created.ID, "admin"); err != nil {
t.Fatalf("AddMember : %v", err)
}
groups, err := service.ListGroups(ctx, created.ID)
if err != nil {
t.Fatalf("ListGroups : %v", err)
}
if !hasGroup(groups, "admins") || !hasGroup(groups, "members") {
t.Fatalf("groupes = %+v, attendu admins et members", groups)
}
members, err := service.ListGroupMembers(ctx, admins.ID)
if err != nil {
t.Fatalf("ListGroupMembers : %v", err)
}
if len(members) != 1 || members[0].ID != created.ID || members[0].Role != "admin" {
t.Fatalf("membres = %+v, attendu alice admin", members)
}
if err := service.RemoveMember(ctx, admins.ID, created.ID); err != nil {
t.Fatalf("RemoveMember : %v", err)
}
if err := service.RemoveMember(ctx, admins.ID, created.ID); !errors.Is(err, ErrNotMember) {
t.Fatalf("erreur = %v, attendu ErrNotMember", err)
}
}
func TestAddMemberRejectsDuplicate(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
members := mustGroup(t, service, "members")
err := service.AddMember(ctx, members.ID, created.ID, "member")
if !errors.Is(err, ErrAlreadyMember) {
t.Fatalf("erreur = %v, attendu ErrAlreadyMember", err)
}
}
func TestAddMemberRejectsInvalidMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
members := mustGroup(t, service, "members")
err := service.AddMember(ctx, members.ID, members.ID, "member")
if !errors.Is(err, ErrInvalidMember) {
t.Fatalf("erreur = %v, attendu ErrInvalidMember", err)
}
err = service.AddMember(ctx, created.ID, created.ID, "member")
if !errors.Is(err, ErrInvalidGroup) {
t.Fatalf("erreur = %v, attendu ErrInvalidGroup", err)
}
}
func hasGroup(groups []Group, name string) bool {
for _, group := range groups {
if group.Name == name {
return true
}
}
return false
}
-7
View File
@@ -1,7 +0,0 @@
package user
const (
RoleAdmin = "admin"
RoleMember = "member"
RoleGuest = "guest"
)
-307
View File
@@ -1,307 +0,0 @@
package user
import (
"context"
"crypto/sha256"
"database/sql"
"errors"
"testing"
"time"
"mediarr/database"
"mediarr/ident"
)
func TestCreateAndValidateSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
session, token, err := service.CreateSession(ctx, CreateSessionParams{
PrincipalID: created.ID,
Kind: "web",
Label: "test",
UserAgent: "go-test",
IPPrefix: "127.0.0.",
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if token == "" {
t.Fatal("token vide")
}
if session.ID.IsZero() {
t.Fatal("identifiant de session vide")
}
tokenHash := sha256.Sum256([]byte(token))
stored, err := service.db.Queries.GetSessionByTokenHash(ctx, tokenHash[:])
if err != nil {
t.Fatalf("GetSessionByTokenHash : %v", err)
}
if len(stored.TokenHash) != 32 {
t.Fatalf("token_hash de %d octets, attendu 32", len(stored.TokenHash))
}
validated, authenticated, err := service.ValidateSession(ctx, token)
if err != nil {
t.Fatalf("ValidateSession : %v", err)
}
if validated.ID != session.ID {
t.Fatalf("id = %s, attendu %s", validated.ID, session.ID)
}
if authenticated.ID != created.ID {
t.Fatalf("utilisateur = %s, attendu %s", authenticated.ID, created.ID)
}
if validated.LastSeenAt < session.LastSeenAt {
t.Fatalf("last_seen_at = %d, attendu >= %d", validated.LastSeenAt, session.LastSeenAt)
}
}
func TestValidateSessionRejectsUnknownToken(t *testing.T) {
service := newTestService(t)
_, _, err := service.ValidateSession(context.Background(), "inconnu")
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestRevokeSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
session, token, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if err := service.RevokeSession(ctx, session.ID); err != nil {
t.Fatalf("RevokeSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestRevokeSessionByToken(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, token, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
if err := service.RevokeSessionByToken(ctx, token); err != nil {
t.Fatalf("RevokeSessionByToken : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestValidateSessionRejectsExpiredSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
token := "session-expiree"
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UnixMilli()
sessionID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: created.ID,
Kind: "web",
CreatedAt: now - 2000,
LastSeenAt: now - 2000,
ExpiresAt: now - 1,
IdleExpiresAt: now + 60_000,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestValidateSessionRejectsIdleExpiredSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
token := "session-inactive"
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UnixMilli()
sessionID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: created.ID,
Kind: "web",
CreatedAt: now - 2000,
LastSeenAt: now - 2000,
ExpiresAt: now + 60_000,
IdleExpiresAt: now - 1,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
_, _, err = service.ValidateSession(ctx, token)
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestCreateSessionRejectsInactivePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, err := service.db.WriteQueries.UpdatePrincipalStatus(ctx, database.UpdatePrincipalStatusParams{
Status: "disabled",
DisabledAt: sql.NullInt64{
Int64: time.Now().UnixMilli(),
Valid: true,
},
ID: created.ID,
})
if err != nil {
t.Fatalf("UpdatePrincipalStatus : %v", err)
}
_, _, err = service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if !errors.Is(err, ErrInvalidSession) {
t.Fatalf("erreur = %v, attendu ErrInvalidSession", err)
}
}
func TestListAndDeleteExpiredSessions(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created := mustCreateUser(t, service, "alice", "correct horse battery staple", RoleMember)
_, _, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: created.ID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
token := "session-expiree-liste"
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UnixMilli()
sessionID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreateSession(ctx, database.CreateSessionParams{
ID: sessionID,
TokenHash: tokenHash[:],
PrincipalID: created.ID,
Kind: "web",
CreatedAt: now - 2000,
LastSeenAt: now - 2000,
ExpiresAt: now - 1,
IdleExpiresAt: now - 1,
})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
sessions, err := service.ListSessions(ctx, created.ID)
if err != nil {
t.Fatalf("ListSessions : %v", err)
}
if len(sessions) != 2 {
t.Fatalf("sessions = %d, attendu 2", len(sessions))
}
deleted, err := service.DeleteExpiredSessions(ctx)
if err != nil {
t.Fatalf("DeleteExpiredSessions : %v", err)
}
if deleted != 1 {
t.Fatalf("sessions supprimées = %d, attendu 1", deleted)
}
sessions, err = service.ListSessions(ctx, created.ID)
if err != nil {
t.Fatalf("ListSessions : %v", err)
}
if len(sessions) != 1 {
t.Fatalf("sessions = %d, attendu 1", len(sessions))
}
}
func TestGuestSession(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
guestID, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: guestID,
Kind: "guest",
Name: "jean",
Status: "active",
CreatedAt: time.Now().UnixMilli(),
})
if err != nil {
t.Fatalf("CreatePrincipal : %v", err)
}
session, token, err := service.CreateSession(ctx, CreateSessionParams{PrincipalID: guestID})
if err != nil {
t.Fatalf("CreateSession : %v", err)
}
validated, guest, err := service.ValidateSession(ctx, token)
if err != nil {
t.Fatalf("ValidateSession : %v", err)
}
if validated.ID != session.ID {
t.Fatalf("id = %s, attendu %s", validated.ID, session.ID)
}
if guest.ID != guestID {
t.Fatalf("id invité = %s, attendu %s", guest.ID, guestID)
}
if guest.Login != "jean" {
t.Fatalf("login = %q, attendu jean", guest.Login)
}
if guest.AccountState != "active" {
t.Fatalf("état = %q, attendu active", guest.AccountState)
}
}