refactor: Extract common git repository preparation logic (#229)

Consolidate duplicated git repository setup code across chain handlers
into a reusable PrepareGitRepository function and GitRepositoryContext struct.

Changes:
- Add GitRepositoryContext struct to hold git operation context
- Add PrepareGitRepository function for common git setup workflow
- Refactor PutDeployConfigs to use PrepareGitRepository
- Refactor PutGitLabCIConfig to use PrepareGitRepository
- Add comprehensive unit tests for PrepareGitRepository

This reduces code duplication and improves maintainability by
centralizing GitServer retrieval, SSH credential extraction,
repository cloning, and branch checkout logic.

Signed-off-by: Sergiy Kulanov <[email protected]>

Author: SergK

controllers/codebase/service/chain/common.go

@@ -5,13 +5,27 @@ import (
 	"fmt"
 	"strconv"
 
+	corev1 "k8s.io/api/core/v1"
 	metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	codebaseApi "github.com/epam/edp-codebase-operator/v2/api/v1"
+	"github.com/epam/edp-codebase-operator/v2/pkg/git"
 	"github.com/epam/edp-codebase-operator/v2/pkg/util"
 )
 
+// GitRepositoryContext holds all context needed for git operations.
+// It contains the GitServer configuration, credentials, and paths
+// required for SSH-based git operations.
+type GitRepositoryContext struct {
+	GitServer     *codebaseApi.GitServer
+	Secret        *corev1.Secret
+	PrivateSSHKey string
+	RepoSSHUrl    string
+	WorkDir       string
+}
+
 func setIntermediateSuccessFields(ctx context.Context, c client.Client, cb *codebaseApi.Codebase, action codebaseApi.ActionType) error {
 	// Set WebHookRef from WebHookID for backward compatibility.
 	webHookRef := cb.Status.WebHookRef
@@ -71,3 +85,92 @@ func updateGitStatusWithPatch(
 
 	return nil
 }
+
+// PrepareGitRepository performs complete git repository preparation workflow:
+// 1. Retrieves GitServer resource and its Secret
+// 2. Extracts SSH credentials and builds repository paths
+// 3. Clones repository via SSH if not already present locally
+// 4. Checks out the codebase's default branch
+//
+// This function handles the common git setup operations shared across
+// multiple chain handlers. Provider-specific operations (e.g., Gerrit hooks)
+// should be handled by the caller after this function returns.
+//
+// Returns GitRepositoryContext containing all necessary context for
+// subsequent git operations (commit, push, etc.).
+func PrepareGitRepository(
+	ctx context.Context,
+	c client.Client,
+	g git.Git,
+	codebase *codebaseApi.Codebase,
+) (*GitRepositoryContext, error) {
+	log := ctrl.LoggerFrom(ctx)
+
+	// Step 1: Retrieve GitServer resource
+	gitServer := &codebaseApi.GitServer{}
+	if err := c.Get(
+		ctx,
+		client.ObjectKey{Name: codebase.Spec.GitServer, Namespace: codebase.Namespace},
+		gitServer,
+	); err != nil {
+		return nil, fmt.Errorf("failed to get GitServer: %w", err)
+	}
+
+	// Step 2: Retrieve GitServer Secret
+	gitServerSecret := &corev1.Secret{}
+	if err := c.Get(
+		ctx,
+		client.ObjectKey{Name: gitServer.Spec.NameSshKeySecret, Namespace: codebase.Namespace},
+		gitServerSecret,
+	); err != nil {
+		return nil, fmt.Errorf("failed to get GitServer secret: %w", err)
+	}
+
+	// Step 3: Extract SSH key and build paths
+	privateSSHKey := string(gitServerSecret.Data[util.PrivateSShKeyName])
+	repoSshUrl := util.GetSSHUrl(gitServer, codebase.Spec.GetProjectID())
+	wd := util.GetWorkDir(codebase.Name, codebase.Namespace)
+
+	// Step 4: Clone repository if needed
+	if !util.DoesDirectoryExist(wd) || util.IsDirectoryEmpty(wd) {
+		log.Info("Start cloning repository", "url", repoSshUrl)
+
+		if err := g.CloneRepositoryBySsh(
+			ctx,
+			privateSSHKey,
+			gitServer.Spec.GitUser,
+			repoSshUrl,
+			wd,
+			gitServer.Spec.SshPort,
+		); err != nil {
+			return nil, fmt.Errorf("failed to clone git repository: %w", err)
+		}
+
+		log.Info("Repository has been cloned", "url", repoSshUrl)
+	}
+
+	// Step 5: Get repo URL for checkout
+	repoUrl, err := util.GetRepoUrl(codebase)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build repo url: %w", err)
+	}
+
+	// Step 6: Checkout default branch
+	log.Info("Start checkout default branch", "branch", codebase.Spec.DefaultBranch, "repo", repoUrl)
+
+	err = CheckoutBranch(repoUrl, wd, codebase.Spec.DefaultBranch, g, codebase, c)
+	if err != nil {
+		return nil, fmt.Errorf("failed to checkout default branch %v: %w", codebase.Spec.DefaultBranch, err)
+	}
+
+	log.Info("Default branch has been checked out", "branch", codebase.Spec.DefaultBranch, "repo", repoUrl)
+
+	// Return context for subsequent operations
+	return &GitRepositoryContext{
+		GitServer:     gitServer,
+		Secret:        gitServerSecret,
+		PrivateSSHKey: privateSSHKey,
+		RepoSSHUrl:    repoSshUrl,
+		WorkDir:       wd,
+	}, nil
+}

controllers/codebase/service/chain/common_test.go

@@ -5,13 +5,17 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	testify "github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
 	codebaseApi "github.com/epam/edp-codebase-operator/v2/api/v1"
+	gitMocks "github.com/epam/edp-codebase-operator/v2/pkg/git/mocks"
 	"github.com/epam/edp-codebase-operator/v2/pkg/util"
 )
 
