Feat/cli add --fail-on-error param to trigger cmd

README.md

@@ -84,6 +84,7 @@ The trigger command is used to trigger a single TeamCity build. It allows you to
 | `--require-artifacts`         | If downloadArtifacts is true, and no artifacts found, return an error |
 | `-w, --wait-for-build`        | Wait for build to finish and get status           |
 | `-t, --wait-timeout duration` | Timeout for waiting for build to finish (default 15m0s) |
+| `--fail-on-error`             | Fail command if build status is not SUCCESS (only valid with --wait-for-build) |
 
 #### Example
 

cmd/multitrigger/triggerBuilds.go

@@ -5,9 +5,10 @@ import (
 	"bbox/teamcity"
 	"errors"
 	"fmt"
-	log "github.com/sirupsen/logrus"
 	"sync"
 	"time"
+
+	log "github.com/sirupsen/logrus"
 )
 
 // triggerBuilds triggers the builds for each set of build parameters, wait and download artifacts if needed using work group.

cmd/multitrigger/triggerBuilds_test.go

@@ -5,9 +5,10 @@ import (
 	"bbox/pkg/utils/testutils"
 	"bbox/teamcity"
 	"errors"
-	"github.com/stretchr/testify/assert"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 type buildTestCase struct {

cmd/trigger.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"net/url"
 	"os"
+	"strings"
 	"time"
 
 	"bbox/teamcity"
@@ -23,13 +24,20 @@ var (
 	waitForBuild        bool
 	waitForBuildTimeout = 15 * time.Minute
 	requireArtifacts    bool
+	failOnError         bool
 )
 
 var triggerCmd = &cobra.Command{
 	Use:   "trigger",
 	Short: "Trigger a single TeamCity Build",
 	Long:  `Trigger a single TeamCity Build`,
 	Run: func(cmd *cobra.Command, args []string) {
+		// Validate that failOnError is only used with waitForBuild
+		if failOnError && !waitForBuild {
+			log.Errorf("--fail-on-error can only be used with --wait-for-build")
+			os.Exit(2)
+		}
+
 		url, err := url.Parse(TeamcityURL)
 		if err != nil {
 			log.Errorf("error parsing TeamCity URL: %s", err)
@@ -42,7 +50,7 @@ var triggerCmd = &cobra.Command{
 			log.Errorf("error initializing TeamCity Client: %s", err)
 			os.Exit(2)
 		}
-		trigger(client, buildTypeID, branchName, artifactsPath, propertiesFlag, requireArtifacts, waitForBuild, downloadArtifacts, waitForBuildTimeout)
+		trigger(client, buildTypeID, branchName, artifactsPath, propertiesFlag, requireArtifacts, waitForBuild, downloadArtifacts, waitForBuildTimeout, failOnError)
 	},
 }
 
@@ -57,9 +65,10 @@ func init() {
 	triggerCmd.PersistentFlags().StringVarP(&branchName, "branch-name", "b", branchName, "The Branch Name")
 	triggerCmd.PersistentFlags().StringToStringVarP(&propertiesFlag, "properties", "p", nil, "The properties in key=value format")
 	triggerCmd.PersistentFlags().BoolVar(&requireArtifacts, "require-artifacts", false, "If downloadArtifacts is true, and no artifacts found, return an error")
+	triggerCmd.PersistentFlags().BoolVar(&failOnError, "fail-on-error", false, "Fail command if build status is not SUCCESS (only valid with --wait-for-build)")
 }
 
-func trigger(client *teamcity.Client, buildTypeID, branchName, artifactsPath string, propertiesFlag map[string]string, requireArtifacts, waitForBuild, downloadArtifacts bool, waitForBuildTimeout time.Duration) {
+func trigger(client *teamcity.Client, buildTypeID, branchName, artifactsPath string, propertiesFlag map[string]string, requireArtifacts, waitForBuild, downloadArtifacts bool, waitForBuildTimeout time.Duration, failOnError bool) {
 	log.WithFields(log.Fields{
 		"TeamcityURL":       TeamcityURL,
 		"branchName":        branchName,
@@ -99,7 +108,14 @@ func trigger(client *teamcity.Client, buildTypeID, branchName, artifactsPath str
 			"buildState":  build.State,
 		}).Infof("Build %s Finished", triggerResponse.BuildType.Name)
 
-		if downloadArtifacts && status == "SUCCESS" {
+		if failOnError {
+			if !strings.EqualFold(status, "SUCCESS") {
+				log.Errorf("build %s finished with status '%s', but expected 'SUCCESS'", triggerResponse.BuildType.Name, status)
+				os.Exit(2)
+			}
+		}
+
+		if downloadArtifacts && strings.EqualFold(status, "SUCCESS") {
 			artifactsExist := client.Artifacts.BuildHasArtifact(build.ID)
 
 			if requireArtifacts && !artifactsExist {

cmd/trigger_test.go

@@ -119,7 +119,7 @@ func TestTrigger(t *testing.T) {
 				mockArtifacts.On("GetArtifactChildren", tt.triggerBuildResponse.ID).Return(tt.getArtifactChildrenResponse, tt.getArtifactChildrenError)
 			}
 
-			trigger(client, tt.buildTypeID, tt.branchName, tt.artifactsPath, tt.properties, tt.requireArtifacts, tt.waitForBuild, tt.downloadArtifacts, tt.waitForBuildTimeout)
+			trigger(client, tt.buildTypeID, tt.branchName, tt.artifactsPath, tt.properties, tt.requireArtifacts, tt.waitForBuild, tt.downloadArtifacts, tt.waitForBuildTimeout, false)
 
 			mockBuild.AssertExpectations(t)
 			mockArtifacts.AssertExpectations(t)

pkg/utils/testutils/teamcity.go

@@ -3,9 +3,10 @@ package testutils
 import (
 	"bbox/pkg/types"
 	"bbox/teamcity"
-	"github.com/stretchr/testify/mock"
 	"net/http"
 	"time"
+
+	"github.com/stretchr/testify/mock"
 )
 
 type MockTeamCityClient struct {

teamcity/build_test.go

@@ -0,0 +1,71 @@
+package teamcity
+
+import (
+	"bbox/pkg/types"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBuildService_WaitForBuild(t *testing.T) {
+	tests := []struct {
+		name           string
+		mockResponse   types.BuildStatusResponse // Single response that represents finished state
+		expectedResult types.BuildStatusResponse
+		expectedError  string
+	}{
+		{
+			name:           "Successful build",
+			mockResponse:   types.BuildStatusResponse{ID: 123, Status: "SUCCESS", State: "finished"},
+			expectedResult: types.BuildStatusResponse{ID: 123, Status: "SUCCESS", State: "finished"},
+			expectedError:  "",
+		},
+		{
+			name:           "Failed build",
+			mockResponse:   types.BuildStatusResponse{ID: 123, Status: "FAILURE", State: "finished"},
+			expectedResult: types.BuildStatusResponse{ID: 123, Status: "FAILURE", State: "finished"},
+			expectedError:  "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a test server that returns finished state immediately
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusOK)
+				_ = json.NewEncoder(w).Encode(tt.mockResponse)
+			}))
+			defer server.Close()
+
+			// Parse server URL
+			serverURL, err := url.Parse(server.URL)
+			require.NoError(t, err)
+
+			// Create client
+			client, err := NewTeamCityClient(serverURL, "testuser", "testpass")
+			require.NoError(t, err)
+
+			// Call WaitForBuild
+			result, err := client.Build.WaitForBuild("TestBuild", 123, 30*time.Second)
+
+			// Assert results
+			if tt.expectedError != "" {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tt.expectedError)
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, tt.expectedResult.ID, result.ID)
+			assert.Equal(t, tt.expectedResult.Status, result.Status)
+			assert.Equal(t, tt.expectedResult.State, result.State)
+		})
+	}
+}

teamcity/teamcity.go

@@ -6,12 +6,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	log "github.com/sirupsen/logrus"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
+
+	log "github.com/sirupsen/logrus"
 )
 
 var (

version/version.txt

@@ -1 +1 @@
-1.0.0-rc1
+1.1.0