Files
archie/internal/gateway/review_tools_test.go
T
sam ad1e6ea0d3 feat(gateway): operator-triggered PR review with selectable reviewer model
Add a channel-neutral review_pr command that runs the adversarial reviewer
against an existing pull request and returns structured findings. The Web UI
chat and Telegram invoke the same command; the reviewer model is models.reviewer
(falling back to models.builder), configurable independently of planner/builder.

- forge: PullRequest + PullRequestReader.GetPullRequest (github, gitea)
- worktree: Manager.CheckoutPR materialises a PR head for Diff/Snapshot
- agentworker: NewOperatorReviewer + ReviewerModel (single model-resolution rule)
- gateway: review_pr tool, ChatPRReviewer, wired into TurnRunner for every channel
- archied: prReviewer adapter with identity-scoped repo allow-list and
  per-PR single-flight, so duplicate/concurrent reviews are deterministic

Closes archie-core-h019.8.
2026-09-10 01:09:31 +10:00

106 lines
3.4 KiB
Go

package gateway
import (
"context"
"errors"
"testing"
)
type fakePRReviewer struct {
gotIdentity *string
gotRepo string
gotNumber int
result PRReviewResult
err error
}
func (f *fakePRReviewer) ReviewPR(_ context.Context, identity *string, repo string, number int) (PRReviewResult, error) {
f.gotIdentity = identity
f.gotRepo = repo
f.gotNumber = number
return f.result, f.err
}
func TestReviewToolOmittedWhenReviewerNil(t *testing.T) {
if entries := ReviewTools(nil, "archie"); len(entries) != 0 {
t.Fatalf("ReviewTools(nil) = %d entries, want 0 -- a tool that cannot run must not be advertised", len(entries))
}
}
func TestReviewToolAppearsWhenReviewerNonNil(t *testing.T) {
entries := ReviewTools(&fakePRReviewer{}, "archie")
if len(entries) != 1 {
t.Fatalf("ReviewTools() = %d entries, want 1", len(entries))
}
if err := entries[0].Validate(); err != nil {
t.Fatalf("entry.Validate() = %v", err)
}
}
func TestReviewPRToolBindsIdentityAndReturnsFindings(t *testing.T) {
reviewer := &fakePRReviewer{
result: PRReviewResult{
Repo: "acme/widget", Number: 7, Model: "openai/gpt-5", Status: "completed",
Findings: []PRReviewFinding{{File: "a.go", Line: 3, Defect: "nil deref", FailureScenario: "x", Verdict: "confirmed", Level: "error", Category: "nil-risk", Blocking: true}},
},
}
entry := toolNamed(t, ReviewTools(reviewer, "archie"), "review_pr")
out, err := entry.Handler(context.Background(), map[string]any{
"repo": "acme/widget", "pr_number": float64(7), "identity": "someone-else",
})
if err != nil {
t.Fatal(err)
}
// The model supplied an identity; it must be ignored in favour of the
// bound identity.
if reviewer.gotIdentity == nil || *reviewer.gotIdentity != "archie" {
t.Fatalf("identity = %v, want bound \"archie\"", reviewer.gotIdentity)
}
if reviewer.gotRepo != "acme/widget" || reviewer.gotNumber != 7 {
t.Fatalf("ReviewPR called with (%q, %d), want (acme/widget, 7)", reviewer.gotRepo, reviewer.gotNumber)
}
result, ok := out.(PRReviewResult)
if !ok {
t.Fatalf("handler returned %T, want PRReviewResult", out)
}
if result.Status != "completed" || len(result.Findings) != 1 || !result.Findings[0].Blocking {
t.Fatalf("result = %+v, want completed with one blocking finding", result)
}
}
func TestReviewPRToolValidatesInput(t *testing.T) {
reviewer := &fakePRReviewer{}
entry := toolNamed(t, ReviewTools(reviewer, "archie"), "review_pr")
tests := []struct {
name string
input map[string]any
}{
{"missing repo", map[string]any{"pr_number": float64(7)}},
{"missing number", map[string]any{"repo": "acme/widget"}},
{"zero number", map[string]any{"repo": "acme/widget", "pr_number": float64(0)}},
{"negative number", map[string]any{"repo": "acme/widget", "pr_number": float64(-1)}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if _, err := entry.Handler(context.Background(), tt.input); err == nil {
t.Fatalf("handler error = nil, want validation error for %v", tt.input)
}
})
}
}
func TestReviewPRToolSurfacesReviewerError(t *testing.T) {
reviewer := &fakePRReviewer{err: errors.New("review already in progress")}
entry := toolNamed(t, ReviewTools(reviewer, "archie"), "review_pr")
if _, err := entry.Handler(context.Background(), map[string]any{
"repo": "acme/widget", "pr_number": float64(7),
}); err == nil {
t.Fatal("handler error = nil, want the reviewer failure surfaced")
}
}