| package github |
| |
| import ( |
| "context" |
| "fmt" |
| "net/http" |
| "net/url" |
| "testing" |
| "time" |
| |
| "github.com/go-chi/chi/v5" |
| "github.com/google/go-github/v29/github" |
| "github.com/stretchr/testify/require" |
| |
| "go.skia.org/infra/go/git" |
| "go.skia.org/infra/go/mockhttpclient" |
| "go.skia.org/infra/go/testutils" |
| "go.skia.org/infra/go/vcsinfo" |
| ) |
| |
| func TestAddComment(t *testing.T) { |
| reqType := "application/json" |
| reqBody := []byte(`{"body":"test msg"} |
| `) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockPostDialogueWithResponseCode(reqType, reqBody, nil, http.StatusCreated) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Post("/repos/kryptonians/krypton/issues/1234/comments", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| addCommentErr := githubClient.AddComment(1234, "test msg") |
| require.NoError(t, addCommentErr) |
| } |
| |
| func TestGetAuthenticatedUser(t *testing.T) { |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetError("OK", http.StatusOK) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/user", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| _, getUserErr := githubClient.GetAuthenticatedUser() |
| require.NoError(t, getUserErr) |
| } |
| |
| func TestListOpenPullRequests(t *testing.T) { |
| prNum1 := 1 |
| prNum2 := 101 |
| respBody := []byte(testutils.MarshalJSON(t, []*github.PullRequest{ |
| {Number: &prNum1}, |
| {Number: &prNum2}, |
| })) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/pulls", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| prs, getPullErr := githubClient.ListOpenPullRequests() |
| require.NoError(t, getPullErr) |
| require.Equal(t, 2, len(prs)) |
| require.Equal(t, prNum1, prs[0].GetNumber()) |
| require.Equal(t, prNum2, prs[1].GetNumber()) |
| } |
| |
| func TestGetPullRequest(t *testing.T) { |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{State: &CLOSED_STATE})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/pulls/1234", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| pr, getPullErr := githubClient.GetPullRequest(1234) |
| require.NoError(t, getPullErr) |
| require.Equal(t, CLOSED_STATE, *pr.State) |
| } |
| |
| func TestGetReference(t *testing.T) { |
| testSHA := "xyz" |
| testRef := "test-branch" |
| testRepoOwner := "batman" |
| testRepoName := "gotham" |
| respBody := []byte(testutils.MarshalJSON(t, &github.Reference{Object: &github.GitObject{SHA: &testSHA}})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get(fmt.Sprintf("/repos/%s/%s/git/refs/%s", testRepoOwner, testRepoName, url.QueryEscape(testRef)), md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), testRepoOwner, testRepoName, httpClient) |
| require.NoError(t, err) |
| ref, err := githubClient.GetReference(testRepoOwner, testRepoName, testRef) |
| require.NoError(t, err) |
| require.Equal(t, testSHA, *ref.Object.SHA) |
| } |
| |
| func TestListMatchingReferences(t *testing.T) { |
| testSHA1 := "abc" |
| testSHA2 := "xyz" |
| testRef := "test-branch" |
| testRepoOwner := "batman" |
| testRepoName := "gotham" |
| retRef1 := github.Reference{Object: &github.GitObject{SHA: &testSHA1}} |
| retRef2 := github.Reference{Object: &github.GitObject{SHA: &testSHA2}} |
| respBody := []byte(testutils.MarshalJSON(t, []github.Reference{retRef1, retRef2})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get(fmt.Sprintf("/repos/%s/%s/git/refs/%s", testRepoOwner, testRepoName, url.QueryEscape(testRef)), md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), testRepoOwner, testRepoName, httpClient) |
| require.NoError(t, err) |
| retRefs, err := githubClient.ListMatchingReferences(testRepoOwner, testRepoName, testRef) |
| require.NoError(t, err) |
| require.Equal(t, 2, len(retRefs)) |
| require.Equal(t, testSHA1, *retRefs[0].Object.SHA) |
| require.Equal(t, testSHA2, *retRefs[1].Object.SHA) |
| } |
| |
| func TestDeleteReference(t *testing.T) { |
| testRef := "test-branch" |
| testRepoOwner := "batman" |
| testRepoName := "gotham" |
| r := chi.NewRouter() |
| md := mockhttpclient.MockDeleteDialogueWithResponseCode("", nil, nil, http.StatusNoContent) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Delete(fmt.Sprintf("/repos/%s/%s/git/refs/%s", testRepoOwner, testRepoName, testRef), md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), testRepoOwner, testRepoName, httpClient) |
| require.NoError(t, err) |
| err = githubClient.DeleteReference(testRepoOwner, testRepoName, testRef) |
| require.NoError(t, err) |
| } |
| |
| func TestCreateReference(t *testing.T) { |
| testSHA := "xyz" |
| testRef := "test-branch" |
| testRepoOwner := "batman" |
| testRepoName := "gotham" |
| reqBody := []byte(fmt.Sprintf(`{"ref":"refs/%s","sha":"%s"} |
| `, testRef, testSHA)) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockPostDialogueWithResponseCode("application/json", reqBody, nil, http.StatusCreated) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Post(fmt.Sprintf("/repos/%s/%s/git/refs", testRepoOwner, testRepoName), md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), testRepoOwner, testRepoName, httpClient) |
| require.NoError(t, err) |
| err = githubClient.CreateReference(testRepoOwner, testRepoName, testRef, testSHA) |
| require.NoError(t, err) |
| } |
| |
| func TestCreatePullRequest(t *testing.T) { |
| reqType := "application/json" |
| reqBody := []byte(`{"title":"title","head":"headBranch","base":"baseBranch","body":"testBody"} |
| `) |
| number := 12345 |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{Number: &number})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockPostDialogueWithResponseCode(reqType, reqBody, respBody, http.StatusCreated) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Post("/repos/kryptonians/krypton/pulls", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| pullRequest, createPullErr := githubClient.CreatePullRequest("title", "baseBranch", "headBranch", "testBody") |
| require.NoError(t, createPullErr) |
| require.Equal(t, number, *pullRequest.Number) |
| } |
| |
| func TestMergePullRequest(t *testing.T) { |
| reqType := "application/json" |
| reqBody := []byte(`{"commit_message":"test comment","merge_method":"squash"} |
| `) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockPutDialogue(reqType, reqBody, nil) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Put("/repos/kryptonians/krypton/pulls/1234/merge", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| mergePullErr := githubClient.MergePullRequest(1234, "test comment", "squash") |
| require.NoError(t, mergePullErr) |
| } |
| |
| func TestClosePullRequest(t *testing.T) { |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{State: &CLOSED_STATE})) |
| reqType := "application/json" |
| reqBody := []byte(`{"state":"closed"} |
| `) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockPatchDialogue(reqType, reqBody, respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Patch("/repos/kryptonians/krypton/pulls/1234", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| pr, closePullErr := githubClient.ClosePullRequest(1234) |
| require.NoError(t, closePullErr) |
| require.Equal(t, CLOSED_STATE, *pr.State) |
| } |
| |
| func TestGetIssues(t *testing.T) { |
| id1 := int64(11) |
| id2 := int64(22) |
| issue1 := github.Issue{ID: &id1} |
| issue2 := github.Issue{ID: &id2} |
| respBody := []byte(testutils.MarshalJSON(t, []*github.Issue{&issue1, &issue2})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com"), |
| mockhttpclient.QueryMatcher("labels", "label1,label2", "per_page", "123", "state", "open")). |
| Get("/repos/kryptonians/krypton/issues", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| issues, getIssuesErr := githubClient.GetIssues(true, []string{"label1", "label2"}, 123) |
| require.NoError(t, getIssuesErr) |
| require.Equal(t, 2, len(issues)) |
| require.Equal(t, id1, issues[0].GetID()) |
| require.Equal(t, id2, issues[1].GetID()) |
| } |
| |
| func TestGetLabelsRequest(t *testing.T) { |
| label1Name := "test1" |
| label2Name := "test2" |
| label1 := github.Label{Name: &label1Name} |
| label2 := github.Label{Name: &label2Name} |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{Labels: []*github.Label{&label1, &label2}})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/issues/1234", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| labels, getLabelsErr := githubClient.GetLabels(1234) |
| require.NoError(t, getLabelsErr) |
| require.Equal(t, []string{label1Name, label2Name}, labels) |
| } |
| |
| func TestAddLabelRequest(t *testing.T) { |
| label1Name := "test1" |
| label2Name := "test2" |
| label1 := github.Label{Name: &label1Name} |
| label2 := github.Label{Name: &label2Name} |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{Labels: []*github.Label{&label1, &label2}})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/issues/1234", md.ServeHTTP) |
| |
| patchRespBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{})) |
| patchReqType := "application/json" |
| patchReqBody := []byte(`{"labels":["test1","test2","test3"]} |
| `) |
| patchMd := mockhttpclient.MockPatchDialogue(patchReqType, patchReqBody, patchRespBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Patch("/repos/kryptonians/krypton/issues/1234", patchMd.ServeHTTP) |
| |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| addLabelErr := githubClient.AddLabel(1234, "test3") |
| require.NoError(t, addLabelErr) |
| } |
| |
| func TestRemoveLabelRequest(t *testing.T) { |
| label1Name := "test1" |
| label2Name := "test2" |
| label1 := github.Label{Name: &label1Name} |
| label2 := github.Label{Name: &label2Name} |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{Labels: []*github.Label{&label1, &label2}})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/issues/1234", md.ServeHTTP) |
| |
| patchRespBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{})) |
| patchReqType := "application/json" |
| patchReqBody := []byte(`{"labels":["test1"]} |
| `) |
| patchMd := mockhttpclient.MockPatchDialogue(patchReqType, patchReqBody, patchRespBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Patch("/repos/kryptonians/krypton/issues/1234", patchMd.ServeHTTP) |
| |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| removeLabelErr1 := githubClient.RemoveLabel(1234, "test2") |
| require.NoError(t, removeLabelErr1) |
| } |
| |
| func TestReplaceLabelRequest(t *testing.T) { |
| label1Name := "test1" |
| label2Name := "test2" |
| label1 := github.Label{Name: &label1Name} |
| label2 := github.Label{Name: &label2Name} |
| respBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{Labels: []*github.Label{&label1, &label2}})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/issues/1234", md.ServeHTTP) |
| |
| patchRespBody := []byte(testutils.MarshalJSON(t, &github.PullRequest{})) |
| patchReqType := "application/json" |
| patchReqBody := []byte(`{"labels":["test2","test3"]} |
| `) |
| patchMd := mockhttpclient.MockPatchDialogue(patchReqType, patchReqBody, patchRespBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Patch("/repos/kryptonians/krypton/issues/1234", patchMd.ServeHTTP) |
| |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| removeLabelErr := githubClient.ReplaceLabel(1234, "test1", "test3") |
| require.NoError(t, removeLabelErr) |
| } |
| |
| func TestGetChecksRequest(t *testing.T) { |
| |
| // Mock out check-runs call. |
| checkID1 := int64(100) |
| checkName1 := "check1" |
| check1 := github.CheckRun{ID: &checkID1, Name: &checkName1, StartedAt: &github.Timestamp{Time: time.Now()}} |
| respBody := []byte(testutils.MarshalJSON(t, &github.ListCheckRunsResults{CheckRuns: []*github.CheckRun{&check1}})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/commits/abcd/check-runs", md.ServeHTTP) |
| |
| // Mock out status call. |
| checkID2 := int64(200) |
| checkName2 := "check2" |
| pendingState := "pending" |
| repoStatusCheck2 := github.RepoStatus{ID: &checkID2, Context: &checkName2, State: &pendingState} |
| statusRespBody := []byte(testutils.MarshalJSON(t, &github.CombinedStatus{Statuses: []github.RepoStatus{repoStatusCheck2}})) |
| mdStatus := mockhttpclient.MockGetDialogue(statusRespBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/commits/abcd/status", mdStatus.ServeHTTP) |
| |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| checks, getChecksErr := githubClient.GetChecks("abcd") |
| require.NoError(t, getChecksErr) |
| require.Equal(t, 2, len(checks)) |
| require.Equal(t, checkID1, checks[0].ID) |
| require.Equal(t, checkName1, checks[0].Name) |
| require.Equal(t, checkID2, checks[1].ID) |
| require.Equal(t, checkName2, checks[1].Name) |
| } |
| |
| func TestReRequestLatestCheckSuite(t *testing.T) { |
| |
| // Mock out list check suites call. |
| totalResults := int(1) |
| checkSuiteID := int64(100) |
| checkSuiteStatus := "failed" |
| checkSuite := github.CheckSuite{ID: &checkSuiteID, Status: &checkSuiteStatus} |
| respBody := []byte(testutils.MarshalJSON(t, &github.ListCheckSuiteResults{Total: &totalResults, CheckSuites: []*github.CheckSuite{&checkSuite}})) |
| r := chi.NewRouter() |
| listmd := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/commits/abcd/check-suites", listmd.ServeHTTP) |
| |
| // Mock out rerequest check suite call. |
| rerequestmd := mockhttpclient.MockPostDialogueWithResponseCode("application/json", nil, nil, http.StatusCreated) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Post("/repos/kryptonians/krypton/check-suites/100/rerequest", rerequestmd.ServeHTTP) |
| |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| rerequestErr := githubClient.ReRequestLatestCheckSuite("abcd") |
| require.NoError(t, rerequestErr) |
| } |
| |
| func TestGetDescription(t *testing.T) { |
| body := "test test test" |
| respBody := []byte(testutils.MarshalJSON(t, &github.Issue{Body: &body})) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("api.github.com")). |
| Get("/repos/kryptonians/krypton/issues/12345", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| desc, err := githubClient.GetDescription(12345) |
| require.NoError(t, err) |
| require.Equal(t, body, desc) |
| } |
| |
| func TestReadRawFileRequest(t *testing.T) { |
| respBody := []byte(`abcd`) |
| r := chi.NewRouter() |
| md := mockhttpclient.MockGetDialogue(respBody) |
| r.With( |
| mockhttpclient.SchemeMatcher("https"), |
| mockhttpclient.HostMatcher("raw.githubusercontent.com")). |
| Get("/kryptonians/krypton/main//dummy/path/to/this.txt", md.ServeHTTP) |
| httpClient := mockhttpclient.NewMuxClient(r) |
| |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| contents, readRawErr := githubClient.ReadRawFile(git.MainBranch, "/dummy/path/to/this.txt") |
| require.NoError(t, readRawErr) |
| require.Equal(t, "abcd", contents) |
| } |
| |
| func TestGetFullHistoryUrl(t *testing.T) { |
| httpClient := mockhttpclient.NewMuxClient(chi.NewRouter()) |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| fullHistoryUrl := githubClient.GetFullHistoryUrl("superman@krypton.com") |
| require.Equal(t, "https://github.com/kryptonians/krypton/pulls/superman", fullHistoryUrl) |
| } |
| |
| func TestGetPullRequestUrlBase(t *testing.T) { |
| httpClient := mockhttpclient.NewMuxClient(chi.NewRouter()) |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| pullRequestUrlBase := githubClient.GetPullRequestUrlBase() |
| require.Equal(t, "https://github.com/kryptonians/krypton/pull/", pullRequestUrlBase) |
| } |
| |
| func TestGetIssueUrlBase(t *testing.T) { |
| httpClient := mockhttpclient.NewMuxClient(chi.NewRouter()) |
| githubClient, err := NewGitHub(context.Background(), "kryptonians", "krypton", httpClient) |
| require.NoError(t, err) |
| issueUrlBase := githubClient.GetIssueUrlBase() |
| require.Equal(t, "https://github.com/kryptonians/krypton/issues/", issueUrlBase) |
| } |
| |
| func TestParseRepoOwnerAndName(t *testing.T) { |
| testCases := []struct { |
| url string |
| repoOwner string |
| repoName string |
| expectErr bool |
| errContains string |
| description string |
| }{ |
| { |
| url: "https://github.com/google/skia", |
| repoOwner: "google", |
| repoName: "skia", |
| expectErr: false, |
| description: "https URL", |
| }, |
| { |
| url: "git@github.com:google/skia.git", |
| repoOwner: "google", |
| repoName: "skia", |
| expectErr: false, |
| description: "git URL", |
| }, |
| { |
| url: "https://github.com/some-user/some-repo.git", |
| repoOwner: "some-user", |
| repoName: "some-repo", |
| expectErr: false, |
| description: "hyphenated user and repo", |
| }, |
| { |
| url: "https://github.com/some_user/some_repo.git", |
| repoOwner: "some_user", |
| repoName: "some_repo", |
| expectErr: false, |
| description: "underscored user and repo", |
| }, |
| { |
| url: "https://github.com/some.user/some.repo.git", |
| repoOwner: "some.user", |
| repoName: "some.repo", |
| expectErr: false, |
| description: "dotted user and repo", |
| }, |
| { |
| url: "https://not-github.com/google/skia", |
| expectErr: true, |
| errContains: "failed to parse repo URL", |
| description: "invalid URL", |
| }, |
| } |
| for _, tc := range testCases { |
| t.Run(tc.description, func(t *testing.T) { |
| repoOwner, repoName, err := ParseRepoOwnerAndName(tc.url) |
| if tc.expectErr { |
| require.Error(t, err) |
| require.Contains(t, err.Error(), tc.errContains) |
| } else { |
| require.NoError(t, err) |
| require.Equal(t, tc.repoOwner, repoOwner) |
| require.Equal(t, tc.repoName, repoName) |
| } |
| }) |
| } |
| } |
| |
| func TestCommitToLongCommit(t *testing.T) { |
| ts := time.Date(2020, 1, 1, 12, 0, 0, 0, time.UTC) |
| testCases := []struct { |
| description string |
| commit *github.RepositoryCommit |
| expected *vcsinfo.LongCommit |
| }{ |
| { |
| description: "Simple commit", |
| commit: &github.RepositoryCommit{ |
| SHA: github.String("abcdef123456"), |
| Commit: &github.Commit{ |
| Author: &github.CommitAuthor{ |
| Name: github.String("Test User"), |
| Email: github.String("test@google.com"), |
| }, |
| Committer: &github.CommitAuthor{ |
| Date: &ts, |
| }, |
| Message: github.String("Subject"), |
| }, |
| }, |
| expected: &vcsinfo.LongCommit{ |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "abcdef123456", |
| Author: "Test User (test@google.com)", |
| Subject: "Subject", |
| }, |
| Parents: []string{}, |
| Body: "", |
| Timestamp: ts, |
| }, |
| }, |
| { |
| description: "Commit with body", |
| commit: &github.RepositoryCommit{ |
| SHA: github.String("abcdef123456"), |
| Commit: &github.Commit{ |
| Author: &github.CommitAuthor{ |
| Name: github.String("Test User"), |
| Email: github.String("test@google.com"), |
| }, |
| Committer: &github.CommitAuthor{ |
| Date: &ts, |
| }, |
| Message: github.String("Subject\n\nThis is the body."), |
| }, |
| }, |
| expected: &vcsinfo.LongCommit{ |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "abcdef123456", |
| Author: "Test User (test@google.com)", |
| Subject: "Subject", |
| }, |
| Parents: []string{}, |
| Body: "This is the body.", |
| Timestamp: ts, |
| }, |
| }, |
| { |
| description: "Commit with parents", |
| commit: &github.RepositoryCommit{ |
| SHA: github.String("abcdef123456"), |
| Commit: &github.Commit{ |
| Author: &github.CommitAuthor{ |
| Name: github.String("Test User"), |
| Email: github.String("test@google.com"), |
| }, |
| Committer: &github.CommitAuthor{ |
| Date: &ts, |
| }, |
| Message: github.String("Subject"), |
| }, |
| Parents: []github.Commit{ |
| { |
| SHA: github.String("parent1"), |
| }, |
| { |
| SHA: github.String("parent2"), |
| }, |
| }, |
| }, |
| expected: &vcsinfo.LongCommit{ |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "abcdef123456", |
| Author: "Test User (test@google.com)", |
| Subject: "Subject", |
| }, |
| Parents: []string{"parent1", "parent2"}, |
| Body: "", |
| Timestamp: ts, |
| }, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.description, func(t *testing.T) { |
| actual := CommitToLongCommit(tc.commit) |
| require.Equal(t, tc.expected, actual) |
| }) |
| } |
| } |
