package forgerpc import ( "context" "errors" "log/slog" "slices" "testing" "time" "github.com/nats-io/nats-server/v2/server" natssrv "github.com/nats-io/nats-server/v2/test" "github.com/nats-io/nats.go" "github.com/samcharles93/archie-core/internal/domain/workflow" "github.com/samcharles93/archie-core/internal/forge" ) func startEmbedded(t *testing.T) *server.Server { t.Helper() srv := natssrv.RunRandClientPortServer() t.Cleanup(srv.Shutdown) return srv } func connect(t *testing.T, url string) *nats.Conn { t.Helper() nc, err := nats.Connect(url) if err != nil { t.Fatalf("nats connect: %v", err) } t.Cleanup(nc.Close) return nc } // fakeForge implements forge.Forge, recording calls to the four methods // workflow stages invoke mid-run. Every other method panics if called -- // this RPC layer must never proxy them. type fakeForge struct { comments []commentCall closes []closeCall prs []prCall stateLabels []stateLabelCall branches []branchCall commentErr error closeErr error prErr error reviews []reviewCommentsCall reviewErr error } type reviewCommentsCall struct { owner, repo string number int reviewedSHA string comments []forge.InlineReviewComment } type commentCall struct { owner, repo string number int body string } type closeCall struct { owner, repo string number int comment string } type prCall struct { owner, repo, title, head, base, body string } type stateLabelCall struct { owner, repo string number int label string knownLabels []string } type branchCall struct { owner, repo, branch string number int } func (f *fakeForge) Comment(_ context.Context, owner, repo string, number int, body string) (int64, error) { f.comments = append(f.comments, commentCall{owner, repo, number, body}) if f.commentErr != nil { return 0, f.commentErr } return 99, nil } func (f *fakeForge) CloseIssue(_ context.Context, owner, repo string, number int, comment string) error { f.closes = append(f.closes, closeCall{owner, repo, number, comment}) return f.closeErr } func (f *fakeForge) CreatePR(_ context.Context, owner, repo, title, head, base, body string) (int, error) { f.prs = append(f.prs, prCall{owner, repo, title, head, base, body}) if f.prErr != nil { return 0, f.prErr } return 7, nil } func (f *fakeForge) SetStateLabel(_ context.Context, owner, repo string, number int, label string, knownLabels []string) { f.stateLabels = append(f.stateLabels, stateLabelCall{owner, repo, number, label, knownLabels}) } func (f *fakeForge) LinkBranch(_ context.Context, owner, repo string, number int, branch string) error { f.branches = append(f.branches, branchCall{owner: owner, repo: repo, number: number, branch: branch}) return nil } // CreateReviewComments makes fakeForge satisfy forge.ReviewCommentWriter, the // optional capability the server type-asserts. func (f *fakeForge) CreateReviewComments(_ context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error { f.reviews = append(f.reviews, reviewCommentsCall{owner: owner, repo: repo, number: number, reviewedSHA: reviewedHeadSHA, comments: comments}) return f.reviewErr } func (f *fakeForge) AcceptInvitations(context.Context) error { panic("unexpected call") } func (f *fakeForge) AssignedIssues(context.Context, string, string, string) ([]forge.Issue, error) { panic("unexpected call") } func (f *fakeForge) IssuesWithLabel(context.Context, string, string, string) ([]forge.Issue, error) { panic("unexpected call") } func (f *fakeForge) PRState(context.Context, string, string, int) (string, error) { panic("unexpected call") } func (f *fakeForge) CreateIssue(context.Context, string, string, string, string, []string) (int, error) { panic("unexpected call") } func (f *fakeForge) React(context.Context, string, string, int, string) error { panic("unexpected call") } func (f *fakeForge) VerifyPush(context.Context, string, string) error { panic("unexpected call") } func newTestServer(t *testing.T) (*fakeForge, *Client) { t.Helper() fg := &fakeForge{} srv := startEmbedded(t) url := srv.ClientURL() serverConn := connect(t, url) rpcServer := &Server{Forge: fg, Log: slog.New(slog.DiscardHandler)} unsub, err := rpcServer.Register(serverConn) if err != nil { t.Fatalf("register: %v", err) } t.Cleanup(unsub) clientConn := connect(t, url) client := &Client{Conn: clientConn, Timeout: 2 * time.Second} return fg, client } func TestClientCommentPersistsViaServer(t *testing.T) { fg, client := newTestServer(t) id, err := client.Comment(context.Background(), "acme", "widget", 1, "hello") if err != nil { t.Fatalf("Comment: %v", err) } if id != 99 { t.Fatalf("expected comment id 99, got %d", id) } if len(fg.comments) != 1 || fg.comments[0] != (commentCall{"acme", "widget", 1, "hello"}) { t.Fatalf("comment did not reach server, got %+v", fg.comments) } } func TestClientCloseIssuePersistsViaServer(t *testing.T) { fg, client := newTestServer(t) if err := client.CloseIssue(context.Background(), "acme", "widget", 2, "done"); err != nil { t.Fatalf("CloseIssue: %v", err) } if len(fg.closes) != 1 || fg.closes[0] != (closeCall{"acme", "widget", 2, "done"}) { t.Fatalf("close did not reach server, got %+v", fg.closes) } } func TestClientCreatePRPersistsViaServer(t *testing.T) { fg, client := newTestServer(t) num, err := client.CreatePR(context.Background(), "acme", "widget", "title", "head", "main", "body") if err != nil { t.Fatalf("CreatePR: %v", err) } if num != 7 { t.Fatalf("expected PR number 7, got %d", num) } if len(fg.prs) != 1 || fg.prs[0] != (prCall{"acme", "widget", "title", "head", "main", "body"}) { t.Fatalf("PR did not reach server, got %+v", fg.prs) } } func TestClientLinkBranchPersistsViaServer(t *testing.T) { f, client := newTestServer(t) if err := client.LinkBranch(context.Background(), "acme", "widget", 4, "fix/4-bug"); err != nil { t.Fatalf("LinkBranch: %v", err) } if len(f.branches) != 1 || f.branches[0] != (branchCall{owner: "acme", repo: "widget", number: 4, branch: "fix/4-bug"}) { t.Fatalf("branch link did not reach server, got %+v", f.branches) } } func TestClientCreateReviewCommentsPersistsViaServer(t *testing.T) { fg, client := newTestServer(t) comments := []workflow.ReviewComment{ {Path: "a.go", Line: 12, Body: "**confirmed (warn)**: nil deref\n\n```suggestion\nreturn nil\n```"}, {Path: "b.go", Line: 3, Body: "**plausible (warn)**: possible race"}, } if err := client.CreateReviewComments(context.Background(), "acme", "widget", 7, "reviewed-head-sha", comments); err != nil { t.Fatalf("CreateReviewComments: %v", err) } if len(fg.reviews) != 1 { t.Fatalf("reviews reached server %d times, want 1 batch", len(fg.reviews)) } got := fg.reviews[0] if got.owner != "acme" || got.repo != "widget" || got.number != 7 { t.Errorf("anchored at %s/%s#%d, want acme/widget#7", got.owner, got.repo, got.number) } // The daemon is the only side that can read a pull request's head, so the // revision the worker measured has to survive the round trip for the drift // check to have anything to compare against. if got.reviewedSHA != "reviewed-head-sha" { t.Errorf("server saw reviewed head %q, want the worker's measured revision", got.reviewedSHA) } want := []forge.InlineReviewComment{ {Path: "a.go", Line: 12, Body: comments[0].Body}, {Path: "b.go", Line: 3, Body: comments[1].Body}, } if !slices.Equal(got.comments, want) { t.Errorf("comments = %+v, want %+v", got.comments, want) } } // TestClientCreateReviewCommentsReportsAnIncapableForge is the degrade path: a // forge without the optional writer must answer with an error the best-effort // stage can log, not a silent success that leaves the operator believing // comments were posted. func TestClientCreateReviewCommentsReportsAnIncapableForge(t *testing.T) { fg := &fakeForge{} srv := startEmbedded(t) serverConn := connect(t, srv.ClientURL()) // Embedding the forge.Forge INTERFACE (not the fake) keeps the promoted // method set free of CreateReviewComments, which is what makes the type // assertion fail -- exactly as it does for the noop forge. rpcServer := &Server{Forge: noReviewCommentsForge{Forge: fg}, Log: slog.New(slog.DiscardHandler)} unsub, err := rpcServer.Register(serverConn) if err != nil { t.Fatalf("register: %v", err) } t.Cleanup(unsub) client := &Client{Conn: connect(t, srv.ClientURL()), Timeout: 2 * time.Second} err = client.CreateReviewComments(context.Background(), "acme", "widget", 7, "reviewed-sha", []workflow.ReviewComment{{Path: "a.go", Line: 1, Body: "x"}}) if err == nil { t.Fatal("CreateReviewComments error = nil, want an incapable-forge error") } if len(fg.reviews) != 0 { t.Errorf("the forge was called %d times despite lacking the capability", len(fg.reviews)) } } func TestClientCreateReviewCommentsPropagatesAForgeError(t *testing.T) { fg := &fakeForge{reviewErr: errors.New("422 line is not part of the diff")} srv := startEmbedded(t) serverConn := connect(t, srv.ClientURL()) rpcServer := &Server{Forge: fg, Log: slog.New(slog.DiscardHandler)} unsub, err := rpcServer.Register(serverConn) if err != nil { t.Fatalf("register: %v", err) } t.Cleanup(unsub) client := &Client{Conn: connect(t, srv.ClientURL()), Timeout: 2 * time.Second} err = client.CreateReviewComments(context.Background(), "acme", "widget", 7, "reviewed-sha", []workflow.ReviewComment{{Path: "a.go", Line: 1, Body: "x"}}) if err == nil { t.Fatal("CreateReviewComments error = nil, want the forge failure surfaced") } } // noReviewCommentsForge is a forge.Forge whose method set lacks the optional // review-comment writer. type noReviewCommentsForge struct{ forge.Forge } func TestClientPropagatesServerError(t *testing.T) { fg := &fakeForge{commentErr: errors.New("forge unavailable")} srv := startEmbedded(t) url := srv.ClientURL() rpcServer := &Server{Forge: fg, Log: slog.New(slog.DiscardHandler)} unsub, err := rpcServer.Register(connect(t, url)) if err != nil { t.Fatalf("register: %v", err) } t.Cleanup(unsub) client := &Client{Conn: connect(t, url), Timeout: 2 * time.Second} _, err = client.Comment(context.Background(), "acme", "widget", 1, "hello") if err == nil { t.Fatal("expected Comment to propagate the server-side error") } } func TestClientCommentTimesOutWithNoResponder(t *testing.T) { srv := startEmbedded(t) client := &Client{Conn: connect(t, srv.ClientURL()), Timeout: 100 * time.Millisecond} _, err := client.Comment(context.Background(), "acme", "widget", 1, "hello") if err == nil { t.Fatal("expected Comment to time out with no server registered") } } // TestIdentityScopedRoutingIsolatesForges proves the critical fix: an // identity-scoped client must reach the forge wired to that identity's // subject, never the root forge. Before identity-scoped subjects existed, // every container-mode task's RPC was served by the root forge regardless // of which identity owned the task. func TestIdentityScopedRoutingIsolatesForges(t *testing.T) { rootFg := &fakeForge{} archieFg := &fakeForge{} srv := startEmbedded(t) url := srv.ClientURL() serverConn := connect(t, url) // Root server on root subjects. unsubRoot, err := (&Server{Forge: rootFg, Log: slog.New(slog.DiscardHandler)}).Register(serverConn) if err != nil { t.Fatalf("register root: %v", err) } t.Cleanup(unsubRoot) // Identity server on archie-scoped subjects. unsubArch, err := (&Server{Forge: archieFg, Log: slog.New(slog.DiscardHandler)}).RegisterFor(serverConn, "archie") if err != nil { t.Fatalf("register archie: %v", err) } t.Cleanup(unsubArch) clientConn := connect(t, url) ctx := context.Background() // Identity-scoped call reaches archie's forge only. archieClient := &Client{Conn: clientConn, Timeout: 2 * time.Second, Identity: "archie"} if err := archieClient.CloseIssue(ctx, "acme", "widget", 1, "done"); err != nil { t.Fatalf("identity-scoped CloseIssue: %v", err) } if len(archieFg.closes) != 1 { t.Fatalf("archie forge closes = %d, want 1", len(archieFg.closes)) } if len(rootFg.closes) != 0 { t.Fatalf("root forge closes = %d, want 0 (identity call leaked to root)", len(rootFg.closes)) } // Root (identity-less) call reaches the root forge only. rootClient := &Client{Conn: clientConn, Timeout: 2 * time.Second} if err := rootClient.CloseIssue(ctx, "acme", "widget", 2, "done"); err != nil { t.Fatalf("root-scoped CloseIssue: %v", err) } if len(rootFg.closes) != 1 { t.Fatalf("root forge closes = %d, want 1", len(rootFg.closes)) } if len(archieFg.closes) != 1 { t.Fatalf("archie forge closes = %d, want still 1 (root call leaked to identity)", len(archieFg.closes)) } } // SubjectFor leaves the root subject unchanged for an empty identity and // prefixes the identity for a non-empty one -- the root subjects must stay // byte-identical so single-identity deployments and older agent images keep // working. func TestSubjectFor(t *testing.T) { if got := SubjectFor("", SubjectComment); got != SubjectComment { t.Fatalf("SubjectFor(\"\", %q) = %q, want unchanged root subject", SubjectComment, got) } if got := SubjectFor("archie", SubjectComment); got != "archie.forge.archie.comment" { t.Fatalf("SubjectFor(\"archie\", %q) = %q", SubjectComment, got) } if got := SubjectFor("archie", SubjectCreatePR); got != "archie.forge.archie.create_pr" { t.Fatalf("SubjectFor(\"archie\", %q) = %q", SubjectCreatePR, got) } }