Merge pull request #35 from git-pkgs/add-list-forks

Add list forks support

Author: andrew

bitbucket/bitbucket.go

@@ -311,6 +311,36 @@ func (s *bitbucketRepoService) Fork(ctx context.Context, owner, repo string, opt
 	return &result, nil
 }
 
+func (s *bitbucketRepoService) ListForks(ctx context.Context, owner, repo string, opts forge.ListForksOpts) ([]forge.Repository, error) {
+	perPage := opts.PerPage
+	if perPage <= 0 {
+		perPage = 100
+	}
+
+	var all []forge.Repository
+	url := fmt.Sprintf("%s/repositories/%s/%s/forks?pagelen=%d", bitbucketAPI, owner, repo, perPage)
+
+	for url != "" {
+		var page bbReposResponse
+		if err := s.getJSON(ctx, url, &page); err != nil {
+			return nil, err
+		}
+		for _, bb := range page.Values {
+			all = append(all, convertBitbucketRepo(bb))
+		}
+		if opts.Limit > 0 && len(all) >= opts.Limit {
+			break
+		}
+		url = page.Next
+	}
+
+	if opts.Limit > 0 && len(all) > opts.Limit {
+		all = all[:opts.Limit]
+	}
+
+	return all, nil
+}
+
 func (s *bitbucketRepoService) ListTags(ctx context.Context, owner, repo string) ([]forge.Tag, error) {
 	var allTags []forge.Tag
 	url := fmt.Sprintf("%s/repositories/%s/%s/refs/tags?pagelen=100", bitbucketAPI, owner, repo)

bitbucket/forks_test.go

@@ -0,0 +1,52 @@
+package bitbucket
+
+import (
+	"context"
+	"encoding/json"
+	forge "github.com/git-pkgs/forge"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestBitbucketListForks(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /2.0/repositories/atlassian/stash/forks", func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"values": []map[string]any{
+				{
+					"full_name":  "alice/stash",
+					"name":       "stash",
+					"language":   "Java",
+					"created_on": "2024-01-01T00:00:00Z",
+					"updated_on": "2024-06-01T00:00:00Z",
+					"links": map[string]any{
+						"html":  map[string]string{"href": "https://bitbucket.org/alice/stash"},
+						"clone": []map[string]string{{"href": "https://bitbucket.org/alice/stash.git", "name": "https"}},
+					},
+					"owner": map[string]any{"nickname": "alice"},
+				},
+			},
+			"next": "",
+		})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	oldAPI := bitbucketAPI
+	setBitbucketAPI(srv.URL + "/2.0")
+	defer func() { bitbucketAPI = oldAPI }()
+
+	f := New("token", nil)
+	forks, err := f.Repos().ListForks(context.Background(), "atlassian", "stash", forge.ListForksOpts{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(forks) != 1 {
+		t.Fatalf("expected 1 fork, got %d", len(forks))
+	}
+	if forks[0].FullName != "alice/stash" {
+		t.Errorf("expected full_name alice/stash, got %s", forks[0].FullName)
+	}
+}

forges_test.go

@@ -540,6 +540,12 @@ func (m *mockRepoService) Fork(_ context.Context, owner, repo string, opts ForkR
 	return m.repo, nil
 }
 
+func (m *mockRepoService) ListForks(_ context.Context, owner, repo string, opts ListForksOpts) ([]Repository, error) {
+	m.lastOwner = owner
+	m.lastRepo = repo
+	return m.repos, nil
+}
+
 func (m *mockRepoService) ListTags(_ context.Context, owner, repo string) ([]Tag, error) {
 	m.lastOwner = owner
 	m.lastRepo = repo

gitea/forks_test.go

@@ -0,0 +1,76 @@
+package gitea
+
+import (
+	"context"
+	"encoding/json"
+	forge "github.com/git-pkgs/forge"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func TestGiteaListForks(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/version", giteaVersionHandler)
+	mux.HandleFunc("GET /api/v1/repos/testorg/testrepo/forks", func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode([]map[string]any{
+			{
+				"full_name":      "alice/testrepo",
+				"name":           "testrepo",
+				"html_url":       "https://codeberg.org/alice/testrepo",
+				"default_branch": "main",
+				"fork":           true,
+				"archived":       false,
+				"private":        false,
+				"owner":          map[string]any{"login": "alice"},
+				"created_at":     time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).Format(time.RFC3339),
+				"updated_at":     time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC).Format(time.RFC3339),
+			},
+			{
+				"full_name":      "bob/testrepo",
+				"name":           "testrepo",
+				"html_url":       "https://codeberg.org/bob/testrepo",
+				"default_branch": "main",
+				"fork":           true,
+				"archived":       false,
+				"private":        false,
+				"owner":          map[string]any{"login": "bob"},
+				"created_at":     time.Date(2024, 2, 1, 0, 0, 0, 0, time.UTC).Format(time.RFC3339),
+				"updated_at":     time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC).Format(time.RFC3339),
+			},
+		})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	f := New(srv.URL, "test-token", nil)
+	forks, err := f.Repos().ListForks(context.Background(), "testorg", "testrepo", forge.ListForksOpts{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(forks) != 2 {
+		t.Fatalf("expected 2 forks, got %d", len(forks))
+	}
+	assertEqual(t, "forks[0].FullName", "alice/testrepo", forks[0].FullName)
+	assertEqual(t, "forks[1].FullName", "bob/testrepo", forks[1].FullName)
+}
+
+func TestGiteaListForksNotFound(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/version", giteaVersionHandler)
+	mux.HandleFunc("GET /api/v1/repos/testorg/nope/forks", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		_ = json.NewEncoder(w).Encode(map[string]string{"message": "Not Found"})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	f := New(srv.URL, "test-token", nil)
+	_, err := f.Repos().ListForks(context.Background(), "testorg", "nope", forge.ListForksOpts{})
+	if err != forge.ErrNotFound {
+		t.Fatalf("expected forge.ErrNotFound, got %v", err)
+	}
+}

gitea/gitea.go

@@ -293,6 +293,43 @@ func (s *giteaRepoService) Fork(ctx context.Context, owner, repo string, opts fo
 	return &result, nil
 }
 
+func (s *giteaRepoService) ListForks(ctx context.Context, owner, repo string, opts forge.ListForksOpts) ([]forge.Repository, error) {
+	perPage := opts.PerPage
+	if perPage <= 0 {
+		perPage = 50
+	}
+	page := opts.Page
+	if page <= 0 {
+		page = 1
+	}
+
+	var all []forge.Repository
+	for {
+		forks, resp, err := s.client.ListForks(owner, repo, gitea.ListForksOptions{
+			ListOptions: gitea.ListOptions{Page: page, PageSize: perPage},
+		})
+		if err != nil {
+			if resp != nil && resp.StatusCode == http.StatusNotFound {
+				return nil, forge.ErrNotFound
+			}
+			return nil, err
+		}
+		for _, r := range forks {
+			all = append(all, convertGiteaRepo(r))
+		}
+		if len(forks) < perPage || (opts.Limit > 0 && len(all) >= opts.Limit) {
+			break
+		}
+		page++
+	}
+
+	if opts.Limit > 0 && len(all) > opts.Limit {
+		all = all[:opts.Limit]
+	}
+
+	return all, nil
+}
+
 func (s *giteaRepoService) ListTags(ctx context.Context, owner, repo string) ([]forge.Tag, error) {
 	var allTags []forge.Tag
 	page := 1

github/forks_test.go

@@ -0,0 +1,85 @@
+package github
+
+import (
+	"context"
+	"encoding/json"
+	forge "github.com/git-pkgs/forge"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/google/go-github/v82/github"
+)
+
+func TestGitHubListForks(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v3/repos/octocat/hello-world/forks", func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode([]*github.Repository{
+			{FullName: ptr("alice/hello-world"), Name: ptr("hello-world"), Fork: ptrBool(true), Owner: &github.User{Login: ptr("alice")}},
+			{FullName: ptr("bob/hello-world"), Name: ptr("hello-world"), Fork: ptrBool(true), Owner: &github.User{Login: ptr("bob")}},
+		})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	c := github.NewClient(nil)
+	c, _ = c.WithEnterpriseURLs(srv.URL+"/api/v3", srv.URL+"/api/v3")
+	s := &gitHubRepoService{client: c}
+
+	forks, err := s.ListForks(context.Background(), "octocat", "hello-world", forge.ListForksOpts{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(forks) != 2 {
+		t.Fatalf("expected 2 forks, got %d", len(forks))
+	}
+	assertEqual(t, "forks[0].FullName", "alice/hello-world", forks[0].FullName)
+	assertEqual(t, "forks[1].FullName", "bob/hello-world", forks[1].FullName)
+}
+
+func TestGitHubListForksNotFound(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v3/repos/octocat/nope/forks", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		_ = json.NewEncoder(w).Encode(map[string]string{"message": "Not Found"})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	c := github.NewClient(nil)
+	c, _ = c.WithEnterpriseURLs(srv.URL+"/api/v3", srv.URL+"/api/v3")
+	s := &gitHubRepoService{client: c}
+
+	_, err := s.ListForks(context.Background(), "octocat", "nope", forge.ListForksOpts{})
+	if err != forge.ErrNotFound {
+		t.Fatalf("expected forge.ErrNotFound, got %v", err)
+	}
+}
+
+func TestGitHubListForksWithLimit(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v3/repos/octocat/hello-world/forks", func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode([]*github.Repository{
+			{FullName: ptr("alice/hello-world"), Name: ptr("hello-world"), Fork: ptrBool(true), Owner: &github.User{Login: ptr("alice")}},
+			{FullName: ptr("bob/hello-world"), Name: ptr("hello-world"), Fork: ptrBool(true), Owner: &github.User{Login: ptr("bob")}},
+			{FullName: ptr("carol/hello-world"), Name: ptr("hello-world"), Fork: ptrBool(true), Owner: &github.User{Login: ptr("carol")}},
+		})
+	})
+
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	c := github.NewClient(nil)
+	c, _ = c.WithEnterpriseURLs(srv.URL+"/api/v3", srv.URL+"/api/v3")
+	s := &gitHubRepoService{client: c}
+
+	forks, err := s.ListForks(context.Background(), "octocat", "hello-world", forge.ListForksOpts{Limit: 2})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(forks) != 2 {
+		t.Fatalf("expected 2 forks (limit), got %d", len(forks))
+	}
+}

github/github.go

@@ -302,6 +302,46 @@ func (s *gitHubRepoService) Fork(ctx context.Context, owner, repo string, opts f
 	return &result, nil
 }
 
+func (s *gitHubRepoService) ListForks(ctx context.Context, owner, repo string, opts forge.ListForksOpts) ([]forge.Repository, error) {
+	perPage := opts.PerPage
+	if perPage <= 0 {
+		perPage = 100
+	}
+	page := opts.Page
+	if page <= 0 {
+		page = 1
+	}
+
+	ghOpts := &github.RepositoryListForksOptions{
+		Sort:        opts.Sort,
+		ListOptions: github.ListOptions{PerPage: perPage, Page: page},
+	}
+
+	var all []forge.Repository
+	for {
+		forks, resp, err := s.client.Repositories.ListForks(ctx, owner, repo, ghOpts)
+		if err != nil {
+			if resp != nil && resp.StatusCode == http.StatusNotFound {
+				return nil, forge.ErrNotFound
+			}
+			return nil, err
+		}
+		for _, r := range forks {
+			all = append(all, convertGitHubRepo(r))
+		}
+		if resp.NextPage == 0 || (opts.Limit > 0 && len(all) >= opts.Limit) {
+			break
+		}
+		ghOpts.Page = resp.NextPage
+	}
+
+	if opts.Limit > 0 && len(all) > opts.Limit {
+		all = all[:opts.Limit]
+	}
+
+	return all, nil
+}
+
 func (s *gitHubRepoService) ListTags(ctx context.Context, owner, repo string) ([]forge.Tag, error) {
 	var allTags []forge.Tag
 	opts := &github.ListOptions{PerPage: 100}