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

package store

import (
	"encoding/json"
	"os"
	"path/filepath"
	"testing"
	"time"

	agentcommand "agent-command"
)

func TestProjectCommandAuditsUseStoredConversationProjectAndFixedCutoff(t *testing.T) {
	st, err := OpenSQLite(filepath.Join(t.TempDir(), "audit.db"))
	if err != nil {
		t.Fatal(err)
	}
	defer st.Close()
	if err := st.EnsureUser("alice", "Alice at action time"); err != nil {
		t.Fatal(err)
	}
	projectA, err := st.CreateProject("alice", "A")
	if err != nil {
		t.Fatal(err)
	}
	projectB, err := st.CreateProject("alice", "B")
	if err != nil {
		t.Fatal(err)
	}
	convA, err := st.CreateConversation("alice", string(projectA.ID), "A work", "")
	if err != nil {
		t.Fatal(err)
	}
	convB, err := st.CreateConversation("alice", string(projectB.ID), "B work", "")
	if err != nil {
		t.Fatal(err)
	}
	appendCommand := func(owner, conversation, command string) {
		t.Helper()
		if err := st.AppendAudit(owner, agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: command, ConversationID: conversation, State: agentcommand.StateCommitted, ParamsDigest: "private-digest"}); err != nil {
			t.Fatal(err)
		}
	}
	appendCommand("alice", string(convA.ID), "a.one")
	appendCommand("alice", string(convB.ID), "b.one")
	appendCommand("alice", "client-supplied-only", "unbound")
	appendCommand("bob", string(convA.ID), "wrong-owner")
	appendCommand("alice", string(convA.ID), "a.two")
	var expectedCutoff int64
	if err := st.db.QueryRow(st.q(`SELECT id FROM command_audit WHERE command_id=?`), "a.two").Scan(&expectedCutoff); err != nil {
		t.Fatal(err)
	}
	appendCommand("alice", string(convB.ID), "b.latest")

	first, cutoff, next, err := st.ListProjectCommandAudits("alice", string(projectA.ID), 0, 0, 1)
	if err != nil {
		t.Fatal(err)
	}
	if len(first) != 1 || first[0].Envelope.CommandID != "a.two" || first[0].ActorName != "Alice at action time" || next == 0 || cutoff != expectedCutoff {
		t.Fatalf("first page: rows=%+v cutoff=%d next=%d", first, cutoff, next)
	}
	appendCommand("alice", string(convA.ID), "a.late")
	second, fixed, next, err := st.ListProjectCommandAudits("alice", string(projectA.ID), next, cutoff, 1)
	if err != nil {
		t.Fatal(err)
	}
	if fixed != cutoff || len(second) != 1 || second[0].Envelope.CommandID != "a.one" || next != 0 {
		t.Fatalf("second page: rows=%+v cutoff=%d next=%d", second, fixed, next)
	}
	other, _, _, err := st.ListProjectCommandAudits("alice", string(projectB.ID), 0, 0, 10)
	if err != nil {
		t.Fatal(err)
	}
	if len(other) != 2 || other[0].Envelope.CommandID != "b.latest" || other[1].Envelope.CommandID != "b.one" {
		t.Fatalf("B rows: %+v", other)
	}
	unknown, _, _, err := st.ListProjectCommandAudits("alice", "untrusted-project", 0, 0, 10)
	if err != nil {
		t.Fatal(err)
	}
	if len(unknown) != 0 {
		t.Fatalf("untrusted project rows: %+v", unknown)
	}
}

func TestProjectCommandAuditKeepsActorNameSnapshot(t *testing.T) {
	st, err := OpenSQLite(filepath.Join(t.TempDir(), "audit.db"))
	if err != nil {
		t.Fatal(err)
	}
	defer st.Close()
	if err := st.EnsureUser("alice", "Former name"); err != nil {
		t.Fatal(err)
	}
	p, err := st.CreateProject("alice", "A")
	if err != nil {
		t.Fatal(err)
	}
	c, err := st.CreateConversation("alice", string(p.ID), "A work", "")
	if err != nil {
		t.Fatal(err)
	}
	if err := st.AppendAudit("alice", agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: "old", ConversationID: string(c.ID)}); err != nil {
		t.Fatal(err)
	}
	if _, err := st.db.Exec(st.q(`UPDATE users SET name=? WHERE owner=?`), "Current name", "alice"); err != nil {
		t.Fatal(err)
	}
	if err := st.AppendAudit("alice", agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: "new", ConversationID: string(c.ID)}); err != nil {
		t.Fatal(err)
	}
	legacy, err := json.Marshal(agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: "legacy", ConversationID: string(c.ID)})
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.db.Exec(st.q(`INSERT INTO command_audit (time, command_id, source, entrance, state, operation_id, conversation_id, owner, payload) VALUES (?, ?, '', '', '', '', ?, ?, ?)`), time.Now().UTC().Format(time.RFC3339Nano), "legacy", string(c.ID), "alice", string(legacy)); err != nil {
		t.Fatal(err)
	}
	rows, _, _, err := st.ListProjectCommandAudits("alice", string(p.ID), 0, 0, 10)
	if err != nil {
		t.Fatal(err)
	}
	if len(rows) != 2 || rows[0].ActorName != "Current name" || rows[1].ActorName != "Former name" {
		t.Fatalf("names: %+v", rows)
	}
	var legacyProject string
	if err := st.db.QueryRow(st.q(`SELECT project_id FROM command_audit WHERE command_id=?`), "legacy").Scan(&legacyProject); err != nil {
		t.Fatal(err)
	}
	if legacyProject != "" {
		t.Fatalf("legacy attribution was fabricated: %q", legacyProject)
	}
}

