fix: Branch repository provisioning with gitprovider v2

controllers/codebase/service/chain/checkout_branch.go

@@ -33,25 +33,28 @@ func GetRepositoryCredentialsIfExists(cb *codebaseApi.Codebase, c client.Client)
 
 func CheckoutBranch(
 	ctx context.Context,
-	repository, projectPath, branchName string,
-	g gitproviderv2.Git,
+	branchName string,
+	repoContext *GitRepositoryContext,
 	cb *codebaseApi.Codebase,
 	c client.Client,
-	createGitProviderWithConfig func(config gitproviderv2.Config) gitproviderv2.Git,
+	gitProviderFactory func(config gitproviderv2.Config) gitproviderv2.Git,
 ) error {
-	currentBranchName, err := g.GetCurrentBranchName(ctx, projectPath)
+	log := ctrl.LoggerFrom(ctx)
+	gitProvider := gitProviderFactory(gitproviderv2.NewConfigFromGitServerAndSecret(repoContext.GitServer, repoContext.GitServerSecret))
+
+	currentBranchName, err := gitProvider.GetCurrentBranchName(ctx, repoContext.WorkDir)
 	if err != nil {
 		return fmt.Errorf("failed to get current branch name: %w", err)
 	}
 
 	if currentBranchName == branchName {
-		ctrl.Log.Info("default branch is already active", "name", branchName)
+		log.Info("Default branch is already active", "name", branchName)
 		return nil
 	}
 
 	switch cb.Spec.Strategy {
 	case "create":
-		if err := g.Checkout(ctx, projectPath, branchName, false); err != nil {
+		if err := gitProvider.Checkout(ctx, repoContext.WorkDir, branchName, false); err != nil {
 			return fmt.Errorf("failed to checkout to default branch %s (create strategy): %w", branchName, err)
 		}
 
@@ -61,20 +64,17 @@ func CheckoutBranch(
 			return err
 		}
 
-		cloneRepoGitProvider := g
-
+		cfg := gitproviderv2.Config{}
 		if user != nil && password != nil {
-			cloneRepoGitProvider = createGitProviderWithConfig(gitproviderv2.Config{
-				Username: *user,
-				Token:    *password,
-			})
+			cfg.Username = *user
+			cfg.Token = *password
 		}
 
-		if err := cloneRepoGitProvider.Checkout(ctx, projectPath, branchName, true); err != nil {
+		if err := gitProviderFactory(cfg).Checkout(ctx, repoContext.WorkDir, branchName, true); err != nil {
 			return fmt.Errorf("failed to checkout to default branch %s (clone strategy): %w", branchName, err)
 		}
 	case "import":
-		if err := g.CheckoutRemoteBranch(ctx, projectPath, branchName); err != nil {
+		if err := gitProvider.CheckoutRemoteBranch(ctx, repoContext.WorkDir, branchName); err != nil {
 			return fmt.Errorf("failed to checkout to default branch %s (import strategy): %w", branchName, err)
 		}
 	default:

controllers/codebase/service/chain/checkout_branch_test.go

@@ -81,48 +81,30 @@ func TestGetRepositoryCredentialsIfExists_ShouldFail(t *testing.T) {
 	}
 }
 
-func TestCheckoutBranch_ShouldFailOnGetSecret(t *testing.T) {
+func TestCheckoutBranch_ShouldFailOnGetCurrentBranchName(t *testing.T) {
 	c := &codebaseApi.Codebase{
 		ObjectMeta: metaV1.ObjectMeta{
 			Name:      "fake-name",
 			Namespace: fakeNamespace,
 		},
 		Spec: codebaseApi.CodebaseSpec{
+			GitServer: "git",
 			Repository: &codebaseApi.Repository{
 				Url: "repo",
 			},
 			Strategy: codebaseApi.Clone,
 		},
 	}
-
-	scheme := runtime.NewScheme()
-	scheme.AddKnownTypes(codebaseApi.GroupVersion, c)
-	fakeCl := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(c).Build()
-
-	mGit := gitServerMocks.NewMockGit(t)
-	mGit.On("GetCurrentBranchName", testify.Anything, "project-path").Return("some-other-branch", nil)
-
-	err := CheckoutBranch(context.Background(), "repo", "project-path", "branch", mGit, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
-		return mGit
-	})
-	assert.Error(t, err)
-
-	if !strings.Contains(err.Error(), "failed to get secret repository-codebase-fake-name-temp") {
-		t.Fatalf("wrong error returned: %s", err.Error())
-	}
-}
-
-func TestCheckoutBranch_ShouldFailOnGetCurrentBranchName(t *testing.T) {
-	c := &codebaseApi.Codebase{
+	gs := &codebaseApi.GitServer{
 		ObjectMeta: metaV1.ObjectMeta{
-			Name:      "fake-name",
+			Name:      "git",
 			Namespace: fakeNamespace,
 		},
-		Spec: codebaseApi.CodebaseSpec{
-			Repository: &codebaseApi.Repository{
-				Url: "repo",
-			},
-			Strategy: codebaseApi.Clone,
+		Spec: codebaseApi.GitServerSpec{
+			NameSshKeySecret: fakeName,
+			GitHost:          fakeName,
+			SshPort:          22,
+			GitUser:          fakeName,
 		},
 	}
 	s := &coreV1.Secret{
@@ -135,15 +117,32 @@ func TestCheckoutBranch_ShouldFailOnGetCurrentBranchName(t *testing.T) {
 			"password": []byte("pass"),
 		},
 	}
+	ssh := &coreV1.Secret{
+		ObjectMeta: metaV1.ObjectMeta{
+			Name:      fakeName,
+			Namespace: fakeNamespace,
+		},
+		Data: map[string][]byte{
+			util.PrivateSShKeyName: []byte("fake-ssh-key"),
+		},
+	}
 	scheme := runtime.NewScheme()
-	scheme.AddKnownTypes(coreV1.SchemeGroupVersion, s)
-	scheme.AddKnownTypes(codebaseApi.GroupVersion, c)
-	fakeCl := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(s, c).Build()
+	scheme.AddKnownTypes(coreV1.SchemeGroupVersion, s, ssh)
+	scheme.AddKnownTypes(codebaseApi.GroupVersion, c, gs)
+	fakeCl := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(s, c, gs, ssh).Build()
 
 	mGit := gitServerMocks.NewMockGit(t)
 	mGit.On("GetCurrentBranchName", testify.Anything, "project-path").Return("", errors.New("FATAL:FAILED"))
 
-	err := CheckoutBranch(context.Background(), "repo", "project-path", "branch", mGit, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
+	err := CheckoutBranch(context.Background(), "branch", &GitRepositoryContext{
+		GitServer:       gs,
+		GitServerSecret: ssh,
+		PrivateSSHKey:   "fake-ssh-key",
+		UserName:        "user",
+		Token:           "pass",
+		RepoGitUrl:      "repo",
+		WorkDir:         "project-path",
+	}, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
 		return mGit
 	})
 	assert.Error(t, err)
@@ -154,19 +153,31 @@ func TestCheckoutBranch_ShouldFailOnGetCurrentBranchName(t *testing.T) {
 }
 
 func TestCheckoutBranch_ShouldFailOnCheckout(t *testing.T) {
-	repo := "repo"
 	c := &codebaseApi.Codebase{
 		ObjectMeta: metaV1.ObjectMeta{
 			Name:      "fake-name",
 			Namespace: fakeNamespace,
 		},
 		Spec: codebaseApi.CodebaseSpec{
+			GitServer: "git",
 			Repository: &codebaseApi.Repository{
 				Url: "repo",
 			},
 			Strategy: codebaseApi.Clone,
 		},
 	}
+	gs := &codebaseApi.GitServer{
+		ObjectMeta: metaV1.ObjectMeta{
+			Name:      "git",
+			Namespace: fakeNamespace,
+		},
+		Spec: codebaseApi.GitServerSpec{
+			NameSshKeySecret: fakeName,
+			GitHost:          fakeName,
+			SshPort:          22,
+			GitUser:          fakeName,
+		},
+	}
 	s := &coreV1.Secret{
 		ObjectMeta: metaV1.ObjectMeta{
 			Name:      "repository-codebase-fake-name-temp",
@@ -177,16 +188,33 @@ func TestCheckoutBranch_ShouldFailOnCheckout(t *testing.T) {
 			"password": []byte("pass1"),
 		},
 	}
+	ssh := &coreV1.Secret{
+		ObjectMeta: metaV1.ObjectMeta{
+			Name:      fakeName,
+			Namespace: fakeNamespace,
+		},
+		Data: map[string][]byte{
+			util.PrivateSShKeyName: []byte("fake-ssh-key"),
+		},
+	}
 	scheme := runtime.NewScheme()
-	scheme.AddKnownTypes(coreV1.SchemeGroupVersion, s)
-	scheme.AddKnownTypes(codebaseApi.GroupVersion, c)
-	fakeCl := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(s, c).Build()
+	scheme.AddKnownTypes(coreV1.SchemeGroupVersion, s, ssh)
+	scheme.AddKnownTypes(codebaseApi.GroupVersion, c, gs)
+	fakeCl := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(s, c, gs, ssh).Build()
 
 	mGit := gitServerMocks.NewMockGit(t)
 	mGit.On("GetCurrentBranchName", testify.Anything, "project-path").Return("some-other-branch", nil)
 	mGit.On("Checkout", testify.Anything, "project-path", "branch", true).Return(errors.New("FATAL:FAILED"))
 
-	err := CheckoutBranch(context.Background(), repo, "project-path", "branch", mGit, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
+	err := CheckoutBranch(context.Background(), "branch", &GitRepositoryContext{
+		GitServer:       gs,
+		GitServerSecret: ssh,
+		PrivateSSHKey:   "fake-ssh-key",
+		UserName:        "user1",
+		Token:           "pass1",
+		RepoGitUrl:      "repo",
+		WorkDir:         "project-path",
+	}, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
 		return mGit
 	})
 	assert.Error(t, err)
@@ -197,7 +225,6 @@ func TestCheckoutBranch_ShouldFailOnCheckout(t *testing.T) {
 }
 
 func TestCheckoutBranch_ShouldPassForCloneStrategy(t *testing.T) {
-	repo := "repo"
 	c := &codebaseApi.Codebase{
 		ObjectMeta: metaV1.ObjectMeta{
 			Name:      "fake-name",
@@ -251,7 +278,15 @@ func TestCheckoutBranch_ShouldPassForCloneStrategy(t *testing.T) {
 	mGit.On("GetCurrentBranchName", testify.Anything, "project-path").Return("some-other-branch", nil)
 	mGit.On("CheckoutRemoteBranch", testify.Anything, "project-path", "branch").Return(nil)
 
-	err := CheckoutBranch(context.Background(), repo, "project-path", "branch", mGit, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
+	err := CheckoutBranch(context.Background(), "branch", &GitRepositoryContext{
+		GitServer:       gs,
+		GitServerSecret: ssh,
+		PrivateSSHKey:   "fake",
+		UserName:        "user",
+		Token:           "pass",
+		RepoGitUrl:      "repo",
+		WorkDir:         "project-path",
+	}, c, fakeCl, func(config gitproviderv2.Config) gitproviderv2.Git {
 		return mGit
 	})
 	assert.NoError(t, err)

controllers/codebase/service/chain/common.go

@@ -105,47 +105,35 @@ func PrepareGitRepository(
 	c client.Client,
 	codebase *codebaseApi.Codebase,
 	gitProviderFactory gitproviderv2.GitProviderFactory,
-	createGitProviderWithConfig func(config gitproviderv2.Config) gitproviderv2.Git,
 ) (*GitRepositoryContext, error) {
 	log := ctrl.LoggerFrom(ctx)
 
-	// Step 1-2: Get git repository context (GitServer, Secret, and paths)
 	gitRepoCtx, err := GetGitRepositoryContext(ctx, c, codebase)
 	if err != nil {
 		return nil, err
 	}
 
-	// Step 3: Create git provider using factory
-	g := gitProviderFactory(gitRepoCtx.GitServer, gitRepoCtx.GitServerSecret)
+	gitProvider := gitProviderFactory(gitproviderv2.NewConfigFromGitServerAndSecret(gitRepoCtx.GitServer, gitRepoCtx.GitServerSecret))
 
-	// Step 4: Clone repository if needed
 	if !util.DoesDirectoryExist(gitRepoCtx.WorkDir) || util.IsDirectoryEmpty(gitRepoCtx.WorkDir) {
 		log.Info("Start cloning repository", "url", gitRepoCtx.RepoGitUrl)
 
-		if err := g.Clone(ctx, gitRepoCtx.RepoGitUrl, gitRepoCtx.WorkDir, 0); err != nil {
+		if err := gitProvider.Clone(ctx, gitRepoCtx.RepoGitUrl, gitRepoCtx.WorkDir); err != nil {
 			return nil, fmt.Errorf("failed to clone git repository: %w", err)
 		}
 
 		log.Info("Repository has been cloned", "url", gitRepoCtx.RepoGitUrl)
 	}
 
-	// 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)
+	log.Info("Start checkout default branch", "branch", codebase.Spec.DefaultBranch)
 
-	err = CheckoutBranch(ctx, repoUrl, gitRepoCtx.WorkDir, codebase.Spec.DefaultBranch, g, codebase, c, createGitProviderWithConfig)
+	err = CheckoutBranch(ctx, codebase.Spec.DefaultBranch, gitRepoCtx, codebase, c, gitProviderFactory)
 	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)
+	log.Info("Default branch has been checked out", "branch", codebase.Spec.DefaultBranch)
 
-	// Return context for subsequent operations
 	return gitRepoCtx, nil
 }
 

controllers/codebase/service/chain/common_test.go

@@ -310,9 +310,7 @@ func TestPrepareGitRepository(t *testing.T) {
 			objects: []client.Object{gitServer, secret},
 			gitClient: func(t *testing.T) *gitMocks.MockGit {
 				m := gitMocks.NewMockGit(t)
-				m.On("Clone",
-					testify.Anything, testify.Anything, testify.Anything, testify.Anything,
-				).Return(nil)
+				m.On("Clone", testify.Anything, testify.Anything, testify.Anything).Return(nil)
 				m.On("GetCurrentBranchName", testify.Anything, testify.Anything).Return("main", nil)
 				return m
 			},
@@ -388,7 +386,7 @@ func TestPrepareGitRepository(t *testing.T) {
 			objects: []client.Object{gitServer, secret},
 			gitClient: func(t *testing.T) *gitMocks.MockGit {
 				m := gitMocks.NewMockGit(t)
-				m.On("Clone", testify.Anything, testify.Anything, testify.Anything, testify.Anything).
+				m.On("Clone", testify.Anything, testify.Anything, testify.Anything).
 					Return(assert.AnError)
 				return m
 			},
@@ -431,8 +429,7 @@ func TestPrepareGitRepository(t *testing.T) {
 			},
 			gitClient: func(t *testing.T) *gitMocks.MockGit {
 				m := gitMocks.NewMockGit(t)
-				m.On("Clone", testify.Anything, testify.Anything, testify.Anything, testify.Anything).
-					Return(nil)
+				m.On("Clone", testify.Anything, testify.Anything, testify.Anything).Return(nil)
 				m.On("GetCurrentBranchName", testify.Anything, testify.Anything).
 					Return("", errors.New("failed to get current branch"))
 				return m
@@ -463,15 +460,14 @@ func TestPrepareGitRepository(t *testing.T) {
 				WithObjects(allObjects...).
 				Build()
 
+			gitProvider := tt.gitClient(t)
+
 			gitCtx, err := PrepareGitRepository(
 				context.Background(),
 				k8sClient,
 				tt.codebase,
-				func(gitServer *codebaseApi.GitServer, secret *corev1.Secret) gitproviderv2.Git {
-					return tt.gitClient(t)
-				},
-				func(config gitproviderv2.Config) gitproviderv2.Git {
-					return tt.gitClient(t)
+				func(cfg gitproviderv2.Config) gitproviderv2.Git {
+					return gitProvider
 				},
 			)
 

controllers/codebase/service/chain/factory.go

@@ -22,22 +22,17 @@ func MakeChain(ctx context.Context, c client.Client) handler.CodebaseHandler {
 	ch := &chain{}
 	gitlabCIManager := gitlabci.NewManager(c)
 
-	createGitProviderWithConfig := func(config gitproviderv2.Config) gitproviderv2.Git {
-		return gitproviderv2.NewGitProvider(config)
-	}
-
 	ch.Use(
 		NewPutGitWebRepoUrl(c),
 		NewPutProject(
 			c,
 			&gerrit.SSHGerritClient{},
 			gitprovider.NewGitProjectProvider,
-			gitproviderv2.DefaultGitProviderFactory,
-			createGitProviderWithConfig,
+			gitproviderv2.NewGitProviderFactory,
 		),
 		NewPutWebHook(c, resty.New()),
-		NewPutGitLabCIConfig(c, gitlabCIManager, gitproviderv2.DefaultGitProviderFactory, createGitProviderWithConfig),
-		NewPutDeployConfigs(c, gitproviderv2.DefaultGitProviderFactory, createGitProviderWithConfig),
+		NewPutGitLabCIConfig(c, gitlabCIManager, gitproviderv2.NewGitProviderFactory),
+		NewPutDeployConfigs(c, gitproviderv2.NewGitProviderFactory),
 		NewPutDefaultCodeBaseBranch(c),
 		NewCleaner(c),
 	)