package github import ( "context" "errors" "net/http" "strconv" "strings" "testing" "time" ) func TestPATClient_SetsAuthAndVersionHeadersOnGET(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{"/user": `{"login":"octocat"}`}) if _, err := c.GetAuthenticatedUser(context.Background()); err != nil { t.Fatalf("GetAuthenticatedUser: %v", err) } if len(*requests) != 1 { t.Fatalf("requests = %d, want 1", len(*requests)) } got := (*requests)[0] if got.Method != http.MethodGet { t.Errorf("method = %q, want GET", got.Method) } if got.Header.Get("Authorization") != "token test-token" { t.Errorf("Authorization = %q, want %q", got.Header.Get("Authorization"), "token test-token") } if got.Header.Get("Accept") != githubAccept { t.Errorf("Accept = %q, want %q", got.Header.Get("Accept"), githubAccept) } if got.Header.Get("X-GitHub-Api-Version") != githubAPIVersion { t.Errorf("X-GitHub-Api-Version = %q, want %q", got.Header.Get("X-GitHub-Api-Version"), githubAPIVersion) } } func TestPATClient_GetAuthenticatedUser_CachesLogin(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{"/user": `{"login":"octocat"}`}) first, err := c.GetAuthenticatedUser(context.Background()) if err != nil { t.Fatalf("first call: %v", err) } second, err := c.GetAuthenticatedUser(context.Background()) if err != nil { t.Fatalf("second call: %v", err) } if first != "octocat" || second != "octocat" { t.Fatalf("logins = (%q, %q), want both octocat", first, second) } if len(*requests) != 1 { t.Fatalf("requests = %d, want 1 (second call must hit the cache)", len(*requests)) } } func TestPATClient_IsAuthenticated(t *testing.T) { t.Run("valid token", func(t *testing.T) { c, _ := newRecordingPATServer(t, map[string]string{"/user": `{"login":"octocat"}`}) ok, err := c.IsAuthenticated(context.Background()) if err != nil { t.Fatalf("IsAuthenticated: %v", err) } if !ok { t.Error("authenticated = false, want true") } }) t.Run("rejected token reports false without an error", func(t *testing.T) { // No /user route → 404 → GetAuthenticatedUser errors, which // IsAuthenticated must translate into (false, nil). c, _ := newRecordingPATServer(t, nil) ok, err := c.IsAuthenticated(context.Background()) if err != nil { t.Fatalf("IsAuthenticated must swallow the auth failure, got %v", err) } if ok { t.Error("authenticated = true, want false") } }) } func TestPATClient_HasRepositoryAccess(t *testing.T) { t.Run("repo readable", func(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/repos/acme/widget": `{"full_name":"acme/widget"}`, }) ok, err := c.HasRepositoryAccess(context.Background(), "acme", "widget") if err != nil { t.Fatalf("HasRepositoryAccess: %v", err) } if !ok { t.Error("access = false, want true") } if (*requests)[0].Path != "/repos/acme/widget" { t.Errorf("path = %q, want /repos/acme/widget", (*requests)[0].Path) } }) t.Run("empty full_name reports no access", func(t *testing.T) { c, _ := newRecordingPATServer(t, map[string]string{"/repos/acme/widget": `{}`}) ok, err := c.HasRepositoryAccess(context.Background(), "acme", "widget") if err != nil { t.Fatalf("HasRepositoryAccess: %v", err) } if ok { t.Error("access = true, want false when full_name is absent") } }) t.Run("404 surfaces a typed API error", func(t *testing.T) { c, _ := newRecordingPATServer(t, nil) ok, err := c.HasRepositoryAccess(context.Background(), "acme", "widget") if ok { t.Error("access = true, want false on error") } var apiErr *GitHubAPIError if !errors.As(err, &apiErr) || apiErr.StatusCode != http.StatusNotFound { t.Fatalf("err = %v, want *GitHubAPIError with 404", err) } }) } func TestPATClient_GetPR_DecodesEveryField(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/repos/acme/widget/pulls/42": `{ "number":42,"title":"Add widgets","html_url":"https://github.com/acme/widget/pull/42", "body":"the body","state":"open","draft":true,"mergeable":true,"mergeable_state":"CLEAN", "additions":12,"deletions":3, "created_at":"2026-01-01T10:00:00Z","updated_at":"2026-01-02T11:00:00Z", "merged_at":null,"closed_at":null,"maintainer_can_modify":true, "requested_reviewers":[{"login":"alice"}], "requested_teams":[{"slug":"platform","name":"Platform Team"}], "user":{"login":"bob"}, "head":{"ref":"feature","sha":"abc123","repo":{"id":77,"name":"widget-fork","full_name":"contributor/widget-fork","clone_url":"https://github.com/contributor/widget-fork.git"}}, "base":{"ref":"main","repo":{"id":11,"name":"widget","full_name":"acme/widget","default_branch":"trunk"}} }`, }) pr, err := c.GetPR(context.Background(), "acme", "widget", 42) if err != nil { t.Fatalf("GetPR: %v", err) } if (*requests)[0].Path != "/repos/acme/widget/pulls/42" { t.Errorf("path = %q, want /repos/acme/widget/pulls/42", (*requests)[0].Path) } assertPRScalars(t, pr) assertPRRepositories(t, pr) if len(pr.RequestedReviewers) != 2 { t.Fatalf("requested reviewers = %#v, want user + team", pr.RequestedReviewers) } if pr.RequestedReviewers[0] != (RequestedReviewer{Login: "alice", Type: reviewerTypeUser}) { t.Errorf("reviewer[0] = %#v", pr.RequestedReviewers[0]) } if pr.RequestedReviewers[1] != (RequestedReviewer{Login: "platform", Type: reviewerTypeTeam}) { t.Errorf("reviewer[1] = %#v", pr.RequestedReviewers[1]) } if pr.MergedAt != nil || pr.ClosedAt != nil { t.Errorf("MergedAt = %v, ClosedAt = %v, want both nil", pr.MergedAt, pr.ClosedAt) } } func assertPRScalars(t *testing.T, pr *PR) { t.Helper() if pr.Number != 42 || pr.Title != "Add widgets" { t.Errorf("number/title = (%d, %q)", pr.Number, pr.Title) } if pr.HTMLURL != "https://github.com/acme/widget/pull/42" { t.Errorf("html_url = %q", pr.HTMLURL) } if pr.Body != "the body" || pr.State != "open" { t.Errorf("body/state = (%q, %q)", pr.Body, pr.State) } if !pr.Draft || !pr.Mergeable || !pr.MaintainerCanModify { t.Errorf("draft=%v mergeable=%v maintainerCanModify=%v, want all true", pr.Draft, pr.Mergeable, pr.MaintainerCanModify) } if pr.MergeableState != "clean" { t.Errorf("mergeable_state = %q, want lowercased clean", pr.MergeableState) } if pr.Additions != 12 || pr.Deletions != 3 { t.Errorf("additions/deletions = (%d, %d), want (12, 3)", pr.Additions, pr.Deletions) } if pr.HeadBranch != "feature" || pr.HeadSHA != "abc123" || pr.BaseBranch != "main" { t.Errorf("head/base = (%q, %q, %q)", pr.HeadBranch, pr.HeadSHA, pr.BaseBranch) } if pr.AuthorLogin != "bob" || pr.RepoOwner != "acme" || pr.RepoName != "widget" { t.Errorf("author/repo = (%q, %q, %q)", pr.AuthorLogin, pr.RepoOwner, pr.RepoName) } if !pr.CreatedAt.Equal(time.Date(2026, 1, 1, 10, 0, 0, 0, time.UTC)) { t.Errorf("created_at = %v", pr.CreatedAt) } if !pr.UpdatedAt.Equal(time.Date(2026, 1, 2, 11, 0, 0, 0, time.UTC)) { t.Errorf("updated_at = %v", pr.UpdatedAt) } } // assertPRRepositories pins the nested head.repo / base.repo decode, which // only happens through patPR's custom UnmarshalJSON. func assertPRRepositories(t *testing.T, pr *PR) { t.Helper() if pr.HeadRepoID != 77 || pr.HeadRepoOwner != "contributor" || pr.HeadRepoName != "widget-fork" { t.Errorf("head repo = (%d, %q, %q), want (77, contributor, widget-fork)", pr.HeadRepoID, pr.HeadRepoOwner, pr.HeadRepoName) } if pr.HeadRepoCloneURL != "https://github.com/contributor/widget-fork.git" { t.Errorf("head clone url = %q", pr.HeadRepoCloneURL) } if pr.BaseRepoID != 11 || pr.BaseRepoOwner != "acme" || pr.BaseRepoName != "widget" { t.Errorf("base repo = (%d, %q, %q), want (11, acme, widget)", pr.BaseRepoID, pr.BaseRepoOwner, pr.BaseRepoName) } if pr.BaseDefaultBranch != "trunk" { t.Errorf("base default branch = %q, want trunk", pr.BaseDefaultBranch) } } // TestPATClient_GetPR_DecodesOutcomeFields covers AC-09's REST half: // changed_files, merged_by, and a non-null auto_merge decode onto PR. func TestPATClient_GetPR_DecodesOutcomeFields(t *testing.T) { c, _ := newRecordingPATServer(t, map[string]string{ "/repos/kdlbs/kandev/pulls/2554": `{ "number":2554,"state":"closed","merged_at":"2026-08-12T00:00:00Z", "changed_files":8,"merged_by":{"login":"carlosflorencio"}, "auto_merge":{"enabled_by":{"login":"carlosflorencio"},"merge_method":"squash"}, "user":{"login":"carlosflorencio"},"head":{"ref":"f"},"base":{"ref":"main"} }`, }) pr, err := c.GetPR(context.Background(), "kdlbs", "kandev", 2554) if err != nil { t.Fatalf("GetPR: %v", err) } if pr.ChangedFiles != 8 { t.Errorf("ChangedFiles = %d, want 8", pr.ChangedFiles) } if pr.MergedByLogin != "carlosflorencio" { t.Errorf("MergedByLogin = %q, want carlosflorencio", pr.MergedByLogin) } if !pr.AutoMergeEnabled { t.Error("AutoMergeEnabled = false, want true (non-null auto_merge)") } } // TestPATClient_GetPR_NullMergedByAndAutoMergeDecodeToZeroValues covers the // "never observed / not armed" side: GitHub reports auto_merge: null once it // fires (merged PR 2554 in the spec's live sample) or when never armed, and // merged_by: null on an unmerged PR. func TestPATClient_GetPR_NullMergedByAndAutoMergeDecodeToZeroValues(t *testing.T) { c, _ := newRecordingPATServer(t, map[string]string{ "/repos/kdlbs/kandev/pulls/2476": `{ "number":2476,"state":"closed","draft":true,"changed_files":114, "merged_by":null,"auto_merge":null, "user":{"login":"nova28"},"head":{"ref":"f"},"base":{"ref":"main"} }`, }) pr, err := c.GetPR(context.Background(), "kdlbs", "kandev", 2476) if err != nil { t.Fatalf("GetPR: %v", err) } if pr.MergedByLogin != "" { t.Errorf("MergedByLogin = %q, want empty", pr.MergedByLogin) } if pr.AutoMergeEnabled { t.Error("AutoMergeEnabled = true, want false (null auto_merge)") } if pr.ChangedFiles != 114 { t.Errorf("ChangedFiles = %d, want 114", pr.ChangedFiles) } } func TestPATClient_GetPR_MergedStateAndTimestamps(t *testing.T) { c, _ := newRecordingPATServer(t, map[string]string{ "/repos/acme/widget/pulls/9": `{"number":9,"state":"closed", "merged_at":"2026-02-03T09:00:00Z","closed_at":"2026-02-03T09:00:00Z", "user":{"login":"bob"},"head":{"ref":"f"},"base":{"ref":"main"}}`, }) pr, err := c.GetPR(context.Background(), "acme", "widget", 9) if err != nil { t.Fatalf("GetPR: %v", err) } if pr.State != prStateMerged { t.Errorf("state = %q, want merged (merged_at promotes closed → merged)", pr.State) } want := time.Date(2026, 2, 3, 9, 0, 0, 0, time.UTC) if pr.MergedAt == nil || !pr.MergedAt.Equal(want) { t.Errorf("merged_at = %v, want %v", pr.MergedAt, want) } if pr.ClosedAt == nil || !pr.ClosedAt.Equal(want) { t.Errorf("closed_at = %v, want %v", pr.ClosedAt, want) } // No head.repo / base.repo in the payload: the identity fields stay zero. if pr.HeadRepoID != 0 || pr.BaseRepoID != 0 || pr.BaseDefaultBranch != "" { t.Errorf("expected zero repo identity, got head=%d base=%d branch=%q", pr.HeadRepoID, pr.BaseRepoID, pr.BaseDefaultBranch) } } func TestPATClient_GetPR_ErrorIsWrappedWithNumber(t *testing.T) { c, _ := newRecordingPATServer(t, nil) pr, err := c.GetPR(context.Background(), "acme", "widget", 42) if pr != nil { t.Errorf("pr = %#v, want nil on error", pr) } if err == nil || !strings.Contains(err.Error(), "get PR #42") { t.Fatalf("err = %v, want it to name PR #42", err) } var apiErr *GitHubAPIError if !errors.As(err, &apiErr) || apiErr.StatusCode != http.StatusNotFound { t.Fatalf("err = %v, want an unwrappable *GitHubAPIError with 404", err) } } func TestPATClient_GetIssue_DecodesEveryField(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/repos/acme/widget/issues/5": `{ "number":5,"title":"Broken login","html_url":"https://github.com/acme/widget/issues/5", "body":"steps to repro","state":"CLOSED", "created_at":"2026-03-01T08:00:00Z","updated_at":"2026-03-02T08:00:00Z", "closed_at":"2026-03-03T08:00:00Z", "user":{"login":"carol"}, "labels":[{"name":"bug"},{"name":"p1"}], "assignees":[{"login":"dave"}] }`, }) issue, err := c.GetIssue(context.Background(), "acme", "widget", 5) if err != nil { t.Fatalf("GetIssue: %v", err) } if (*requests)[0].Path != "/repos/acme/widget/issues/5" { t.Errorf("path = %q, want /repos/acme/widget/issues/5", (*requests)[0].Path) } if issue.Number != 5 || issue.Title != "Broken login" || issue.Body != "steps to repro" { t.Errorf("issue scalars = %#v", issue) } if issue.URL != "https://github.com/acme/widget/issues/5" || issue.HTMLURL != issue.URL { t.Errorf("URL/HTMLURL = (%q, %q), want both the html_url", issue.URL, issue.HTMLURL) } if issue.State != "closed" { t.Errorf("state = %q, want lowercased closed", issue.State) } if issue.AuthorLogin != "carol" || issue.RepoOwner != "acme" || issue.RepoName != "widget" { t.Errorf("author/repo = (%q, %q, %q)", issue.AuthorLogin, issue.RepoOwner, issue.RepoName) } if strings.Join(issue.Labels, ",") != "bug,p1" { t.Errorf("labels = %v, want [bug p1]", issue.Labels) } if strings.Join(issue.Assignees, ",") != "dave" { t.Errorf("assignees = %v, want [dave]", issue.Assignees) } if !issue.CreatedAt.Equal(time.Date(2026, 3, 1, 8, 0, 0, 0, time.UTC)) { t.Errorf("created_at = %v", issue.CreatedAt) } if !issue.UpdatedAt.Equal(time.Date(2026, 3, 2, 8, 0, 0, 0, time.UTC)) { t.Errorf("updated_at = %v", issue.UpdatedAt) } wantClosed := time.Date(2026, 3, 3, 8, 0, 0, 0, time.UTC) if issue.ClosedAt == nil || !issue.ClosedAt.Equal(wantClosed) { t.Errorf("closed_at = %v, want %v", issue.ClosedAt, wantClosed) } } func TestPATClient_GetIssue_OpenIssueHasNilClosedAt(t *testing.T) { c, _ := newRecordingPATServer(t, map[string]string{ "/repos/acme/widget/issues/6": `{"number":6,"state":"open","closed_at":null,"user":{"login":"carol"}}`, }) issue, err := c.GetIssue(context.Background(), "acme", "widget", 6) if err != nil { t.Fatalf("GetIssue: %v", err) } if issue.ClosedAt != nil { t.Errorf("closed_at = %v, want nil for an open issue", issue.ClosedAt) } if len(issue.Labels) != 0 || len(issue.Assignees) != 0 { t.Errorf("labels/assignees = (%v, %v), want empty", issue.Labels, issue.Assignees) } } func TestPATClient_GetIssue_ErrorIsWrappedWithNumber(t *testing.T) { c, _ := newRecordingPATServer(t, nil) if _, err := c.GetIssue(context.Background(), "acme", "widget", 6); err == nil || !strings.Contains(err.Error(), "get issue #6") { t.Fatalf("err = %v, want it to name issue #6", err) } } func TestPATClient_GetIssueState(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/repos/acme/widget/issues/7": `{"state":"closed","number":7}`, }) state, err := c.GetIssueState(context.Background(), "acme", "widget", 7) if err != nil { t.Fatalf("GetIssueState: %v", err) } if state != "closed" { t.Errorf("state = %q, want closed", state) } if (*requests)[0].Path != "/repos/acme/widget/issues/7" { t.Errorf("path = %q", (*requests)[0].Path) } } func TestPATClient_GetIssueState_Error(t *testing.T) { c, _ := newRecordingPATServer(t, nil) state, err := c.GetIssueState(context.Background(), "acme", "widget", 7) if state != "" { t.Errorf("state = %q, want empty on error", state) } if err == nil || !strings.Contains(err.Error(), "get issue state") { t.Fatalf("err = %v, want a wrapped get-issue-state error", err) } } func TestPATClient_ListAuthoredPRs_KeepsOnlyTheAuthenticatedUsersPRs(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/user": `{"login":"octocat"}`, "/repos/acme/widget/pulls": `[ {"number":1,"title":"mine","state":"open","user":{"login":"octocat"},"head":{"ref":"a"},"base":{"ref":"main"}}, {"number":2,"title":"theirs","state":"open","user":{"login":"someone-else"},"head":{"ref":"b"},"base":{"ref":"main"}}, {"number":3,"title":"mine too","state":"open","user":{"login":"octocat"},"head":{"ref":"c"},"base":{"ref":"main"}} ]`, }) prs, err := c.ListAuthoredPRs(context.Background(), "acme", "widget") if err != nil { t.Fatalf("ListAuthoredPRs: %v", err) } if len(prs) != 2 { t.Fatalf("prs = %d, want 2 (the other author must be filtered out)", len(prs)) } if prs[0].Number != 1 || prs[1].Number != 3 { t.Errorf("numbers = (%d, %d), want (1, 3)", prs[0].Number, prs[1].Number) } if prs[0].RepoOwner != "acme" || prs[0].RepoName != "widget" { t.Errorf("repo = (%q, %q), want acme/widget", prs[0].RepoOwner, prs[0].RepoName) } listQuery := (*requests)[1].Query if !strings.Contains(listQuery, "state=open") || !strings.Contains(listQuery, "per_page=100") { t.Errorf("query = %q, want state=open and per_page=100", listQuery) } } func TestPATClient_ListAuthoredPRs_PropagatesAuthFailure(t *testing.T) { c, requests := newRecordingPATServer(t, nil) prs, err := c.ListAuthoredPRs(context.Background(), "acme", "widget") if err == nil { t.Fatal("expected an error when /user fails") } if prs != nil { t.Errorf("prs = %v, want nil", prs) } if len(*requests) != 1 { t.Errorf("requests = %d, want 1 — the PR list must not run after auth fails", len(*requests)) } } func TestPATClient_ListReviewRequestedPRs_BuildsScopedQuery(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/search/issues": `{"items":[{"id":501,"node_id":"PR_a","number":3,"title":"Review me", "html_url":"https://github.com/acme/web/pull/3","state":"closed","draft":true, "created_at":"2026-04-01T00:00:00Z","updated_at":"2026-04-02T00:00:00Z", "repository_url":"https://api.github.com/repos/acme/web", "user":{"login":"erin"},"pull_request":{"merged_at":"2026-04-03T00:00:00Z"}}]}`, }) prs, err := c.ListReviewRequestedPRs(context.Background(), ReviewScopeUser, "repo:acme/web", "") if err != nil { t.Fatalf("ListReviewRequestedPRs: %v", err) } query := (*requests)[0].Query for _, want := range []string{"user-review-requested", "per_page=50", "repo%3Aacme%2Fweb"} { if !strings.Contains(query, want) { t.Errorf("query = %q, want it to contain %q", query, want) } } if len(prs) != 1 { t.Fatalf("prs = %d, want 1", len(prs)) } pr := prs[0] if pr.ID != 501 || pr.NodeID != "PR_a" || pr.Number != 3 || pr.Title != "Review me" { t.Errorf("identity = %#v", pr) } if pr.State != prStateMerged { t.Errorf("state = %q, want merged — a non-empty pull_request.merged_at promotes closed", pr.State) } if pr.AuthorLogin != "erin" || !pr.Draft { t.Errorf("author/draft = (%q, %v)", pr.AuthorLogin, pr.Draft) } if pr.RepoOwner != "acme" || pr.RepoName != "web" { t.Errorf("repo = (%q, %q), want acme/web parsed from repository_url", pr.RepoOwner, pr.RepoName) } if pr.MergedAt == nil || !pr.MergedAt.Equal(time.Date(2026, 4, 3, 0, 0, 0, 0, time.UTC)) { t.Errorf("merged_at = %v", pr.MergedAt) } } func TestPATClient_ListReviewRequestedPRs_Error(t *testing.T) { c, _ := newRecordingPATServer(t, nil) if _, err := c.ListReviewRequestedPRs(context.Background(), "", "", ""); err == nil || !strings.Contains(err.Error(), "search review-requested") { t.Fatalf("err = %v, want a wrapped search error", err) } } func TestPATClient_SearchPRs_UsesFirstPageOfFifty(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/search/issues": `{"total_count":2,"items":[ {"id":1,"number":1,"title":"one","state":"open","repository_url":"https://api.github.com/repos/o/r","pull_request":{}}, {"id":2,"number":2,"title":"two","state":"open","repository_url":"https://api.github.com/repos/o/r","pull_request":{}} ]}`, }) prs, err := c.SearchPRs(context.Background(), "is:open", "") if err != nil { t.Fatalf("SearchPRs: %v", err) } if len(prs) != 2 || prs[0].Number != 1 || prs[1].Number != 2 { t.Fatalf("prs = %#v", prs) } query := (*requests)[0].Query if !strings.Contains(query, "per_page=50") || !strings.Contains(query, "page=1") { t.Errorf("query = %q, want per_page=50 and page=1", query) } if !strings.Contains(query, "type%3Apr") { t.Errorf("query = %q, want the injected type:pr qualifier", query) } } func TestPATClient_SearchPRsPaged_ClampsPageAndPerPage(t *testing.T) { cases := []struct { name string page, perPage int wantPage, wantPerPage int }{ {"zero page floors to 1", 0, 25, 1, 25}, {"negative page floors to 1", -3, 25, 1, 25}, {"zero per_page defaults to 50", 2, 0, 2, 50}, {"per_page above cap clamps to 100", 2, 500, 2, 100}, {"in-range values pass through", 3, 30, 3, 30}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/search/issues": `{"total_count":7,"items":[]}`, }) page, err := c.SearchPRsPaged(context.Background(), "", "", tc.page, tc.perPage) if err != nil { t.Fatalf("SearchPRsPaged: %v", err) } if page.Page != tc.wantPage || page.PerPage != tc.wantPerPage { t.Errorf("page/per_page = (%d, %d), want (%d, %d)", page.Page, page.PerPage, tc.wantPage, tc.wantPerPage) } if page.TotalCount != 7 { t.Errorf("total_count = %d, want 7", page.TotalCount) } if len(page.PRs) != 0 { t.Errorf("prs = %#v, want empty", page.PRs) } gotQuery := (*requests)[0].Query for _, want := range []string{ "page=" + strconv.Itoa(tc.wantPage), "per_page=" + strconv.Itoa(tc.wantPerPage), } { if !strings.Contains(gotQuery, want) { t.Errorf("query = %q, want %q", gotQuery, want) } } }) } } func TestPATClient_ListIssuesPaged_DropsPullRequestsFromSearchResults(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/search/issues": `{"total_count":3,"items":[ {"id":10,"node_id":"I_a","number":10,"title":"a real issue","body":"details", "html_url":"https://github.com/o/r/issues/10","state":"open", "created_at":"2026-05-01T00:00:00Z","updated_at":"2026-05-02T00:00:00Z", "repository_url":"https://api.github.com/repos/o/r","user":{"login":"frank"}, "labels":[{"name":"bug"}],"assignees":[{"login":"grace"}]}, {"id":11,"number":11,"title":"a PR in disguise","state":"open", "repository_url":"https://api.github.com/repos/o/r","pull_request":{"url":"https://api/pulls/11"}} ]}`, }) page, err := c.ListIssuesPaged(context.Background(), "", "", 1, 20) if err != nil { t.Fatalf("ListIssuesPaged: %v", err) } if len(page.Issues) != 1 { t.Fatalf("issues = %d, want 1 — the pull_request item must be dropped", len(page.Issues)) } got := page.Issues[0] if got.ID != 10 || got.NodeID != "I_a" || got.Number != 10 { t.Errorf("identity = %#v", got) } if got.Title != "a real issue" || got.Body != "details" || got.State != "open" { t.Errorf("scalars = %#v", got) } if got.RepoOwner != "o" || got.RepoName != "r" || got.AuthorLogin != "frank" { t.Errorf("repo/author = (%q, %q, %q)", got.RepoOwner, got.RepoName, got.AuthorLogin) } if strings.Join(got.Labels, ",") != "bug" || strings.Join(got.Assignees, ",") != "grace" { t.Errorf("labels/assignees = (%v, %v)", got.Labels, got.Assignees) } // TotalCount is reported verbatim by GitHub — it is NOT the filtered length. if page.TotalCount != 3 || page.Page != 1 || page.PerPage != 20 { t.Errorf("page meta = (%d, %d, %d), want (3, 1, 20)", page.TotalCount, page.Page, page.PerPage) } if !strings.Contains((*requests)[0].Query, "type%3Aissue") { t.Errorf("query = %q, want the injected type:issue qualifier", (*requests)[0].Query) } } func TestPATClient_ListIssues_DelegatesToFirstPage(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/search/issues": `{"total_count":1,"items":[{"id":1,"number":1,"title":"x", "repository_url":"https://api.github.com/repos/o/r"}]}`, }) issues, err := c.ListIssues(context.Background(), "", "is:open label:bug") if err != nil { t.Fatalf("ListIssues: %v", err) } if len(issues) != 1 || issues[0].Number != 1 { t.Fatalf("issues = %#v", issues) } query := (*requests)[0].Query if !strings.Contains(query, "per_page=50") || !strings.Contains(query, "page=1") { t.Errorf("query = %q, want the default first page of 50", query) } } func TestPATClient_ListIssuesPaged_Error(t *testing.T) { c, _ := newRecordingPATServer(t, nil) if _, err := c.ListIssuesPaged(context.Background(), "", "", 1, 10); err == nil || !strings.Contains(err.Error(), "search issues") { t.Fatalf("err = %v, want a wrapped search-issues error", err) } } func TestPATClient_ListUserOrgs(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/user/orgs": `[{"login":"acme","avatar_url":"https://avatars/acme"},{"login":"other","avatar_url":""}]`, }) orgs, err := c.ListUserOrgs(context.Background()) if err != nil { t.Fatalf("ListUserOrgs: %v", err) } if len(orgs) != 2 { t.Fatalf("orgs = %d, want 2", len(orgs)) } if orgs[0] != (GitHubOrg{Login: "acme", AvatarURL: "https://avatars/acme"}) { t.Errorf("orgs[0] = %#v", orgs[0]) } if orgs[1] != (GitHubOrg{Login: "other"}) { t.Errorf("orgs[1] = %#v", orgs[1]) } if !strings.Contains((*requests)[0].Query, "per_page=100") { t.Errorf("query = %q, want per_page=100", (*requests)[0].Query) } } func TestPATClient_ListUserOrgs_Error(t *testing.T) { c, _ := newRecordingPATServer(t, nil) orgs, err := c.ListUserOrgs(context.Background()) if orgs != nil { t.Errorf("orgs = %v, want nil", orgs) } if err == nil || !strings.Contains(err.Error(), "list user orgs") { t.Fatalf("err = %v, want a wrapped list-user-orgs error", err) } } func TestPATClient_SearchOrgRepos(t *testing.T) { cases := []struct { name string query string limit int wantQ string wantP string }{ {"no free-text query", "", 30, "org:acme", "30"}, {"with free-text query", "widget", 30, "org:acme widget", "30"}, {"limit clamps to the cap", "", 900, "org:acme", "100"}, {"zero limit takes the default", "", 0, "org:acme", "20"}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { c, requests := newRecordingPATServer(t, map[string]string{ "/search/repositories": `{"items":[{"full_name":"acme/widget","owner":{"login":"acme"}, "name":"widget","private":true,"default_branch":"main","description":"w", "pushed_at":"2026-06-01T00:00:00Z"}]}`, }) repos, err := c.SearchOrgRepos(context.Background(), "acme", tc.query, tc.limit) if err != nil { t.Fatalf("SearchOrgRepos: %v", err) } if len(repos) != 1 { t.Fatalf("repos = %d, want 1", len(repos)) } got := repos[0] if got.FullName != "acme/widget" || got.Owner != "acme" || got.Name != "widget" { t.Errorf("identity = %#v", got) } if !got.Private || got.DefaultBranch != "main" || got.Description != "w" { t.Errorf("attributes = %#v", got) } if got.PushedAt == nil || !got.PushedAt.Equal(time.Date(2026, 6, 1, 0, 0, 0, 0, time.UTC)) { t.Errorf("pushed_at = %v", got.PushedAt) } values := parseQueryValues(t, (*requests)[0].Query) if values.Get("q") != tc.wantQ { t.Errorf("q = %q, want %q", values.Get("q"), tc.wantQ) } if values.Get("per_page") != tc.wantP { t.Errorf("per_page = %q, want %q", values.Get("per_page"), tc.wantP) } }) } } func TestPATClient_SearchOrgRepos_Error(t *testing.T) { c, _ := newRecordingPATServer(t, nil) repos, err := c.SearchOrgRepos(context.Background(), "acme", "", 10) if repos != nil { t.Errorf("repos = %v, want nil", repos) } if err == nil || !strings.Contains(err.Error(), "search org repos") { t.Fatalf("err = %v, want a wrapped search-org-repos error", err) } }