func TestProjectCommandAuditDoesNotMoveWithConversation(t *testing.T) {
	st, err := OpenSQLite(filepath.Join(t.TempDir(), "audit.db"))
	if err != nil {
		t.Fatal(err)
	}
	defer st.Close()
	a, err := st.CreateProject("alice", "A")
	if err != nil {
		t.Fatal(err)
	}
	b, err := st.CreateProject("alice", "B")
	if err != nil {
		t.Fatal(err)
	}
	c, err := st.CreateConversation("alice", string(a.ID), "work", "")
	if err != nil {
		t.Fatal(err)
	}
	appendCommand := func(id string) {
		t.Helper()
		if err := st.AppendAudit("alice", agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: id, ConversationID: string(c.ID)}); err != nil {
			t.Fatal(err)
		}
	}
	appendCommand("before-move")
	if _, err := st.db.Exec(st.q(`UPDATE conversations SET project_id=? WHERE id=?`), string(b.ID), string(c.ID)); err != nil {
		t.Fatal(err)
	}
	appendCommand("after-move")
	oldProject, _, _, err := st.ListProjectCommandAudits("alice", string(a.ID), 0, 0, 10)
	if err != nil {
		t.Fatal(err)
	}
	newProject, _, _, err := st.ListProjectCommandAudits("alice", string(b.ID), 0, 0, 10)
	if err != nil {
		t.Fatal(err)
	}
	if len(oldProject) != 1 || oldProject[0].Envelope.CommandID != "before-move" || len(newProject) != 1 || newProject[0].Envelope.CommandID != "after-move" {
		t.Fatalf("project attribution changed: A=%+v B=%+v", oldProject, newProject)
	}
}

// Under the old PostgreSQL SERIAL default, an uncommitted middle ID can be
// skipped after a higher committed row advances the page cursor past it.
// The committed-prefix implementation must keep the later writer waiting.
func TestProjectAuditPostgresCursorNeverSkipsLateCommit(t *testing.T) {
	if os.Getenv("AGENT_PG_TEST_DSN") == "" {
		t.Skip("AGENT_PG_TEST_DSN unset: PG concurrency check NOT_RUN")
	}
	st := openTestStore(t)
	if st.Dialect() != "postgres" {
		t.Fatal("expected postgres")
	}
	if err := st.EnsureUser("alice", "Alice"); err != nil {
		t.Fatal(err)
	}
	p, err := st.CreateProject("alice", "A")
	if err != nil {
		t.Fatal(err)
	}
	c, err := st.CreateConversation("alice", string(p.ID), "work", "")
	if err != nil {
		t.Fatal(err)
	}
	for _, command := range []string{"lower-one", "lower-two"} {
		if err := st.AppendAudit("alice", agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: command, ConversationID: string(c.ID), State: agentcommand.StateCommitted}); err != nil {
			t.Fatal(err)
		}
	}
	env := agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: "middle-pending", ConversationID: string(c.ID), State: agentcommand.StateCommitted}
	raw, err := json.Marshal(env)
	if err != nil {
		t.Fatal(err)
	}
	tx, err := st.db.Begin()
	if err != nil {
		t.Fatal(err)
	}
	defer tx.Rollback()
	var middleID int64
	if err := tx.QueryRow(st.q(`INSERT INTO command_audit(time,command_id,source,entrance,state,operation_id,conversation_id,owner,payload,actor_name,project_id)
		VALUES (?,?,'','','committed','',?,?,?,?,?) RETURNING id`), time.Now().UTC().Format(time.RFC3339Nano), "middle-pending", string(c.ID), "alice", string(raw), "Alice", string(p.ID)).Scan(&middleID); err != nil {
		t.Fatal(err)
	}
	highDone := make(chan error, 1)
	started := make(chan struct{})
	go func() {
		close(started)
		highDone <- st.AppendAudit("alice", agentcommand.AuditEnvelope{Time: time.Now(), Actor: "alice", CommandID: "higher-committed", ConversationID: string(c.ID), State: agentcommand.StateCommitted})
	}()
	<-started
	highCommittedEarly := false
	select {
	case err := <-highDone:
		if err != nil {
			t.Fatal(err)
		}
		highCommittedEarly = true
	case <-time.After(250 * time.Millisecond):
	}
	var first []ProjectCommandAuditRow
	var cutoff, next int64
	if highCommittedEarly {
		first, cutoff, next, err = st.ListProjectCommandAudits("alice", string(p.ID), 0, 0, 2)
		if err != nil {
			tx.Rollback()
			t.Fatal(err)
		}
	}
	if err := tx.Commit(); err != nil {
		t.Fatal(err)
	}
	if !highCommittedEarly {
		if err := <-highDone; err != nil {
			t.Fatal(err)
		}
		first, cutoff, next, err = st.ListProjectCommandAudits("alice", string(p.ID), 0, 0, 2)
		if err != nil {
			t.Fatal(err)
		}
	}
	second, fixed, _, err := st.ListProjectCommandAudits("alice", string(p.ID), next, cutoff, 2)
	if err != nil {
		t.Fatal(err)
	}
	seen := map[string]bool{}
	for _, row := range append(first, second...) {
		seen[row.Envelope.CommandID] = true
	}
	if next == 0 || fixed != cutoff || len(seen) != 4 || !seen["middle-pending"] {
		t.Fatalf("cross-page audit omitted a committed row: early=%v middleID=%d first=%+v second=%+v cutoff=%d next=%d", highCommittedEarly, middleID, first, second, cutoff, next)
	}
}