Connections for Gerrit Source for Batch Changes (#52401)

Part of https://github.com/sourcegraph/sourcegraph/issues/50867.

You will probably notice that some things about the translation of
Gerrit Change data to Changeset aren't filled in, and that's because the
Gerrit Change API does not give you much info to go off of.

This is an example of what a Gerrit API response looks like
```json
{
"id": "src-cli~master~I5de272baea22ef34dfbd00d6e96c45b25019697f",
"project": "src-cli",
"branch": "master",
"hashtags": [
"testhash"
],
"change_id": "I5de272baea22ef34dfbd00d6e96c45b25019697f",
"subject": "testing off of a diff branch",
"status": "NEW",
"created": "2023-05-24 19:04:01.000000000",
"updated": "2023-05-24 19:50:00.000000000",
"submit_type": "MERGE_IF_NECESSARY",
"mergeable": true,
"insertions": 1,
"deletions": 0,
"total_comment_count": 0,
"unresolved_comment_count": 0,
"has_review_started": true,
"_number": 329,
"owner": {
"_account_id": 1000018
},
"requirements": []
}
```

I plan to do the event/reviewer stuff in follow-up PRs

## Test plan
Added additional unit tests

Author: varsanojidan

client/web/src/enterprise/batches/settings/AddCredentialModal.tsx

@@ -59,8 +59,15 @@ const scopeRequirements: Record<ExternalServiceKind, JSX.Element> = {
             permissions.
         </span>
     ),
+    [ExternalServiceKind.GERRIT]: (
+        // TODO: @varsanojidan change this after spike
+        <span>
+            with <Code>Organization:All accessible organizations</Code>, <Code>Code:Full</Code>,{' '}
+            <Code>Code:Status</Code>, <Code>Pull Request Threads:Read & Write</Code>, and <Code>User Profile:Read</Code>{' '}
+            permissions.
+        </span>
+    ),
     // These are just for type completeness and serve as placeholders for a bright future.
-    [ExternalServiceKind.GERRIT]: <span>Unsupported</span>,
     [ExternalServiceKind.GITOLITE]: <span>Unsupported</span>,
     [ExternalServiceKind.GOMODULES]: <span>Unsupported</span>,
     [ExternalServiceKind.PYTHONPACKAGES]: <span>Unsupported</span>,

enterprise/cmd/frontend/internal/batches/resolvers/code_host.go

@@ -31,7 +31,7 @@ func (c *batchChangesCodeHostResolver) RequiresSSH() bool {
 
 func (c *batchChangesCodeHostResolver) RequiresUsername() bool {
 	switch c.codeHost.ExternalServiceType {
-	case extsvc.TypeBitbucketCloud, extsvc.TypeAzureDevOps:
+	case extsvc.TypeBitbucketCloud, extsvc.TypeAzureDevOps, extsvc.TypeGerrit:
 		return true
 	}
 

enterprise/cmd/frontend/internal/batches/resolvers/resolver.go

@@ -1256,6 +1256,13 @@ func (r *Resolver) generateAuthenticatorForCredential(ctx context.Context, exter
 			PublicKey:  keypair.PublicKey,
 			Passphrase: keypair.Passphrase,
 		}
+	} else if externalServiceType == extsvc.TypeGerrit {
+		a = &extsvcauth.BasicAuthWithSSH{
+			BasicAuth:  extsvcauth.BasicAuth{Username: *username, Password: credential},
+			PrivateKey: keypair.PrivateKey,
+			PublicKey:  keypair.PublicKey,
+			Passphrase: keypair.Passphrase,
+		}
 	} else {
 		a = &extsvcauth.OAuthBearerTokenWithSSH{
 			OAuthBearerToken: extsvcauth.OAuthBearerToken{Token: credential},

enterprise/internal/batches/sources/BUILD.bazel

@@ -4,6 +4,7 @@ import (
 	"context"
 	"net/url"
 
+	gerritbatches "github.com/sourcegraph/sourcegraph/enterprise/internal/batches/sources/gerrit"
 	"github.com/sourcegraph/sourcegraph/internal/errcode"
 	"github.com/sourcegraph/sourcegraph/internal/extsvc/auth"
 	"github.com/sourcegraph/sourcegraph/internal/extsvc/gerrit"
@@ -19,8 +20,6 @@ type GerritSource struct {
 	client gerrit.Client
 }
 
-var _ ForkableChangesetSource = GerritSource{}
-
 func NewGerritSource(ctx context.Context, svc *types.ExternalService, cf *httpcli.Factory) (*GerritSource, error) {
 	rawConfig, err := svc.Config.Decrypt(ctx)
 	if err != nil {
@@ -42,7 +41,7 @@ func NewGerritSource(ctx context.Context, svc *types.ExternalService, cf *httpcl
 
 	gerritURL, err := url.Parse(c.Url)
 	if err != nil {
-		return nil, errors.Wrap(err, "parsing Gerrit URL")
+		return nil, errors.Wrap(err, "parsing Gerrit CodeHostURL")
 	}
 
 	client, err := gerrit.NewClient(svc.URN(), gerritURL, &gerrit.AccountCredentials{Username: c.Username, Password: c.Password}, cli)
@@ -87,21 +86,26 @@ func (s GerritSource) LoadChangeset(ctx context.Context, cs *Changeset) error {
 		if errcode.IsNotFound(err) {
 			return ChangesetNotFoundError{Changeset: cs}
 		}
-		return errors.Wrap(err, "getting pull request")
+		return errors.Wrap(err, "getting change")
 	}
 
-	return errors.Wrap(s.setChangesetMetadata(ctx, pr, cs), "setting Gerrit changeset metadata")
+	return errors.Wrap(s.setChangesetMetadata(pr, cs), "setting Gerrit changeset metadata")
 }
 
 // CreateChangeset will create the Changeset on the source. If it already
 // exists, *Changeset will be populated and the return value will be true.
-// noop, Gerrit creates changes through commits directly
-func (s GerritSource) CreateChangeset(_ context.Context, _ *Changeset) (bool, error) {
+func (s GerritSource) CreateChangeset(ctx context.Context, cs *Changeset) (bool, error) {
+	// For Gerrit, the Change is created at `git push` time, so we just load it here to verify it
+	// was created successfully.
+	err := s.LoadChangeset(ctx, cs)
+	if err != nil {
+		return false, err
+	}
 	return true, nil
 }
 
 // CreateDraftChangeset creates the given changeset on the code host in draft mode.
-// no-op, Gerrit creates changes through commits directly
+// Noop, Gerrit creates changes through commits directly
 func (s GerritSource) CreateDraftChangeset(context.Context, *Changeset) (bool, error) {
 	return true, nil
 }
@@ -118,10 +122,10 @@ func (s GerritSource) UndraftChangeset(context.Context, *Changeset) error {
 func (s GerritSource) CloseChangeset(ctx context.Context, cs *Changeset) error {
 	updated, err := s.client.AbandonChange(ctx, cs.ExternalID)
 	if err != nil {
-		return errors.Wrap(err, "abandoning pull request")
+		return errors.Wrap(err, "abandoning change")
 	}
 
-	return errors.Wrap(s.setChangesetMetadata(ctx, updated, cs), "setting Gerrit changeset metadata")
+	return errors.Wrap(s.setChangesetMetadata(updated, cs), "setting Gerrit changeset metadata")
 }
 
 // UpdateChangeset can update Changesets.
@@ -135,10 +139,10 @@ func (s GerritSource) UpdateChangeset(context.Context, *Changeset) error {
 func (s GerritSource) ReopenChangeset(ctx context.Context, cs *Changeset) error {
 	updated, err := s.client.RestoreChange(ctx, cs.ExternalID)
 	if err != nil {
-		return errors.Wrap(err, "updating pull request")
+		return errors.Wrap(err, "restoring change")
 	}
 
-	return errors.Wrap(s.setChangesetMetadata(ctx, updated, cs), "setting Gerrit changeset metadata")
+	return errors.Wrap(s.setChangesetMetadata(updated, cs), "setting Gerrit changeset metadata")
 }
 
 // CreateComment posts a comment on the Changeset.
@@ -154,31 +158,29 @@ func (s GerritSource) CreateComment(ctx context.Context, cs *Changeset, comment
 // merge. If the changeset cannot be merged, because it is in an unmergeable
 // state, ChangesetNotMergeableError must be returned.
 // Gerrit changes are always single commit, so squash does not matter.
-func (s GerritSource) MergeChangeset(ctx context.Context, cs *Changeset, squash bool) error {
+func (s GerritSource) MergeChangeset(ctx context.Context, cs *Changeset, _ bool) error {
 	updated, err := s.client.SubmitChange(ctx, cs.ExternalID)
 	if err != nil {
 		if errcode.IsNotFound(err) {
-			return errors.Wrap(err, "merging pull request")
+			return errors.Wrap(err, "submitting change")
 		}
 		return ChangesetNotMergeableError{ErrorMsg: err.Error()}
 	}
 
-	return errors.Wrap(s.setChangesetMetadata(ctx, updated, cs), "setting Gerrit changeset metadata")
-}
-
-// GetFork returns a repo pointing to a fork of the target repo, ensuring that the fork
-// exists and creating it if it doesn't. If namespace is not provided, the original namespace is used.
-// If name is not provided, the fork will be named with the default Sourcegraph convention:
-// "${original-namespace}-${original-name}"
-// Noop, Gerrit does not support Changes from forks.
-func (s GerritSource) GetFork(_ context.Context, _ *types.Repo, _, _ *string) (*types.Repo, error) {
-	return nil, nil
+	return errors.Wrap(s.setChangesetMetadata(updated, cs), "setting Gerrit changeset metadata")
 }
 
-func (s GerritSource) setChangesetMetadata(_ context.Context, pr *gerrit.Change, cs *Changeset) error {
-	if err := cs.SetMetadata(pr); err != nil {
+func (s GerritSource) setChangesetMetadata(change *gerrit.Change, cs *Changeset) error {
+	apr := s.annotatePullRequest(change)
+	if err := cs.SetMetadata(apr); err != nil {
 		return errors.Wrap(err, "setting changeset metadata")
 	}
-
 	return nil
 }
+
+func (s GerritSource) annotatePullRequest(change *gerrit.Change) *gerritbatches.AnnotatedChange {
+	return &gerritbatches.AnnotatedChange{
+		Change:      change,
+		CodeHostURL: s.client.GetURL(),
+	}
+}

enterprise/internal/batches/sources/gerrit.go

@@ -0,0 +1,16 @@
+package gerrit
+
+import (
+	"net/url"
+
+	"github.com/sourcegraph/sourcegraph/internal/extsvc/gerrit"
+)
+
+// AnnotatedChange adds metadata we need that lives outside the main
+// Change type returned by the Gerrit API.
+// This type is used as the primary metadata type for Gerrit
+// changesets.
+type AnnotatedChange struct {
+	*gerrit.Change
+	CodeHostURL *url.URL
+}

enterprise/internal/batches/sources/gerrit/BUILD.bazel

@@ -2,6 +2,7 @@ package sources
 
 import (
 	"context"
+	"net/url"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -124,6 +125,7 @@ func TestGerritSource_LoadChangeset(t *testing.T) {
 		s, client := mockGerritSource()
 
 		change := mockGerritChange(&testProject)
+		client.GetURLFunc.SetDefaultReturn(&url.URL{})
 		client.GetChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
 			assert.Equal(t, changeID, testGerritChangeID)
 			return change, nil
@@ -134,6 +136,57 @@ func TestGerritSource_LoadChangeset(t *testing.T) {
 	})
 }
 
+func TestGerritSource_CreateChangeset(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("error getting pull request", func(t *testing.T) {
+		cs, _ := mockGerritChangeset()
+		s, client := mockGerritSource()
+		want := errors.New("error")
+		client.GetChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
+			assert.Equal(t, changeID, testGerritChangeID)
+			return &gerrit.Change{}, want
+		})
+
+		b, err := s.CreateChangeset(ctx, cs)
+		assert.NotNil(t, err)
+		assert.ErrorIs(t, err, want)
+		assert.False(t, b)
+	})
+
+	t.Run("pull request not found", func(t *testing.T) {
+		cs, _ := mockGerritChangeset()
+		s, client := mockGerritSource()
+		client.GetChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
+			assert.Equal(t, changeID, testGerritChangeID)
+			return &gerrit.Change{}, &notFoundError{}
+		})
+
+		b, err := s.CreateChangeset(ctx, cs)
+		assert.NotNil(t, err)
+		target := ChangesetNotFoundError{}
+		assert.ErrorAs(t, err, &target)
+		assert.Same(t, target.Changeset, cs)
+		assert.False(t, b)
+	})
+
+	t.Run("success", func(t *testing.T) {
+		cs, _ := mockGerritChangeset()
+		s, client := mockGerritSource()
+
+		change := mockGerritChange(&testProject)
+		client.GetURLFunc.SetDefaultReturn(&url.URL{})
+		client.GetChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
+			assert.Equal(t, changeID, testGerritChangeID)
+			return change, nil
+		})
+
+		b, err := s.CreateChangeset(ctx, cs)
+		assert.Nil(t, err)
+		assert.True(t, b)
+	})
+}
+
 func TestGerritSource_CloseChangeset(t *testing.T) {
 	ctx := context.Background()
 
@@ -157,6 +210,7 @@ func TestGerritSource_CloseChangeset(t *testing.T) {
 		s, client := mockGerritSource()
 
 		pr := mockGerritChange(&testProject)
+		client.GetURLFunc.SetDefaultReturn(&url.URL{})
 		client.AbandonChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
 			assert.Equal(t, changeID, testGerritChangeID)
 			return pr, nil
@@ -240,6 +294,7 @@ func TestGerritSource_MergeChangeset(t *testing.T) {
 		s, client := mockGerritSource()
 
 		pr := mockGerritChange(&testProject)
+		client.GetURLFunc.SetDefaultReturn(&url.URL{})
 		client.SubmitChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
 			assert.Equal(t, testGerritChangeID, changeID)
 			return pr, nil
@@ -256,6 +311,7 @@ func TestGerritSource_MergeChangeset(t *testing.T) {
 		s, client := mockGerritSource()
 
 		pr := mockGerritChange(&testProject)
+		client.GetURLFunc.SetDefaultReturn(&url.URL{})
 		client.SubmitChangeFunc.SetDefaultHook(func(ctx context.Context, changeID string) (*gerrit.Change, error) {
 			assert.Equal(t, testGerritChangeID, changeID)
 			return pr, nil

enterprise/internal/batches/sources/gerrit/types.go

@@ -291,7 +291,8 @@ func loadExternalService(ctx context.Context, s database.ExternalServiceStore, o
 			*schema.BitbucketServerConnection,
 			*schema.GitLabConnection,
 			*schema.BitbucketCloudConnection,
-			*schema.AzureDevOpsConnection:
+			*schema.AzureDevOpsConnection,
+			*schema.GerritConnection:
 			return e, nil
 		}
 	}
@@ -313,6 +314,8 @@ func buildChangesetSource(ctx context.Context, cf *httpcli.Factory, externalServ
 		return NewBitbucketCloudSource(ctx, externalService, cf)
 	case extsvc.KindAzureDevOps:
 		return NewAzureDevOpsSource(ctx, externalService, cf)
+	case extsvc.KindGerrit:
+		return NewGerritSource(ctx, externalService, cf)
 	default:
 		return nil, errors.Errorf("unsupported external service type %q", extsvc.KindToType(externalService.Kind))
 	}