Files
iam/pkg/store/prepare_test.go
zeekayandHanzo Dev 7f465a90a7 store: Connect opens a store without preparing it, for reading one that must stay as it is
A comparison (cloud's `iam copy --check`) reads both sides and must write neither; Open prepares the store it opens.

Co-authored-by: Hanzo Dev <[email protected]>
2026-10-02 23:31:49 -07:00

320 lines
10 KiB
Go

// Copyright 2026 Hanzo AI, Inc.
// SPDX-License-Identifier: MIT OR Apache-2.0
package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"path/filepath"
"strings"
"sync"
"testing"
"github.com/hanzoai/orm"
ormdb "github.com/hanzoai/orm/db"
"github.com/hanzoai/iam/pkg/schema"
)
func fileDB(t *testing.T) (orm.DB, string) {
t.Helper()
_ = schema.Kinds()
path := filepath.Join(t.TempDir(), "iam.db")
db, err := orm.OpenSQLite(&ormdb.SQLiteDBConfig{
Path: path,
Config: ormdb.SQLiteConfig{BusyTimeout: 5000, JournalMode: "WAL"},
})
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
t.Cleanup(func() { _ = db.Close() })
return db, path
}
func putUser(t *testing.T, db orm.DB, owner, name, email string) {
t.Helper()
u := orm.New[schema.User](db)
u.Owner, u.Name, u.Email = owner, name, email
u.SetId(owner + "/" + name)
if err := u.CreateCtx(context.Background()); err != nil {
t.Fatalf("create %s/%s: %v", owner, name, err)
}
}
// unkey makes rows look as an older binary leaves them: no nameKey field at all.
// where narrows which rows, as SQL over _entities.
func unkey(t *testing.T, path, where string) {
t.Helper()
raw, err := sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
defer raw.Close()
if _, err := raw.Exec(`UPDATE _entities SET data = json_remove(data, '$.nameKey') WHERE kind IN ('users', 'memberships') AND (` + where + `)`); err != nil {
t.Fatalf("unkey: %v", err)
}
}
func member(t *testing.T, db orm.DB, user, org string) {
t.Helper()
if _, err := EnsureMembership(context.Background(), db, user, org, "member"); err != nil {
t.Fatal(err)
}
}
// The half-keyed store a deploy meets: a legacy Alice with no key beside keyed
// CAROL and Carol; two/jo on shared's roster with no key, three/jo with one.
// Before Prepare the lookups see only the keyed half, which is the bug: a second
// "alice" could register, and "jo" would name three/jo alone. After it, they see
// every row.
func TestPrepareMakesAHalfKeyedStoreWhole(t *testing.T) {
db, path := fileDB(t)
ctx := context.Background()
putUser(t, db, "acme", "Alice", "")
putUser(t, db, "acme", "CAROL", "")
putUser(t, db, "acme", "Carol", "")
putUser(t, db, "two", "jo", "")
putUser(t, db, "three", "jo", "")
member(t, db, "two/jo", "shared")
member(t, db, "three/jo", "shared")
unkey(t, path, `id = 'acme/Alice' OR json_extract(data, '$.user') = 'two/jo'`)
if u, _ := GetUserByName(ctx, db, "acme", "ALICE"); u != nil {
t.Fatal("the unkeyed Alice was found before Prepare: the store is not half keyed")
}
if u, err := MemberByIdentifier(ctx, db, "shared", "jo"); err != nil || u == nil || u.Owner != "three" {
t.Fatalf("before Prepare, jo: %v, %v; want three/jo alone (the bug)", u, err)
}
p, err := Prepare(ctx, db)
if err != nil || p.Keyed != 2 || len(p.Skipped) != 0 {
t.Fatalf("Prepare keyed %d, skipped %v, %v; want Alice and two/jo's membership", p.Keyed, p.Skipped, err)
}
if u, err := GetUserByName(ctx, db, "acme", "ALICE"); err != nil || u == nil || u.Name != "Alice" {
t.Fatalf("ALICE after Prepare: %v, %v", u, err)
}
if _, err := GetUserByName(ctx, db, "acme", "cArOl"); err == nil {
t.Fatal("cArOl folds to two accounts and was answered")
}
if _, err := MemberByIdentifier(ctx, db, "shared", "jo"); !errors.Is(err, ErrMemberAmbiguous) {
t.Fatalf("jo after Prepare: %v; want ErrMemberAmbiguous", err)
}
if p, err := Prepare(ctx, db); err != nil || p.Keyed != 0 {
t.Fatalf("a second Prepare keyed %d, %v; want nothing", p.Keyed, err)
}
}
// More rows than a page: every one is keyed, through several reads.
func TestPrepareKeysPastOnePage(t *testing.T) {
db, path := fileDB(t)
ctx := context.Background()
const users = 3*preparePage + 17
for i := 0; i < users; i++ {
putUser(t, db, "acme", fmt.Sprintf("User%04d", i), "")
}
for i := 0; i < preparePage+3; i++ {
member(t, db, fmt.Sprintf("acme/User%04d", i), "shared")
}
unkey(t, path, `1 = 1`)
p, err := Prepare(ctx, db)
if want := users + preparePage + 3; err != nil || p.Keyed != want {
t.Fatalf("Prepare keyed %d, %v; want every user and membership, %d", p.Keyed, err, want)
}
for _, i := range []int{0, preparePage, 2*preparePage + 1, users - 1} {
name := fmt.Sprintf("USER%04d", i)
if u, err := GetUserByName(ctx, db, "acme", name); err != nil || u == nil {
t.Fatalf("%s after Prepare: %v, %v", name, u, err)
}
}
if u, err := MemberByIdentifier(ctx, db, "shared", fmt.Sprintf("user%04d", preparePage+2)); err != nil || u == nil {
t.Fatalf("a member past the first page: %v, %v", u, err)
}
}
// A rollback to a binary that does not know the key unkeys what it saves, and the
// roll forward keys it again: Prepare keeps no mark that would skip it.
func TestPrepareKeysAgainAfterARollback(t *testing.T) {
db, path := fileDB(t)
ctx := context.Background()
putUser(t, db, "acme", "Dana", "")
if _, err := Prepare(ctx, db); err != nil {
t.Fatal(err)
}
unkey(t, path, `id = 'acme/Dana'`) // the rolled-back binary saved Dana
putUser(t, db, "acme", "Erin", "")
unkey(t, path, `id = 'acme/Erin'`) // and created Erin
if p, err := Prepare(ctx, db); err != nil || p.Keyed != 2 {
t.Fatalf("Prepare after the roll forward keyed %d, %v; want Dana and Erin", p.Keyed, err)
}
for _, name := range []string{"DANA", "ERIN"} {
if u, err := GetUserByName(ctx, db, "acme", name); err != nil || u == nil {
t.Fatalf("%s: %v, %v", name, u, err)
}
}
}
// A write that races Prepare is kept: each row is keyed from a fresh read in its
// own transaction, so a field changed in between is not written back.
func TestPrepareKeepsAConcurrentWrite(t *testing.T) {
db, path := fileDB(t)
ctx := context.Background()
const n = 2 * preparePage
for i := 0; i < n; i++ {
putUser(t, db, "acme", fmt.Sprintf("u%04d", i), "")
}
unkey(t, path, `1 = 1`)
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < n; i++ {
u, err := GetUserByName(ctx, db, "acme", fmt.Sprintf("u%04d", i))
if err != nil || u == nil {
t.Errorf("u%04d: %v, %v", i, u, err)
return
}
u.Bio = "edited"
if err := u.UpdateCtx(ctx); err != nil {
t.Errorf("update u%04d: %v", i, err)
return
}
}
}()
if _, err := Prepare(ctx, db); err != nil {
t.Fatal(err)
}
wg.Wait()
for i := 0; i < n; i++ {
u, err := GetUserByName(ctx, db, "acme", fmt.Sprintf("U%04d", i))
if err != nil || u == nil {
t.Fatalf("U%04d not found by its key: %v, %v", i, u, err)
}
if u.Bio != "edited" {
t.Fatalf("u%04d lost the write that raced Prepare", i)
}
}
}
// Opening a store prepares it.
func TestOpenPreparesTheStore(t *testing.T) {
path := filepath.Join(t.TempDir(), "iam.db")
db, err := Open("sqlite", path, "")
if err != nil {
t.Fatal(err)
}
putUser(t, db, "acme", "Gail", "")
_ = db.Close()
unkey(t, path, `1 = 1`)
db, err = Open("sqlite", path, "")
if err != nil {
t.Fatal(err)
}
defer db.Close()
if u, err := GetUserByName(context.Background(), db, "acme", "GAIL"); err != nil || u == nil {
t.Fatalf("GAIL after Open: %v, %v", u, err)
}
}
// putRaw stores a document as it is, the way an older or foreign writer might.
func putRaw(t *testing.T, db orm.DB, kind, id, doc string) {
t.Helper()
if _, err := db.Put(context.Background(), db.NewKey(kind, id, 0, nil), json.RawMessage(doc)); err != nil {
t.Fatal(err)
}
}
func rawDoc(t *testing.T, db orm.DB, kind, id string) map[string]any {
t.Helper()
var raw json.RawMessage
if err := db.Get(context.Background(), db.NewKey(kind, id, 0, nil), &raw); err != nil {
t.Fatalf("read %s: %v", id, err)
}
var m map[string]any
if err := json.Unmarshal(raw, &m); err != nil {
t.Fatal(err)
}
return m
}
// One row this binary cannot decode whole never stops the open. A user whose other
// fields would fail a typed decode is keyed from its name; one whose name cannot be
// read is skipped, reported and left exactly as it was; the rest are keyed.
func TestPrepareSurvivesARowItCannotRead(t *testing.T) {
db, _ := fileDB(t)
ctx := context.Background()
putRaw(t, db, "users", "acme/Bad", `{"owner":"acme","name":"Bad","isAdmin":"yes","createdTime":"2025-01-01T00:00:00Z"}`)
putRaw(t, db, "users", "acme/nameless", `{"owner":"acme","name":5}`)
putRaw(t, db, "users", "acme/Good", `{"owner":"acme","name":"Good"}`)
p, err := Prepare(ctx, db)
if err != nil {
t.Fatalf("Prepare failed the open over one row: %v", err)
}
if p.Keyed != 2 || len(p.Skipped) != 1 || p.Skipped[0].ID != "acme/nameless" || !strings.Contains(p.Skipped[0].Why, "not a string") {
t.Fatalf("keyed %d, skipped %+v; want Bad and Good keyed, nameless skipped", p.Keyed, p.Skipped)
}
bad := rawDoc(t, db, "users", "acme/Bad")
if bad["nameKey"] != schema.Fold("Bad") || bad["isAdmin"] != "yes" || bad["createdTime"] != "2025-01-01T00:00:00Z" {
t.Fatalf("the bad row after Prepare: %v; want its key added and every other field as stored", bad)
}
if _, ok := bad["updatedAt"]; ok {
t.Fatalf("Prepare stamped the row: %v", bad)
}
if n := rawDoc(t, db, "users", "acme/nameless"); n["nameKey"] != nil || n["name"] != float64(5) {
t.Fatalf("the skipped row was changed: %v", n)
}
if _, err := Open("sqlite", t.TempDir()+"/iam.db", ""); err != nil {
t.Fatalf("open: %v", err)
}
}
// A keyed row's timestamps are the ones it was stored with.
func TestPrepareKeepsTheTimestamps(t *testing.T) {
db, path := fileDB(t)
ctx := context.Background()
putUser(t, db, "acme", "Hal", "")
unkey(t, path, `1 = 1`)
before := rawDoc(t, db, "users", "acme/Hal")
if _, err := Prepare(ctx, db); err != nil {
t.Fatal(err)
}
after := rawDoc(t, db, "users", "acme/Hal")
for _, f := range []string{"createdAt", "updatedAt", "createdTime", "updatedTime"} {
if before[f] != after[f] {
t.Fatalf("%s moved from %v to %v", f, before[f], after[f])
}
}
if after["nameKey"] != schema.Fold("Hal") {
t.Fatalf("not keyed: %v", after)
}
}
// Connect writes nothing: an unkeyed row stays unkeyed, where Open would key it.
func TestConnectLeavesTheStoreAsItIs(t *testing.T) {
path := filepath.Join(t.TempDir(), "iam.db")
db, err := Open("sqlite", path, "")
if err != nil {
t.Fatal(err)
}
putUser(t, db, "acme", "Jade", "")
_ = db.Close()
unkey(t, path, `1 = 1`)
db, err = Connect("sqlite", path, "")
if err != nil {
t.Fatal(err)
}
defer db.Close()
if doc := rawDoc(t, db, "users", "acme/Jade"); doc["nameKey"] != nil {
t.Fatalf("Connect keyed the row: %v", doc)
}
}