Files
archie/modules/governance/auth_test.go
T
samandCopilot c12f6b7947 feat(governance): sign in to the archie binary from the Vue dashboard (#2017)
The binary serves the account routes the Vue client already calls: status,
setup, password and passkey sign-in, recovery, sign-out, OIDC, account
passkeys, password and recovery codes, personal tokens and capabilities.
The API authenticates a session cookie, a personal token or the bootstrap
admin token, and unsafe requests pass cross-origin protection. The
dashboard serves the Vue app at /.

Copied from internal/webui/{accounts,passkeys,personal_tokens,
api_capabilities,auth}.go, internal/infrastructure/oidc/{flow,oidc}.go and
internal/app/archieui/account_oidc.go, which archie-ui still imports.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-20 00:30:11 +11:00

139 lines
5.9 KiB
Go

package governance
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/platform/httpapi"
"github.com/samcharles93/archie-core/internal/platform/httpjson"
)
// fakeCredentials holds sessions and personal tokens by their raw value.
type fakeCredentials struct {
sessions map[string]Identity
tokens map[Subject]PersonalToken
subjects map[Subject]Identity
principals map[IdentityID]Principal
}
func (f fakeCredentials) ResolveAccountSession(_ context.Context, token string) (Identity, error) {
if token == "broken" {
return Identity{}, errors.New("database down")
}
if v, ok := f.sessions[token]; ok {
return v, nil
}
return Identity{}, ErrIdentityNotFound
}
func (f fakeCredentials) ResolveSubject(_ context.Context, s Subject) (Identity, error) {
if v, ok := f.subjects[s]; ok {
return v, nil
}
return Identity{}, ErrIdentityNotFound
}
func (f fakeCredentials) PersonalTokenOf(_ context.Context, s Subject) (PersonalToken, error) {
if v, ok := f.tokens[s]; ok {
return v, nil
}
return PersonalToken{}, ErrIdentityNotFound
}
func (fakeCredentials) TouchPersonalToken(context.Context, Subject, time.Time) error { return nil }
func (f fakeCredentials) PrincipalFor(_ context.Context, id IdentityID) (Principal, error) {
return f.principals[id], nil
}
// TestAuthenticateRequest guards the API's credential check: a session
// cookie or personal token acts as its own identity with that identity's
// role, the bootstrap admin token acts as the instance owner, and a
// tampered, expired or inactive credential is refused rather than acting as
// anyone.
func TestAuthenticateRequest(t *testing.T) {
const admin = "a-plainly-fake-admin-token" //nolint:gosec // test fixture, not a credential
now := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
past := now.Add(-time.Hour)
owner := Identity{ID: "owner", Kind: KindUser, Lifecycle: LifecycleActive}
viewer := Identity{ID: "viewer", Kind: KindUser, Lifecycle: LifecycleActive}
suspended := Identity{ID: "suspended", Kind: KindUser, Lifecycle: LifecycleSuspended}
ownerToken, ownerSubject := personalToken(t)
viewerToken, viewerSubject := personalToken(t)
expiredToken, expiredSubject := personalToken(t)
creds := fakeCredentials{
sessions: map[string]Identity{"owner-session": owner, "viewer-session": viewer, "suspended-session": suspended},
tokens: map[Subject]PersonalToken{
ownerSubject: {}, viewerSubject: {}, expiredSubject: {ExpiresAt: &past},
},
subjects: map[Subject]Identity{ownerSubject: owner, viewerSubject: viewer, expiredSubject: owner},
principals: map[IdentityID]Principal{
"owner": {IdentityID: "owner", Org: DefaultOrgID, Memberships: []Membership{{IdentityID: "owner", OrgID: DefaultOrgID, Role: RoleOwner}}},
"viewer": {IdentityID: "viewer", Org: DefaultOrgID, Memberships: []Membership{{IdentityID: "viewer", OrgID: DefaultOrgID, Role: RoleViewer}}},
},
}
tests := []struct {
name, cookie, bearer, adminHash string
wantErr error
wantID IdentityID
wantRole Role
wantAdmin bool
}{
{name: "no credential", wantErr: httpapi.ErrUnauthenticated},
{name: "owner session", cookie: "owner-session", wantID: "owner", wantRole: RoleOwner, wantAdmin: true},
{name: "viewer session", cookie: "viewer-session", wantID: "viewer", wantRole: RoleViewer},
{name: "tampered session", cookie: "owner-sessiom", wantErr: httpapi.ErrUnauthenticated},
{name: "suspended identity's session", cookie: "suspended-session", wantErr: httpapi.ErrUnauthenticated},
{name: "a failed session lookup is not a refusal", cookie: "broken", wantErr: errors.New("any")},
{name: "owner's personal token", bearer: ownerToken, wantID: "owner", wantRole: RoleOwner, wantAdmin: true},
{name: "viewer's personal token keeps the viewer role", bearer: viewerToken, wantID: "viewer", wantRole: RoleViewer},
{name: "expired personal token", bearer: expiredToken, wantErr: httpapi.ErrUnauthenticated},
{name: "unknown personal token", bearer: "archie_pat_00", wantErr: httpapi.ErrUnauthenticated}, //nolint:gosec // G101: a token no store holds, which must be refused.
{name: "admin token", bearer: admin, adminHash: httpjson.TokenHash(admin), wantID: SystemID, wantRole: RoleOwner, wantAdmin: true},
{name: "wrong admin token", bearer: "other", adminHash: httpjson.TokenHash(admin), wantErr: httpapi.ErrUnauthenticated},
{name: "no admin hash locks the admin token out", bearer: admin, wantErr: httpapi.ErrUnauthenticated},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
auth := authenticator{creds: creds, adminHash: tt.adminHash, now: func() time.Time { return now }}
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/thing", nil)
if tt.cookie != "" {
req.AddCookie(&http.Cookie{Name: httpapi.SessionCookie, Value: tt.cookie}) //nolint:gosec // G124: a request cookie; attributes are the server's to set.
}
if tt.bearer != "" {
req.Header.Set("Authorization", "Bearer "+tt.bearer)
}
acting, admin, err := auth.Authenticate(req.Context(), req)
if tt.wantErr != nil {
if err == nil {
t.Fatal("authenticated, want refused")
}
if errors.Is(tt.wantErr, httpapi.ErrUnauthenticated) != errors.Is(err, httpapi.ErrUnauthenticated) {
t.Fatalf("err = %v, want %v", err, tt.wantErr)
}
return
}
if err != nil {
t.Fatalf("Authenticate: %v", err)
}
p, ok := PrincipalFromContext(acting)
if !ok || p.IdentityID != tt.wantID || p.Role("") != tt.wantRole || admin != tt.wantAdmin {
t.Fatalf("acts as %s role %q admin %v, want %s role %q admin %v", p.IdentityID, p.Role(""), admin, tt.wantID, tt.wantRole, tt.wantAdmin)
}
})
}
}
func personalToken(t *testing.T) (string, Subject) {
t.Helper()
raw, subject, err := NewPersonalToken()
if err != nil {
t.Fatal(err)
}
return raw, subject
}