Agent-System-Backend/internal/store/settings_account_write_test.go

package store

import (
	"errors"
	"testing"
	"time"

	core "agent-system-core"
)

func TestSettingsAccountCheckedScopesAndSnapshots(t *testing.T) {
	st := openTestStore(t)
	for _, a := range []struct {
		owner string
		admin bool
	}{{"admin", true}, {"admin2", true}, {"alice", false}, {"bob", false}} {
		if err := st.CreateAccount(a.owner, "", "", a.admin); err != nil {
			t.Fatal(err)
		}
	}
	project, err := st.CreateProject("alice", "owned")
	if err != nil {
		t.Fatal(err)
	}
	merge := func(cur map[string]any) (map[string]any, error) {
		return core.MergeSettings(cur, map[string]any{"ui": map[string]any{"theme": "light"}}), nil
	}
	if err := st.UpdateSettingsScopeAccountChecked("alice", "alice", "user", false, merge); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("alice", "alice", "project:"+project.ID, false, merge); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("bob", "alice", "user", false, merge); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("foreign user scope admitted: %v", err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("alice", "", "system", false, merge); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("non-admin system scope admitted: %v", err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("admin", "", "system", false, merge); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("alice", "alice", "project:missing", false, merge); !errors.Is(err, ErrNotFound) {
		t.Fatalf("missing project scope admitted: %v", err)
	}
	if saved, err := st.SaveSnapshotIfChangedAccountChecked("alice", "alice", "user", `{"ui":{"theme":"light"}}`, "save", false); err != nil || !saved {
		t.Fatalf("guarded snapshot: saved=%v err=%v", saved, err)
	}
	if saved, err := st.SaveSnapshotIfChangedAccountChecked("alice", "alice", "user", `{"ui":{"theme":"light"}}`, "save", false); err != nil || saved {
		t.Fatalf("unchanged snapshot duplicated: saved=%v err=%v", saved, err)
	}
	if _, err := st.SaveSnapshotIfChangedAccountChecked("alice", "", "system", `{}`, "save", false); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("non-admin system snapshot admitted: %v", err)
	}
	account, err := st.GetAccountByOwner("alice")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
		t.Fatal(err)
	}
	for _, mutate := range []func() error{
		func() error { return st.UpdateSettingsScopeAccountChecked("alice", "alice", "user", false, merge) },
		func() error {
			return st.UpdateSettingsScopeAccountChecked("alice", "alice", "project:"+project.ID, false, merge)
		},
		func() error {
			_, err := st.SaveSnapshotIfChangedAccountChecked("alice", "alice", "user", `{"late":true}`, "save", false)
			return err
		},
	} {
		if err := mutate(); !errors.Is(err, ErrAccountForbidden) {
			t.Fatalf("disabled account wrote settings/snapshot: %v", err)
		}
	}
	var snapshots int
	if err := st.DB().QueryRow(st.q(`SELECT COUNT(*) FROM settings_snapshots WHERE owner=? AND scope=?`), "alice", "user").Scan(&snapshots); err != nil || snapshots != 1 {
		t.Fatalf("rejected snapshot changed row count: %d %v", snapshots, err)
	}
	admin, err := st.GetAccountByOwner("admin")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.SetAccountEnabled("admin2", admin.ID, admin.StateVersion, false); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("admin", "", "system", false, merge); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("disabled administrator wrote system settings: %v", err)
	}
	if _, err := st.SaveSnapshotIfChangedAccountChecked("admin", "", "system", `{}`, "save", false); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("disabled administrator wrote system snapshot: %v", err)
	}
}

func TestSettingsAccountCheckedImplicitDefault(t *testing.T) {
	st := openTestStore(t)
	merge := func(cur map[string]any) (map[string]any, error) { return map[string]any{"enabled": true}, nil }
	if err := st.UpdateSettingsScopeAccountChecked(OwnerDefault, OwnerDefault, "user", false, merge); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("unapproved implicit default admitted: %v", err)
	}
	if err := st.UpdateSettingsScopeAccountChecked(OwnerDefault, OwnerDefault, "user", true, merge); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked(OwnerDefault, "", "system", true, merge); err != nil {
		t.Fatalf("embedded local system write rejected: %v", err)
	}
	if err := st.CreateAccount("admin", "", "", true); err != nil {
		t.Fatal(err)
	}
	if err := st.EnsureUser(OwnerDefault, ""); err != nil {
		t.Fatal(err)
	}
	account, err := st.GetAccountByOwner(OwnerDefault)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked(OwnerDefault, "", "system", true, merge); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("disabled embedded local system write admitted: %v", err)
	}
}

func TestPGSettingsAccountWriteSerializesWithDisable(t *testing.T) {
	st := openTestStore(t)
	if st.Dialect() != "postgres" {
		t.Skip("real PostgreSQL required")
	}
	other := reopenAccountModelStore(t, st)
	if err := st.CreateAccount("admin", "", "", true); err != nil {
		t.Fatal(err)
	}
	if err := st.CreateAccount("alice", "", "", false); err != nil {
		t.Fatal(err)
	}
	account, err := st.GetAccountByOwner("alice")
	if err != nil {
		t.Fatal(err)
	}
	release := holdPGAccountWrite(t, st, "settings", "INSERT", "settings")
	writeDone := make(chan error, 1)
	go func() {
		writeDone <- st.UpdateSettingsScopeAccountChecked("alice", "alice", "user", false,
			func(cur map[string]any) (map[string]any, error) { return map[string]any{"first": true}, nil })
	}()
	waitForPGAccountWrite(t, st, "settings")
	disableDone := make(chan error, 1)
	go func() {
		_, err := other.SetAccountEnabled("admin", account.ID, account.StateVersion, false)
		disableDone <- err
	}()
	select {
	case err := <-disableDone:
		t.Fatalf("disable committed ahead of paused settings insert: %v", err)
	case <-time.After(100 * time.Millisecond):
	}
	release()
	if err := awaitPGAccountResult(t, writeDone); err != nil {
		t.Fatal(err)
	}
	if err := awaitPGAccountResult(t, disableDone); err != nil {
		t.Fatal(err)
	}
	if err := st.UpdateSettingsScopeAccountChecked("alice", "alice", "user", false,
		func(cur map[string]any) (map[string]any, error) { return map[string]any{"late": true}, nil }); !errors.Is(err, ErrAccountForbidden) {
		t.Fatalf("late settings write passed: %v", err)
	}
}