Merge pull request #40 from git-pkgs/add-commit-statuses

Add commit status support

Author: andrew

bitbucket/commit_statuses.go

@@ -0,0 +1,21 @@
+package bitbucket
+
+import (
+	"context"
+
+	forge "github.com/git-pkgs/forge"
+)
+
+type bitbucketCommitStatusService struct{}
+
+func (f *bitbucketForge) CommitStatuses() forge.CommitStatusService {
+	return &bitbucketCommitStatusService{}
+}
+
+func (s *bitbucketCommitStatusService) List(_ context.Context, _, _, _ string) ([]forge.CommitStatus, error) {
+	return nil, forge.ErrNotSupported
+}
+
+func (s *bitbucketCommitStatusService) Set(_ context.Context, _, _, _ string, _ forge.SetCommitStatusOpts) (*forge.CommitStatus, error) {
+	return nil, forge.ErrNotSupported
+}

bitbucket/commit_statuses_test.go

@@ -0,0 +1,23 @@
+package bitbucket
+
+import (
+	"context"
+	forge "github.com/git-pkgs/forge"
+	"testing"
+)
+
+func TestBitbucketListCommitStatusesNotSupported(t *testing.T) {
+	s := New("", nil).CommitStatuses()
+	_, err := s.List(context.Background(), "owner", "repo", "abc123")
+	if err != forge.ErrNotSupported {
+		t.Errorf("List: expected forge.ErrNotSupported, got %v", err)
+	}
+}
+
+func TestBitbucketSetCommitStatusNotSupported(t *testing.T) {
+	s := New("", nil).CommitStatuses()
+	_, err := s.Set(context.Background(), "owner", "repo", "abc123", forge.SetCommitStatusOpts{})
+	if err != forge.ErrNotSupported {
+		t.Errorf("Set: expected forge.ErrNotSupported, got %v", err)
+	}
+}

forge.go

@@ -47,6 +47,7 @@ type Forge interface {
 	Reviews() ReviewService
 	Files() FileService
 	Collaborators() CollaboratorService
+	CommitStatuses() CommitStatusService
 	GetRateLimit(ctx context.Context) (*RateLimit, error)
 }
 

forges_test.go

@@ -485,6 +485,10 @@ func (m *mockForge) Collaborators() CollaboratorService {
 	return &mockCollaboratorService{}
 }
 
+func (m *mockForge) CommitStatuses() CommitStatusService {
+	return &mockCommitStatusService{}
+}
+
 func (m *mockForge) GetRateLimit(_ context.Context) (*RateLimit, error) {
 	return nil, ErrNotSupported
 }
@@ -513,6 +517,16 @@ func (m *mockCollaboratorService) Remove(_ context.Context, _, _, _ string) erro
 	return nil
 }
 
