fix: don't error when a release exists (#29)

Author: corang

src/platforms/github/release.go

@@ -10,6 +10,7 @@ import (
 	"regexp"
 	"time"
 
+	"github.com/defenseunicorns/uds-releaser/src/platforms"
 	"github.com/defenseunicorns/uds-releaser/src/types"
 	"github.com/defenseunicorns/uds-releaser/src/utils"
 	github "github.com/google/go-github/v66/github"
@@ -51,7 +52,11 @@ func (Platform) TagAndRelease(flavor types.Flavor, tokenVarName string) error {
 		GenerateReleaseNotes: github.Bool(true),
 	}
 
-	_, _, err = githubClient.Repositories.CreateRelease(context.Background(), owner, repoName, release)
+	fmt.Printf("Creating release %s-%s\n", flavor.Version, flavor.Name)
+
+	_, response, err := githubClient.Repositories.CreateRelease(context.Background(), owner, repoName, release)
+
+	err = platforms.ReleaseExists(422, response.StatusCode, err, `already_exists`, zarfPackageName, flavor)
 	if err != nil {
 		return err
 	}

src/platforms/gitlab/release.go

@@ -24,20 +24,12 @@ func (Platform) TagAndRelease(flavor types.Flavor, tokenVarName string) error {
 		return err
 	}
 
-	fmt.Println("Remote URL: ", remoteURL)
-
 	// Parse the GitLab base URL from the remote URL
 	gitlabBaseURL, err := getGitlabBaseUrl(remoteURL)
 	if err != nil {
 		return err
 	}
 
-	fmt.Println("Base URL: ", gitlabBaseURL)
-
-	fmt.Printf("Default branch: %s\n", defaultBranch)
-
-	fmt.Println("token var name: ", tokenVarName)
-
 	// Create a new GitLab client
 	gitlabClient, err := gitlab.NewClient(os.Getenv(tokenVarName), gitlab.WithBaseURL(gitlabBaseURL))
 	if err != nil {
@@ -60,14 +52,12 @@ func (Platform) TagAndRelease(flavor types.Flavor, tokenVarName string) error {
 	}
 
 	// Create the release
-	release, _, err := gitlabClient.Releases.CreateRelease(os.Getenv("CI_PROJECT_ID"), releaseOpts)
+	_, response, err := gitlabClient.Releases.CreateRelease(os.Getenv("CI_PROJECT_ID"), releaseOpts)
+
+	err = platforms.ReleaseExists(409, response.StatusCode, err, `message: Release already exists`, zarfPackageName, flavor)
 	if err != nil {
-		fmt.Println("Error creating release: ", err)
 		return err
 	}
-
-	fmt.Printf("Release %s created\n", release.Name)
-
 	return nil
 }
 

src/platforms/platform.go

@@ -7,6 +7,8 @@ import (
 	"fmt"
 	"os"
 
+	"regexp"
+
 	"github.com/defenseunicorns/uds-releaser/src/types"
 	"github.com/defenseunicorns/uds-releaser/src/utils"
 )
@@ -41,3 +43,18 @@ func VerifyEnvVar(varName string) error {
 
 	return nil
 }
+
+func ReleaseExists(expectedStatusCode, receivedStatusCode int, err error, pattern string, packageName string, flavor types.Flavor) error {
+	if err != nil {
+		if receivedStatusCode == expectedStatusCode && regexp.MustCompile(pattern).MatchString(err.Error()) {
+			fmt.Printf("Release with tag %s-%s already exists\n", flavor.Version, flavor.Name)
+			return nil
+		} else {
+			fmt.Println("Error creating release: ", err)
+			return err
+		}
+	} else {
+		fmt.Printf("Release %s %s-%s created\n", packageName, flavor.Version, flavor.Name)
+		return nil
+	}
+}

src/platforms/platform_test.go

@@ -0,0 +1,126 @@
+// Copyright 2024 Defense Unicorns
+// SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-Defense-Unicorns-Commercial
+
+package platforms
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/defenseunicorns/uds-releaser/src/types"
+)
+
+func TestVerifyEnvVar(t *testing.T) {
+	tests := []struct {
+		varName       string
+		setVar        bool
+		varContents   string
+		expectError bool
+	}{
+		{
+			varName:       "TEST_VAR",
+			setVar:        true,
+			varContents:   "test",
+			expectError: false,
+		},
+		{
+			varName:       "TEST_VAR",
+			setVar:        false,
+			varContents:   "",
+			expectError: true,
+		},
+		{
+			varName:       "TEST_VAR",
+			setVar:        true,
+			varContents:   "",
+			expectError: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("setVar: %t contents:%s", test.setVar, test.varContents), func(t *testing.T) {
+			if test.setVar {
+				os.Setenv(test.varName, test.varContents)
+				defer os.Unsetenv(test.varName)
+			} else {
+				os.Unsetenv(test.varName)
+			}
+
+			err := VerifyEnvVar(test.varName)
+			if test.expectError {
+				if err == nil {
+					t.Errorf("Expected error, got nil")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Expected no error, got %s", err)
+				}
+			}
+		})
+	}
+}
+
+func TestReleaseExists(t *testing.T) {
+	tests := []struct {
+		expectedStatusCode int
+		receivedStatusCode int
+		err                error
+		pattern            string
+		packageName        string
+		flavor             types.Flavor
+		expectError        bool
+	}{
+		{
+			expectedStatusCode: 409,
+			receivedStatusCode: 200,
+			err:                nil,
+			pattern:            "already_exists",
+			packageName:        "test",
+			flavor:             types.Flavor{Name: "test", Version: "1.0"},
+			expectError: false,
+		},
+		{
+			expectedStatusCode: 409,
+			receivedStatusCode: 409,
+			err:                fmt.Errorf("message: already_exists"),
+			pattern:            "already_exists",
+			packageName:        "test",
+			flavor:             types.Flavor{Name: "test", Version: "1.0"},
+			expectError: false,
+		},
+		{
+			expectedStatusCode: 409,
+			receivedStatusCode: 409,
+			err:                fmt.Errorf("message: other error"),
+			pattern:            "already_exists",
+			packageName:        "test",
+			flavor:             types.Flavor{Name: "test", Version: "1.0"},
+			expectError: true,
+		},
+		{
+			expectedStatusCode: 409,
+			receivedStatusCode: 411,
+			err:                fmt.Errorf("message: other error"),
+			pattern:            "already_exists",
+			packageName:        "test",
+			flavor:             types.Flavor{Name: "test", Version: "1.0"},
+			expectError: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("expectedCode: %d receivedCode: %d error: %v", test.expectedStatusCode, test.receivedStatusCode, test.err), func(t *testing.T) {
+			err := ReleaseExists(test.expectedStatusCode, test.receivedStatusCode, test.err, test.pattern, test.packageName, test.flavor)
+			if test.expectError {
+				if err == nil {
+					t.Errorf("Expected error, got nil")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Expected no error, got %s", err)
+				}
+			}
+		})
+	}
+}