@@ -248,3 +252,230 @@ func TestUpdateGitStatusWithPatch_SequentialUpdates(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, util.ProjectTemplatesPushedStatus, updated.Status.Git)
 }
+
+func TestPrepareGitRepository(t *testing.T) {
+	scheme := runtime.NewScheme()
+	require.NoError(t, codebaseApi.AddToScheme(scheme))
+	require.NoError(t, corev1.AddToScheme(scheme))
+
+	gitServer := &codebaseApi.GitServer{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-gitserver",
+			Namespace: fakeNamespace,
+		},
+		Spec: codebaseApi.GitServerSpec{
+			GitHost:          "github.com",
+			GitUser:          "git",
+			NameSshKeySecret: "git-secret",
+			SshPort:          22,
+			GitProvider:      codebaseApi.GitProviderGithub,
+		},
+	}
+
+	secret := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "git-secret",
+			Namespace: fakeNamespace,
+		},
+		Data: map[string][]byte{
+			util.PrivateSShKeyName: []byte("test-ssh-key"),
+		},
+	}
+
+	tests := []struct {
+		name      string
+		codebase  *codebaseApi.Codebase
+		objects   []client.Object
+		gitClient func(t *testing.T) *gitMocks.MockGit
+		setup     func(t *testing.T)
+		wantErr   require.ErrorAssertionFunc
+		want      func(t *testing.T, gitCtx *GitRepositoryContext)
+	}{
+		{
+			name: "successfully prepare repository - clone required",
+			codebase: &codebaseApi.Codebase{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      fakeName,
+					Namespace: fakeNamespace,
+				},
+				Spec: codebaseApi.CodebaseSpec{
+					GitServer:     gitServer.Name,
+					DefaultBranch: "main",
+					Strategy:      codebaseApi.Create,
+					GitUrlPath:    fakeName,
+				},
+			},
+			objects: []client.Object{gitServer, secret},
+			gitClient: func(t *testing.T) *gitMocks.MockGit {
+				m := gitMocks.NewMockGit(t)
+				m.On("CloneRepositoryBySsh",
+					testify.Anything, "test-ssh-key", "git",
+					testify.Anything, testify.Anything, int32(22),
+				).Return(nil)
+				m.On("GetCurrentBranchName", testify.Anything).Return("main", nil)
+				m.On("CheckPermissions", testify.Anything, testify.Anything, testify.Anything, testify.Anything).Return(true)
+				return m
+			},
+			wantErr: require.NoError,
+			want: func(t *testing.T, gitCtx *GitRepositoryContext) {
+				require.NotNil(t, gitCtx)
+				assert.Equal(t, "test-ssh-key", gitCtx.PrivateSSHKey)
+				assert.Equal(t, gitServer.Name, gitCtx.GitServer.Name)
+				assert.Equal(t, secret.Name, gitCtx.Secret.Name)
+				assert.NotEmpty(t, gitCtx.RepoSSHUrl)
+				assert.NotEmpty(t, gitCtx.WorkDir)
+			},
+		},
+		{
+			name: "failed to get GitServer",
+			codebase: &codebaseApi.Codebase{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      fakeName,
+					Namespace: fakeNamespace,
+				},
+				Spec: codebaseApi.CodebaseSpec{
+					GitServer:     "missing-gitserver",
+					DefaultBranch: "main",
+				},
+			},
+			gitClient: func(t *testing.T) *gitMocks.MockGit {
+				return gitMocks.NewMockGit(t)
+			},
+			wantErr: func(t require.TestingT, err error, i ...interface{}) {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "failed to get GitServer")
+			},
+			want: func(t *testing.T, gitCtx *GitRepositoryContext) {
+				assert.Nil(t, gitCtx)
+			},
+		},
+		{
+			name: "failed to get GitServer secret",
+			codebase: &codebaseApi.Codebase{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      fakeName,
+					Namespace: fakeNamespace,
+				},
+				Spec: codebaseApi.CodebaseSpec{
+					GitServer:     gitServer.Name,
+					DefaultBranch: "main",
+				},
+			},
+			objects: []client.Object{gitServer},
+			gitClient: func(t *testing.T) *gitMocks.MockGit {
+				return gitMocks.NewMockGit(t)
+			},
+			wantErr: func(t require.TestingT, err error, i ...interface{}) {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "failed to get GitServer secret")
+			},
+			want: func(t *testing.T, gitCtx *GitRepositoryContext) {
+				assert.Nil(t, gitCtx)
+			},
+		},
+		{
+			name: "failed to clone repository",
+			codebase: &codebaseApi.Codebase{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      fakeName,
+					Namespace: fakeNamespace,
+				},
+				Spec: codebaseApi.CodebaseSpec{
+					GitServer:     gitServer.Name,
+					DefaultBranch: "main",
+					Strategy:      codebaseApi.Create,
+				},
+			},
+			objects: []client.Object{gitServer, secret},
+			gitClient: func(t *testing.T) *gitMocks.MockGit {
+				m := gitMocks.NewMockGit(t)
+				m.On("CloneRepositoryBySsh", testify.Anything, testify.Anything, testify.Anything, testify.Anything, testify.Anything, testify.Anything).
+					Return(assert.AnError)
+				return m
+			},
+			wantErr: func(t require.TestingT, err error, i ...interface{}) {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "failed to clone git repository")
+			},
+			want: func(t *testing.T, gitCtx *GitRepositoryContext) {
+				assert.Nil(t, gitCtx)
+			},
+		},
+		{
+			name: "failed to checkout default branch",
+			codebase: &codebaseApi.Codebase{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      fakeName,
+					Namespace: fakeNamespace,
+				},
+				Spec: codebaseApi.CodebaseSpec{
+					GitServer:     gitServer.Name,
+					DefaultBranch: "main",
+					Strategy:      codebaseApi.Create,
+					GitUrlPath:    fakeName,
+					Repository:    &codebaseApi.Repository{Url: "https://github.com/test/repo.git"},
+				},
+			},
+			objects: []client.Object{
+				gitServer,
+				secret,
+				&corev1.Secret{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "repository-codebase-fake-name-temp",
+						Namespace: fakeNamespace,
+					},
+					Data: map[string][]byte{
+						"username": []byte("user"),
+						"password": []byte("pass"),
+					},
+				},
+			},
+			gitClient: func(t *testing.T) *gitMocks.MockGit {
+				m := gitMocks.NewMockGit(t)
+				m.On("CloneRepositoryBySsh", testify.Anything, testify.Anything, testify.Anything, testify.Anything, testify.Anything, testify.Anything).
+					Return(nil)
+				m.On("CheckPermissions", testify.Anything, testify.Anything, testify.Anything, testify.Anything).
+					Return(false)
+				return m
+			},
+			wantErr: func(t require.TestingT, err error, i ...interface{}) {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "cannot get access to the repository")
+			},
+			want: func(t *testing.T, gitCtx *GitRepositoryContext) {
+				assert.Nil(t, gitCtx)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			t.Setenv(util.WorkDirEnv, tmpDir)
+
+			if tt.setup != nil {
+				tt.setup(t)
+			}
+
+			allObjects := append(tt.objects, tt.codebase)
+
+			k8sClient := fake.NewClientBuilder().
+				WithScheme(scheme).
+				WithObjects(allObjects...).
+				Build()
+
+			gitCtx, err := PrepareGitRepository(
+				context.Background(),
+				k8sClient,
+				tt.gitClient(t),
+				tt.codebase,
+			)
+
+			tt.wantErr(t, err)
+
+			if tt.want != nil {
+				tt.want(t, gitCtx)
+			}
+		})
+	}
+}