Files
kandev/apps/backend/internal/github/service_review_cleanup_test.go
T
2026-09-23 17:39:51 +01:00

389 lines
13 KiB
Go

package github
import (
"context"
"errors"
"fmt"
"testing"
"time"
)
type countingCleanupClient struct {
*MockClient
prCalls int
reviewCalls int
}
func (c *countingCleanupClient) GetPRFeedback(ctx context.Context, owner, repo string, number int) (*PRFeedback, error) {
return c.MockClient.GetPRFeedback(ctx, owner, repo, number)
}
func (c *countingCleanupClient) GetPR(ctx context.Context, owner, repo string, number int) (*PR, error) {
c.prCalls++
return c.MockClient.GetPR(ctx, owner, repo, number)
}
func (c *countingCleanupClient) ListPRReviews(ctx context.Context, owner, repo string, number int) ([]PRReview, error) {
c.reviewCalls++
return c.MockClient.ListPRReviews(ctx, owner, repo, number)
}
func TestCleanupMergedReviewTasksIncludesHistoricalTasks(t *testing.T) {
_, svc, mockClient, store := setupPollerTest(t)
ctx := context.Background()
client := &countingCleanupClient{MockClient: mockClient}
configureTestWorkspaceAuth(t, svc, client, "ws-1")
watch := &ReviewWatch{WorkspaceID: "ws-1", Enabled: true}
if err := store.CreateReviewWatch(ctx, watch); err != nil {
t.Fatalf("CreateReviewWatch: %v", err)
}
seedTask(t, store, "active-review", false)
seedTask(t, store, "archived-review", true)
rows := []*ReviewPRTask{
{ReviewWatchID: watch.ID, RepoOwner: "acme", RepoName: "widget", PRNumber: 1, TaskID: "active-review"},
{ReviewWatchID: watch.ID, RepoOwner: "acme", RepoName: "widget", PRNumber: 2, TaskID: "archived-review"},
{ReviewWatchID: watch.ID, RepoOwner: "acme", RepoName: "widget", PRNumber: 3, TaskID: "missing-review"},
{ReviewWatchID: watch.ID, RepoOwner: "acme", RepoName: "widget", PRNumber: 4},
{ReviewWatchID: watch.ID, RepoOwner: "acme", RepoName: "widget", PRNumber: 5},
}
for _, row := range rows {
if err := store.CreateReviewPRTask(ctx, row); err != nil {
t.Fatalf("CreateReviewPRTask #%d: %v", row.PRNumber, err)
}
}
mockClient.AddPR(&PR{Number: 1, State: prStateMerged, RepoOwner: "acme", RepoName: "widget"})
mockClient.AddPR(&PR{Number: 2, State: prStateMerged, RepoOwner: "acme", RepoName: "widget"})
mockClient.AddPR(&PR{Number: 3, State: prStateMerged, RepoOwner: "acme", RepoName: "widget"})
mockClient.AddPR(&PR{Number: 4, State: prStateMerged, RepoOwner: "acme", RepoName: "widget"})
mockClient.AddPR(&PR{Number: 5, State: prStateOpen, RepoOwner: "acme", RepoName: "widget"})
recorder := &recordingTaskDeleter{}
svc.SetTaskDeleter(recorder)
deleted, err := svc.CleanupMergedReviewTasks(ctx, watch)
if err != nil {
t.Fatalf("CleanupMergedReviewTasks: %v", err)
}
if deleted != 3 {
t.Fatalf("deleted = %d, want active, archived, and hard-deleted tasks", deleted)
}
if len(recorder.calls) != 3 || recorder.calls[0] != "active-review" ||
recorder.calls[1] != "archived-review" || recorder.calls[2] != "missing-review" {
t.Fatalf("DeleteTask calls = %v, want active, archived, and hard-deleted task IDs", recorder.calls)
}
if client.prCalls != 5 {
t.Fatalf("GetPR calls = %d, want all five inventory rows", client.prCalls)
}
if client.reviewCalls != 1 {
t.Fatalf("ListPRReviews calls = %d, want 1 for the open reservation", client.reviewCalls)
}
remaining, err := store.ListReviewPRTaskIDsByWatch(ctx, watch.ID)
if err != nil {
t.Fatalf("ListReviewPRTaskIDsByWatch: %v", err)
}
got := make(map[string]bool, len(remaining))
for _, taskID := range remaining {
got[taskID] = true
}
if len(got) != 1 || !got[""] {
t.Fatalf("remaining task IDs = %#v, want only the open empty reservation", got)
}
}
type minimalCleanupClient struct {
NoopClient
prs map[int]*PR
reviews map[int][]PRReview
user string
getPRCalls int
listReviewCalls int
userCalls int
feedbackCalls int
commentCalls int
checkCalls int
workflowRunCalls int
workflowJobCalls int
}
func (c *minimalCleanupClient) GetPR(_ context.Context, owner, repo string, number int) (*PR, error) {
c.getPRCalls++
pr, ok := c.prs[number]
if !ok {
return nil, errors.New("unexpected PR lookup")
}
copy := *pr
copy.RepoOwner = owner
copy.RepoName = repo
return &copy, nil
}
func (c *minimalCleanupClient) ListPRReviews(_ context.Context, _, _ string, number int) ([]PRReview, error) {
c.listReviewCalls++
return append([]PRReview(nil), c.reviews[number]...), nil
}
func (c *minimalCleanupClient) GetAuthenticatedUser(context.Context) (string, error) {
c.userCalls++
return c.user, nil
}
func (c *minimalCleanupClient) GetPRFeedback(context.Context, string, string, int) (*PRFeedback, error) {
c.feedbackCalls++
return nil, errors.New("cleanup must not fetch PR feedback")
}
func (c *minimalCleanupClient) ListPRComments(context.Context, string, string, int, *time.Time) ([]PRComment, error) {
c.commentCalls++
return nil, errors.New("cleanup must not fetch PR comments")
}
func (c *minimalCleanupClient) ListCheckRuns(context.Context, string, string, string) ([]CheckRun, error) {
c.checkCalls++
return nil, errors.New("cleanup must not fetch check runs")
}
func (c *minimalCleanupClient) ListWorkflowRuns(context.Context, string, string, string) ([]WorkflowRun, error) {
c.workflowRunCalls++
return nil, errors.New("cleanup must not fetch workflow runs")
}
func (c *minimalCleanupClient) ListWorkflowRunJobs(context.Context, string, string, int64, int) ([]WorkflowJob, error) {
c.workflowJobCalls++
return nil, errors.New("cleanup must not fetch workflow jobs")
}
func TestCleanupUsesMinimalPRReads(t *testing.T) {
_, svc, _, store := setupPollerTest(t)
ctx := context.Background()
client := &minimalCleanupClient{
prs: map[int]*PR{
1: {Number: 1, State: prStateMerged},
2: {Number: 2, State: prStateClosed},
3: {Number: 3, State: prStateOpen},
4: {Number: 4, State: prStateOpen},
},
reviews: map[int][]PRReview{
3: {{State: "APPROVED", Author: "alice"}},
4: {{State: "COMMENTED", Author: "reviewer"}},
},
user: "alice",
}
configureTestWorkspaceAuth(t, svc, client, "ws-1")
watch := &ReviewWatch{WorkspaceID: "ws-1", Enabled: true, CleanupPolicy: CleanupPolicyAlways}
if err := store.CreateReviewWatch(ctx, watch); err != nil {
t.Fatalf("CreateReviewWatch: %v", err)
}
for number := 1; number <= 4; number++ {
taskID := fmt.Sprintf("cleanup-task-%d", number)
seedTask(t, store, taskID, false)
if err := store.CreateReviewPRTask(ctx, &ReviewPRTask{
ReviewWatchID: watch.ID,
RepoOwner: "acme",
RepoName: "widget",
PRNumber: number,
TaskID: taskID,
}); err != nil {
t.Fatalf("CreateReviewPRTask #%d: %v", number, err)
}
}
recorder := &recordingTaskDeleter{}
svc.SetTaskDeleter(recorder)
deleted, err := svc.CleanupMergedReviewTasks(ctx, watch)
if err != nil || deleted != 3 {
t.Fatalf("cleanup = %d, %v; want three terminal or approved tasks", deleted, err)
}
if client.getPRCalls != 4 {
t.Fatalf("GetPR calls = %d, want 4", client.getPRCalls)
}
if client.listReviewCalls != 2 {
t.Fatalf("ListPRReviews calls = %d, want 2 for open PRs", client.listReviewCalls)
}
if client.userCalls != 1 {
t.Fatalf("GetAuthenticatedUser calls = %d, want 1 for the approval candidate", client.userCalls)
}
if client.feedbackCalls != 0 || client.commentCalls != 0 || client.checkCalls != 0 || client.workflowRunCalls != 0 || client.workflowJobCalls != 0 {
t.Fatalf("unexpected cleanup reads: feedback=%d comments=%d checks=%d workflow_runs=%d workflow_jobs=%d", client.feedbackCalls, client.commentCalls, client.checkCalls, client.workflowRunCalls, client.workflowJobCalls)
}
}
// stubTaskDeleter implements TaskDeleter for testing.
type stubTaskDeleter struct {
err error
}
func (s *stubTaskDeleter) DeleteTask(_ context.Context, _ string) error {
return s.err
}
// TestCleanupMergedReviewTasks_TaskAlreadyDeleted verifies that cleanup removes
// a stale dedup row after the task service reports it was already deleted.
func TestCleanupMergedReviewTasks_TaskAlreadyDeleted(t *testing.T) {
_, svc, mockClient, store := setupPollerTest(t)
ctx := context.Background()
// Create a review watch.
watch := &ReviewWatch{WorkspaceID: "ws-1", Enabled: true}
if err := store.CreateReviewWatch(ctx, watch); err != nil {
t.Fatalf("CreateReviewWatch: %v", err)
}
// Create a dedup record pointing to an already-deleted task.
taskID := "task-already-gone"
rpt := &ReviewPRTask{
ReviewWatchID: watch.ID,
RepoOwner: "acme",
RepoName: "widget",
PRNumber: 42,
PRURL: "https://github.com/acme/widget/pull/42",
TaskID: taskID,
}
if err := store.CreateReviewPRTask(ctx, rpt); err != nil {
t.Fatalf("CreateReviewPRTask: %v", err)
}
// Mock: PR is merged so shouldDeleteReviewTask returns true.
mockClient.AddPR(&PR{
Number: 42,
State: prStateMerged,
RepoOwner: "acme",
RepoName: "widget",
})
// The task deleter reports the prior hard deletion so cleanup can release
// the stale reservation row without counting a newly deleted task.
svc.SetTaskDeleter(&stubTaskDeleter{
err: fmt.Errorf("%w: %s", ErrTaskNotFound, taskID),
})
deleted, err := svc.CleanupMergedReviewTasks(ctx, watch)
if err != nil {
t.Fatalf("CleanupMergedReviewTasks returned error: %v", err)
}
if deleted != 1 {
t.Errorf("deleted = %d, want stale dedup row cleanup to count as one", deleted)
}
remaining, err := store.ListReviewPRTaskIDsByWatch(ctx, watch.ID)
if err != nil {
t.Fatalf("ListReviewPRTaskIDsByWatch: %v", err)
}
if len(remaining) != 0 {
t.Errorf("remaining task IDs = %v, want stale dedup row removed", remaining)
}
}
type callbackTaskDeleter func(context.Context, string) error
func (f callbackTaskDeleter) DeleteTask(ctx context.Context, taskID string) error {
return f(ctx, taskID)
}
func TestCleanupMergedReviewTasks_TaskDeletedAfterSelection(t *testing.T) {
_, svc, mockClient, store := setupPollerTest(t)
ctx := context.Background()
watch := &ReviewWatch{WorkspaceID: "ws-1", Enabled: true}
if err := store.CreateReviewWatch(ctx, watch); err != nil {
t.Fatalf("CreateReviewWatch: %v", err)
}
seedTask(t, store, "task-race", false)
if err := store.CreateReviewPRTask(ctx, &ReviewPRTask{
ReviewWatchID: watch.ID,
RepoOwner: "acme",
RepoName: "widget",
PRNumber: 43,
TaskID: "task-race",
}); err != nil {
t.Fatalf("CreateReviewPRTask: %v", err)
}
mockClient.AddPR(&PR{Number: 43, State: prStateMerged, RepoOwner: "acme", RepoName: "widget"})
svc.SetTaskDeleter(callbackTaskDeleter(func(ctx context.Context, taskID string) error {
if _, err := store.db.ExecContext(ctx, `DELETE FROM tasks WHERE id = ?`, taskID); err != nil {
t.Fatalf("delete selected task: %v", err)
}
return fmt.Errorf("%w: %s", ErrTaskNotFound, taskID)
}))
deleted, err := svc.CleanupMergedReviewTasks(ctx, watch)
if err != nil {
t.Fatalf("CleanupMergedReviewTasks: %v", err)
}
if deleted != 1 {
t.Fatalf("deleted = %d, want 1 after selected task disappears", deleted)
}
remaining, err := store.ListReviewPRTaskIDsByWatch(ctx, watch.ID)
if err != nil {
t.Fatalf("ListReviewPRTaskIDsByWatch: %v", err)
}
if len(remaining) != 0 {
t.Fatalf("remaining task IDs = %v, want none", remaining)
}
}
// Regression: when a task already has a TaskPR row pointing to PR #1 and
// AssociatePRWithTask is called with a different PR #2 (e.g. first PR
// closed, new PR opened — or a multi-branch task gaining a second PR on a
// different branch), the new row must be inserted as a sibling without
// touching the existing #1 row. Multi-branch tasks rely on this so two
// PRs on the same (task, repo) coexist; the old "delete-then-insert"
// behavior collapsed multi-branch tasks down to one PR row.
func TestAssociatePRWithTask_AddsSecondPRAsSibling(t *testing.T) {
svc, store, _ := setupSyncTest(t)
ctx := context.Background()
// Seed an existing association for PR #1.
if err := store.CreateTaskPR(ctx, &TaskPR{
TaskID: "t1",
Owner: "owner",
Repo: "repo",
PRNumber: 1,
PRURL: "https://github.com/owner/repo/pull/1",
PRTitle: "First",
HeadBranch: "feat-a",
BaseBranch: "main",
State: "closed",
}); err != nil {
t.Fatalf("seed TaskPR: %v", err)
}
// Associate a new PR #2 on a different branch.
newPR := &PR{
Number: 2,
Title: "Second",
HTMLURL: "https://github.com/owner/repo/pull/2",
HeadBranch: "feat-b",
BaseBranch: "main",
State: "open",
RepoOwner: "owner",
RepoName: "repo",
AuthorLogin: "alice",
}
tp, err := svc.AssociatePRWithTask(ctx, "t1", "", newPR)
if err != nil {
t.Fatalf("AssociatePRWithTask: %v", err)
}
if tp.PRNumber != 2 {
t.Errorf("returned TaskPR.PRNumber=%d, want 2", tp.PRNumber)
}
all, err := store.ListTaskPRsByTask(ctx, "t1")
if err != nil {
t.Fatalf("ListTaskPRsByTask: %v", err)
}
if len(all) != 2 {
t.Fatalf("expected 2 PR rows after associating second PR, got %d", len(all))
}
nums := map[int]bool{}
for _, r := range all {
nums[r.PRNumber] = true
}
if !nums[1] || !nums[2] {
t.Errorf("missing expected PR numbers: %v", nums)
}
}