+type mockCommitStatusService struct{}
+
+func (m *mockCommitStatusService) List(_ context.Context, _, _, _ string) ([]CommitStatus, error) {
+	return nil, nil
+}
+
+func (m *mockCommitStatusService) Set(_ context.Context, _, _, _ string, _ SetCommitStatusOpts) (*CommitStatus, error) {
+	return nil, nil
+}
+
 type mockRepoService struct {
 	repo      *Repository
 	repos     []Repository

gitea/commit_statuses.go

@@ -0,0 +1,78 @@
+package gitea
+
+import (
+	"context"
+	forge "github.com/git-pkgs/forge"
+	"net/http"
+
+	"code.gitea.io/sdk/gitea"
+)
+
+type giteaCommitStatusService struct {
+	client *gitea.Client
+}
+
+func (f *giteaForge) CommitStatuses() forge.CommitStatusService {
+	return &giteaCommitStatusService{client: f.client}
+}
+
+func (s *giteaCommitStatusService) List(ctx context.Context, owner, repo, sha string) ([]forge.CommitStatus, error) {
+	var all []forge.CommitStatus
+	page := 1
+	for {
+		statuses, resp, err := s.client.ListStatuses(owner, repo, sha, gitea.ListStatusesOption{
+			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+		})
+		if err != nil {
+			if resp != nil && resp.StatusCode == http.StatusNotFound {
+				return nil, forge.ErrNotFound
+			}
+			return nil, err
+		}
+		for _, st := range statuses {
+			cs := forge.CommitStatus{
+				State:       string(st.State),
+				Context:     st.Context,
+				Description: st.Description,
+				TargetURL:   st.TargetURL,
+				CreatedAt:   st.Created,
+			}
+			if st.Creator != nil {
+				cs.Creator = st.Creator.UserName
+			}
+			all = append(all, cs)
+		}
+		if len(statuses) < 50 {
+			break
+		}
+		page++
+	}
+	return all, nil
+}
+
+func (s *giteaCommitStatusService) Set(ctx context.Context, owner, repo, sha string, opts forge.SetCommitStatusOpts) (*forge.CommitStatus, error) {
+	result, resp, err := s.client.CreateStatus(owner, repo, sha, gitea.CreateStatusOption{
+		State:       gitea.StatusState(opts.State),
+		TargetURL:   opts.TargetURL,
+		Description: opts.Description,
+		Context:     opts.Context,
+	})
+	if err != nil {
+		if resp != nil && resp.StatusCode == http.StatusNotFound {
+			return nil, forge.ErrNotFound
+		}
+		return nil, err
+	}
+
+	cs := &forge.CommitStatus{
+		State:       string(result.State),
+		Context:     result.Context,
+		Description: result.Description,
+		TargetURL:   result.TargetURL,
+		CreatedAt:   result.Created,
+	}
+	if result.Creator != nil {
+		cs.Creator = result.Creator.UserName
+	}
+	return cs, nil
+}

gitea/commit_statuses_test.go

@@ -0,0 +1,91 @@
+package gitea
+
+import (
+	"context"
+	"encoding/json"
+	forge "github.com/git-pkgs/forge"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestGiteaListCommitStatuses(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/version", giteaVersionHandler)
+	mux.HandleFunc("GET /api/v1/repos/testorg/testrepo/commits/abc123/statuses", func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode([]map[string]any{
+			{
+				"id":          1,
+				"status":      "success",
+				"context":     "ci/tests",
+				"description": "All tests passed",
+				"target_url":  "https://ci.example.com/1",
+				"creator":     map[string]any{"login": "bot"},
+			},
+		})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	f := New(srv.URL, "test-token", nil)
+	statuses, err := f.CommitStatuses().List(context.Background(), "testorg", "testrepo", "abc123")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(statuses) != 1 {
+		t.Fatalf("expected 1 status, got %d", len(statuses))
+	}
+	assertEqual(t, "statuses[0].State", "success", statuses[0].State)
+	assertEqual(t, "statuses[0].Context", "ci/tests", statuses[0].Context)
+	assertEqual(t, "statuses[0].Creator", "bot", statuses[0].Creator)
+}
+
+func TestGiteaSetCommitStatus(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/version", giteaVersionHandler)
+	mux.HandleFunc("POST /api/v1/repos/testorg/testrepo/statuses/abc123", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"id":          1,
+			"status":      "success",
+			"context":     "my-check",
+			"description": "Everything passed",
+			"target_url":  "https://example.com",
+			"creator":     map[string]any{"login": "bot"},
+		})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	f := New(srv.URL, "test-token", nil)
+	status, err := f.CommitStatuses().Set(context.Background(), "testorg", "testrepo", "abc123", forge.SetCommitStatusOpts{
+		State:       "success",
+		Context:     "my-check",
+		Description: "Everything passed",
+		TargetURL:   "https://example.com",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	assertEqual(t, "State", "success", status.State)
+	assertEqual(t, "Context", "my-check", status.Context)
+}
+
+func TestGiteaListCommitStatusesNotFound(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/version", giteaVersionHandler)
+	mux.HandleFunc("GET /api/v1/repos/testorg/nope/commits/abc123/statuses", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	f := New(srv.URL, "test-token", nil)
+	_, err := f.CommitStatuses().List(context.Background(), "testorg", "nope", "abc123")
+	if err != forge.ErrNotFound {
+		t.Fatalf("expected forge.ErrNotFound, got %v", err)
+	}
+}

github/commit_statuses.go

@@ -0,0 +1,82 @@
+package github
+
+import (
+	"context"
+	forge "github.com/git-pkgs/forge"
+	"net/http"
+
+	"github.com/google/go-github/v82/github"
+)
+
+type gitHubCommitStatusService struct {
+	client *github.Client
+}
+
+func (f *gitHubForge) CommitStatuses() forge.CommitStatusService {
+	return &gitHubCommitStatusService{client: f.client}
+}
+
+func (s *gitHubCommitStatusService) List(ctx context.Context, owner, repo, sha string) ([]forge.CommitStatus, error) {
+	var all []forge.CommitStatus
+	opts := &github.ListOptions{PerPage: 100}
+	for {
+		statuses, resp, err := s.client.Repositories.ListStatuses(ctx, owner, repo, sha, opts)
+		if err != nil {
+			if resp != nil && resp.StatusCode == http.StatusNotFound {
+				return nil, forge.ErrNotFound
+			}
+			return nil, err
+		}
+		for _, st := range statuses {
+			cs := forge.CommitStatus{
+				State:       st.GetState(),
+				Context:     st.GetContext(),
+				Description: st.GetDescription(),
+				TargetURL:   st.GetTargetURL(),
+			}
+			if st.Creator != nil {
+				cs.Creator = st.Creator.GetLogin()
+			}
+			if st.CreatedAt != nil {
+				cs.CreatedAt = st.CreatedAt.Time
+			}
+			all = append(all, cs)
+		}
+		if resp.NextPage == 0 {
+			break
+		}
+		opts.Page = resp.NextPage
+	}
+	return all, nil
+}
+
+func (s *gitHubCommitStatusService) Set(ctx context.Context, owner, repo, sha string, opts forge.SetCommitStatusOpts) (*forge.CommitStatus, error) {
+	status := github.RepoStatus{
+		State:       &opts.State,
+		Context:     &opts.Context,
+		Description: &opts.Description,
+		TargetURL:   &opts.TargetURL,
+	}
+
+	result, resp, err := s.client.Repositories.CreateStatus(ctx, owner, repo, sha, status)
+	if err != nil {
+		if resp != nil && resp.StatusCode == http.StatusNotFound {
+			return nil, forge.ErrNotFound
+		}
+		return nil, err
+	}
+
+	cs := &forge.CommitStatus{
+		State:       result.GetState(),
+		Context:     result.GetContext(),
+		Description: result.GetDescription(),
+		TargetURL:   result.GetTargetURL(),
+	}
+	if result.Creator != nil {
+		cs.Creator = result.Creator.GetLogin()
+	}
+	if result.CreatedAt != nil {
+		cs.CreatedAt = result.CreatedAt.Time
+	}
+	return cs, nil
+}