608 lines
23 KiB
Go
608 lines
23 KiB
Go
package review
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/aoagents/agent-orchestrator/backend/internal/domain"
|
|
"github.com/aoagents/agent-orchestrator/backend/internal/ports"
|
|
)
|
|
|
|
// --- fakes ---
|
|
|
|
type fakeStore struct {
|
|
review *domain.Review
|
|
runs []domain.ReviewRun
|
|
// insertErr, when set, makes the next InsertReviewRun model a concurrent
|
|
// writer that already recorded a run for this commit: it records that
|
|
// winner (so a follow-up GetReviewRunBySessionAndSHA finds it) and returns
|
|
// insertErr instead of recording the caller's run.
|
|
insertErr error
|
|
}
|
|
|
|
func (f *fakeStore) UpsertReview(_ context.Context, r domain.Review) error {
|
|
cp := r
|
|
f.review = &cp
|
|
return nil
|
|
}
|
|
func (f *fakeStore) GetReviewBySession(_ context.Context, _ domain.SessionID) (domain.Review, bool, error) {
|
|
if f.review == nil {
|
|
return domain.Review{}, false, nil
|
|
}
|
|
return *f.review, true, nil
|
|
}
|
|
func (f *fakeStore) InsertReviewRun(_ context.Context, r domain.ReviewRun) error {
|
|
if f.insertErr != nil {
|
|
winner := r
|
|
winner.ID = "winner-" + r.ID
|
|
f.runs = append(f.runs, winner)
|
|
return f.insertErr
|
|
}
|
|
for _, existing := range f.runs {
|
|
if existing.SessionID == r.SessionID &&
|
|
existing.PRURL == r.PRURL &&
|
|
existing.TargetSHA == r.TargetSHA &&
|
|
existing.TargetSHA != "" &&
|
|
existing.Status != domain.ReviewRunFailed &&
|
|
existing.Verdict != domain.VerdictChangesRequested {
|
|
return domain.ErrDuplicateReviewRun
|
|
}
|
|
}
|
|
f.runs = append(f.runs, r)
|
|
return nil
|
|
}
|
|
func (f *fakeStore) UpdateReviewRunResult(_ context.Context, id string, status domain.ReviewRunStatus, verdict domain.ReviewVerdict, body, githubReviewID string) (bool, error) {
|
|
for i := range f.runs {
|
|
if f.runs[i].ID == id {
|
|
if f.runs[i].Status != domain.ReviewRunRunning {
|
|
return false, nil
|
|
}
|
|
f.runs[i].Status = status
|
|
f.runs[i].Verdict = verdict
|
|
f.runs[i].Body = body
|
|
f.runs[i].GithubReviewID = githubReviewID
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
func (f *fakeStore) SupersedeReviewRun(_ context.Context, id, body string) (bool, error) {
|
|
for i := range f.runs {
|
|
if f.runs[i].ID == id {
|
|
if f.runs[i].Verdict != domain.VerdictNone || f.runs[i].Status == domain.ReviewRunFailed {
|
|
return false, nil
|
|
}
|
|
f.runs[i].Status = domain.ReviewRunFailed
|
|
f.runs[i].Body = body
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
func (f *fakeStore) SupersedeStaleRunningReviewRuns(_ context.Context, sessionID domain.SessionID, prURL, targetSHA, body string) (int64, error) {
|
|
var n int64
|
|
for i := range f.runs {
|
|
if f.runs[i].SessionID == sessionID && f.runs[i].PRURL == prURL && f.runs[i].TargetSHA != targetSHA && f.runs[i].Status == domain.ReviewRunRunning && f.runs[i].Verdict == domain.VerdictNone {
|
|
f.runs[i].Status = domain.ReviewRunFailed
|
|
f.runs[i].Body = body
|
|
n++
|
|
}
|
|
}
|
|
return n, nil
|
|
}
|
|
func (f *fakeStore) GetReviewRun(_ context.Context, id string) (domain.ReviewRun, bool, error) {
|
|
for _, r := range f.runs {
|
|
if r.ID == id {
|
|
return r, true, nil
|
|
}
|
|
}
|
|
return domain.ReviewRun{}, false, nil
|
|
}
|
|
func (f *fakeStore) GetReviewRunBySessionPRAndSHA(_ context.Context, sessionID domain.SessionID, prURL, sha string) (domain.ReviewRun, bool, error) {
|
|
for i := len(f.runs) - 1; i >= 0; i-- {
|
|
if f.runs[i].SessionID == sessionID && f.runs[i].PRURL == prURL && f.runs[i].TargetSHA == sha {
|
|
return f.runs[i], true, nil
|
|
}
|
|
}
|
|
return domain.ReviewRun{}, false, nil
|
|
}
|
|
func (f *fakeStore) ListReviewRunsBySession(_ context.Context, _ domain.SessionID) ([]domain.ReviewRun, error) {
|
|
return f.runs, nil
|
|
}
|
|
|
|
type fakeSessions struct {
|
|
rec domain.SessionRecord
|
|
ok bool
|
|
}
|
|
|
|
func (f fakeSessions) GetSession(_ context.Context, _ domain.SessionID) (domain.SessionRecord, bool, error) {
|
|
return f.rec, f.ok, nil
|
|
}
|
|
|
|
type fakePRs struct{ prs []domain.PullRequest }
|
|
|
|
func (f fakePRs) ListPRsBySession(_ context.Context, _ domain.SessionID) ([]domain.PullRequest, error) {
|
|
return f.prs, nil
|
|
}
|
|
|
|
type fakeProjects struct{ cfg domain.ProjectConfig }
|
|
|
|
func (f fakeProjects) GetProject(_ context.Context, id string) (domain.ProjectRecord, bool, error) {
|
|
return domain.ProjectRecord{ID: id, Config: f.cfg}, true, nil
|
|
}
|
|
|
|
type fakeLauncher struct {
|
|
handle string
|
|
alive bool
|
|
spawnErr error
|
|
notifyErr error
|
|
spawned bool
|
|
spawnCount int
|
|
notified bool
|
|
gotSpec LaunchSpec
|
|
gotHandle string
|
|
specs []LaunchSpec
|
|
handles []string
|
|
}
|
|
|
|
func (f *fakeLauncher) Spawn(_ context.Context, spec LaunchSpec) (string, error) {
|
|
f.spawned = true
|
|
f.spawnCount++
|
|
f.gotSpec = spec
|
|
f.specs = append(f.specs, spec)
|
|
if f.spawnErr != nil {
|
|
return "", f.spawnErr
|
|
}
|
|
return f.handle, nil
|
|
}
|
|
func (f *fakeLauncher) Notify(_ context.Context, handleID string, spec LaunchSpec) error {
|
|
f.notified = true
|
|
f.gotHandle = handleID
|
|
f.gotSpec = spec
|
|
f.handles = append(f.handles, handleID)
|
|
f.specs = append(f.specs, spec)
|
|
return f.notifyErr
|
|
}
|
|
func (f *fakeLauncher) Alive(_ context.Context, _ string) (bool, error) {
|
|
return f.alive || f.spawned, nil
|
|
}
|
|
|
|
func liveWorker() domain.SessionRecord {
|
|
return domain.SessionRecord{
|
|
ID: "mer-1",
|
|
ProjectID: "mer",
|
|
Harness: domain.HarnessClaudeCode,
|
|
Metadata: domain.SessionMetadata{WorkspacePath: "/ws/mer-1"},
|
|
}
|
|
}
|
|
|
|
func newEngineForTest(store Store, sessions Sessions, prs PRs, projects Projects, launcher Launcher) *Engine {
|
|
ids := 0
|
|
return New(Deps{
|
|
Store: store, Sessions: sessions, PRs: prs, Projects: projects, Launcher: launcher,
|
|
Clock: func() time.Time { return time.Unix(0, 0).UTC() },
|
|
NewID: func() string { ids++; return "id-" + string(rune('0'+ids)) },
|
|
})
|
|
}
|
|
|
|
func prAt(sha string) fakePRs {
|
|
return fakePRs{prs: []domain.PullRequest{{URL: "https://github.com/o/r/pull/1", Number: 1, HeadSHA: sha}}}
|
|
}
|
|
|
|
// --- tests ---
|
|
|
|
func TestTriggerSpawnsNewReviewerAndRecordsRunAfterLaunch(t *testing.T) {
|
|
store := &fakeStore{}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !res.Created || res.ReviewerHandleID != "review-mer-1" {
|
|
t.Fatalf("result = %+v", res)
|
|
}
|
|
if !launcher.spawned || launcher.notified {
|
|
t.Fatalf("expected spawn (no live reviewer): %+v", launcher)
|
|
}
|
|
if res.Run.TargetSHA != "sha1" || res.Run.Status != domain.ReviewRunRunning || res.Run.Harness != domain.ReviewerClaudeCode {
|
|
t.Fatalf("run = %+v", res.Run)
|
|
}
|
|
if launcher.gotSpec.RunID != res.Run.ID {
|
|
t.Fatalf("launch spec run id %q != run id %q", launcher.gotSpec.RunID, res.Run.ID)
|
|
}
|
|
if len(store.runs) != 1 || store.review == nil || store.review.ReviewerHandleID != "review-mer-1" {
|
|
t.Fatalf("persisted review=%+v runs=%+v", store.review, store.runs)
|
|
}
|
|
}
|
|
|
|
func TestTriggerConcurrentSameWorkerSpawnsOnce(t *testing.T) {
|
|
store := &fakeStore{}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
const n = 8
|
|
var wg sync.WaitGroup
|
|
results := make([]TriggerResult, n)
|
|
errs := make([]error, n)
|
|
wg.Add(n)
|
|
for i := 0; i < n; i++ {
|
|
go func(i int) {
|
|
defer wg.Done()
|
|
results[i], errs[i] = eng.Trigger(context.Background(), "mer-1")
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
|
|
created := 0
|
|
for i := 0; i < n; i++ {
|
|
if errs[i] != nil {
|
|
t.Fatalf("Trigger[%d]: %v", i, errs[i])
|
|
}
|
|
if results[i].Created {
|
|
created++
|
|
}
|
|
}
|
|
if created != 1 {
|
|
t.Errorf("Created=true count = %d, want exactly 1", created)
|
|
}
|
|
if launcher.spawnCount != 1 {
|
|
t.Errorf("reviewer spawn count = %d, want 1", launcher.spawnCount)
|
|
}
|
|
if len(store.runs) != 1 {
|
|
t.Errorf("recorded review runs = %d, want 1", len(store.runs))
|
|
}
|
|
}
|
|
|
|
func TestTriggerFallsBackToExistingRunOnUniqueConflict(t *testing.T) {
|
|
// The idempotency check passes (no run yet), but the insert loses to a
|
|
// concurrent writer the unique index already accepted.
|
|
store := &fakeStore{insertErr: domain.ErrDuplicateReviewRun}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if res.Created {
|
|
t.Fatalf("expected Created=false on unique conflict: %+v", res)
|
|
}
|
|
if res.Run.TargetSHA != "sha1" || !strings.HasPrefix(res.Run.ID, "winner-") {
|
|
t.Fatalf("expected the recorded winner run, got %+v", res.Run)
|
|
}
|
|
if launcher.spawnCount != 0 {
|
|
t.Fatalf("reviewer should not launch after unique conflict: %+v", launcher)
|
|
}
|
|
}
|
|
|
|
func TestTriggerIsIdempotentForSameCommit(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{
|
|
ID: "run-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1",
|
|
Status: domain.ReviewRunComplete, Verdict: domain.VerdictApproved,
|
|
}},
|
|
}
|
|
launcher := &fakeLauncher{alive: true}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if res.Created || res.Run.ID != "run-1" || res.ReviewerHandleID != "review-mer-1" {
|
|
t.Fatalf("expected reuse of existing run: %+v", res)
|
|
}
|
|
if launcher.spawned || launcher.notified {
|
|
t.Fatalf("should not launch for an already-reviewed commit: %+v", launcher)
|
|
}
|
|
if len(store.runs) != 1 {
|
|
t.Fatalf("should not insert another run: %+v", store.runs)
|
|
}
|
|
}
|
|
|
|
func TestTriggerReusesRunningRowWithNoVerdict(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1", Status: domain.ReviewRunRunning}},
|
|
}
|
|
launcher := &fakeLauncher{alive: false, handle: "review-mer-2"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if res.Created || res.Run.ID != "run-1" {
|
|
t.Fatalf("expected reuse of the running review for the same commit: %+v", res)
|
|
}
|
|
if launcher.spawned || launcher.notified {
|
|
t.Fatalf("running same-commit review should not relaunch: %+v", launcher)
|
|
}
|
|
if got := store.runs[0]; got.Status != domain.ReviewRunRunning {
|
|
t.Fatalf("running row should remain running, got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestTriggerSupersedesNonRunningRowWithNoVerdict(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1", Status: domain.ReviewRunComplete}},
|
|
}
|
|
launcher := &fakeLauncher{alive: true, handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !res.Created {
|
|
t.Fatalf("expected a fresh pass when prior non-running row has no verdict: %+v", res)
|
|
}
|
|
if !launcher.notified || launcher.spawned {
|
|
t.Fatalf("expected notify on live reviewer pane, not spawn: %+v", launcher)
|
|
}
|
|
if stale := store.runs[0]; stale.ID != "run-1" || stale.Status != domain.ReviewRunFailed {
|
|
t.Fatalf("expected stale run-1 marked failed, got %+v", stale)
|
|
}
|
|
}
|
|
|
|
func TestTriggerNotifiesLiveReviewerOnNewCommit(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-0", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha0", Status: domain.ReviewRunComplete}},
|
|
}
|
|
launcher := &fakeLauncher{alive: true}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !launcher.notified || launcher.spawned {
|
|
t.Fatalf("expected notify on live reviewer: %+v", launcher)
|
|
}
|
|
if launcher.gotHandle != "review-mer-1" {
|
|
t.Fatalf("notify handle = %q", launcher.gotHandle)
|
|
}
|
|
if !res.Created || res.Run.TargetSHA != "sha1" || len(store.runs) != 2 {
|
|
t.Fatalf("expected a new run for sha1: res=%+v runs=%+v", res, store.runs)
|
|
}
|
|
}
|
|
|
|
func TestTriggerSupersedesOlderRunningRunOnNewCommit(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-old", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha0", Status: domain.ReviewRunRunning}},
|
|
}
|
|
launcher := &fakeLauncher{alive: true, handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !res.Created || res.Run.TargetSHA != "sha1" {
|
|
t.Fatalf("expected new run for new commit, got %+v", res)
|
|
}
|
|
if old := store.runs[0]; old.ID != "run-old" || old.Status != domain.ReviewRunFailed {
|
|
t.Fatalf("expected older running run to be failed, got %+v", old)
|
|
}
|
|
if !launcher.notified || launcher.spawned {
|
|
t.Fatalf("expected live reviewer pane reused for new commit: %+v", launcher)
|
|
}
|
|
}
|
|
|
|
func TestTriggerSpawnsWhenReviewerDead(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-0", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha0", Status: domain.ReviewRunComplete}},
|
|
}
|
|
launcher := &fakeLauncher{alive: false, handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
if _, err := eng.Trigger(context.Background(), "mer-1"); err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !launcher.spawned || launcher.notified {
|
|
t.Fatalf("expected spawn when reviewer dead: %+v", launcher)
|
|
}
|
|
}
|
|
|
|
func TestTriggerLaunchFailureRecordsFailedRun(t *testing.T) {
|
|
store := &fakeStore{}
|
|
launcher := &fakeLauncher{spawnErr: fmt.Errorf("claude: %w", ports.ErrAgentBinaryNotFound)}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
if _, err := eng.Trigger(context.Background(), "mer-1"); !errors.Is(err, ports.ErrAgentBinaryNotFound) {
|
|
t.Fatalf("err = %v, want ports.ErrAgentBinaryNotFound", err)
|
|
}
|
|
if store.review == nil || len(store.runs) != 1 {
|
|
t.Fatalf("expected persisted failed review/run: review=%+v runs=%+v", store.review, store.runs)
|
|
}
|
|
run := store.runs[0]
|
|
if run.Status != domain.ReviewRunFailed || run.Verdict != domain.VerdictNone {
|
|
t.Fatalf("run = %+v, want failed with no verdict", run)
|
|
}
|
|
if !strings.Contains(run.Body, "claude") || !strings.Contains(run.Body, ports.ErrAgentBinaryNotFound.Error()) {
|
|
t.Fatalf("run body = %q, want launch cause", run.Body)
|
|
}
|
|
}
|
|
|
|
func TestTriggerRetriesAfterFailedRunForSameCommit(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-failed", ReviewID: "rev-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1", Status: domain.ReviewRunFailed}},
|
|
}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !res.Created || res.Run.ID == "run-failed" {
|
|
t.Fatalf("expected retry to create a new run, got %+v", res)
|
|
}
|
|
if len(store.runs) != 2 || !launcher.spawned {
|
|
t.Fatalf("expected new launch/run after failed pass: launched=%v runs=%+v", launcher.spawned, store.runs)
|
|
}
|
|
}
|
|
|
|
func TestTriggerCreatesRunsForMultipleEligiblePRsWithOneReviewer(t *testing.T) {
|
|
store := &fakeStore{}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
prs := fakePRs{prs: []domain.PullRequest{
|
|
{URL: "https://github.com/o/r/pull/1", Number: 1, HeadSHA: "sha1"},
|
|
{URL: "https://github.com/o/r/pull/2", Number: 2, HeadSHA: "sha2"},
|
|
}}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prs, fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !res.Created || len(res.CreatedRuns) != 2 || len(store.runs) != 2 {
|
|
t.Fatalf("created batch = %+v runs=%+v", res, store.runs)
|
|
}
|
|
if res.CreatedRuns[0].BatchID == "" || res.CreatedRuns[0].BatchID != res.CreatedRuns[1].BatchID {
|
|
t.Fatalf("created runs should share one batch id: %+v", res.CreatedRuns)
|
|
}
|
|
if launcher.spawnCount != 1 || len(launcher.handles) != 0 {
|
|
t.Fatalf("expected one spawn and no extra notify, launcher=%+v", launcher)
|
|
}
|
|
if len(launcher.specs) != 1 {
|
|
t.Fatalf("launch specs = %d, want 1: %+v", len(launcher.specs), launcher.specs)
|
|
}
|
|
spec := launcher.specs[0]
|
|
if spec.ReviewIndex != 0 || len(spec.ReviewQueue) != 2 {
|
|
t.Fatalf("spec queue context = index %d queue %+v", spec.ReviewIndex, spec.ReviewQueue)
|
|
}
|
|
if spec.ReviewQueue[0].PRURL != "https://github.com/o/r/pull/1" || spec.ReviewQueue[1].PRURL != "https://github.com/o/r/pull/2" {
|
|
t.Fatalf("spec queue URLs = %+v", spec.ReviewQueue)
|
|
}
|
|
if store.review == nil || store.review.ReviewerHandleID != "review-mer-1" || store.review.PRURL != "" {
|
|
t.Fatalf("review row = %+v, want shared handle and no behavioral pr_url", store.review)
|
|
}
|
|
}
|
|
|
|
func TestTriggerAllowsTwoPRsWithSameHeadSHA(t *testing.T) {
|
|
store := &fakeStore{}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
prs := fakePRs{prs: []domain.PullRequest{
|
|
{URL: "https://github.com/o/r/pull/1", Number: 1, HeadSHA: "same"},
|
|
{URL: "https://github.com/o/r/pull/2", Number: 2, HeadSHA: "same"},
|
|
}}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prs, fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if len(res.CreatedRuns) != 2 {
|
|
t.Fatalf("created runs = %d, want 2: %+v", len(res.CreatedRuns), res.CreatedRuns)
|
|
}
|
|
if store.runs[0].PRURL == store.runs[1].PRURL || store.runs[0].TargetSHA != store.runs[1].TargetSHA {
|
|
t.Fatalf("runs should differ by PR only: %+v", store.runs)
|
|
}
|
|
}
|
|
|
|
func TestTriggerSkipsApprovedAndRunningCurrentHead(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{
|
|
{ID: "approved", ReviewID: "rev-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1", Status: domain.ReviewRunComplete, Verdict: domain.VerdictApproved, CreatedAt: time.Unix(1, 0)},
|
|
{ID: "running", ReviewID: "rev-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/2", TargetSHA: "sha2", Status: domain.ReviewRunRunning, CreatedAt: time.Unix(2, 0)},
|
|
},
|
|
}
|
|
launcher := &fakeLauncher{alive: true}
|
|
prs := fakePRs{prs: []domain.PullRequest{
|
|
{URL: "https://github.com/o/r/pull/1", Number: 1, HeadSHA: "sha1"},
|
|
{URL: "https://github.com/o/r/pull/2", Number: 2, HeadSHA: "sha2"},
|
|
}}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prs, fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if res.Created || len(res.CreatedRuns) != 0 || launcher.spawned || launcher.notified {
|
|
t.Fatalf("expected no new work: res=%+v launcher=%+v", res, launcher)
|
|
}
|
|
if len(res.Reviews) != 2 || res.Reviews[0].Status != ReviewStateUpToDate || res.Reviews[1].Status != ReviewStateRunning {
|
|
t.Fatalf("review states = %+v", res.Reviews)
|
|
}
|
|
}
|
|
|
|
func TestTriggerCreatesRunForChangesRequestedCurrentHead(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{
|
|
ID: "changes", ReviewID: "rev-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1",
|
|
Status: domain.ReviewRunComplete, Verdict: domain.VerdictChangesRequested, CreatedAt: time.Unix(1, 0),
|
|
}},
|
|
}
|
|
launcher := &fakeLauncher{alive: true, handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if !res.Created || len(res.CreatedRuns) != 1 || !launcher.notified || launcher.spawned {
|
|
t.Fatalf("expected rerun on changes_requested current head: res=%+v launcher=%+v", res, launcher)
|
|
}
|
|
}
|
|
|
|
func TestTriggerUsesConfiguredReviewerHarness(t *testing.T) {
|
|
store := &fakeStore{}
|
|
projects := fakeProjects{cfg: domain.ProjectConfig{Reviewers: []domain.ReviewerConfig{{Harness: domain.ReviewerHarness("greptile")}}}}
|
|
launcher := &fakeLauncher{handle: "review-mer-1"}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), projects, launcher)
|
|
|
|
res, err := eng.Trigger(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("Trigger: %v", err)
|
|
}
|
|
if res.Run.Harness != domain.ReviewerHarness("greptile") || launcher.gotSpec.Harness != domain.ReviewerHarness("greptile") {
|
|
t.Fatalf("harness not used: run=%+v spec=%+v", res.Run, launcher.gotSpec)
|
|
}
|
|
}
|
|
|
|
func TestTriggerRejectsBadWorkerState(t *testing.T) {
|
|
t.Run("unknown worker", func(t *testing.T) {
|
|
eng := newEngineForTest(&fakeStore{}, fakeSessions{ok: false}, prAt("sha1"), fakeProjects{}, &fakeLauncher{})
|
|
if _, err := eng.Trigger(context.Background(), "mer-1"); !errors.Is(err, ErrNotFound) {
|
|
t.Fatalf("err = %v, want ErrNotFound", err)
|
|
}
|
|
})
|
|
t.Run("no pr", func(t *testing.T) {
|
|
eng := newEngineForTest(&fakeStore{}, fakeSessions{rec: liveWorker(), ok: true}, fakePRs{}, fakeProjects{}, &fakeLauncher{})
|
|
if _, err := eng.Trigger(context.Background(), "mer-1"); !errors.Is(err, ErrInvalid) {
|
|
t.Fatalf("err = %v, want ErrInvalid", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestListReturnsHandleAndRuns(t *testing.T) {
|
|
store := &fakeStore{
|
|
review: &domain.Review{ID: "rev-1", SessionID: "mer-1", ReviewerHandleID: "review-mer-1"},
|
|
runs: []domain.ReviewRun{{ID: "run-1", SessionID: "mer-1", PRURL: "https://github.com/o/r/pull/1", TargetSHA: "sha1"}},
|
|
}
|
|
eng := newEngineForTest(store, fakeSessions{rec: liveWorker(), ok: true}, prAt("sha1"), fakeProjects{}, &fakeLauncher{})
|
|
got, err := eng.List(context.Background(), "mer-1")
|
|
if err != nil {
|
|
t.Fatalf("List: %v", err)
|
|
}
|
|
if got.ReviewerHandleID != "review-mer-1" || len(got.Runs) != 1 {
|
|
t.Fatalf("list = %+v", got)
|
|
}
|
|
}
|