mirror of
https://github.com/hanzoai/ca.git
synced 2026-11-03 18:08:27 +00:00
* Fix issues F-003, 006, 001, 022
* Fix issues F-025, 026, 010, 008
- Login tokens name their identity provider in the `provider` claim;
SelectOrg and GetUserToken read it with pb.IDPFromString, which also
takes the number older tokens carry, and AuthenticateAPIKey answers
Provider Undefined.
- A login that fails after the callback decodes its state lands on the
redirect URI of the client, in its response mode, with `error` and
`error_description` (RFC 6749 section 4.1.2.1); a server-side failure
is described by its status text only. The calls to an IdP take the
request context and a client with a timeout, and the answer of the IdP
stays in the server log.
- The platform bootstrap reads its ca-config with ca.LoadBootstrapConfig,
which refuses an issuer URL template with `${ISSUER_ID}` or
`$ISSUER_ID`: the loader expands them to an empty string. The proto,
README and CLI help name `:ISSUER_ID`.
- CaDb.RegisterIssuer takes the trust anchor of a root issuer and writes
both in one transaction; the backend service and the bootstrap pass it,
and an anchor registered in another scope is AlreadyExists.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
* Address PR review comments
- Invite acceptance deletes the invite in its transaction
(query.TakeInvite, DELETE ... RETURNING) and grants from the deleted
row: a withdrawn or already accepted invite grants nothing, a re-issued
one grants its current role, and an email mismatch, an expired invite or
a failed grant rolls the delete back.
- CaDb.RegisterIssuer requires the anchor of a root issuer and refuses one
for any other issuer; the service always builds it for a root.
- The OAuth response is merged into the query of a redirect URI that has
one, and replaces its fragment in fragment mode.
- The codemap describes the transactions of RegisterOrg and the invite
acceptance.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
---------
Co-authored-by: Claude Opus 5.5 <[email protected]>
338 lines
10 KiB
Go
338 lines
10 KiB
Go
package pgsql_test
|
|
|
|
import (
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/effective-security/trustyca/api/pb"
|
|
"github.com/effective-security/trustyca/internal/db/model"
|
|
"github.com/effective-security/trustyca/internal/db/pgsql/query"
|
|
"github.com/effective-security/xdb"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func Test_Invite(t *testing.T) {
|
|
owner, org := setupOwnerAndOrg(t, "Test_Invite")
|
|
|
|
inviteeEmail := provider.NextID().String() + "@example.com"
|
|
inviteeEmail2 := provider.NextID().String() + "@example.com"
|
|
invite, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: inviteeEmail,
|
|
Role: pb.Role_User,
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, inviteeEmail, invite.Email)
|
|
assert.Equal(t, pb.Role_User, invite.Role)
|
|
|
|
got, err := provider.GetInvite(ctx, invite.ID.UInt64())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, invite.ID, got.ID)
|
|
|
|
got2, err := provider.GetInviteByOrgAndEmail(ctx, org.ID.UInt64(), 0, inviteeEmail)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, invite.ID, got2.ID)
|
|
|
|
list, err := provider.GetOrgInvites(ctx, org.ID.UInt64())
|
|
require.NoError(t, err)
|
|
require.Len(t, list, 1)
|
|
assert.Equal(t, invite.ID, list[0].ID)
|
|
|
|
list, err = provider.GetUserInvites(ctx, inviteeEmail)
|
|
require.NoError(t, err)
|
|
require.Len(t, list, 1)
|
|
assert.Equal(t, invite.ID, list[0].ID)
|
|
|
|
// re-inviting with a different role updates the existing invite
|
|
invite2, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: inviteeEmail,
|
|
Role: pb.Role_Admin,
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, pb.Role_Admin, invite2.Role)
|
|
|
|
count, err := provider.DeleteInvite(ctx, &query.DeleteInviteRequest{
|
|
OrgID: org.ID.UInt64(),
|
|
Email: inviteeEmail,
|
|
})
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 1, count)
|
|
|
|
_, err = provider.GetInvite(ctx, invite.ID.UInt64())
|
|
assert.ErrorContains(t, err, "record not found")
|
|
|
|
invite3, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: inviteeEmail2,
|
|
Role: pb.Role_User,
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, pb.Role_User, invite3.Role)
|
|
|
|
count, err = provider.DeleteInviteByID(ctx, invite3.ID.UInt64())
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, 1, count)
|
|
|
|
_, err = provider.GetInvite(ctx, invite3.ID.UInt64())
|
|
assert.ErrorContains(t, err, "record not found")
|
|
}
|
|
|
|
func Test_Invite_InvalidRequests(t *testing.T) {
|
|
owner, org := setupOwnerAndOrg(t, "Test_Invite_Invalid")
|
|
|
|
_, err := provider.CreateInvite(ctx, &model.Invite{
|
|
InviterID: owner.ID,
|
|
Email: "[email protected]",
|
|
Role: pb.Role_User,
|
|
})
|
|
assert.EqualError(t, err, "invalid org_id")
|
|
|
|
_, err = provider.DeleteInvite(ctx, &query.DeleteInviteRequest{})
|
|
assert.EqualError(t, err, "orgID or email is required")
|
|
|
|
_, err = provider.GetInvite(ctx, 123)
|
|
assert.ErrorContains(t, err, "record not found")
|
|
|
|
_ = org
|
|
}
|
|
|
|
func Test_AcceptInvite(t *testing.T) {
|
|
owner, org := setupOwnerAndOrg(t, "Test_AcceptInvite")
|
|
|
|
inviteeID := provider.NextID()
|
|
inviteeLogin := &model.Login{
|
|
ID: inviteeID,
|
|
ExternalID: inviteeID.String(),
|
|
Name: "Invitee",
|
|
Email: inviteeID.String() + "@example.com",
|
|
Provider: pb.IDP_Google,
|
|
}
|
|
_, invitee, err := provider.LoginUser(ctx, inviteeLogin)
|
|
require.NoError(t, err)
|
|
defer func() {
|
|
_, err := provider.DeleteUserByEmail(ctx, inviteeLogin.Email)
|
|
assert.NoError(t, err)
|
|
}()
|
|
|
|
invite, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: invitee.Email,
|
|
Role: pb.Role_Admin,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
membership, err := provider.AcceptInvite(ctx, invite.ID.UInt64(), invitee.ID.UInt64())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, org.ID.UInt64(), membership.OrgID.UInt64())
|
|
assert.Equal(t, invitee.ID.UInt64(), membership.UserID.UInt64())
|
|
assert.Equal(t, pb.Role_Admin, membership.Role)
|
|
|
|
// invite should be gone after acceptance
|
|
_, err = provider.GetInvite(ctx, invite.ID.UInt64())
|
|
assert.ErrorContains(t, err, "record not found")
|
|
|
|
memberships, err := provider.ListMemberships(ctx, &query.ListMembershipsRequest{OrgID: org.ID.UInt64()})
|
|
require.NoError(t, err)
|
|
require.Len(t, memberships, 2) // owner + invitee
|
|
}
|
|
|
|
func Test_AcceptInvite_EmailMismatch(t *testing.T) {
|
|
owner, org := setupOwnerAndOrg(t, "Test_AcceptInvite_Mismatch")
|
|
|
|
otherID := provider.NextID()
|
|
otherLogin := &model.Login{
|
|
ID: otherID,
|
|
ExternalID: otherID.String(),
|
|
Name: "Other",
|
|
Email: otherID.String() + "@example.com",
|
|
Provider: pb.IDP_Google,
|
|
}
|
|
_, other, err := provider.LoginUser(ctx, otherLogin)
|
|
require.NoError(t, err)
|
|
defer func() {
|
|
_, err := provider.DeleteUserByEmail(ctx, otherLogin.Email)
|
|
assert.NoError(t, err)
|
|
}()
|
|
|
|
invite, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: "[email protected]",
|
|
Role: pb.Role_User,
|
|
})
|
|
require.NoError(t, err)
|
|
defer func() {
|
|
_, err := provider.DeleteInvite(ctx, &query.DeleteInviteRequest{OrgID: org.ID.UInt64(), Email: invite.Email})
|
|
assert.NoError(t, err)
|
|
}()
|
|
|
|
_, err = provider.AcceptInvite(ctx, invite.ID.UInt64(), other.ID.UInt64())
|
|
assert.EqualError(t, err, "invite email does not match user email")
|
|
// the refusal rolls back the delete: the invite stays pending
|
|
_, err = provider.GetInvite(ctx, invite.ID.UInt64())
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
// Test_AcceptInvite_Pending checks that an acceptance grants the invite as
|
|
// it is when it is deleted, and nothing for an invite that is gone or
|
|
// expired
|
|
func Test_AcceptInvite_Pending(t *testing.T) {
|
|
owner, org := setupOwnerAndOrg(t, "Test_AcceptInvite_Pending")
|
|
|
|
inviteeID := provider.NextID()
|
|
inviteeLogin := &model.Login{
|
|
ID: inviteeID,
|
|
ExternalID: inviteeID.String(),
|
|
Name: "Invitee",
|
|
Email: inviteeID.String() + "@example.com",
|
|
Provider: pb.IDP_Google,
|
|
}
|
|
_, invitee, err := provider.LoginUser(ctx, inviteeLogin)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
_, err := provider.DeleteUserByEmail(ctx, inviteeLogin.Email)
|
|
assert.NoError(t, err)
|
|
})
|
|
members := func() int {
|
|
list, err := provider.ListMemberships(ctx, &query.ListMembershipsRequest{OrgID: org.ID.UInt64()})
|
|
require.NoError(t, err)
|
|
return len(list)
|
|
}
|
|
newInvite := func(expiresAt time.Time) *model.Invite {
|
|
invite, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: invitee.Email,
|
|
Role: pb.Role_Admin,
|
|
ExpiresAt: xdb.Time(expiresAt),
|
|
})
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
_, _ = provider.DeleteInviteByID(ctx, invite.ID.UInt64())
|
|
})
|
|
return invite
|
|
}
|
|
|
|
// a withdrawn invite grants nothing
|
|
invite := newInvite(time.Now().Add(time.Hour))
|
|
count, err := provider.DeleteInviteByID(ctx, invite.ID.UInt64())
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 1, count)
|
|
_, err = provider.AcceptInvite(ctx, invite.ID.UInt64(), invitee.ID.UInt64())
|
|
assert.ErrorContains(t, err, "record not found")
|
|
assert.Equal(t, 1, members(), "the owner only")
|
|
|
|
// an expired invite grants nothing and stays for the cleanup
|
|
invite = newInvite(time.Now().Add(-time.Hour))
|
|
_, err = provider.AcceptInvite(ctx, invite.ID.UInt64(), invitee.ID.UInt64())
|
|
assert.EqualError(t, err, "invite expired")
|
|
_, err = provider.GetInvite(ctx, invite.ID.UInt64())
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 1, members())
|
|
|
|
// the invite is re-issued with another role and expiry: the row is
|
|
// updated in place, and the grant has the role it has when it is taken
|
|
invite = newInvite(time.Now().Add(time.Hour))
|
|
_, err = provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: invitee.Email,
|
|
Role: pb.Role_Viewer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// concurrent acceptances of one invite: the delete locks the row, so
|
|
// only the first grants it and the others do not find it
|
|
const callers = 4
|
|
var (
|
|
wg sync.WaitGroup
|
|
start = make(chan struct{})
|
|
granted = make(chan *model.Membership, callers)
|
|
notFound = make(chan error, callers)
|
|
)
|
|
for range callers {
|
|
wg.Go(func() {
|
|
<-start
|
|
m, err := provider.AcceptInvite(ctx, invite.ID.UInt64(), invitee.ID.UInt64())
|
|
if err != nil {
|
|
notFound <- err
|
|
return
|
|
}
|
|
granted <- m
|
|
})
|
|
}
|
|
close(start)
|
|
wg.Wait()
|
|
close(granted)
|
|
close(notFound)
|
|
|
|
require.Len(t, granted, 1)
|
|
m := <-granted
|
|
assert.Equal(t, pb.Role_Viewer, m.Role, "the role of the re-issued invite")
|
|
assert.Equal(t, invitee.ID.UInt64(), m.UserID.UInt64())
|
|
assert.Len(t, notFound, callers-1)
|
|
for err := range notFound {
|
|
assert.ErrorContains(t, err, "record not found")
|
|
}
|
|
assert.Equal(t, 2, members())
|
|
_, err = provider.GetInvite(ctx, invite.ID.UInt64())
|
|
assert.ErrorContains(t, err, "record not found")
|
|
}
|
|
|
|
func Test_AcceptInvites_GrantFails(t *testing.T) {
|
|
owner, org := setupOwnerAndOrg(t, "Test_AcceptInvites_GrantFails")
|
|
|
|
inviteeID := provider.NextID()
|
|
inviteeEmail := inviteeID.String() + "@example.com"
|
|
invite, err := provider.CreateInvite(ctx, &model.Invite{
|
|
OrgID: org.ID,
|
|
InviterID: owner.ID,
|
|
Email: inviteeEmail,
|
|
Role: pb.Role_User,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// the user is not registered: the grant violates its foreign key, and
|
|
// the invite stays pending for a later login
|
|
accepted, err := provider.AcceptInvites(ctx, &model.User{ID: inviteeID, Email: inviteeEmail})
|
|
require.NoError(t, err)
|
|
assert.Empty(t, accepted)
|
|
|
|
pending, err := provider.GetUserInvites(ctx, inviteeEmail)
|
|
require.NoError(t, err)
|
|
require.Len(t, pending, 1)
|
|
assert.Equal(t, invite.ID.UInt64(), pending[0].ID.UInt64())
|
|
|
|
inviteeLogin := &model.Login{
|
|
ID: inviteeID,
|
|
ExternalID: inviteeID.String(),
|
|
Name: "Invitee",
|
|
Email: inviteeEmail,
|
|
Provider: pb.IDP_Github,
|
|
}
|
|
_, invitee, err := provider.LoginUser(ctx, inviteeLogin)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
_, err := provider.DeleteUserByEmail(ctx, inviteeLogin.Email)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
accepted, err = provider.AcceptInvites(ctx, invitee)
|
|
require.NoError(t, err)
|
|
require.Len(t, accepted, 1)
|
|
assert.Equal(t, org.ID.UInt64(), accepted[0].OrgID.UInt64())
|
|
assert.Equal(t, invitee.ID.UInt64(), accepted[0].UserID.UInt64())
|
|
assert.Equal(t, pb.Role_User, accepted[0].Role)
|
|
|
|
pending, err = provider.GetUserInvites(ctx, inviteeEmail)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, pending)
|
|
}
|