mirror of
https://github.com/hanzoai/iam.git
synced 2026-11-19 18:37:16 +00:00
245 lines
7.5 KiB
Go
245 lines
7.5 KiB
Go
// Copyright 2026 Hanzo AI, Inc.
|
|
// SPDX-License-Identifier: MIT OR Apache-2.0
|
|
|
|
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/hanzoai/orm"
|
|
ormdb "github.com/hanzoai/orm/db"
|
|
|
|
"github.com/hanzoai/iam/pkg/schema"
|
|
)
|
|
|
|
func memDB(t *testing.T) orm.DB {
|
|
t.Helper()
|
|
_ = schema.Kinds()
|
|
dir := t.TempDir()
|
|
db, err := orm.OpenSQLite(&ormdb.SQLiteDBConfig{
|
|
Path: filepath.Join(dir, "iamtest.db"),
|
|
Config: ormdb.SQLiteConfig{BusyTimeout: 5000, JournalMode: "WAL"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("open sqlite: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = db.Close() })
|
|
return db
|
|
}
|
|
|
|
// EnsureMembership is the ONE way a membership is made: idempotent on the
|
|
// (user, org) pair and never a downgrade, so a routine backfill can neither
|
|
// duplicate a row nor quietly strip authority.
|
|
func TestEnsureMembership_IdempotentAndNoDowngrade(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
|
|
added, err := EnsureMembership(ctx, db, "hanzo/alice", "hanzo", RoleOwner)
|
|
if err != nil || !added {
|
|
t.Fatalf("first ensure: added=%v err=%v", added, err)
|
|
}
|
|
// Same pair again: no new row, and the role is NOT downgraded owner→member.
|
|
added, err = EnsureMembership(ctx, db, "hanzo/alice", "hanzo", RoleMember)
|
|
if err != nil || added {
|
|
t.Fatalf("re-ensure must add nothing: added=%v err=%v", added, err)
|
|
}
|
|
m, err := GetMembership(ctx, db, "hanzo/alice", "hanzo")
|
|
if err != nil || m == nil {
|
|
t.Fatalf("membership vanished: %v", err)
|
|
}
|
|
if m.Role != RoleOwner {
|
|
t.Fatalf("role = %q, want owner — re-ensure downgraded authority", m.Role)
|
|
}
|
|
if m.Owner != MembershipOwner {
|
|
t.Fatalf("owner = %q, want the reserved %q", m.Owner, MembershipOwner)
|
|
}
|
|
}
|
|
|
|
// The two hot lookups: a user's orgs, and an org's roster.
|
|
func TestMembershipsByUserAndByOrg(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
|
|
for _, m := range []struct{ user, org, role string }{
|
|
{"hanzo/alice", "hanzo", RoleMember},
|
|
{"hanzo/alice", "team-x", RoleAdmin}, // alice also acts in a team org
|
|
{"hanzo/bob", "hanzo", RoleMember},
|
|
} {
|
|
if _, err := EnsureMembership(ctx, db, m.user, m.org, m.role); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
byUser, err := MembershipsByUser(ctx, db, "hanzo/alice")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(byUser) != 2 {
|
|
t.Fatalf("alice acts in %d orgs, want 2", len(byUser))
|
|
}
|
|
|
|
byOrg, err := MembershipsByOrg(ctx, db, "hanzo")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(byOrg) != 2 {
|
|
t.Fatalf("hanzo roster = %d, want 2 (alice, bob)", len(byOrg))
|
|
}
|
|
|
|
// Empty inputs resolve to nothing, never a table scan.
|
|
if rows, _ := MembershipsByUser(ctx, db, ""); rows != nil {
|
|
t.Fatal("empty user must resolve to no rows")
|
|
}
|
|
}
|
|
|
|
// MemberOrgRefs is the ONE way a user's token `orgs` claim is built: the HOME org
|
|
// first (its role from HomeRole, never an explicit row), then every explicit
|
|
// membership, deduped by org — home wins and is never emitted twice.
|
|
func TestMemberOrgRefs_HomeFirstAndDedup(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
|
|
// alice is a regular user (home role = member) with team memberships AND a
|
|
// redundant explicit row for her OWN home org carrying a DIFFERENT (owner) role.
|
|
alice := orm.New[schema.User](db)
|
|
alice.Owner, alice.Name = "hanzo", "alice"
|
|
alice.SetId("hanzo/alice")
|
|
if err := alice.CreateCtx(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, m := range []struct{ org, role string }{
|
|
{"hanzo", RoleOwner}, // redundant home row — must NOT override home role or duplicate
|
|
{"team-x", RoleAdmin},
|
|
{"team-y", RoleMember},
|
|
} {
|
|
if _, err := EnsureMembership(ctx, db, "hanzo/alice", m.org, m.role); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
refs := MemberOrgRefs(ctx, db, alice)
|
|
// Home first, home role from HomeRole (member) — NOT the explicit owner row —
|
|
// then the team orgs in Org order, with hanzo never repeated.
|
|
want := []schema.OrgRef{
|
|
{Org: "hanzo", Role: RoleMember},
|
|
{Org: "team-x", Role: RoleAdmin},
|
|
{Org: "team-y", Role: RoleMember},
|
|
}
|
|
if len(refs) != len(want) {
|
|
t.Fatalf("orgs = %+v, want %+v (home-first, deduped)", refs, want)
|
|
}
|
|
for i, w := range want {
|
|
if refs[i] != w {
|
|
t.Fatalf("orgs[%d] = %+v, want %+v", i, refs[i], w)
|
|
}
|
|
}
|
|
seen := map[string]int{}
|
|
for _, r := range refs {
|
|
seen[r.Org]++
|
|
}
|
|
if seen["hanzo"] != 1 {
|
|
t.Fatalf("home org emitted %d times, want exactly 1", seen["hanzo"])
|
|
}
|
|
}
|
|
|
|
// A user with no explicit membership still carries its home org; an admin's home
|
|
// role is admin; a nil/unresolved user (a machine token) carries nothing.
|
|
func TestMemberOrgRefs_HomeOnlyAndNil(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
|
|
boss := orm.New[schema.User](db)
|
|
boss.Owner, boss.Name, boss.IsAdmin = "hanzo", "boss", true
|
|
boss.SetId("hanzo/boss")
|
|
if err := boss.CreateCtx(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
refs := MemberOrgRefs(ctx, db, boss)
|
|
if len(refs) != 1 || refs[0] != (schema.OrgRef{Org: "hanzo", Role: RoleAdmin}) {
|
|
t.Fatalf("no-explicit admin orgs = %+v, want [{hanzo admin}]", refs)
|
|
}
|
|
if refs := MemberOrgRefs(ctx, db, nil); refs != nil {
|
|
t.Fatalf("nil user must carry no membership, got %+v", refs)
|
|
}
|
|
}
|
|
|
|
// The boot backfill seeds the HOME-org membership for every user, idempotently.
|
|
func TestBackfillMemberships(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
|
|
for _, u := range []struct {
|
|
owner, name string
|
|
admin bool
|
|
}{
|
|
{"hanzo", "alice", false},
|
|
{"hanzo", "boss", true},
|
|
} {
|
|
row := orm.New[schema.User](db)
|
|
row.Owner, row.Name, row.IsAdmin = u.owner, u.name, u.admin
|
|
row.SetId(u.owner + "/" + u.name)
|
|
if err := row.CreateCtx(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
created, err := BackfillMemberships(ctx, db)
|
|
if err != nil || created != 2 {
|
|
t.Fatalf("backfill created=%d err=%v, want 2", created, err)
|
|
}
|
|
// An admin's home role is admin; a regular user's is member.
|
|
if m, _ := GetMembership(ctx, db, "hanzo/boss", "hanzo"); m == nil || m.Role != RoleAdmin {
|
|
t.Fatalf("boss home role = %+v, want admin", m)
|
|
}
|
|
if m, _ := GetMembership(ctx, db, "hanzo/alice", "hanzo"); m == nil || m.Role != RoleMember {
|
|
t.Fatalf("alice home role = %+v, want member", m)
|
|
}
|
|
// Idempotent: a second backfill creates nothing.
|
|
if created, _ := BackfillMemberships(ctx, db); created != 0 {
|
|
t.Fatalf("second backfill created %d, want 0", created)
|
|
}
|
|
}
|
|
|
|
// The cap counts the orgs an account founded, so giving up ownership frees nothing.
|
|
func TestFoundTooMany(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
for i := range MaxFoundedOrgs {
|
|
o := orm.New[schema.Organization](db)
|
|
o.Owner, o.Name, o.Founder = "admin", fmt.Sprintf("org-%d", i), "founder-key"
|
|
o.SetId("admin/" + o.Name)
|
|
if err := o.CreateCtx(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if over, err := FoundTooMany(ctx, db, "founder-key"); err != nil || !over {
|
|
t.Fatalf("founder of %d orgs: over=%v err=%v, want over", MaxFoundedOrgs, over, err)
|
|
}
|
|
if over, _ := FoundTooMany(ctx, db, "someone-else"); over {
|
|
t.Fatal("an account that founded nothing is over the cap")
|
|
}
|
|
}
|
|
|
|
// An org never loses its last owner to a revoke.
|
|
func TestDeleteMembership_keepsTheLastOwner(t *testing.T) {
|
|
db := memDB(t)
|
|
ctx := context.Background()
|
|
if _, err := EnsureMembership(ctx, db, "acme/bob", "side", RoleOwner); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := DeleteMembership(ctx, db, "acme/bob", "side"); !errors.Is(err, ErrLastOwner) {
|
|
t.Fatalf("revoking the last owner: %v, want ErrLastOwner", err)
|
|
}
|
|
if _, err := EnsureMembership(ctx, db, "acme/carol", "side", RoleOwner); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if removed, err := DeleteMembership(ctx, db, "acme/bob", "side"); err != nil || !removed {
|
|
t.Fatalf("revoking one of two owners: %v %v", removed, err)
|
|
}
|
|
}
|