Merge pull request #351 from drone/ritek/PIPE-32185-new

feat: [PIPE-32185]: handle deprecated cross-workspace API endpoints

Author: ritek01

scm/driver/bitbucket/content_test.go

@@ -244,7 +244,7 @@ func TestContentList(t *testing.T) {
 func TestContentListWithUrlInput(t *testing.T) {
 	defer gock.Off()
 
-	mockNextPageUri := "https://api.bitbucket.org/2.0/repositories/atlassian/atlaskit/src/master/packages/activity?pageLen=3&page=RPfL"
+	mockNextPageUri := "https://api.bitbucket.org/2.0/repositories/atlassian/atlaskit/src/master/packages/activity?pagelen=3&page=RPfL"
 
 	gock.New(mockNextPageUri).
 		Reply(200).

scm/driver/bitbucket/org.go

@@ -11,6 +11,10 @@ import (
 	"github.com/drone/go-scm/scm"
 )
 
+const (
+	avatarURLTemplate = "https://bitbucket.org/account/%s/avatar/32/"
+)
+
 type organizationService struct {
 	client *wrapper
 }
@@ -27,33 +31,43 @@ func (s *organizationService) FindMembership(ctx context.Context, name, username
 }
 
 func (s *organizationService) List(ctx context.Context, opts scm.ListOptions) ([]*scm.Organization, *scm.Response, error) {
-	path := fmt.Sprintf("2.0/workspaces?%s", encodeListRoleOptions(opts))
-	out := new(organizationList)
+	path := fmt.Sprintf("2.0/user/workspaces?%s", encodeListRoleOptions(opts))
+	out := new(workspaceAccessList)
 	res, err := s.client.do(ctx, "GET", path, nil, out)
 	copyPagination(out.pagination, res)
-	return convertOrganizationList(out), res, err
+	return convertWorkspaceAccessList(out), res, err
 }
 
-func convertOrganizationList(from *organizationList) []*scm.Organization {
+func convertWorkspaceAccessList(from *workspaceAccessList) []*scm.Organization {
 	to := []*scm.Organization{}
-	for _, v := range from.Values {
-		to = append(to, convertOrganization(v))
+	for _, value := range from.Values {
+		if value.Workspace != nil {
+			to = append(to, convertWorkspace(value.Workspace))
+		}
 	}
 	return to
 }
 
-type organizationList struct {
-	pagination
-	Values []*organization `json:"values"`
-}
-
 type organization struct {
 	Login string `json:"slug"`
 }
 
 func convertOrganization(from *organization) *scm.Organization {
 	return &scm.Organization{
 		Name:   from.Login,
-		Avatar: fmt.Sprintf("https://bitbucket.org/account/%s/avatar/32/", from.Login),
+		Avatar: fmt.Sprintf(avatarURLTemplate, from.Login),
+	}
+}
+
+func convertWorkspace(workspace *workspace) *scm.Organization {
+	avatar := ""
+	if workspace.Links.Avatar.Href != "" {
+		avatar = workspace.Links.Avatar.Href
+	} else {
+		avatar = fmt.Sprintf(avatarURLTemplate, workspace.Slug)
+	}
+	return &scm.Organization{
+		Name:   workspace.Slug,
+		Avatar: avatar,
 	}
 }

scm/driver/bitbucket/org_test.go

@@ -45,12 +45,13 @@ func TestOrganizationList(t *testing.T) {
 	defer gock.Off()
 
 	gock.New("https://api.bitbucket.org").
-		Get("/2.0/workspaces").
+		Get("/2.0/user/workspaces").
 		MatchParam("pagelen", "30").
 		MatchParam("page", "1").
+		MatchParam("role", "member").
 		Reply(200).
 		Type("application/json").
-		File("testdata/teams.json")
+		File("testdata/user_workspaces.json")
 
 	client, _ := New("https://api.bitbucket.org")
 	got, _, err := client.Organizations.List(context.Background(), scm.ListOptions{Size: 30, Page: 1})
@@ -59,11 +60,125 @@ func TestOrganizationList(t *testing.T) {
 	}
 
 	want := []*scm.Organization{}
-	raw, _ := ioutil.ReadFile("testdata/teams.json.golden")
+	raw, _ := ioutil.ReadFile("testdata/user_workspaces.json.golden")
 	json.Unmarshal(raw, &want)
 
 	if diff := cmp.Diff(got, want); diff != "" {
 		t.Errorf("Unexpected Results")
 		t.Log(diff)
 	}
 }
+
+func TestConvertWorkspace(t *testing.T) {
+	tests := []struct {
+		name      string
+		workspace *workspace
+		want      *scm.Organization
+	}{
+		{
+			name: "workspace with avatar link",
+			workspace: &workspace{
+				Slug: "my-workspace",
+				Links: struct {
+					Avatar link `json:"avatar"`
+				}{
+					Avatar: link{Href: "https://bitbucket.org/account/my-workspace/avatar/32/"},
+				},
+			},
+			want: &scm.Organization{
+				Name:   "my-workspace",
+				Avatar: "https://bitbucket.org/account/my-workspace/avatar/32/",
+			},
+		},
+		{
+			name: "workspace without avatar link",
+			workspace: &workspace{
+				Slug: "test-workspace",
+				Links: struct {
+					Avatar link `json:"avatar"`
+				}{
+					Avatar: link{Href: ""},
+				},
+			},
+			want: &scm.Organization{
+				Name:   "test-workspace",
+				Avatar: "https://bitbucket.org/account/test-workspace/avatar/32/",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := convertWorkspace(tt.workspace)
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("convertWorkspace() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestConvertWorkspaceAccessList(t *testing.T) {
+	tests := []struct {
+		name string
+		from *workspaceAccessList
+		want []*scm.Organization
+	}{
+		{
+			name: "valid workspaces",
+			from: &workspaceAccessList{
+				Values: []*workspaceAccess{
+					{
+						Workspace: &workspace{
+							Slug: "workspace1",
+							Links: struct {
+								Avatar link `json:"avatar"`
+							}{
+								Avatar: link{Href: "https://bitbucket.org/account/workspace1/avatar/32/"},
+							},
+						},
+					},
+					{
+						Workspace: &workspace{
+							Slug: "workspace2",
+							Links: struct {
+								Avatar link `json:"avatar"`
+							}{
+								Avatar: link{Href: ""},
+							},
+						},
+					},
+				},
+			},
+			want: []*scm.Organization{
+				{
+					Name:   "workspace1",
+					Avatar: "https://bitbucket.org/account/workspace1/avatar/32/",
+				},
+				{
+					Name:   "workspace2",
+					Avatar: "https://bitbucket.org/account/workspace2/avatar/32/",
+				},
+			},
+		},
+		{
+			name: "nil workspace",
+			from: &workspaceAccessList{
+				Values: []*workspaceAccess{
+					{
+						Workspace: nil,
+					},
+				},
+			},
+			want: []*scm.Organization{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := convertWorkspaceAccessList(tt.from)
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("convertWorkspaceAccessList() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}

scm/driver/bitbucket/repo.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"net/url"
+	"strings"
 	"time"
 
 	"github.com/drone/go-scm/scm"
@@ -87,34 +88,108 @@ func (s *repositoryService) FindHook(ctx context.Context, repo string, id string
 
 // FindPerms returns the repository permissions.
 func (s *repositoryService) FindPerms(ctx context.Context, repo string) (*scm.Perm, *scm.Response, error) {
-	path := fmt.Sprintf("2.0/user/permissions/repositories?q=repository.full_name=%q", repo)
-	out := new(perms)
-	res, err := s.client.do(ctx, "GET", path, nil, out)
-	return convertPerms(out), res, err
+	// First, try to fetch using the repo identifier provided
+	perm, res, err := s.findPermsWithIdentifier(ctx, repo)
+	if err == nil {
+		return perm, res, nil
+	}
+
+	// If that fails and repo isn't in "workspace/repo" format,
+	// search all workspaces as a fallback
+	if !strings.Contains(repo, "/") {
+		return s.findPermsAcrossWorkspaces(ctx, repo)
+	}
+
+	// Repo is in "workspace/repo" format and fetch failed
+	return nil, res, err
 }
 
-// List returns the user repository list.
+// findPermsWithIdentifier attempts to fetch permissions using either the
+// extracted workspace from the client URL or the workspace in "workspace/repo" format.
+func (s *repositoryService) findPermsWithIdentifier(ctx context.Context, repo string) (*scm.Perm, *scm.Response, error) {
+	workspace := s.client.extractWorkspaceFromURL()
+	repoSlug := repo
+
+	// If workspace is available from URL, use it and only extract repo slug
+	if workspace != "" {
+		if strings.Contains(repo, "/") {
+			_, repoSlug = scm.Split(repo)
+		}
+		return s.fetchRepoPerms(ctx, workspace, repoSlug)
+	}
+
+	// If repo is in "workspace/repo" format, use the workspace from repo identifier
+	if strings.Contains(repo, "/") {
+		workspace, repoSlug = scm.Split(repo)
+		return s.fetchRepoPerms(ctx, workspace, repoSlug)
+	}
+
+	// No workspace available
+	return nil, nil, fmt.Errorf("unable to determine workspace for repository %s", repo)
+}
+
+// findPermsAcrossWorkspaces searches all user workspaces for the repository
+// and returns permissions if the user has access.
+func (s *repositoryService) findPermsAcrossWorkspaces(ctx context.Context, repoSlug string) (*scm.Perm, *scm.Response, error) {
+	workspaces, err := s.client.fetchAllWorkspaces(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	for _, workspace := range workspaces {
+		perm, res, err := s.fetchRepoPerms(ctx, workspace, repoSlug)
+		if err != nil {
+			// If it's a 404, the repo doesn't exist in this workspace
+			if res != nil && res.Status == 404 {
+				continue
+			}
+			// For other errors (network, auth, etc.), return immediately
+			return nil, res, err
+		}
+
+		// Return permissions if user has any access to the repository
+		if perm.Pull || perm.Push || perm.Admin {
+			return perm, res, nil
+		}
+	}
+
+	return nil, nil, fmt.Errorf("repository %s not found in any workspace", repoSlug)
+}
+
+// List returns the user repository list using workspace-aware pagination.
 func (s *repositoryService) List(ctx context.Context, opts scm.ListOptions) ([]*scm.Repository, *scm.Response, error) {
-	path := fmt.Sprintf("2.0/repositories?%s", encodeListRoleOptions(opts))
 	if opts.URL != "" {
-		path = opts.URL
+		out := new(repositories)
+		res, err := s.client.do(ctx, "GET", opts.URL, nil, &out)
+		if err != nil {
+			return nil, res, err
+		}
+		copyPagination(out.pagination, res)
+		return convertRepositoryList(out), res, err
 	}
-	out := new(repositories)
-	res, err := s.client.do(ctx, "GET", path, nil, &out)
-	copyPagination(out.pagination, res)
-	return convertRepositoryList(out), res, err
+
+	if opts.Page == 0 {
+		opts.Page = 1
+	}
+	return s.client.fetchReposWithPagination(ctx, encodeListRoleOptions(opts), opts.Page, opts.Size)
 }
 
 // ListV2 returns the user repository list based on the searchTerm passed.
 func (s *repositoryService) ListV2(ctx context.Context, opts scm.RepoListOptions) ([]*scm.Repository, *scm.Response, error) {
-	path := fmt.Sprintf("2.0/repositories?%s", encodeRepoListOptions(opts))
 	if opts.ListOptions.URL != "" {
-		path = opts.ListOptions.URL
+		out := new(repositories)
+		res, err := s.client.do(ctx, "GET", opts.ListOptions.URL, nil, &out)
+		if err != nil {
+			return nil, res, err
+		}
+		copyPagination(out.pagination, res)
+		return convertRepositoryList(out), res, err
 	}
-	out := new(repositories)
-	res, err := s.client.do(ctx, "GET", path, nil, &out)
-	copyPagination(out.pagination, res)
-	return convertRepositoryList(out), res, err
+
+	if opts.ListOptions.Page == 0 {
+		opts.ListOptions.Page = 1
+	}
+	return s.client.fetchReposWithPagination(ctx, encodeRepoListOptions(opts), opts.ListOptions.Page, opts.ListOptions.Size)
 }
 
 func (s *repositoryService) ListNamespace(ctx context.Context, namespace string, opts scm.ListOptions) ([]*scm.Repository, *scm.Response, error) {
@@ -391,3 +466,43 @@ func convertFromState(from scm.State) string {
 		return "FAILED"
 	}
 }
+
+// workspaceRepoPerms represents the response from
+// GET /2.0/workspaces/{workspace}/permissions/repositories/{repo_slug}
+type workspaceRepoPerms struct {
+	Values []*workspaceRepoPerm `json:"values"`
+}
+
+type workspaceRepoPerm struct {
+	Permission string `json:"permission"` // "admin", "write", "read"
+}
+
+func convertWorkspaceRepoPerms(from *workspaceRepoPerms) *scm.Perm {
+	to := new(scm.Perm)
+	if len(from.Values) == 0 {
+		return to
+	}
+	switch from.Values[0].Permission {
+	case "admin":
+		to.Pull = true
+		to.Push = true
+		to.Admin = true
+	case "write":
+		to.Pull = true
+		to.Push = true
+	default:
+		to.Pull = true
+	}
+	return to
+}
+
+// fetchRepoPerms fetches repository permissions for a given workspace and repo slug.
+func (s *repositoryService) fetchRepoPerms(ctx context.Context, workspace, repoSlug string) (*scm.Perm, *scm.Response, error) {
+	path := fmt.Sprintf("2.0/workspaces/%s/permissions/repositories/%s", workspace, repoSlug)
+	out := new(workspaceRepoPerms)
+	res, err := s.client.do(ctx, "GET", path, nil, out)
+	if err != nil {
+		return nil, res, err
+	}
+	return convertWorkspaceRepoPerms(out), res, nil
+}