From 276a9fe32022396480992d2ad21ca3fd272138f4 Mon Sep 17 00:00:00 2001 From: venture Date: Sat, 14 Nov 2026 09:52:18 +0100 Subject: [PATCH] follow sql schema --- auth/auth.go | 35 ++ auth/helpers_test.go | 42 +++ {user => auth}/login.go | 2 +- {user => auth}/password.go | 16 +- {user => auth}/password_test.go | 2 +- auth/service.go | 41 +++ {user => auth}/session.go | 10 +- auth/session_test.go | 199 ++++++++++++ {user => auth}/user.go | 95 +++--- {user => auth}/user_test.go | 69 ++-- {user => identity}/group.go | 19 +- identity/group_test.go | 107 ++++++ {user => identity}/helpers_test.go | 15 +- identity/identity.go | 55 ++++ identity/principal.go | 142 ++++++++ identity/principal_test.go | 107 ++++++ {user => identity}/service.go | 4 +- node/node.go | 11 +- node/{node_user_test.go => node_auth_test.go} | 16 +- user/errors.go | 19 -- user/group_test.go | 83 ----- user/role.go | 7 - user/session_test.go | 307 ------------------ 23 files changed, 855 insertions(+), 548 deletions(-) create mode 100644 auth/auth.go create mode 100644 auth/helpers_test.go rename {user => auth}/login.go (98%) rename {user => auth}/password.go (82%) rename {user => auth}/password_test.go (99%) create mode 100644 auth/service.go rename {user => auth}/session.go (95%) create mode 100644 auth/session_test.go rename {user => auth}/user.go (74%) rename {user => auth}/user_test.go (79%) rename {user => identity}/group.go (89%) create mode 100644 identity/group_test.go rename {user => identity}/helpers_test.go (71%) create mode 100644 identity/identity.go create mode 100644 identity/principal.go create mode 100644 identity/principal_test.go rename {user => identity}/service.go (96%) rename node/{node_user_test.go => node_auth_test.go} (53%) delete mode 100644 user/errors.go delete mode 100644 user/group_test.go delete mode 100644 user/role.go delete mode 100644 user/session_test.go diff --git a/auth/auth.go b/auth/auth.go new file mode 100644 index 0000000..f020479 --- /dev/null +++ b/auth/auth.go @@ -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") +) diff --git a/auth/helpers_test.go b/auth/helpers_test.go new file mode 100644 index 0000000..5b62c68 --- /dev/null +++ b/auth/helpers_test.go @@ -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 +} diff --git a/user/login.go b/auth/login.go similarity index 98% rename from user/login.go rename to auth/login.go index e5214e4..1670d8f 100644 --- a/user/login.go +++ b/auth/login.go @@ -1,4 +1,4 @@ -package user +package auth import ( "fmt" diff --git a/user/password.go b/auth/password.go similarity index 82% rename from user/password.go rename to auth/password.go index 26893e9..b87ca58 100644 --- a/user/password.go +++ b/auth/password.go @@ -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 diff --git a/user/password_test.go b/auth/password_test.go similarity index 99% rename from user/password_test.go rename to auth/password_test.go index 17d932a..a062a4d 100644 --- a/user/password_test.go +++ b/auth/password_test.go @@ -1,4 +1,4 @@ -package user +package auth import ( "errors" diff --git a/auth/service.go b/auth/service.go new file mode 100644 index 0000000..c89d9b2 --- /dev/null +++ b/auth/service.go @@ -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") +} diff --git a/user/session.go b/auth/session.go similarity index 95% rename from user/session.go rename to auth/session.go index 137a42c..7893be8 100644 --- a/user/session.go +++ b/auth/session.go @@ -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 } diff --git a/auth/session_test.go b/auth/session_test.go new file mode 100644 index 0000000..2382cdd --- /dev/null +++ b/auth/session_test.go @@ -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) + } +} diff --git a/user/user.go b/auth/user.go similarity index 74% rename from user/user.go rename to auth/user.go index 6b2cf39..e7a15dd 100644 --- a/user/user.go +++ b/auth/user.go @@ -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 &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 } +} - groups, err := s.ListGroups(ctx, id) - if err != nil { - 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, } - - return &User{ - ID: principal.ID, - Login: login, - Name: principal.Name, - Status: principal.Status, - AccountState: accountState, - MustChangePassword: mustChangePassword, - CreatedAt: principal.CreatedAt, - Groups: groups, - }, nil } diff --git a/user/user_test.go b/auth/user_test.go similarity index 79% rename from user/user_test.go rename to auth/user_test.go index 6d557e5..c9aeb00 100644 --- a/user/user_test.go +++ b/auth/user_test.go @@ -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) } diff --git a/user/group.go b/identity/group.go similarity index 89% rename from user/group.go rename to identity/group.go index 55ba7bf..9f5d396 100644 --- a/user/group.go +++ b/identity/group.go @@ -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) } diff --git a/identity/group_test.go b/identity/group_test.go new file mode 100644 index 0000000..e5ca18a --- /dev/null +++ b/identity/group_test.go @@ -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 +} diff --git a/user/helpers_test.go b/identity/helpers_test.go similarity index 71% rename from user/helpers_test.go rename to identity/helpers_test.go index 895dd5d..1937743 100644 --- a/user/helpers_test.go +++ b/identity/helpers_test.go @@ -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 { diff --git a/identity/identity.go b/identity/identity.go new file mode 100644 index 0000000..d7628ed --- /dev/null +++ b/identity/identity.go @@ -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") +) diff --git a/identity/principal.go b/identity/principal.go new file mode 100644 index 0000000..937632c --- /dev/null +++ b/identity/principal.go @@ -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 + } +} diff --git a/identity/principal_test.go b/identity/principal_test.go new file mode 100644 index 0000000..5a67045 --- /dev/null +++ b/identity/principal_test.go @@ -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) + } +} diff --git a/user/service.go b/identity/service.go similarity index 96% rename from user/service.go rename to identity/service.go index 88e3a4c..9fa7226 100644 --- a/user/service.go +++ b/identity/service.go @@ -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 { diff --git a/node/node.go b/node/node.go index 84e7e91..9e839f4 100644 --- a/node/node.go +++ b/node/node.go @@ -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) } diff --git a/node/node_user_test.go b/node/node_auth_test.go similarity index 53% rename from node/node_user_test.go rename to node/node_auth_test.go index 1efb099..a266a39 100644 --- a/node/node_user_test.go +++ b/node/node_auth_test.go @@ -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) } } diff --git a/user/errors.go b/user/errors.go deleted file mode 100644 index 8ee86da..0000000 --- a/user/errors.go +++ /dev/null @@ -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") -) diff --git a/user/group_test.go b/user/group_test.go deleted file mode 100644 index 02467da..0000000 --- a/user/group_test.go +++ /dev/null @@ -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 -} diff --git a/user/role.go b/user/role.go deleted file mode 100644 index 7dd56b7..0000000 --- a/user/role.go +++ /dev/null @@ -1,7 +0,0 @@ -package user - -const ( - RoleAdmin = "admin" - RoleMember = "member" - RoleGuest = "guest" -) diff --git a/user/session_test.go b/user/session_test.go deleted file mode 100644 index 97741df..0000000 --- a/user/session_test.go +++ /dev/null @@ -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) - } -}