José Almeida
7de788ceed
* feat: add cross-integration entity references * fix(web): anchor entity reference menu to composer * fix: keep Kandev tasks under @ mentions * fix: address entity reference review findings * test(e2e): use option role for prompt menu * test(e2e): update passthrough mention roles * fix: preserve queued references and paginate Azure PRs
622 lines
17 KiB
Go
622 lines
17 KiB
Go
package github
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestBuildReviewSearchQuery(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
scope string
|
|
filter string
|
|
customQuery string
|
|
want string
|
|
}{
|
|
{
|
|
name: "customQuery overrides everything",
|
|
scope: ReviewScopeUser,
|
|
filter: "repo:owner/name",
|
|
customQuery: "type:pr is:open assignee:@me",
|
|
want: "type:pr is:open assignee:@me",
|
|
},
|
|
{
|
|
name: "user scope without filter",
|
|
scope: ReviewScopeUser,
|
|
want: "type:pr state:open user-review-requested:@me -is:draft",
|
|
},
|
|
{
|
|
name: "user scope with repo filter",
|
|
scope: ReviewScopeUser,
|
|
filter: "repo:owner/repo",
|
|
want: "type:pr state:open user-review-requested:@me -is:draft repo:owner/repo",
|
|
},
|
|
{
|
|
name: "user_and_teams scope without filter",
|
|
scope: ReviewScopeUserAndTeams,
|
|
want: "type:pr state:open review-requested:@me -is:draft",
|
|
},
|
|
{
|
|
name: "user_and_teams scope with org filter",
|
|
scope: ReviewScopeUserAndTeams,
|
|
filter: "org:myorg",
|
|
want: "type:pr state:open review-requested:@me -is:draft org:myorg",
|
|
},
|
|
{
|
|
name: "empty scope defaults to user_and_teams",
|
|
scope: "",
|
|
want: "type:pr state:open review-requested:@me -is:draft",
|
|
},
|
|
{
|
|
name: "empty customQuery falls through to scope logic",
|
|
scope: ReviewScopeUserAndTeams,
|
|
customQuery: "",
|
|
want: "type:pr state:open review-requested:@me -is:draft",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := buildReviewSearchQuery(tt.scope, tt.filter, tt.customQuery)
|
|
if got != tt.want {
|
|
t.Errorf("buildReviewSearchQuery(%q, %q, %q) = %q, want %q",
|
|
tt.scope, tt.filter, tt.customQuery, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConvertRawCheckRuns(t *testing.T) {
|
|
conclusion := "success"
|
|
summary := "All tests passed"
|
|
startedAt := "2025-01-15T10:00:00Z"
|
|
completedAt := "2025-01-15T10:05:00Z"
|
|
|
|
raw := []ghCheckRun{
|
|
{
|
|
Name: "ci/test",
|
|
Status: "completed",
|
|
Conclusion: &conclusion,
|
|
HTMLURL: "https://github.com/owner/repo/runs/1",
|
|
StartedAt: startedAt,
|
|
CompletedAt: completedAt,
|
|
Output: struct {
|
|
Title *string `json:"title"`
|
|
Summary *string `json:"summary"`
|
|
}{Summary: &summary},
|
|
},
|
|
{
|
|
Name: "ci/lint",
|
|
Status: "in_progress",
|
|
Conclusion: nil,
|
|
HTMLURL: "https://github.com/owner/repo/runs/2",
|
|
},
|
|
}
|
|
|
|
checks := convertRawCheckRuns(raw)
|
|
|
|
if len(checks) != 2 {
|
|
t.Fatalf("expected 2 checks, got %d", len(checks))
|
|
}
|
|
|
|
// Check first (completed)
|
|
if checks[0].Name != "ci/test" {
|
|
t.Errorf("expected name ci/test, got %s", checks[0].Name)
|
|
}
|
|
if checks[0].Source != checkSourceCheckRun {
|
|
t.Errorf("expected source %q, got %q", checkSourceCheckRun, checks[0].Source)
|
|
}
|
|
if checks[0].Conclusion != "success" {
|
|
t.Errorf("expected conclusion success, got %s", checks[0].Conclusion)
|
|
}
|
|
if checks[0].Output != "All tests passed" {
|
|
t.Errorf("expected output 'All tests passed', got %s", checks[0].Output)
|
|
}
|
|
if checks[0].StartedAt == nil {
|
|
t.Error("expected non-nil StartedAt")
|
|
}
|
|
|
|
// Check second (in progress, nil conclusion)
|
|
if checks[1].Conclusion != "" {
|
|
t.Errorf("expected empty conclusion, got %s", checks[1].Conclusion)
|
|
}
|
|
if checks[1].StartedAt != nil {
|
|
t.Error("expected nil StartedAt for empty string")
|
|
}
|
|
}
|
|
|
|
func TestConvertRawCheckRunsEmpty(t *testing.T) {
|
|
checks := convertRawCheckRuns(nil)
|
|
if len(checks) != 0 {
|
|
t.Errorf("expected empty slice, got %d", len(checks))
|
|
}
|
|
}
|
|
|
|
func TestConvertRawComments(t *testing.T) {
|
|
now := time.Now()
|
|
raw := []ghComment{
|
|
{
|
|
ID: 1,
|
|
Path: "main.go",
|
|
Line: 42,
|
|
Side: "RIGHT",
|
|
Body: "Looks good",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
User: struct {
|
|
Login string `json:"login"`
|
|
AvatarURL string `json:"avatar_url"`
|
|
Type string `json:"type"`
|
|
}{Login: "alice", AvatarURL: "https://avatar.example.com/alice", Type: "User"},
|
|
},
|
|
}
|
|
|
|
comments := convertRawComments(raw)
|
|
|
|
if len(comments) != 1 {
|
|
t.Fatalf("expected 1 comment, got %d", len(comments))
|
|
}
|
|
if comments[0].Author != "alice" {
|
|
t.Errorf("expected author alice, got %s", comments[0].Author)
|
|
}
|
|
if comments[0].Path != "main.go" {
|
|
t.Errorf("expected path main.go, got %s", comments[0].Path)
|
|
}
|
|
if comments[0].Line != 42 {
|
|
t.Errorf("expected line 42, got %d", comments[0].Line)
|
|
}
|
|
if comments[0].CommentType != commentTypeReview {
|
|
t.Errorf("expected comment type %q, got %q", commentTypeReview, comments[0].CommentType)
|
|
}
|
|
if comments[0].AuthorIsBot {
|
|
t.Error("expected non-bot comment")
|
|
}
|
|
}
|
|
|
|
func TestConvertRawIssueComments(t *testing.T) {
|
|
now := time.Now()
|
|
raw := []ghIssueComment{
|
|
{
|
|
ID: 10,
|
|
Body: "Snyk report",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
User: struct {
|
|
Login string `json:"login"`
|
|
AvatarURL string `json:"avatar_url"`
|
|
Type string `json:"type"`
|
|
}{
|
|
Login: "snyk-io",
|
|
AvatarURL: "https://avatar.example.com/snyk",
|
|
Type: "Bot",
|
|
},
|
|
},
|
|
}
|
|
|
|
comments := convertRawIssueComments(raw)
|
|
if len(comments) != 1 {
|
|
t.Fatalf("expected 1 comment, got %d", len(comments))
|
|
}
|
|
if comments[0].CommentType != commentTypeIssue {
|
|
t.Errorf("expected comment type %q, got %q", commentTypeIssue, comments[0].CommentType)
|
|
}
|
|
if !comments[0].AuthorIsBot {
|
|
t.Error("expected bot comment")
|
|
}
|
|
}
|
|
|
|
func TestMergeAndSortPRComments(t *testing.T) {
|
|
t1 := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
t2 := time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC)
|
|
t3 := time.Date(2025, 1, 3, 0, 0, 0, 0, time.UTC)
|
|
review := []PRComment{
|
|
{ID: 2, CommentType: commentTypeReview, CreatedAt: t2},
|
|
{ID: 3, CommentType: commentTypeReview, CreatedAt: t3},
|
|
}
|
|
issue := []PRComment{
|
|
{ID: 1, CommentType: commentTypeIssue, CreatedAt: t1},
|
|
}
|
|
|
|
got := mergeAndSortPRComments(review, issue)
|
|
if len(got) != 3 {
|
|
t.Fatalf("expected 3 comments, got %d", len(got))
|
|
}
|
|
if got[0].ID != 1 || got[1].ID != 2 || got[2].ID != 3 {
|
|
t.Errorf("unexpected merge/sort order: %#v", got)
|
|
}
|
|
}
|
|
|
|
func TestConvertRawStatusContextsAndMergeChecks(t *testing.T) {
|
|
conclusion := "success"
|
|
checkRuns := []ghCheckRun{
|
|
{
|
|
Name: "ci/test",
|
|
Status: "completed",
|
|
Conclusion: &conclusion,
|
|
HTMLURL: "https://github.com/owner/repo/runs/1",
|
|
},
|
|
}
|
|
statuses := []ghStatusContext{
|
|
{
|
|
Context: "ci/test",
|
|
State: "pending",
|
|
TargetURL: "https://github.com/owner/repo/runs/1",
|
|
},
|
|
{
|
|
Context: "license/snyk",
|
|
State: "success",
|
|
TargetURL: "https://app.snyk.io/check/2",
|
|
},
|
|
}
|
|
|
|
merged := mergeChecks(convertRawCheckRuns(checkRuns), convertRawStatusContexts(statuses))
|
|
if len(merged) != 2 {
|
|
t.Fatalf("expected 2 checks after dedupe, got %d", len(merged))
|
|
}
|
|
if merged[0].Name != "ci/test" || merged[0].Source != checkSourceCheckRun {
|
|
t.Errorf("expected check_run to win dedupe, got %#v", merged[0])
|
|
}
|
|
if merged[1].Name != "license/snyk" || merged[1].Source != checkSourceStatusContext {
|
|
t.Errorf("expected status_context entry, got %#v", merged[1])
|
|
}
|
|
if merged[1].Conclusion != checkStatusSuccess {
|
|
t.Errorf("expected success conclusion, got %q", merged[1].Conclusion)
|
|
}
|
|
}
|
|
|
|
func TestMergeChecksDuplicateCheckRunsByName(t *testing.T) {
|
|
t1 := time.Date(2025, 6, 1, 10, 0, 0, 0, time.UTC)
|
|
t2 := time.Date(2025, 6, 1, 11, 0, 0, 0, time.UTC)
|
|
|
|
// Two check-runs with the same name but different URLs (different check suites).
|
|
checkRuns := []CheckRun{
|
|
{Name: "Analyze (go)", Source: checkSourceCheckRun, Status: "in_progress", HTMLURL: "https://github.com/o/r/runs/1", StartedAt: &t1},
|
|
{Name: "Analyze (go)", Source: checkSourceCheckRun, Status: "in_progress", HTMLURL: "https://github.com/o/r/runs/2", StartedAt: &t2},
|
|
}
|
|
merged := mergeChecks(checkRuns, nil)
|
|
if len(merged) != 1 {
|
|
t.Fatalf("expected 1 check after dedupe, got %d", len(merged))
|
|
}
|
|
if merged[0].HTMLURL != "https://github.com/o/r/runs/2" {
|
|
t.Errorf("expected newer check-run to win, got URL %s", merged[0].HTMLURL)
|
|
}
|
|
}
|
|
|
|
func TestMergeChecksCheckRunWinsOverStatusDifferentURL(t *testing.T) {
|
|
t1 := time.Date(2025, 6, 1, 10, 0, 0, 0, time.UTC)
|
|
|
|
checkRuns := []CheckRun{
|
|
{Name: "ci/test", Source: checkSourceCheckRun, Status: "completed", Conclusion: "success", HTMLURL: "https://github.com/o/r/runs/1", StartedAt: &t1},
|
|
}
|
|
statuses := []CheckRun{
|
|
{Name: "ci/test", Source: checkSourceStatusContext, Status: "in_progress", HTMLURL: "https://other-url.com/status/1", StartedAt: &t1},
|
|
}
|
|
merged := mergeChecks(checkRuns, statuses)
|
|
if len(merged) != 1 {
|
|
t.Fatalf("expected 1 check after dedupe, got %d", len(merged))
|
|
}
|
|
if merged[0].Source != checkSourceCheckRun {
|
|
t.Errorf("expected check_run to win over status_context, got source %s", merged[0].Source)
|
|
}
|
|
}
|
|
|
|
func TestIsNewerCheck(t *testing.T) {
|
|
t1 := time.Date(2025, 6, 1, 10, 0, 0, 0, time.UTC)
|
|
t2 := time.Date(2025, 6, 1, 11, 0, 0, 0, time.UTC)
|
|
|
|
if isNewerCheck(CheckRun{StartedAt: &t1}, CheckRun{StartedAt: &t2}) {
|
|
t.Error("older should not be newer")
|
|
}
|
|
if !isNewerCheck(CheckRun{StartedAt: &t2}, CheckRun{StartedAt: &t1}) {
|
|
t.Error("newer should be newer")
|
|
}
|
|
if isNewerCheck(CheckRun{StartedAt: nil}, CheckRun{StartedAt: &t1}) {
|
|
t.Error("nil StartedAt should not be newer")
|
|
}
|
|
if !isNewerCheck(CheckRun{StartedAt: &t1}, CheckRun{StartedAt: nil}) {
|
|
t.Error("non-nil should be newer than nil")
|
|
}
|
|
}
|
|
|
|
func TestConvertSearchItemToPR(t *testing.T) {
|
|
now := time.Now()
|
|
pr := convertSearchItemToPR(
|
|
101, "PR_kwDOA",
|
|
42, "Fix bug", "https://github.com/owner/repo/pull/42", "open",
|
|
"alice", "https://api.github.com/repos/myorg/myrepo", "", false,
|
|
now, now,
|
|
)
|
|
|
|
if pr.Number != 42 {
|
|
t.Errorf("expected number 42, got %d", pr.Number)
|
|
}
|
|
if pr.ID != 101 || pr.NodeID != "PR_kwDOA" {
|
|
t.Errorf("identity = (%d, %q), want (101, PR_kwDOA)", pr.ID, pr.NodeID)
|
|
}
|
|
if pr.Title != "Fix bug" {
|
|
t.Errorf("expected title 'Fix bug', got %s", pr.Title)
|
|
}
|
|
if pr.RepoOwner != "myorg" {
|
|
t.Errorf("expected owner myorg, got %s", pr.RepoOwner)
|
|
}
|
|
if pr.RepoName != "myrepo" {
|
|
t.Errorf("expected repo myrepo, got %s", pr.RepoName)
|
|
}
|
|
if pr.State != "open" {
|
|
t.Errorf("expected state open, got %s", pr.State)
|
|
}
|
|
}
|
|
|
|
// GitHub's search API returns merged PRs with state "closed" plus a non-empty
|
|
// pull_request.merged_at. The converter must promote those to "merged" so the
|
|
// UI shows the purple merged icon instead of the red closed one.
|
|
func TestConvertSearchItemToPRMerged(t *testing.T) {
|
|
now := time.Now()
|
|
mergedAt := "2025-01-02T03:04:05Z"
|
|
pr := convertSearchItemToPR(
|
|
102, "PR_kwDOB",
|
|
7, "Land feature", "https://github.com/owner/repo/pull/7", "closed",
|
|
"bob", "https://api.github.com/repos/myorg/myrepo", mergedAt, false,
|
|
now, now,
|
|
)
|
|
|
|
if pr.State != prStateMerged {
|
|
t.Errorf("expected state %q, got %q", prStateMerged, pr.State)
|
|
}
|
|
if pr.MergedAt == nil {
|
|
t.Fatal("expected MergedAt to be set, got nil")
|
|
}
|
|
}
|
|
|
|
func TestLatestReviewByAuthor(t *testing.T) {
|
|
t1 := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
t2 := time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC)
|
|
|
|
reviews := []PRReview{
|
|
{Author: "alice", State: "COMMENTED", CreatedAt: t1},
|
|
{Author: "alice", State: "APPROVED", CreatedAt: t2},
|
|
{Author: "bob", State: "CHANGES_REQUESTED", CreatedAt: t1},
|
|
}
|
|
|
|
latest := latestReviewByAuthor(reviews)
|
|
|
|
if len(latest) != 2 {
|
|
t.Fatalf("expected 2 authors, got %d", len(latest))
|
|
}
|
|
if latest["alice"].State != "APPROVED" {
|
|
t.Errorf("expected alice's latest to be APPROVED, got %s", latest["alice"].State)
|
|
}
|
|
if latest["bob"].State != "CHANGES_REQUESTED" {
|
|
t.Errorf("expected bob's latest to be CHANGES_REQUESTED, got %s", latest["bob"].State)
|
|
}
|
|
}
|
|
|
|
func TestLatestReviewByAuthorEmpty(t *testing.T) {
|
|
latest := latestReviewByAuthor(nil)
|
|
if len(latest) != 0 {
|
|
t.Errorf("expected empty map, got %d entries", len(latest))
|
|
}
|
|
}
|
|
|
|
func TestHasFailingChecks(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
checks []CheckRun
|
|
want bool
|
|
}{
|
|
{"empty", nil, false},
|
|
{"all passing", []CheckRun{
|
|
{Status: "completed", Conclusion: "success"},
|
|
}, false},
|
|
{"one failing", []CheckRun{
|
|
{Status: "completed", Conclusion: "success"},
|
|
{Status: "completed", Conclusion: "failure"},
|
|
}, true},
|
|
{"in progress", []CheckRun{
|
|
{Status: "in_progress", Conclusion: ""},
|
|
}, false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := hasFailingChecks(tt.checks)
|
|
if got != tt.want {
|
|
t.Errorf("hasFailingChecks() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCountCheckResults(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
checks []CheckRun
|
|
wantTotal, wantPass int
|
|
}{
|
|
{
|
|
name: "empty",
|
|
wantTotal: 0, wantPass: 0,
|
|
},
|
|
{
|
|
name: "in-progress checks excluded from total",
|
|
checks: []CheckRun{
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionSuccess},
|
|
{Status: "in_progress", Conclusion: ""},
|
|
{Status: "queued", Conclusion: ""},
|
|
},
|
|
wantTotal: 1, wantPass: 1,
|
|
},
|
|
{
|
|
name: "skipped and neutral are excluded",
|
|
checks: []CheckRun{
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionSuccess},
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionSkipped},
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionNeutral},
|
|
},
|
|
wantTotal: 1, wantPass: 1,
|
|
},
|
|
{
|
|
name: "failures count toward total but not passing",
|
|
checks: []CheckRun{
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionSuccess},
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionFail},
|
|
{Status: checkStatusCompleted, Conclusion: checkConclusionTimedOut},
|
|
},
|
|
wantTotal: 3, wantPass: 1,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
total, passing := countCheckResults(tt.checks)
|
|
if total != tt.wantTotal || passing != tt.wantPass {
|
|
t.Errorf("countCheckResults = (%d, %d), want (%d, %d)",
|
|
total, passing, tt.wantTotal, tt.wantPass)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHasChangesRequested(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
reviews []PRReview
|
|
want bool
|
|
}{
|
|
{"empty", nil, false},
|
|
{"approved", []PRReview{{State: "APPROVED"}}, false},
|
|
{"changes requested", []PRReview{
|
|
{State: "APPROVED"},
|
|
{State: "CHANGES_REQUESTED"},
|
|
}, true},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := hasChangesRequested(tt.reviews)
|
|
if got != tt.want {
|
|
t.Errorf("hasChangesRequested() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// --- Reviewer dedup helpers (countApprovedReviewers + reduceReviewSummary) ---
|
|
|
|
func TestCountApprovedReviewers(t *testing.T) {
|
|
t0 := time.Date(2025, 5, 1, 12, 0, 0, 0, time.UTC)
|
|
mk := func(author, state string, offset time.Duration) PRReview {
|
|
return PRReview{Author: author, State: state, CreatedAt: t0.Add(offset)}
|
|
}
|
|
cases := []struct {
|
|
name string
|
|
reviews []PRReview
|
|
want int
|
|
}{
|
|
{name: "empty", reviews: []PRReview{}, want: 0},
|
|
{
|
|
name: "single approval",
|
|
reviews: []PRReview{mk("alice", reviewStateApproved, 0)},
|
|
want: 1,
|
|
},
|
|
{
|
|
name: "dedup same author latest wins",
|
|
reviews: []PRReview{
|
|
mk("alice", reviewStateChangesRequested, 0),
|
|
mk("alice", reviewStateApproved, time.Hour),
|
|
},
|
|
want: 1,
|
|
},
|
|
{
|
|
name: "COMMENTED does not replace prior APPROVED",
|
|
reviews: []PRReview{
|
|
mk("alice", reviewStateApproved, 0),
|
|
mk("alice", "COMMENTED", time.Hour),
|
|
},
|
|
want: 1,
|
|
},
|
|
{
|
|
name: "PENDING never counts even alone",
|
|
reviews: []PRReview{mk("alice", "PENDING", 0)},
|
|
want: 0,
|
|
},
|
|
{
|
|
name: "two distinct approvers",
|
|
reviews: []PRReview{
|
|
mk("alice", reviewStateApproved, 0),
|
|
mk("bob", reviewStateApproved, time.Hour),
|
|
},
|
|
want: 2,
|
|
},
|
|
{
|
|
name: "approve then change-request reverts",
|
|
reviews: []PRReview{
|
|
mk("alice", reviewStateApproved, 0),
|
|
mk("alice", reviewStateChangesRequested, time.Hour),
|
|
},
|
|
want: 0,
|
|
},
|
|
{
|
|
name: "anonymous reviewers counted separately",
|
|
reviews: []PRReview{
|
|
mk("", reviewStateApproved, 0),
|
|
mk("", reviewStateApproved, time.Hour),
|
|
},
|
|
want: 2,
|
|
},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
if got := countApprovedReviewers(tc.reviews); got != tc.want {
|
|
t.Fatalf("countApprovedReviewers = %d, want %d", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReduceReviewSummary(t *testing.T) {
|
|
t0 := time.Date(2025, 5, 1, 12, 0, 0, 0, time.UTC)
|
|
mk := func(author, state string, offset time.Duration) reviewSample {
|
|
return reviewSample{author: author, state: state, at: t0.Add(offset)}
|
|
}
|
|
cases := []struct {
|
|
name string
|
|
in []reviewSample
|
|
want string
|
|
}{
|
|
{name: "empty", in: nil, want: ""},
|
|
{
|
|
name: "single approval",
|
|
in: []reviewSample{mk("a", reviewStateApproved, 0)},
|
|
want: computedReviewStateApproved,
|
|
},
|
|
{
|
|
name: "changes requested wins across authors",
|
|
in: []reviewSample{
|
|
mk("a", reviewStateApproved, 0),
|
|
mk("b", reviewStateChangesRequested, time.Hour),
|
|
},
|
|
want: computedReviewStateChangesRequested,
|
|
},
|
|
{
|
|
name: "later approval supersedes earlier changes-requested from same author",
|
|
in: []reviewSample{
|
|
mk("a", reviewStateChangesRequested, 0),
|
|
mk("a", reviewStateApproved, time.Hour),
|
|
},
|
|
want: computedReviewStateApproved,
|
|
},
|
|
{
|
|
name: "only comments returns empty",
|
|
in: []reviewSample{mk("a", "COMMENTED", 0)},
|
|
want: "",
|
|
},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
if got := reduceReviewSummary(tc.in); got != tc.want {
|
|
t.Fatalf("reduceReviewSummary = %q, want %q", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|