549 lines
19 KiB
Go
549 lines
19 KiB
Go
package lifecycle
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/aoagents/agent-orchestrator/backend/internal/domain"
|
|
"github.com/aoagents/agent-orchestrator/backend/internal/ports"
|
|
)
|
|
|
|
var ctx = context.Background()
|
|
|
|
type fakeStore struct {
|
|
sessions map[domain.SessionID]domain.SessionRecord
|
|
signatures map[string]string
|
|
|
|
signatureWriteErr error
|
|
signatureWrites int
|
|
}
|
|
|
|
func newFakeStore() *fakeStore {
|
|
return &fakeStore{sessions: map[domain.SessionID]domain.SessionRecord{}, signatures: map[string]string{}}
|
|
}
|
|
|
|
func (f *fakeStore) GetSession(_ context.Context, id domain.SessionID) (domain.SessionRecord, bool, error) {
|
|
r, ok := f.sessions[id]
|
|
return r, ok, nil
|
|
}
|
|
|
|
func (f *fakeStore) UpdateSession(_ context.Context, rec domain.SessionRecord) error {
|
|
f.sessions[rec.ID] = rec
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeStore) GetPRLastNudgeSignature(_ context.Context, prURL string) (string, error) {
|
|
return f.signatures[prURL], nil
|
|
}
|
|
|
|
func (f *fakeStore) UpdatePRLastNudgeSignature(_ context.Context, prURL, payload string) error {
|
|
if f.signatureWriteErr != nil {
|
|
return f.signatureWriteErr
|
|
}
|
|
if f.signatures == nil {
|
|
f.signatures = map[string]string{}
|
|
}
|
|
f.signatures[prURL] = payload
|
|
f.signatureWrites++
|
|
return nil
|
|
}
|
|
|
|
type fakeMessenger struct {
|
|
msgs []string
|
|
err error
|
|
}
|
|
|
|
func (f *fakeMessenger) Send(_ context.Context, _ domain.SessionID, msg string) error {
|
|
if f.err != nil {
|
|
return f.err
|
|
}
|
|
f.msgs = append(f.msgs, msg)
|
|
return nil
|
|
}
|
|
|
|
func newManager() (*Manager, *fakeStore, *fakeMessenger) {
|
|
st := newFakeStore()
|
|
msg := &fakeMessenger{}
|
|
return New(st, msg), st, msg
|
|
}
|
|
|
|
func working(id domain.SessionID) domain.SessionRecord {
|
|
return domain.SessionRecord{ID: id, ProjectID: "mer", Activity: domain.Activity{State: domain.ActivityActive, LastActivityAt: time.Now()}}
|
|
}
|
|
|
|
func TestRuntimeObservation_InferredDeathSetsTerminated(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
rec := working("mer-1")
|
|
rec.Activity.LastActivityAt = time.Now().Add(-2 * time.Minute)
|
|
st.sessions["mer-1"] = rec
|
|
if err := m.ApplyRuntimeObservation(ctx, "mer-1", ports.RuntimeFacts{Probe: ports.ProbeDead}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := st.sessions["mer-1"]
|
|
if !got.IsTerminated || got.Activity.State != domain.ActivityExited {
|
|
t.Fatalf("want terminated/exited, got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeObservation_FailedProbeDoesNotMutate(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
before := st.sessions["mer-1"]
|
|
if err := m.ApplyRuntimeObservation(ctx, "mer-1", ports.RuntimeFacts{Probe: ports.ProbeFailed}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if st.sessions["mer-1"] != before {
|
|
t.Fatalf("failed probe should not persist a state, got %+v", st.sessions["mer-1"])
|
|
}
|
|
}
|
|
|
|
func TestActivity_InvalidIsIgnored(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
before := st.sessions["mer-1"]
|
|
if err := m.ApplyActivitySignal(ctx, "mer-1", ports.ActivitySignal{Valid: false, State: domain.ActivityIdle}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if st.sessions["mer-1"] != before {
|
|
t.Fatal("invalid signal must not mutate")
|
|
}
|
|
}
|
|
|
|
func TestMarkTerminated(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
if err := m.MarkTerminated(ctx, "mer-1"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := st.sessions["mer-1"]
|
|
if !got.IsTerminated || got.Activity.State != domain.ActivityExited {
|
|
t.Fatalf("want terminated/exited, got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestMarkSpawnedStoresRuntimeMetadata(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
st.sessions["mer-1"] = domain.SessionRecord{ID: "mer-1", ProjectID: "mer", IsTerminated: true}
|
|
metadata := domain.SessionMetadata{Branch: "b", WorkspacePath: "/ws", RuntimeHandleID: "h1", AgentSessionID: "agent", Prompt: "prompt"}
|
|
if err := m.MarkSpawned(ctx, "mer-1", metadata); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := st.sessions["mer-1"]
|
|
if got.IsTerminated || got.Activity.State != domain.ActivityIdle || got.Metadata.RuntimeHandleID != "h1" {
|
|
t.Fatalf("spawn metadata wrong: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestPRObservation_CIFailingNudgesAgentWithLogs(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.PRObservation{Fetched: true, URL: "pr1", CI: domain.CIFailing, Checks: []ports.PRCheckObservation{{Name: "build", CommitHash: "c1", Status: domain.PRCheckFailed, LogTail: "boom"}}}
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msg.msgs) != 1 || !strings.Contains(msg.msgs[0], "boom") {
|
|
t.Fatalf("want one CI nudge with log tail, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestPRObservation_ReviewCommentsNudgeAgent(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.PRObservation{Fetched: true, URL: "pr1", Review: domain.ReviewChangesRequest, Comments: []ports.PRCommentObservation{{ID: "1", Body: "fix this"}}}
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msg.msgs) != 1 || !strings.Contains(msg.msgs[0], "fix this") {
|
|
t.Fatalf("want review nudge, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestSCMObservationProjectsToExistingPRReactions(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.SCMObservation{
|
|
Fetched: true,
|
|
PR: ports.SCMPRObservation{URL: "pr1", Number: 1},
|
|
CI: ports.SCMCIObservation{
|
|
Summary: string(domain.CIFailing),
|
|
HeadSHA: "c1",
|
|
FailedChecks: []ports.SCMCheckObservation{{
|
|
Name: "build", Status: string(domain.PRCheckFailed), LogTail: "boom",
|
|
}},
|
|
},
|
|
}
|
|
if err := m.ApplySCMObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msg.msgs) != 1 || !strings.Contains(msg.msgs[0], "boom") {
|
|
t.Fatalf("want SCM CI nudge with log tail, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestSCMObservationUsesPRHeadWhenCIHeadMissing(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.SCMObservation{
|
|
Fetched: true,
|
|
PR: ports.SCMPRObservation{URL: "pr1", HeadSHA: "c1"},
|
|
CI: ports.SCMCIObservation{
|
|
Summary: string(domain.CIFailing),
|
|
FailedChecks: []ports.SCMCheckObservation{{
|
|
Name: "build", Status: string(domain.PRCheckFailed),
|
|
}},
|
|
},
|
|
}
|
|
if err := m.ApplySCMObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
o.PR.HeadSHA = "c2"
|
|
if err := m.ApplySCMObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msg.msgs) != 2 {
|
|
t.Fatalf("want separate CI nudges for distinct PR heads when CI head is absent, got %d: %v", len(msg.msgs), msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestPRObservation_MergeConflictNudgesAgent(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.PRObservation{Fetched: true, URL: "pr1", Mergeability: domain.MergeConflicting}
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msg.msgs) != 1 || !strings.Contains(msg.msgs[0], "merge conflicts") {
|
|
t.Fatalf("want merge-conflict nudge, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestPRObservation_MergedTerminatesWithoutNudge(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", ports.PRObservation{Fetched: true, URL: "pr1", Merged: true}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := st.sessions["mer-1"]
|
|
if !got.IsTerminated || got.Activity.State != domain.ActivityExited {
|
|
t.Fatalf("merged PR should terminate session, got %+v", got)
|
|
}
|
|
if len(msg.msgs) != 0 {
|
|
t.Fatalf("merged PR should not send nudge, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
// TestPRObservation_DedupSurvivesManagerRestart simulates a daemon restart by
|
|
// constructing a second Manager over the same store and asserts that an
|
|
// identical PR observation does not re-fire the nudge — the dedup signature
|
|
// must survive process restart, not just live in the Manager's maps.
|
|
func TestPRObservation_DedupSurvivesManagerRestart(t *testing.T) {
|
|
st := newFakeStore()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
|
|
o := ports.PRObservation{
|
|
Fetched: true,
|
|
URL: "https://github.com/o/r/pull/1",
|
|
CI: domain.CIFailing,
|
|
Checks: []ports.PRCheckObservation{{Name: "build", CommitHash: "c1", Status: domain.PRCheckFailed, LogTail: "boom"}},
|
|
}
|
|
|
|
first := &fakeMessenger{}
|
|
m1 := New(st, first)
|
|
if err := m1.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("first ApplyPRObservation: %v", err)
|
|
}
|
|
if len(first.msgs) != 1 {
|
|
t.Fatalf("first manager: want 1 nudge, got %d", len(first.msgs))
|
|
}
|
|
if got := st.signatures[o.URL]; got == "" {
|
|
t.Fatalf("signature was not persisted; want a non-empty JSON payload for %q", o.URL)
|
|
}
|
|
|
|
// Simulate daemon restart: the second Manager has no in-memory state but
|
|
// shares the same store, so it should hydrate seen/attempts from the
|
|
// persisted payload and suppress the re-send.
|
|
second := &fakeMessenger{}
|
|
m2 := New(st, second)
|
|
if err := m2.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("second ApplyPRObservation: %v", err)
|
|
}
|
|
if len(second.msgs) != 0 {
|
|
t.Fatalf("post-restart manager re-nudged on identical observation, got %d msgs: %v", len(second.msgs), second.msgs)
|
|
}
|
|
|
|
// And a genuinely new signature (different log tail) still fires — proving
|
|
// the persisted state is per-signature, not a blanket "this PR was nudged".
|
|
o2 := o
|
|
o2.Checks = []ports.PRCheckObservation{{Name: "build", CommitHash: "c1", Status: domain.PRCheckFailed, LogTail: "different boom"}}
|
|
if err := m2.ApplyPRObservation(ctx, "mer-1", o2); err != nil {
|
|
t.Fatalf("third ApplyPRObservation: %v", err)
|
|
}
|
|
if len(second.msgs) != 1 {
|
|
t.Fatalf("new signature should send, got %d msgs", len(second.msgs))
|
|
}
|
|
}
|
|
|
|
func TestPRObservation_DedupPersistsAcrossPRs(t *testing.T) {
|
|
st := newFakeStore()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
msg := &fakeMessenger{}
|
|
m := New(st, msg)
|
|
|
|
for _, url := range []string{"https://github.com/o/r/pull/1", "https://github.com/o/r/pull/2"} {
|
|
o := ports.PRObservation{
|
|
Fetched: true, URL: url, CI: domain.CIFailing,
|
|
Checks: []ports.PRCheckObservation{{Name: "build", CommitHash: "c1", Status: domain.PRCheckFailed, LogTail: "boom"}},
|
|
}
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("ApplyPRObservation for %s: %v", url, err)
|
|
}
|
|
}
|
|
if len(msg.msgs) != 2 {
|
|
t.Fatalf("distinct PRs should each get one nudge, got %d", len(msg.msgs))
|
|
}
|
|
if _, ok := st.signatures["https://github.com/o/r/pull/1"]; !ok {
|
|
t.Fatal("missing persisted signature for PR 1")
|
|
}
|
|
if _, ok := st.signatures["https://github.com/o/r/pull/2"]; !ok {
|
|
t.Fatal("missing persisted signature for PR 2")
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_TerminalStateMarksTerminated(t *testing.T) {
|
|
for _, state := range []domain.NormalizedIssueState{domain.IssueDone, domain.IssueCancelled} {
|
|
t.Run(string(state), func(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.TrackerObservation{
|
|
Fetched: true,
|
|
Issue: ports.TrackerIssueObservation{URL: "https://github.com/o/r/issues/1", State: state},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("ApplyTrackerFacts: %v", err)
|
|
}
|
|
got := st.sessions["mer-1"]
|
|
if !got.IsTerminated || got.Activity.State != domain.ActivityExited {
|
|
t.Fatalf("want terminated/exited for state %q, got %+v", state, got)
|
|
}
|
|
if len(msg.msgs) != 0 {
|
|
t.Fatalf("terminal state should not nudge, got %v", msg.msgs)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_AssigneeChangedIsLogOnly(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
before := st.sessions["mer-1"]
|
|
o := ports.TrackerObservation{
|
|
Fetched: true,
|
|
Issue: ports.TrackerIssueObservation{URL: "https://github.com/o/r/issues/1", State: domain.IssueOpen, Assignee: "someone-else"},
|
|
Changed: ports.TrackerChanged{Assignee: true},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("ApplyTrackerFacts: %v", err)
|
|
}
|
|
if st.sessions["mer-1"] != before {
|
|
t.Fatalf("assignee-only change must not mutate the session row, got %+v", st.sessions["mer-1"])
|
|
}
|
|
if len(msg.msgs) != 0 {
|
|
t.Fatalf("assignee-only change must not nudge, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_NewBotCommentNudges(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.TrackerObservation{
|
|
Fetched: true,
|
|
Issue: ports.TrackerIssueObservation{URL: "https://github.com/o/r/issues/1", State: domain.IssueOpen},
|
|
Comments: []ports.TrackerCommentObservation{
|
|
{ID: "human-1", Author: "alice", Body: "human chime-in, must NOT nudge", IsBot: false},
|
|
{ID: "bot-1", Author: "ci-bot[bot]", Body: "please rerun the migration", IsBot: true},
|
|
},
|
|
Changed: ports.TrackerChanged{Comments: true},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("ApplyTrackerFacts: %v", err)
|
|
}
|
|
if len(msg.msgs) != 1 {
|
|
t.Fatalf("want one bot-mention nudge, got %d: %v", len(msg.msgs), msg.msgs)
|
|
}
|
|
if !strings.Contains(msg.msgs[0], "please rerun the migration") {
|
|
t.Fatalf("nudge should include the bot comment body, got %q", msg.msgs[0])
|
|
}
|
|
if strings.Contains(msg.msgs[0], "human chime-in") {
|
|
t.Fatalf("nudge must not include human comments, got %q", msg.msgs[0])
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_NudgeSuppressedOnRepeat(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.TrackerObservation{
|
|
Fetched: true,
|
|
Issue: ports.TrackerIssueObservation{URL: "https://github.com/o/r/issues/1", State: domain.IssueOpen},
|
|
Comments: []ports.TrackerCommentObservation{
|
|
{ID: "bot-1", Author: "ci-bot[bot]", Body: "please rerun the migration", IsBot: true},
|
|
},
|
|
Changed: ports.TrackerChanged{Comments: true},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("first ApplyTrackerFacts: %v", err)
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("second ApplyTrackerFacts: %v", err)
|
|
}
|
|
if len(msg.msgs) != 1 {
|
|
t.Fatalf("repeat observation must dedup; got %d nudges: %v", len(msg.msgs), msg.msgs)
|
|
}
|
|
|
|
// A genuinely new bot comment still fires.
|
|
o.Comments = append(o.Comments, ports.TrackerCommentObservation{ID: "bot-2", Author: "ci-bot[bot]", Body: "now check the seed", IsBot: true})
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("third ApplyTrackerFacts: %v", err)
|
|
}
|
|
if len(msg.msgs) != 2 {
|
|
t.Fatalf("new bot comment id should re-fire, got %d: %v", len(msg.msgs), msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_BotCommentWithEmptyIDIsIgnored(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
// Bot comment lacks an ID — without one we cannot dedup, and the
|
|
// zero-value signature collides with m.react.seen's empty default and
|
|
// would silently suppress every future nudge for this issue. The
|
|
// reducer must skip it entirely.
|
|
o := ports.TrackerObservation{
|
|
Fetched: true,
|
|
Issue: ports.TrackerIssueObservation{URL: "https://github.com/o/r/issues/1", State: domain.IssueOpen},
|
|
Comments: []ports.TrackerCommentObservation{
|
|
{ID: "", Author: "ci-bot[bot]", Body: "no id, must be skipped", IsBot: true},
|
|
},
|
|
Changed: ports.TrackerChanged{Comments: true},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("ApplyTrackerFacts: %v", err)
|
|
}
|
|
if len(msg.msgs) != 0 {
|
|
t.Fatalf("bot comment with empty ID must not nudge, got %v", msg.msgs)
|
|
}
|
|
// A subsequent, properly-formed bot comment must still nudge — the
|
|
// earlier empty-ID entry must not have polluted the dedup signature.
|
|
o.Comments = []ports.TrackerCommentObservation{
|
|
{ID: "bot-1", Author: "ci-bot[bot]", Body: "now with an id", IsBot: true},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("second ApplyTrackerFacts: %v", err)
|
|
}
|
|
if len(msg.msgs) != 1 {
|
|
t.Fatalf("follow-up bot comment with real ID should nudge, got %d: %v", len(msg.msgs), msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_NotFetchedIsNoop(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
before := st.sessions["mer-1"]
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", ports.TrackerObservation{Fetched: false}); err != nil {
|
|
t.Fatalf("ApplyTrackerFacts: %v", err)
|
|
}
|
|
if st.sessions["mer-1"] != before {
|
|
t.Fatalf("not-fetched observation must not mutate state")
|
|
}
|
|
if len(msg.msgs) != 0 {
|
|
t.Fatalf("not-fetched observation must not nudge")
|
|
}
|
|
}
|
|
|
|
func TestApplyTrackerFacts_TerminatedSessionDoesNotRefireOrNudge(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = domain.SessionRecord{ID: "mer-1", ProjectID: "mer", IsTerminated: true, Activity: domain.Activity{State: domain.ActivityExited}}
|
|
o := ports.TrackerObservation{
|
|
Fetched: true,
|
|
Issue: ports.TrackerIssueObservation{URL: "https://github.com/o/r/issues/1", State: domain.IssueOpen},
|
|
Comments: []ports.TrackerCommentObservation{
|
|
{ID: "bot-1", Body: "x", IsBot: true},
|
|
},
|
|
Changed: ports.TrackerChanged{Comments: true},
|
|
}
|
|
if err := m.ApplyTrackerFacts(ctx, "mer-1", o); err != nil {
|
|
t.Fatalf("ApplyTrackerFacts: %v", err)
|
|
}
|
|
if len(msg.msgs) != 0 {
|
|
t.Fatalf("terminated session must not receive nudges, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestPRObservation_RetriesAfterMessengerFailure(t *testing.T) {
|
|
m, st, msg := newManager()
|
|
st.sessions["mer-1"] = working("mer-1")
|
|
o := ports.PRObservation{Fetched: true, URL: "pr1", Mergeability: domain.MergeConflicting}
|
|
msg.err = errors.New("temporary send failure")
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", o); err == nil {
|
|
t.Fatal("want send error")
|
|
}
|
|
msg.err = nil
|
|
if err := m.ApplyPRObservation(ctx, "mer-1", o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msg.msgs) != 1 {
|
|
t.Fatalf("want retry to send once, got %v", msg.msgs)
|
|
}
|
|
}
|
|
|
|
func TestActivity_FirstSignalStampsReceipt(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
st.sessions["mer-1"] = domain.SessionRecord{ID: "mer-1", ProjectID: "mer", Activity: domain.Activity{State: domain.ActivityIdle, LastActivityAt: time.Now()}}
|
|
// A same-state repeat (idle on an idle-seeded row) must still write: the
|
|
// receipt itself is the durable fact that clears no_signal.
|
|
if err := m.ApplyActivitySignal(ctx, "mer-1", ports.ActivitySignal{Valid: true, State: domain.ActivityIdle}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := st.sessions["mer-1"]
|
|
if got.FirstSignalAt.IsZero() {
|
|
t.Fatalf("first signal not stamped: %+v", got)
|
|
}
|
|
stamped := got.FirstSignalAt
|
|
// Later signals must not move the receipt.
|
|
if err := m.ApplyActivitySignal(ctx, "mer-1", ports.ActivitySignal{Valid: true, State: domain.ActivityActive, Timestamp: time.Now().Add(time.Minute)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := st.sessions["mer-1"]; !got.FirstSignalAt.Equal(stamped) {
|
|
t.Fatalf("first signal moved: %v -> %v", stamped, got.FirstSignalAt)
|
|
}
|
|
}
|
|
|
|
func TestActivity_SameStateRepeatAfterReceiptIsNoOp(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
rec := working("mer-1")
|
|
rec.FirstSignalAt = time.Now()
|
|
st.sessions["mer-1"] = rec
|
|
before := st.sessions["mer-1"]
|
|
if err := m.ApplyActivitySignal(ctx, "mer-1", ports.ActivitySignal{Valid: true, State: domain.ActivityActive}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if st.sessions["mer-1"] != before {
|
|
t.Fatalf("same-state repeat after receipt must not rewrite: %+v", st.sessions["mer-1"])
|
|
}
|
|
}
|
|
|
|
func TestMarkSpawnedClearsFirstSignal(t *testing.T) {
|
|
m, st, _ := newManager()
|
|
rec := working("mer-1")
|
|
rec.FirstSignalAt = time.Now().Add(-time.Hour)
|
|
st.sessions["mer-1"] = rec
|
|
if err := m.MarkSpawned(ctx, "mer-1", domain.SessionMetadata{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := st.sessions["mer-1"]; !got.FirstSignalAt.IsZero() {
|
|
t.Fatalf("spawn/restore must clear the receipt, got %+v", got)
|
|
}
|
|
}
|