| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "context" |
| "flag" |
| "net/http" |
| "testing" |
| "time" |
| |
| "github.com/google/go-cmp/cmp" |
| "github.com/google/go-cmp/cmp/cmpopts" |
| "github.com/google/go-github/github" |
| "golang.org/x/build/devapp/owners" |
| "golang.org/x/build/maintner" |
| ) |
| |
| func TestLabelCommandsFromComments(t *testing.T) { |
| created := time.Now() |
| testCases := []struct { |
| desc string |
| body string |
| cmds []labelCommand |
| }{ |
| { |
| "basic add/remove", |
| "We should fix this issue, but we need help\n\n@gopherbot please add help wanted, needsfix and remove needsinvestigation", |
| []labelCommand{ |
| {action: "add", label: "help wanted", created: created}, |
| {action: "add", label: "needsfix", created: created}, |
| {action: "remove", label: "needsinvestigation", created: created}, |
| }, |
| }, |
| { |
| "no please", |
| "@gopherbot add NeedsFix", |
| []labelCommand{ |
| {action: "add", label: "needsfix", created: created}, |
| }, |
| }, |
| { |
| "with comma", |
| "@gopherbot, NeedsFix", |
| []labelCommand{ |
| {action: "add", label: "needsfix", created: created}, |
| }, |
| }, |
| { |
| "with semicolons", |
| "@gopherbot NeedsFix;help wanted; remove needsinvestigation", |
| []labelCommand{ |
| {action: "add", label: "needsfix", created: created}, |
| {action: "add", label: "help wanted", created: created}, |
| {action: "remove", label: "needsinvestigation", created: created}, |
| }, |
| }, |
| { |
| "case insensitive", |
| "@gopherbot please add HelP WanteD", |
| []labelCommand{ |
| {action: "add", label: "help wanted", created: created}, |
| }, |
| }, |
| { |
| "fun input", |
| "@gopherbot please add help wanted,;needsfix;", |
| []labelCommand{ |
| {action: "add", label: "help wanted", created: created}, |
| {action: "add", label: "needsfix", created: created}, |
| }, |
| }, |
| { |
| "with hyphen", |
| "@gopherbot please add label OS-macOS", |
| []labelCommand{ |
| {action: "add", label: "os-macos", created: created}, |
| }, |
| }, |
| { |
| "unlabel keyword", |
| "@gopherbot please unlabel needsinvestigation, NeedsDecision", |
| []labelCommand{ |
| {action: "remove", label: "needsinvestigation", created: created}, |
| {action: "remove", label: "needsdecision", created: created}, |
| }, |
| }, |
| { |
| "with label[s] keyword", |
| "@gopherbot please add label help wanted and remove labels needsinvestigation, NeedsDecision", |
| []labelCommand{ |
| {action: "add", label: "help wanted", created: created}, |
| {action: "remove", label: "needsinvestigation", created: created}, |
| {action: "remove", label: "needsdecision", created: created}, |
| }, |
| }, |
| { |
| "no label commands", |
| "The cake was a lie", |
| nil, |
| }, |
| } |
| for _, tc := range testCases { |
| cmds := labelCommandsFromBody(tc.body, created) |
| if diff := cmp.Diff(cmds, tc.cmds, cmp.AllowUnexported(labelCommand{})); diff != "" { |
| t.Errorf("%s: commands differ: (-got +want)\n%s", tc.desc, diff) |
| } |
| } |
| } |
| |
| func TestLabelMutations(t *testing.T) { |
| testCases := []struct { |
| desc string |
| cmds []labelCommand |
| add []string |
| remove []string |
| }{ |
| { |
| "basic", |
| []labelCommand{ |
| {action: "add", label: "foo"}, |
| {action: "remove", label: "baz"}, |
| }, |
| []string{"foo"}, |
| []string{"baz"}, |
| }, |
| { |
| "add/remove of same label", |
| []labelCommand{ |
| {action: "add", label: "foo"}, |
| {action: "remove", label: "foo"}, |
| {action: "remove", label: "bar"}, |
| {action: "add", label: "bar"}, |
| }, |
| nil, |
| nil, |
| }, |
| { |
| "deduplication of labels", |
| []labelCommand{ |
| {action: "add", label: "foo"}, |
| {action: "add", label: "foo"}, |
| {action: "remove", label: "bar"}, |
| {action: "remove", label: "bar"}, |
| }, |
| []string{"foo"}, |
| []string{"bar"}, |
| }, |
| { |
| "forbidden actions", |
| []labelCommand{ |
| {action: "add", label: "Proposal-Accepted"}, |
| {action: "add", label: "CherryPickApproved"}, |
| {action: "add", label: "cla: yes"}, |
| {action: "remove", label: "Security"}, |
| }, |
| nil, |
| nil, |
| }, |
| { |
| "can add Security", |
| []labelCommand{ |
| {action: "add", label: "Security"}, |
| }, |
| []string{"Security"}, |
| nil, |
| }, |
| } |
| for _, tc := range testCases { |
| add, remove := mutationsFromCommands(tc.cmds) |
| if diff := cmp.Diff(add, tc.add); diff != "" { |
| t.Errorf("%s: label additions differ: (-got, +want)\n%s", tc.desc, diff) |
| } |
| if diff := cmp.Diff(remove, tc.remove); diff != "" { |
| t.Errorf("%s: label removals differ: (-got, +want)\n%s", tc.desc, diff) |
| } |
| } |
| } |
| |
| type fakeIssuesService struct { |
| labels map[int][]string |
| } |
| |
| func (f *fakeIssuesService) ListLabelsByIssue(ctx context.Context, owner string, repo string, number int, opt *github.ListOptions) ([]*github.Label, *github.Response, error) { |
| var labels []*github.Label |
| if ls, ok := f.labels[number]; ok { |
| for _, l := range ls { |
| name := l |
| labels = append(labels, &github.Label{Name: &name}) |
| } |
| } |
| return labels, nil, nil |
| } |
| |
| func (f *fakeIssuesService) AddLabelsToIssue(ctx context.Context, owner string, repo string, number int, labels []string) ([]*github.Label, *github.Response, error) { |
| if f.labels == nil { |
| f.labels = map[int][]string{number: labels} |
| return nil, nil, nil |
| } |
| ls, ok := f.labels[number] |
| if !ok { |
| f.labels[number] = labels |
| return nil, nil, nil |
| } |
| for _, label := range labels { |
| var found bool |
| for _, l := range ls { |
| if l == label { |
| found = true |
| } |
| } |
| if found { |
| continue |
| } |
| f.labels[number] = append(f.labels[number], label) |
| } |
| return nil, nil, nil |
| } |
| |
| func (f *fakeIssuesService) RemoveLabelForIssue(ctx context.Context, owner string, repo string, number int, label string) (*github.Response, error) { |
| if ls, ok := f.labels[number]; ok { |
| for i, l := range ls { |
| if l == label { |
| f.labels[number] = append(f.labels[number][:i], f.labels[number][i+1:]...) |
| return nil, nil |
| } |
| } |
| } |
| // The GitHub API returns a NotFound error if the label did not exist. |
| return nil, &github.ErrorResponse{ |
| Response: &http.Response{ |
| Status: http.StatusText(http.StatusNotFound), |
| StatusCode: http.StatusNotFound, |
| }, |
| } |
| } |
| |
| func TestAddLabels(t *testing.T) { |
| testCases := []struct { |
| desc string |
| gi *maintner.GitHubIssue |
| labels []string |
| added []string |
| }{ |
| { |
| "basic add", |
| &maintner.GitHubIssue{}, |
| []string{"foo"}, |
| []string{"foo"}, |
| }, |
| { |
| "some labels already present in maintner", |
| &maintner.GitHubIssue{ |
| Labels: map[int64]*maintner.GitHubLabel{ |
| 0: {Name: "NeedsDecision"}, |
| }, |
| }, |
| []string{"foo", "NeedsDecision"}, |
| []string{"foo"}, |
| }, |
| { |
| "all labels already present in maintner", |
| &maintner.GitHubIssue{ |
| Labels: map[int64]*maintner.GitHubLabel{ |
| 0: {Name: "NeedsDecision"}, |
| }, |
| }, |
| []string{"NeedsDecision"}, |
| nil, |
| }, |
| } |
| |
| b := &gopherbot{} |
| for _, tc := range testCases { |
| // Clear any previous state from fake addLabelsToIssue since some test cases may skip calls to it. |
| fis := &fakeIssuesService{} |
| b.is = fis |
| |
| if err := b.addLabels(context.Background(), maintner.GitHubRepoID{ |
| Owner: "golang", |
| Repo: "go", |
| }, tc.gi, tc.labels); err != nil { |
| t.Errorf("%s: b.addLabels got unexpected error: %v", tc.desc, err) |
| continue |
| } |
| if diff := cmp.Diff(fis.labels[int(tc.gi.ID)], tc.added); diff != "" { |
| t.Errorf("%s: labels added differ: (-got, +want)\n%s", tc.desc, diff) |
| } |
| } |
| } |
| |
| func TestRemoveLabels(t *testing.T) { |
| testCases := []struct { |
| desc string |
| gi *maintner.GitHubIssue |
| ghLabels []string |
| toRemove []string |
| want []string |
| }{ |
| { |
| "basic remove", |
| &maintner.GitHubIssue{ |
| Number: 123, |
| Labels: map[int64]*maintner.GitHubLabel{ |
| 0: {Name: "NeedsFix"}, |
| 1: {Name: "help wanted"}, |
| }, |
| }, |
| []string{"NeedsFix", "help wanted"}, |
| []string{"NeedsFix"}, |
| []string{"help wanted"}, |
| }, |
| { |
| "label not present in maintner", |
| &maintner.GitHubIssue{}, |
| []string{"NeedsFix"}, |
| []string{"NeedsFix"}, |
| []string{"NeedsFix"}, |
| }, |
| { |
| "label not present in GitHub", |
| &maintner.GitHubIssue{ |
| Labels: map[int64]*maintner.GitHubLabel{ |
| 0: {Name: "foo"}, |
| }, |
| }, |
| []string{"NeedsFix"}, |
| []string{"foo"}, |
| []string{"NeedsFix"}, |
| }, |
| } |
| |
| b := &gopherbot{} |
| for _, tc := range testCases { |
| // Clear any previous state from fakeIssuesService since some test cases may skip calls to it. |
| fis := &fakeIssuesService{map[int][]string{ |
| int(tc.gi.Number): tc.ghLabels, |
| }} |
| b.is = fis |
| |
| if err := b.removeLabels(context.Background(), maintner.GitHubRepoID{ |
| Owner: "golang", |
| Repo: "go", |
| }, tc.gi, tc.toRemove); err != nil { |
| t.Errorf("%s: b.addLabels got unexpected error: %v", tc.desc, err) |
| continue |
| } |
| if diff := cmp.Diff(fis.labels[int(tc.gi.Number)], tc.want); diff != "" { |
| t.Errorf("%s: labels differ: (-got, +want)\n%s", tc.desc, diff) |
| } |
| } |
| } |
| |
| func TestHumanReviewersInMetas(t *testing.T) { |
| testCases := []struct { |
| desc string |
| commitMsg string |
| hasHuman bool |
| wantIDs []string |
| }{ |
| { |
| desc: "one human reviewer", |
| commitMsg: `Patch-set: 6 |
| Reviewer: Andrew Bonventre <22285@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| `, |
| hasHuman: true, |
| wantIDs: []string{"22285"}, |
| }, |
| { |
| desc: "one human CC", |
| commitMsg: `Patch-set: 6 |
| CC: Andrew Bonventre <22285@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| `, |
| hasHuman: true, |
| wantIDs: []string{"22285"}, |
| }, |
| { |
| desc: "gobot reviewer", |
| commitMsg: `Patch-set: 6 |
| Reviewer: Gobot Gobot <5976@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| `, |
| wantIDs: []string{"5976"}, |
| }, |
| { |
| desc: "gobot reviewer and human CC", |
| commitMsg: `Patch-set: 6 |
| Reviewer: Gobot Gobot <5976@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| CC: Andrew Bonventre <22285@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| `, |
| hasHuman: true, |
| wantIDs: []string{"5976", "22285"}, |
| }, |
| { |
| desc: "gobot reviewer and human reviewer", |
| commitMsg: `Patch-set: 6 |
| Reviewer: Gobot Gobot <5976@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| Reviewer: Andrew Bonventre <22285@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| `, |
| hasHuman: true, |
| wantIDs: []string{"5976", "22285"}, |
| }, |
| { |
| desc: "gobot reviewer and two human reviewers", |
| commitMsg: `Patch-set: 6 |
| Reviewer: Gobot Gobot <5976@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| Reviewer: Andrew Bonventre <22285@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| Reviewer: Rebecca Stambler <16140@62eb7196-b449-3ce5-99f1-c037f21e1705> |
| `, |
| hasHuman: true, |
| wantIDs: []string{"5976", "22285", "16140"}, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.desc, func(t *testing.T) { |
| metas := []*maintner.GerritMeta{ |
| {Commit: &maintner.GitCommit{Msg: tc.commitMsg}}, |
| } |
| ids := reviewersInMetas(metas) |
| if diff := cmp.Diff(tc.wantIDs, ids); diff != "" { |
| t.Fatalf("reviewersInMetas() mismatch (-want +got):\n%s", diff) |
| } |
| }) |
| } |
| } |
| |
| func TestMergeOwnersEntries(t *testing.T) { |
| var ( |
| andybons = owners.Owner{GitHubUsername: "andybons", GerritEmail: "andybons@golang.org"} |
| bradfitz = owners.Owner{GitHubUsername: "bradfitz", GerritEmail: "bradfitz@golang.org"} |
| filippo = owners.Owner{GitHubUsername: "filippo", GerritEmail: "filippo@golang.org"} |
| iant = owners.Owner{GitHubUsername: "iant", GerritEmail: "iant@golang.org"} |
| rsc = owners.Owner{GitHubUsername: "rsc", GerritEmail: "rsc@golang.org"} |
| ) |
| testCases := []struct { |
| desc string |
| entries []*owners.Entry |
| authorEmail string |
| result *owners.Entry |
| }{ |
| { |
| "no entries", |
| nil, |
| "", |
| &owners.Entry{}, |
| }, |
| { |
| "primary merge", |
| []*owners.Entry{ |
| {Primary: []owners.Owner{andybons}}, |
| {Primary: []owners.Owner{bradfitz}}, |
| }, |
| "", |
| &owners.Entry{ |
| Primary: []owners.Owner{andybons, bradfitz}, |
| }, |
| }, |
| { |
| "secondary merge", |
| []*owners.Entry{ |
| {Secondary: []owners.Owner{andybons}}, |
| {Secondary: []owners.Owner{filippo}}, |
| }, |
| "", |
| &owners.Entry{ |
| Secondary: []owners.Owner{andybons, filippo}, |
| }, |
| }, |
| { |
| "promote from secondary to primary", |
| []*owners.Entry{ |
| {Primary: []owners.Owner{andybons, filippo}}, |
| {Secondary: []owners.Owner{filippo}}, |
| }, |
| "", |
| &owners.Entry{ |
| Primary: []owners.Owner{andybons, filippo}, |
| }, |
| }, |
| { |
| "primary filter", |
| []*owners.Entry{ |
| {Primary: []owners.Owner{filippo, andybons}}, |
| }, |
| filippo.GerritEmail, |
| &owners.Entry{ |
| Primary: []owners.Owner{andybons}, |
| }, |
| }, |
| { |
| "secondary filter", |
| []*owners.Entry{ |
| {Secondary: []owners.Owner{filippo, andybons}}, |
| }, |
| filippo.GerritEmail, |
| &owners.Entry{ |
| Secondary: []owners.Owner{andybons}, |
| }, |
| }, |
| { |
| "too many reviewers", |
| []*owners.Entry{ |
| {Primary: []owners.Owner{iant, bradfitz}, Secondary: []owners.Owner{andybons}}, |
| {Primary: []owners.Owner{andybons}, Secondary: []owners.Owner{iant, bradfitz}}, |
| {Primary: []owners.Owner{iant, filippo}, Secondary: []owners.Owner{bradfitz, andybons, rsc}}, |
| }, |
| "", |
| &owners.Entry{ |
| Primary: []owners.Owner{andybons, bradfitz, iant}, |
| }, |
| }, |
| } |
| cmpFn := func(a, b owners.Owner) bool { |
| return a.GitHubUsername < b.GitHubUsername |
| } |
| for _, tc := range testCases { |
| got := mergeOwnersEntries(tc.entries, tc.authorEmail) |
| if diff := cmp.Diff(got, tc.result, cmpopts.SortSlices(cmpFn)); diff != "" { |
| t.Errorf("%s: final entry results differ: (-got, +want)\n%s", tc.desc, diff) |
| } |
| } |
| } |
| |
| func TestFilterGerritOwners(t *testing.T) { |
| var ( |
| andybons = owners.Owner{GitHubUsername: "andybons", GerritEmail: "andybons@golang.org"} |
| bradfitz = owners.Owner{GitHubUsername: "bradfitz", GerritEmail: "bradfitz@golang.org"} |
| toolsTeam = owners.Owner{GitHubUsername: "golang/tools-team"} |
| ) |
| testCases := []struct { |
| name string |
| entries []*owners.Entry |
| want []*owners.Entry |
| }{ |
| { |
| name: "no entries", |
| entries: nil, |
| want: []*owners.Entry{}, |
| }, |
| { |
| name: "all valid", |
| entries: []*owners.Entry{ |
| {Primary: []owners.Owner{andybons}}, |
| {Primary: []owners.Owner{bradfitz}}, |
| }, |
| want: []*owners.Entry{ |
| {Primary: []owners.Owner{andybons}}, |
| {Primary: []owners.Owner{bradfitz}}, |
| }, |
| }, |
| { |
| name: "drop primary", |
| entries: []*owners.Entry{ |
| {Primary: []owners.Owner{andybons, toolsTeam}}, |
| {Primary: []owners.Owner{toolsTeam, bradfitz}}, |
| }, |
| want: []*owners.Entry{ |
| {Primary: []owners.Owner{andybons}}, |
| {Primary: []owners.Owner{bradfitz}}, |
| }, |
| }, |
| { |
| name: "drop secondary", |
| entries: []*owners.Entry{ |
| { |
| Primary: []owners.Owner{andybons}, |
| Secondary: []owners.Owner{bradfitz, toolsTeam}, |
| }, |
| { |
| Primary: []owners.Owner{bradfitz}, |
| Secondary: []owners.Owner{toolsTeam, andybons}, |
| }, |
| }, |
| want: []*owners.Entry{ |
| { |
| Primary: []owners.Owner{andybons}, |
| Secondary: []owners.Owner{bradfitz}, |
| }, |
| { |
| Primary: []owners.Owner{bradfitz}, |
| Secondary: []owners.Owner{andybons}, |
| }, |
| }, |
| }, |
| { |
| name: "upgrade secondary", |
| entries: []*owners.Entry{ |
| { |
| Primary: []owners.Owner{toolsTeam}, |
| Secondary: []owners.Owner{bradfitz}, |
| }, |
| }, |
| want: []*owners.Entry{ |
| { |
| Primary: []owners.Owner{bradfitz}, |
| }, |
| }, |
| }, |
| { |
| name: "no primary", |
| entries: []*owners.Entry{ |
| { |
| Secondary: []owners.Owner{bradfitz}, |
| }, |
| }, |
| want: []*owners.Entry{ |
| { |
| Primary: []owners.Owner{bradfitz}, |
| }, |
| }, |
| }, |
| } |
| cmpFn := func(a, b owners.Owner) bool { |
| return a.GitHubUsername < b.GitHubUsername |
| } |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| got := filterGerritOwners(tc.entries) |
| if diff := cmp.Diff(got, tc.want, cmpopts.SortSlices(cmpFn)); diff != "" { |
| t.Errorf("final entry results differ: (-got, +want)\n%s", diff) |
| } |
| }) |
| } |
| } |
| |
| func TestForeachIssue(t *testing.T) { |
| if testing.Short() || flag.Lookup("test.run").Value.(flag.Getter).Get().(string) != "^TestForeachIssue$" { |
| t.Skip("not running test requiring large Go corpus download in short mode and if not explicitly requested with go test -run=^TestForeachIssue$") |
| } |
| |
| b := &gopherbot{} |
| b.initCorpus() |
| |
| var num int |
| err := b.foreachIssue(b.gorepo, open, func(gi *maintner.GitHubIssue) error { |
| if gi.Closed || gi.PullRequest || gi.NotExist { |
| t.Errorf("issue %d should be skipped but isn't: %#v", gi.Number, gi) |
| } |
| num++ |
| return nil |
| }) |
| if err != nil { |
| t.Errorf("gopherbot.foreachIssue: got %v error, want nil", err) |
| } |
| t.Logf("gopherbot.foreachIssue walked over %d open issues (not including PRs and deleted/transferred/converted issues)", num) |
| |
| var got struct { |
| Open, Closed, PR bool |
| } |
| err = b.foreachIssue(b.gorepo, open|closed|includePRs, func(gi *maintner.GitHubIssue) error { |
| if gi.NotExist { |
| t.Errorf("issue %d should be skipped but isn't: %#v", gi.Number, gi) |
| } |
| got.Open = got.Open || !gi.Closed |
| got.Closed = got.Closed || gi.Closed |
| got.PR = got.PR || gi.PullRequest |
| return nil |
| }) |
| if err != nil { |
| t.Errorf("gopherbot.foreachIssue: got %v error, want nil", err) |
| } |
| if !got.Open || !got.Closed || !got.PR { |
| t.Errorf("got %+v, want all true", got) |
| } |
| } |
