chore: Update test to use existing GitLab project (#371)

Co-authored-by: Andrew Peabody <[email protected]>

Author: josephdt12

examples/tf_cloudbuild_builder_simple_gitlab/scripts/push-to-repo.sh

@@ -43,5 +43,14 @@ git config user.email "[email protected]"
 git config user.name "TF Robot"
 git checkout main || git checkout -b main
 git add Dockerfile
-git commit -m "init tf dockerfile"
-git push origin main -f
+
+# The '-z' flag checks if the following string is empty.
+if [ -z "$(git status --porcelain)" ]; then
+    # If the output is empty, the working directory is clean.
+    echo "No changes to commit. Nothing to do."
+else
+  # If there is output, changes exist, so we commit.
+    echo "Changes detected. Attempting to commit..."
+  git commit -m "init tf dockerfile"
+  git push origin main -f
+fi

test/integration/tf_cloudbuild_builder_simple_gitlab/tf_cloudbuild_builder_simple_gitlab_test.go

@@ -27,100 +27,29 @@ import (
 	cftutils "github.com/GoogleCloudPlatform/cloud-foundation-toolkit/infra/blueprint-test/pkg/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/terraform-google-modules/terraform-google-bootstrap/test/integration/utils"
-	"github.com/xanzy/go-gitlab"
 )
 
-type GitLabClient struct {
-	t         *testing.T
-	client    *gitlab.Client
-	group     string
-	namespace int
-	repo      string
-	project   *gitlab.Project
-}
-
-func NewGitLabClient(t *testing.T, token, owner, repo string) *GitLabClient {
-	t.Helper()
-	client, err := gitlab.NewClient(token)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	return &GitLabClient{
-		t:         t,
-		client:    client,
-		group:     "infrastructure-manager",
-		namespace: 84326276,
-		repo:      repo,
-	}
-}
-
-func (gl *GitLabClient) ProjectName() string {
-	return fmt.Sprintf("%s/%s", gl.group, gl.repo)
-}
-
-func (gl *GitLabClient) GetProject() *gitlab.Project {
-	proj, resp, err := gl.client.Projects.GetProject(gl.ProjectName(), nil)
-	if resp.StatusCode != 404 && err != nil {
-		gl.t.Fatalf("got status code %d, error %s", resp.StatusCode, err.Error())
-	}
-	gl.project = proj
-	return proj
-}
-
-func (gl *GitLabClient) CreateProject() {
-	opts := &gitlab.CreateProjectOptions{
-		Name: gitlab.Ptr(gl.repo),
-		// ID of the the Infrastructure Manager group (gitlab.com/infrastructure-manager)
-		NamespaceID: gitlab.Ptr(gl.namespace),
-		// Required otherwise Cloud Build errors on creating the connection
-		InitializeWithReadme: gitlab.Ptr(true),
-	}
-	proj, _, err := gl.client.Projects.CreateProject(opts)
-	if err != nil {
-		gl.t.Fatal(err.Error())
-	}
-	gl.project = proj
-}
-
-func (gl *GitLabClient) DeleteProject() {
-	resp, err := gl.client.Projects.DeleteProject(gl.ProjectName(), utils.GetDeleteProjectOptions())
-	if resp.StatusCode != 404 && err != nil {
-		gl.t.Errorf("error deleting project with status %s and error %s", resp.Status, err.Error())
-	}
-	gl.project = nil
-}
+const (
+	gitlabProjectName = "b-gl-test"
+)
 
 func TestTFCloudBuildBuilderGitLab(t *testing.T) {
 	gitlabPAT := cftutils.ValFromEnv(t, "IM_GITLAB_PAT")
-	owner := "im-goose"
-	repoName := fmt.Sprintf("b-gl-test-%s", utils.GetRandomStringFromSetup(t))
-
-	client := NewGitLabClient(t, gitlabPAT, owner, repoName)
-
-	proj := client.GetProject()
-	if proj == nil {
-		client.CreateProject()
-	}
+	client := utils.NewGitLabClient(t, gitlabPAT, gitlabProjectName)
+	client.GetProject()
 
 	// Testing the module's feature of appending the ".git" suffix if it's missing
 	// repoURL := strings.TrimSuffix(client.repository.GetCloneURL(), ".git")
 	vars := map[string]interface{}{
 		"gitlab_authorizer_credential":      gitlabPAT,
 		"gitlab_read_authorizer_credential": gitlabPAT,
-		"repository_uri":                    client.project.HTTPURLToRepo,
+		"repository_uri":                    client.Project.HTTPURLToRepo,
 	}
 	bpt := tft.NewTFBlueprintTest(t, tft.WithVars(vars))
 
 	bpt.DefineVerify(func(assert *assert.Assertions) {
 		bpt.DefaultVerify(assert)
 
-		t.Cleanup(func() {
-			// Delete the repository if we hit a failed state
-			if t.Failed() {
-				client.DeleteProject()
-			}
-		})
-
 		location := bpt.GetStringOutput("location")
 		projectID := bpt.GetStringOutput("project_id")
 		artifactRepo := bpt.GetStringOutput("artifact_repo")
@@ -219,7 +148,6 @@ func TestTFCloudBuildBuilderGitLab(t *testing.T) {
 	bpt.DefineTeardown(func(assert *assert.Assertions) {
 		// Guarantee clean up even if the normal gcloud/teardown run into errors
 		t.Cleanup(func() {
-			client.DeleteProject()
 			bpt.DefaultTeardown(assert)
 		})
 	})

test/integration/utils/gitlab_client.go

@@ -0,0 +1,114 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+const (
+	gitlabGroup   = "infrastructure-manager"
+	gitlabGroupID = 84326276
+)
+
+type GitLabClient struct {
+	t         *testing.T
+	client    *gitlab.Client
+	group     string
+	namespace int
+	repo      string
+	Project   *gitlab.Project
+}
+
+func NewGitLabClient(t *testing.T, token, projectName string) *GitLabClient {
+	t.Helper()
+	client, err := gitlab.NewClient(token)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	return &GitLabClient{
+		t:         t,
+		client:    client,
+		group:     gitlabGroup,
+		namespace: gitlabGroupID,
+		repo:      projectName,
+	}
+}
+
+func (gl *GitLabClient) ProjectName() string {
+	return fmt.Sprintf("%s/%s", gl.group, gl.repo)
+}
+
+func (gl *GitLabClient) GetProject() *gitlab.Project {
+	proj, resp, err := gl.client.Projects.GetProject(gl.ProjectName(), nil)
+	if resp.StatusCode != 404 && err != nil {
+		gl.t.Fatalf("got status code %d, error %s", resp.StatusCode, err.Error())
+	}
+	gl.Project = proj
+	return proj
+}
+
+// GetOpenMergeRequest gets the last opened merge request for a given branch if it exists.
+func (gl *GitLabClient) GetOpenMergeRequest(branch string) *gitlab.MergeRequest {
+	opts := gitlab.ListProjectMergeRequestsOptions{
+		State:        gitlab.Ptr("opened"),
+		SourceBranch: gitlab.Ptr(branch),
+	}
+	mergeRequests, _, err := gl.client.MergeRequests.ListProjectMergeRequests(gl.ProjectName(), &opts)
+	if err != nil {
+		gl.t.Fatal(err.Error())
+	}
+	if len(mergeRequests) == 0 {
+		return nil
+	}
+	return mergeRequests[len(mergeRequests)-1]
+}
+
+func (gl *GitLabClient) CreateMergeRequest(title, branch, base string) *gitlab.MergeRequest {
+	opts := gitlab.CreateMergeRequestOptions{
+		Title:        gitlab.Ptr(title),
+		SourceBranch: gitlab.Ptr(branch),
+		TargetBranch: gitlab.Ptr(base),
+	}
+	mergeRequest, _, err := gl.client.MergeRequests.CreateMergeRequest(gl.ProjectName(), &opts)
+	if err != nil {
+		gl.t.Fatal(err.Error())
+	}
+	return mergeRequest
+}
+
+func (gl *GitLabClient) CloseMergeRequest(mr *gitlab.MergeRequest) {
+	_, err := gl.client.MergeRequests.DeleteMergeRequest(gl.ProjectName(), mr.IID)
+	if err != nil {
+		gl.t.Fatal(err.Error())
+	}
+}
+
+func (gl *GitLabClient) AcceptMergeRequest(mr *gitlab.MergeRequest, commitMessage string) *gitlab.MergeRequest {
+	opts := gitlab.AcceptMergeRequestOptions{
+		ShouldRemoveSourceBranch: gitlab.Ptr(true),
+	}
+	merged, resp, err := gl.client.MergeRequests.AcceptMergeRequest(gl.ProjectName(), mr.IID, &opts)
+	if err != nil {
+		gl.t.Fatal(err.Error())
+	}
+	if resp.StatusCode != 200 {
+		gl.t.Fatalf("failed to accept merge request %v", resp)
+	}
+	return merged
+}