agent-company
becb925456
Add four test functions using httptest.NewServer: - TestApplyLabel: verifies POST request path, auth header, label IDs in body, and cache invalidation after success - TestApplyLabel_Error: verifies 404 error propagation - TestSubmitReview: verifies POST path, event/body fields, and cache invalidation after success - TestSubmitReview_Error: verifies 422 error propagation Closes leeworks-agents/gitea-mobile#127 Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
1090 lines
31 KiB
Go
1090 lines
31 KiB
Go
package gitea
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestNewClient(t *testing.T) {
|
|
c := NewClient("https://gitea.example.com")
|
|
if c.baseURL != "https://gitea.example.com" {
|
|
t.Errorf("baseURL = %q, want %q", c.baseURL, "https://gitea.example.com")
|
|
}
|
|
if c.maxConcurrent != 5 {
|
|
t.Errorf("maxConcurrent = %d, want 5", c.maxConcurrent)
|
|
}
|
|
if c.cacheTTL != 30*time.Second {
|
|
t.Errorf("cacheTTL = %v, want 30s", c.cacheTTL)
|
|
}
|
|
}
|
|
|
|
func TestNewClient_TrailingSlash(t *testing.T) {
|
|
c := NewClient("https://gitea.example.com/")
|
|
if c.baseURL != "https://gitea.example.com" {
|
|
t.Errorf("baseURL = %q, want trailing slash removed", c.baseURL)
|
|
}
|
|
}
|
|
|
|
func TestCache(t *testing.T) {
|
|
c := NewClient("https://gitea.example.com")
|
|
|
|
// Cache miss.
|
|
_, ok := c.getFromCache("key1")
|
|
if ok {
|
|
t.Error("expected cache miss")
|
|
}
|
|
|
|
// Cache set and hit.
|
|
c.setCache("key1", "value1")
|
|
val, ok := c.getFromCache("key1")
|
|
if !ok {
|
|
t.Fatal("expected cache hit")
|
|
}
|
|
if val.(string) != "value1" {
|
|
t.Errorf("got %q, want %q", val, "value1")
|
|
}
|
|
|
|
// Invalidate.
|
|
c.invalidateCache("key")
|
|
_, ok = c.getFromCache("key1")
|
|
if ok {
|
|
t.Error("expected cache miss after invalidation")
|
|
}
|
|
}
|
|
|
|
func TestCacheExpiry(t *testing.T) {
|
|
c := NewClient("https://gitea.example.com")
|
|
c.cacheTTL = 1 * time.Millisecond
|
|
|
|
c.setCache("key1", "value1")
|
|
time.Sleep(5 * time.Millisecond)
|
|
|
|
_, ok := c.getFromCache("key1")
|
|
if ok {
|
|
t.Error("expected cache miss after TTL expiry")
|
|
}
|
|
}
|
|
|
|
func TestInvalidateAll(t *testing.T) {
|
|
c := NewClient("https://gitea.example.com")
|
|
c.setCache("key1", "value1")
|
|
c.setCache("key2", "value2")
|
|
|
|
c.InvalidateAll()
|
|
|
|
_, ok1 := c.getFromCache("key1")
|
|
_, ok2 := c.getFromCache("key2")
|
|
if ok1 || ok2 {
|
|
t.Error("expected all cache entries to be invalidated")
|
|
}
|
|
}
|
|
|
|
func TestPriorityScore(t *testing.T) {
|
|
tests := []struct {
|
|
labels []string
|
|
want int
|
|
}{
|
|
{[]string{"P1", "bug"}, 1},
|
|
{[]string{"P2"}, 2},
|
|
{[]string{"P3", "enhancement"}, 3},
|
|
{[]string{"bug", "enhancement"}, 4},
|
|
{nil, 4},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
got := priorityScore(tt.labels)
|
|
if got != tt.want {
|
|
t.Errorf("priorityScore(%v) = %d, want %d", tt.labels, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListOrgs(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/api/v1/user/orgs" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
if r.Header.Get("Authorization") != "token test-token" {
|
|
t.Error("missing or wrong Authorization header")
|
|
}
|
|
|
|
orgs := []Org{
|
|
{Name: "org1", FullName: "Organization 1"},
|
|
{Name: "org2", FullName: "Organization 2"},
|
|
}
|
|
json.NewEncoder(w).Encode(orgs)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
orgs, err := c.ListOrgs(context.Background(), "test-token")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(orgs) != 2 {
|
|
t.Fatalf("got %d orgs, want 2", len(orgs))
|
|
}
|
|
if orgs[0].Name != "org1" {
|
|
t.Errorf("orgs[0].Name = %q, want %q", orgs[0].Name, "org1")
|
|
}
|
|
}
|
|
|
|
func TestListOrgs_Cached(t *testing.T) {
|
|
callCount := 0
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
callCount++
|
|
json.NewEncoder(w).Encode([]Org{{Name: "org1"}})
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
|
|
// First call should hit the server.
|
|
_, err := c.ListOrgs(context.Background(), "test-token")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Second call should use cache.
|
|
_, err = c.ListOrgs(context.Background(), "test-token")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if callCount != 1 {
|
|
t.Errorf("server called %d times, want 1 (cached)", callCount)
|
|
}
|
|
}
|
|
|
|
func TestListOrgRepos(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
repos := []Repo{
|
|
{ID: 1, Name: "repo1", FullName: "org1/repo1"},
|
|
{ID: 2, Name: "repo2", FullName: "org1/repo2"},
|
|
}
|
|
json.NewEncoder(w).Encode(repos)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
repos, err := c.ListOrgRepos(context.Background(), "test-token", "org1")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(repos) != 2 {
|
|
t.Fatalf("got %d repos, want 2", len(repos))
|
|
}
|
|
}
|
|
|
|
func TestGetTriageQueue_Sorting(t *testing.T) {
|
|
queue := []TriageItem{
|
|
{Title: "low", Labels: []string{"P3"}, UpdatedAt: time.Now()},
|
|
{Title: "high", Labels: []string{"P1"}, UpdatedAt: time.Now()},
|
|
{Title: "medium", Labels: []string{"P2"}, UpdatedAt: time.Now()},
|
|
{Title: "none", Labels: nil, UpdatedAt: time.Now()},
|
|
}
|
|
|
|
// Apply the same sort as GetTriageQueue.
|
|
sortTriageQueue(queue)
|
|
|
|
expected := []string{"high", "medium", "low", "none"}
|
|
for i, item := range queue {
|
|
if item.Title != expected[i] {
|
|
t.Errorf("queue[%d].Title = %q, want %q", i, item.Title, expected[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCloseIssue(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPatch {
|
|
t.Errorf("expected PATCH, got %s", r.Method)
|
|
}
|
|
if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
if r.Header.Get("Authorization") != "token test-token" {
|
|
t.Error("missing or wrong Authorization header")
|
|
}
|
|
|
|
var body map[string]string
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
if body["state"] != "closed" {
|
|
t.Errorf("expected state=closed, got %q", body["state"])
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode(map[string]string{"state": "closed"})
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("issues-org1", "should-be-invalidated")
|
|
|
|
err := c.CloseIssue(context.Background(), "test-token", "owner1", "repo1", 42)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Verify cache was invalidated.
|
|
_, ok := c.getFromCache("issues-org1")
|
|
if ok {
|
|
t.Error("expected cache to be invalidated after CloseIssue")
|
|
}
|
|
}
|
|
|
|
func TestSetIssueState(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
state string
|
|
}{
|
|
{"close", "closed"},
|
|
{"reopen", "open"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPatch {
|
|
t.Errorf("expected PATCH, got %s", r.Method)
|
|
}
|
|
if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
|
|
var body map[string]string
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
if body["state"] != tt.state {
|
|
t.Errorf("expected state=%q, got %q", tt.state, body["state"])
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode(map[string]string{"state": tt.state})
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("issues-org1", "should-be-invalidated")
|
|
|
|
err := c.SetIssueState(context.Background(), "test-token", "owner1", "repo1", 42, tt.state)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
_, ok := c.getFromCache("issues-org1")
|
|
if ok {
|
|
t.Error("expected cache to be invalidated after SetIssueState")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAddComment(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
comment := map[string]interface{}{
|
|
"id": 1,
|
|
"body": "test",
|
|
"user": map[string]string{"login": "testuser"},
|
|
"created_at": "2026-03-26T12:00:00Z",
|
|
}
|
|
json.NewEncoder(w).Encode(comment)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
comment, err := c.AddComment(context.Background(), "test-token", "owner1", "repo1", 42, "test")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if comment.Body != "test" {
|
|
t.Errorf("comment.Body = %q, want %q", comment.Body, "test")
|
|
}
|
|
}
|
|
|
|
func TestPostComment(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
t.Errorf("expected POST, got %s", r.Method)
|
|
}
|
|
if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42/comments" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
|
|
var body map[string]string
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
if body["body"] != "test comment" {
|
|
t.Errorf("expected body='test comment', got %q", body["body"])
|
|
}
|
|
|
|
comment := map[string]interface{}{
|
|
"id": 1,
|
|
"body": body["body"],
|
|
"user": map[string]string{"login": "testuser"},
|
|
"created_at": "2026-03-26T12:00:00Z",
|
|
}
|
|
json.NewEncoder(w).Encode(comment)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("issues-org1", "should-be-invalidated")
|
|
|
|
comment, err := c.PostComment(context.Background(), "test-token", "owner1", "repo1", 42, "test comment")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if comment.Body != "test comment" {
|
|
t.Errorf("comment.Body = %q, want %q", comment.Body, "test comment")
|
|
}
|
|
if comment.User != "testuser" {
|
|
t.Errorf("comment.User = %q, want %q", comment.User, "testuser")
|
|
}
|
|
if comment.ID != 1 {
|
|
t.Errorf("comment.ID = %d, want 1", comment.ID)
|
|
}
|
|
|
|
// Verify cache was invalidated.
|
|
_, ok := c.getFromCache("issues-org1")
|
|
if ok {
|
|
t.Error("expected cache to be invalidated after PostComment")
|
|
}
|
|
}
|
|
|
|
// sortTriageQueue is a test helper applying the same sort as GetTriageQueue.
|
|
func sortTriageQueue(queue []TriageItem) {
|
|
for i := 0; i < len(queue); i++ {
|
|
for j := i + 1; j < len(queue); j++ {
|
|
pi := priorityScore(queue[i].Labels)
|
|
pj := priorityScore(queue[j].Labels)
|
|
if pj < pi || (pj == pi && queue[j].UpdatedAt.After(queue[i].UpdatedAt)) {
|
|
queue[i], queue[j] = queue[j], queue[i]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Issue #122: Tests for ListOrgsAndRepos and CreateIssue ---
|
|
|
|
func TestListOrgsAndRepos(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/api/v1/user/orgs":
|
|
orgs := []Org{
|
|
{Name: "org1", FullName: "Organization 1"},
|
|
{Name: "org2", FullName: "Organization 2"},
|
|
}
|
|
json.NewEncoder(w).Encode(orgs)
|
|
case "/api/v1/orgs/org1/repos":
|
|
repos := []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a"},
|
|
{ID: 2, Name: "repo-b", FullName: "org1/repo-b"},
|
|
}
|
|
json.NewEncoder(w).Encode(repos)
|
|
case "/api/v1/orgs/org2/repos":
|
|
repos := []Repo{
|
|
{ID: 3, Name: "repo-c", FullName: "org2/repo-c"},
|
|
}
|
|
json.NewEncoder(w).Encode(repos)
|
|
default:
|
|
t.Errorf("unexpected request path: %s", r.URL.Path)
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
result, err := c.ListOrgsAndRepos(context.Background(), "test-token")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(result) != 2 {
|
|
t.Fatalf("got %d orgs, want 2", len(result))
|
|
}
|
|
if len(result["org1"]) != 2 {
|
|
t.Errorf("org1 has %d repos, want 2", len(result["org1"]))
|
|
}
|
|
if len(result["org2"]) != 1 {
|
|
t.Errorf("org2 has %d repos, want 1", len(result["org2"]))
|
|
}
|
|
if result["org1"][0].Name != "repo-a" {
|
|
t.Errorf("org1 repos[0].Name = %q, want %q", result["org1"][0].Name, "repo-a")
|
|
}
|
|
if result["org2"][0].Name != "repo-c" {
|
|
t.Errorf("org2 repos[0].Name = %q, want %q", result["org2"][0].Name, "repo-c")
|
|
}
|
|
}
|
|
|
|
func TestListOrgsAndRepos_Cached(t *testing.T) {
|
|
orgCallCount := 0
|
|
repoCallCount := 0
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/api/v1/user/orgs":
|
|
orgCallCount++
|
|
json.NewEncoder(w).Encode([]Org{{Name: "org1"}})
|
|
case "/api/v1/orgs/org1/repos":
|
|
repoCallCount++
|
|
json.NewEncoder(w).Encode([]Repo{{ID: 1, Name: "repo1", FullName: "org1/repo1"}})
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
|
|
// First call populates cache.
|
|
_, err := c.ListOrgsAndRepos(context.Background(), "test-token")
|
|
if err != nil {
|
|
t.Fatalf("first call: %v", err)
|
|
}
|
|
|
|
// Second call should use cached orgs and repos (ListOrgs and ListOrgRepos both cache).
|
|
_, err = c.ListOrgsAndRepos(context.Background(), "test-token")
|
|
if err != nil {
|
|
t.Fatalf("second call: %v", err)
|
|
}
|
|
|
|
if orgCallCount != 1 {
|
|
t.Errorf("org endpoint called %d times, want 1 (cached)", orgCallCount)
|
|
}
|
|
if repoCallCount != 1 {
|
|
t.Errorf("repo endpoint called %d times, want 1 (cached)", repoCallCount)
|
|
}
|
|
}
|
|
|
|
func TestCreateIssue(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
t.Errorf("expected POST, got %s", r.Method)
|
|
}
|
|
if r.URL.Path != "/api/v1/repos/owner1/repo1/issues" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
if r.Header.Get("Authorization") != "token test-token" {
|
|
t.Error("missing or wrong Authorization header")
|
|
}
|
|
|
|
var body map[string]interface{}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
if body["title"] != "Test Issue" {
|
|
t.Errorf("expected title='Test Issue', got %q", body["title"])
|
|
}
|
|
if body["body"] != "Issue body here" {
|
|
t.Errorf("expected body='Issue body here', got %q", body["body"])
|
|
}
|
|
|
|
issue := map[string]interface{}{
|
|
"id": 1,
|
|
"number": 42,
|
|
"title": body["title"],
|
|
"body": body["body"],
|
|
"state": "open",
|
|
"created_at": "2026-03-28T00:00:00Z",
|
|
"updated_at": "2026-03-28T00:00:00Z",
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
json.NewEncoder(w).Encode(issue)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
// Pre-populate cache to verify invalidation.
|
|
c.setCache("issues-org1", "should-be-invalidated")
|
|
|
|
issue, err := c.CreateIssue(context.Background(), "test-token", "owner1", "repo1", "Test Issue", "Issue body here", nil)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if issue.Title != "Test Issue" {
|
|
t.Errorf("issue.Title = %q, want %q", issue.Title, "Test Issue")
|
|
}
|
|
if issue.Number != 42 {
|
|
t.Errorf("issue.Number = %d, want 42", issue.Number)
|
|
}
|
|
if issue.RepoOwner != "owner1" {
|
|
t.Errorf("issue.RepoOwner = %q, want %q", issue.RepoOwner, "owner1")
|
|
}
|
|
if issue.RepoName != "repo1" {
|
|
t.Errorf("issue.RepoName = %q, want %q", issue.RepoName, "repo1")
|
|
}
|
|
|
|
// Verify cache was invalidated.
|
|
_, ok := c.getFromCache("issues-org1")
|
|
if ok {
|
|
t.Error("expected cache to be invalidated after CreateIssue")
|
|
}
|
|
}
|
|
|
|
func TestCreateIssue_WithLabels(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var body map[string]interface{}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
|
|
labels, ok := body["labels"]
|
|
if !ok {
|
|
t.Error("expected labels in request body")
|
|
}
|
|
labelSlice, ok := labels.([]interface{})
|
|
if !ok || len(labelSlice) != 2 {
|
|
t.Errorf("expected 2 labels, got %v", labels)
|
|
}
|
|
|
|
issue := map[string]interface{}{
|
|
"id": 2,
|
|
"number": 43,
|
|
"title": body["title"],
|
|
"body": body["body"],
|
|
"state": "open",
|
|
"created_at": "2026-03-28T00:00:00Z",
|
|
"updated_at": "2026-03-28T00:00:00Z",
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
json.NewEncoder(w).Encode(issue)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
issue, err := c.CreateIssue(context.Background(), "test-token", "owner1", "repo1", "Labeled Issue", "body", []int64{10, 20})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if issue.Number != 43 {
|
|
t.Errorf("issue.Number = %d, want 43", issue.Number)
|
|
}
|
|
}
|
|
|
|
// --- Issue #121: Tests for ListAllIssues and ListAllPullRequests ---
|
|
|
|
// newFanOutServer creates a mock HTTP server that serves orgs, repos, issues, and PRs
|
|
// for testing the fan-out aggregation functions.
|
|
func newFanOutServer(t *testing.T) *httptest.Server {
|
|
t.Helper()
|
|
|
|
now := time.Date(2026, 3, 28, 12, 0, 0, 0, time.UTC)
|
|
|
|
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.URL.Path == "/api/v1/orgs/org1/repos":
|
|
repos := []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
}
|
|
json.NewEncoder(w).Encode(repos)
|
|
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
|
|
issues := []Issue{
|
|
{ID: 1, Number: 1, Title: "Issue A1", State: "open", UpdatedAt: now.Add(-1 * time.Hour)},
|
|
{ID: 2, Number: 2, Title: "Issue A2", State: "open", UpdatedAt: now.Add(-3 * time.Hour)},
|
|
}
|
|
json.NewEncoder(w).Encode(issues)
|
|
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-b/issues":
|
|
issues := []Issue{
|
|
{ID: 3, Number: 1, Title: "Issue B1", State: "open", UpdatedAt: now.Add(-2 * time.Hour)},
|
|
}
|
|
json.NewEncoder(w).Encode(issues)
|
|
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/pulls":
|
|
prs := []PullRequest{
|
|
{ID: 10, Number: 5, Title: "PR A1", State: "open", UpdatedAt: now.Add(-30 * time.Minute)},
|
|
}
|
|
json.NewEncoder(w).Encode(prs)
|
|
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-b/pulls":
|
|
prs := []PullRequest{
|
|
{ID: 11, Number: 6, Title: "PR B1", State: "open", UpdatedAt: now.Add(-10 * time.Minute)},
|
|
{ID: 12, Number: 7, Title: "PR B2", State: "open", UpdatedAt: now.Add(-1 * time.Hour)},
|
|
}
|
|
json.NewEncoder(w).Encode(prs)
|
|
|
|
default:
|
|
t.Errorf("unexpected request path: %s", r.URL.Path)
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
}
|
|
|
|
func TestListAllIssues_Sorting(t *testing.T) {
|
|
server := newFanOutServer(t)
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
// Pre-populate org repos cache to avoid needing the /user/orgs endpoint.
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
result, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(result.Issues) != 3 {
|
|
t.Fatalf("got %d issues, want 3", len(result.Issues))
|
|
}
|
|
|
|
// Should be sorted by UpdatedAt descending (newest first).
|
|
// Issue A1 (-1h), Issue B1 (-2h), Issue A2 (-3h).
|
|
expected := []string{"Issue A1", "Issue B1", "Issue A2"}
|
|
for i, title := range expected {
|
|
if result.Issues[i].Title != title {
|
|
t.Errorf("issues[%d].Title = %q, want %q", i, result.Issues[i].Title, title)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListAllIssues_StateFilter(t *testing.T) {
|
|
stateReceived := ""
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.URL.Path == "/api/v1/orgs/org1/repos":
|
|
repos := []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
}
|
|
json.NewEncoder(w).Encode(repos)
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
|
|
stateReceived = r.URL.Query().Get("state")
|
|
json.NewEncoder(w).Encode([]Issue{})
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
_, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "closed", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if stateReceived != "closed" {
|
|
t.Errorf("state query param = %q, want %q", stateReceived, "closed")
|
|
}
|
|
}
|
|
|
|
func TestListAllIssues_DefaultState(t *testing.T) {
|
|
stateReceived := ""
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.URL.Path == "/api/v1/orgs/org1/repos":
|
|
json.NewEncoder(w).Encode([]Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
|
|
stateReceived = r.URL.Query().Get("state")
|
|
json.NewEncoder(w).Encode([]Issue{})
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
_, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if stateReceived != "open" {
|
|
t.Errorf("default state = %q, want %q", stateReceived, "open")
|
|
}
|
|
}
|
|
|
|
func TestListAllIssues_RepoFilter(t *testing.T) {
|
|
server := newFanOutServer(t)
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
result, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "repo-a")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Only issues from repo-a should be returned.
|
|
if len(result.Issues) != 2 {
|
|
t.Fatalf("got %d issues, want 2 (only from repo-a)", len(result.Issues))
|
|
}
|
|
for _, issue := range result.Issues {
|
|
if issue.RepoName != "repo-a" {
|
|
t.Errorf("issue %q has RepoName=%q, want repo-a", issue.Title, issue.RepoName)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListAllIssues_Pagination(t *testing.T) {
|
|
now := time.Date(2026, 3, 28, 12, 0, 0, 0, time.UTC)
|
|
|
|
// Create enough issues to test pagination (PageSize = 20).
|
|
var issues []Issue
|
|
for i := 0; i < 25; i++ {
|
|
issues = append(issues, Issue{
|
|
ID: int64(i + 1),
|
|
Number: int64(i + 1),
|
|
Title: fmt.Sprintf("Issue %d", i+1),
|
|
State: "open",
|
|
UpdatedAt: now.Add(time.Duration(-i) * time.Hour),
|
|
})
|
|
}
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.URL.Path == "/api/v1/orgs/org1/repos":
|
|
json.NewEncoder(w).Encode([]Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
|
|
json.NewEncoder(w).Encode(issues)
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
// Page 1: should have 20 items with HasMore=true.
|
|
page1, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("page 1: %v", err)
|
|
}
|
|
if len(page1.Issues) != 20 {
|
|
t.Errorf("page 1: got %d issues, want 20", len(page1.Issues))
|
|
}
|
|
if !page1.HasMore {
|
|
t.Error("page 1: HasMore should be true")
|
|
}
|
|
|
|
// Page 2: should have 5 items with HasMore=false.
|
|
page2, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 2, "", "")
|
|
if err != nil {
|
|
t.Fatalf("page 2: %v", err)
|
|
}
|
|
if len(page2.Issues) != 5 {
|
|
t.Errorf("page 2: got %d issues, want 5", len(page2.Issues))
|
|
}
|
|
if page2.HasMore {
|
|
t.Error("page 2: HasMore should be false")
|
|
}
|
|
}
|
|
|
|
func TestListAllPullRequests_Sorting(t *testing.T) {
|
|
server := newFanOutServer(t)
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
result, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(result.Pulls) != 3 {
|
|
t.Fatalf("got %d PRs, want 3", len(result.Pulls))
|
|
}
|
|
|
|
// Should be sorted by UpdatedAt descending.
|
|
// PR B1 (-10m), PR A1 (-30m), PR B2 (-1h).
|
|
expected := []string{"PR B1", "PR A1", "PR B2"}
|
|
for i, title := range expected {
|
|
if result.Pulls[i].Title != title {
|
|
t.Errorf("pulls[%d].Title = %q, want %q", i, result.Pulls[i].Title, title)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListAllPullRequests_StateFilter(t *testing.T) {
|
|
stateReceived := ""
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.URL.Path == "/api/v1/orgs/org1/repos":
|
|
json.NewEncoder(w).Encode([]Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/pulls":
|
|
stateReceived = r.URL.Query().Get("state")
|
|
json.NewEncoder(w).Encode([]PullRequest{})
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
_, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "closed", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if stateReceived != "closed" {
|
|
t.Errorf("state query param = %q, want %q", stateReceived, "closed")
|
|
}
|
|
}
|
|
|
|
// --- Issue #127: Tests for ApplyLabel and SubmitReview ---
|
|
|
|
func TestApplyLabel(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
t.Errorf("expected POST, got %s", r.Method)
|
|
}
|
|
if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42/labels" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
if r.Header.Get("Authorization") != "token test-token" {
|
|
t.Error("missing or wrong Authorization header")
|
|
}
|
|
|
|
var body map[string]interface{}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
labels, ok := body["labels"].([]interface{})
|
|
if !ok {
|
|
t.Fatalf("expected labels array, got %T", body["labels"])
|
|
}
|
|
if len(labels) != 2 {
|
|
t.Errorf("expected 2 label IDs, got %d", len(labels))
|
|
}
|
|
// Verify the label IDs are correct (JSON numbers are float64).
|
|
if labels[0].(float64) != 10 || labels[1].(float64) != 20 {
|
|
t.Errorf("expected label IDs [10, 20], got %v", labels)
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode([]map[string]interface{}{
|
|
{"id": 10, "name": "bug"},
|
|
{"id": 20, "name": "enhancement"},
|
|
})
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("issues-org1", "should-be-invalidated")
|
|
|
|
err := c.ApplyLabel(context.Background(), "test-token", "owner1", "repo1", 42, []int64{10, 20})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Verify cache was invalidated.
|
|
_, ok := c.getFromCache("issues-org1")
|
|
if ok {
|
|
t.Error("expected cache to be invalidated after ApplyLabel")
|
|
}
|
|
}
|
|
|
|
func TestApplyLabel_Error(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
fmt.Fprintln(w, `{"message":"issue not found"}`)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
err := c.ApplyLabel(context.Background(), "test-token", "owner1", "repo1", 999, []int64{10})
|
|
if err == nil {
|
|
t.Fatal("expected error for 404 response, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "404") {
|
|
t.Errorf("error should contain status code 404, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSubmitReview(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
t.Errorf("expected POST, got %s", r.Method)
|
|
}
|
|
if r.URL.Path != "/api/v1/repos/owner1/repo1/pulls/7/reviews" {
|
|
t.Errorf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
if r.Header.Get("Authorization") != "token test-token" {
|
|
t.Error("missing or wrong Authorization header")
|
|
}
|
|
|
|
var body map[string]string
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("failed to decode body: %v", err)
|
|
}
|
|
if body["event"] != "APPROVED" {
|
|
t.Errorf("expected event=APPROVED, got %q", body["event"])
|
|
}
|
|
if body["body"] != "Looks good!" {
|
|
t.Errorf("expected body='Looks good!', got %q", body["body"])
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"id": 1,
|
|
"state": "APPROVED",
|
|
"body": body["body"],
|
|
})
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("pulls-org1", "should-be-invalidated")
|
|
|
|
err := c.SubmitReview(context.Background(), "test-token", "owner1", "repo1", 7, "APPROVED", "Looks good!")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Verify cache was invalidated.
|
|
_, ok := c.getFromCache("pulls-org1")
|
|
if ok {
|
|
t.Error("expected cache to be invalidated after SubmitReview")
|
|
}
|
|
}
|
|
|
|
func TestSubmitReview_Error(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusUnprocessableEntity)
|
|
fmt.Fprintln(w, `{"message":"validation failed"}`)
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
err := c.SubmitReview(context.Background(), "test-token", "owner1", "repo1", 7, "INVALID", "")
|
|
if err == nil {
|
|
t.Fatal("expected error for 422 response, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "422") {
|
|
t.Errorf("error should contain status code 422, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestListAllPullRequests_Pagination(t *testing.T) {
|
|
now := time.Date(2026, 3, 28, 12, 0, 0, 0, time.UTC)
|
|
|
|
var prs []PullRequest
|
|
for i := 0; i < 25; i++ {
|
|
prs = append(prs, PullRequest{
|
|
ID: int64(i + 1),
|
|
Number: int64(i + 1),
|
|
Title: fmt.Sprintf("PR %d", i+1),
|
|
State: "open",
|
|
UpdatedAt: now.Add(time.Duration(-i) * time.Hour),
|
|
})
|
|
}
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.URL.Path == "/api/v1/orgs/org1/repos":
|
|
json.NewEncoder(w).Encode([]Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
case r.URL.Path == "/api/v1/repos/org1/repo-a/pulls":
|
|
json.NewEncoder(w).Encode(prs)
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
c := NewClient(server.URL)
|
|
c.setCache("repos-org1", []Repo{
|
|
{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
|
|
Login string `json:"login"`
|
|
}{Login: "org1"}},
|
|
})
|
|
|
|
page1, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
|
|
if err != nil {
|
|
t.Fatalf("page 1: %v", err)
|
|
}
|
|
if len(page1.Pulls) != 20 {
|
|
t.Errorf("page 1: got %d PRs, want 20", len(page1.Pulls))
|
|
}
|
|
if !page1.HasMore {
|
|
t.Error("page 1: HasMore should be true")
|
|
}
|
|
|
|
page2, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "open", 2, "", "")
|
|
if err != nil {
|
|
t.Fatalf("page 2: %v", err)
|
|
}
|
|
if len(page2.Pulls) != 5 {
|
|
t.Errorf("page 2: got %d PRs, want 5", len(page2.Pulls))
|
|
}
|
|
if page2.HasMore {
|
|
t.Error("page 2: HasMore should be false")
|
|
}
|
|
}
|