Merge pull request #1172 from hashicorp/TF-25656/deployment-run-cancel

Add `Cancel` to deployment run interface

Author: Maed223

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Enhancements
 * Add the `Links` attribute to the `StackDeploymentStep` struct to support the deployment step GET endpoint by @shwetamurali [#1167](https://github.com/h)
+* Adds endpoint for cancelling `StackDeploymentRun` by @Maed223 [#1172](https://github.com/hashicorp/go-tfe/pull/1172)
 
 # v1.88.0
 

stack_deployment_runs.go

@@ -17,6 +17,7 @@ type StackDeploymentRuns interface {
 	Read(ctx context.Context, stackDeploymentRunID string) (*StackDeploymentRun, error)
 	ReadWithOptions(ctx context.Context, stackDeploymentRunID string, options *StackDeploymentRunReadOptions) (*StackDeploymentRun, error)
 	ApproveAllPlans(ctx context.Context, deploymentRunID string) error
+	Cancel(ctx context.Context, stackDeploymentRunID string) error
 }
 
 // stackDeploymentRuns implements StackDeploymentRuns.
@@ -120,6 +121,15 @@ func (s stackDeploymentRuns) ApproveAllPlans(ctx context.Context, stackDeploymen
 	return req.Do(ctx, nil)
 }
 
+func (s stackDeploymentRuns) Cancel(ctx context.Context, stackDeploymentRunID string) error {
+	req, err := s.client.NewRequest("POST", fmt.Sprintf("stack-deployment-runs/%s/cancel", url.PathEscape(stackDeploymentRunID)), nil)
+	if err != nil {
+		return err
+	}
+
+	return req.Do(ctx, nil)
+}
+
 func (o *StackDeploymentRunReadOptions) valid() error {
 	for _, include := range o.Include {
 		switch include {

stack_deployment_runs_integration_test.go

@@ -6,6 +6,7 @@ package tfe
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -216,3 +217,96 @@ func TestStackDeploymentRunsApproveAllPlans(t *testing.T) {
 		require.NoError(t, err)
 	})
 }
+
+func TestStackDeploymentRunsCancel(t *testing.T) {
+	skipUnlessBeta(t)
+
+	client := testClient(t)
+	ctx := context.Background()
+
+	orgTest, orgTestCleanup := createOrganization(t, client)
+	t.Cleanup(orgTestCleanup)
+
+	oauthClient, cleanup := createOAuthClient(t, client, orgTest, nil)
+	t.Cleanup(cleanup)
+
+	stack, err := client.Stacks.Create(ctx, StackCreateOptions{
+		Project: orgTest.DefaultProject,
+		Name:    "test-stack",
+		VCSRepo: &StackVCSRepoOptions{
+			Identifier:   "hashicorp-guides/pet-nulls-stack",
+			OAuthTokenID: oauthClient.OAuthTokens[0].ID,
+			Branch:       "main",
+		},
+	})
+	require.NoError(t, err)
+	require.NotNil(t, stack)
+
+	stackUpdated, err := client.Stacks.UpdateConfiguration(ctx, stack.ID)
+	require.NoError(t, err)
+	require.NotNil(t, stackUpdated)
+
+	stack = pollStackDeployments(t, ctx, client, stackUpdated.ID)
+	require.NotNil(t, stack.LatestStackConfiguration)
+
+	// Get the deployment group ID from the stack configuration
+	deploymentGroups, err := client.StackDeploymentGroups.List(ctx, stack.LatestStackConfiguration.ID, nil)
+	require.NoError(t, err)
+	require.NotNil(t, deploymentGroups)
+	require.NotEmpty(t, deploymentGroups.Items)
+
+	deploymentGroupID := deploymentGroups.Items[0].ID
+
+	runList, err := client.StackDeploymentRuns.List(ctx, deploymentGroupID, nil)
+	require.NoError(t, err)
+	assert.NotNil(t, runList)
+
+	deploymentRunID := runList.Items[0].ID
+
+	t.Run("cancel deployment run", func(t *testing.T) {
+		t.Parallel()
+		err := client.StackDeploymentRuns.ApproveAllPlans(ctx, deploymentRunID)
+		require.NoError(t, err)
+
+		pollStackDeploymentRunForDeployingStatus(t, ctx, client, deploymentRunID)
+
+		err = client.StackDeploymentRuns.Cancel(ctx, deploymentRunID)
+		require.NoError(t, err)
+
+		dr, err := client.StackDeploymentRuns.Read(ctx, deploymentRunID)
+		require.NoError(t, err)
+		assert.NotNil(t, dr)
+		assert.Equal(t, "abandoned", dr.Status)
+	})
+}
+
+func pollStackDeploymentRunForDeployingStatus(t *testing.T, ctx context.Context, client *Client, stackDeploymentRunID string) {
+	t.Helper()
+
+	ctx, cancel := context.WithDeadline(ctx, time.Now().Add(5*time.Minute))
+	defer cancel()
+
+	deadline, _ := ctx.Deadline()
+	t.Logf("Polling stack deployment run %q for deploying status, with deadline of %s", stackDeploymentRunID, deadline)
+
+	ticker := time.NewTicker(2 * time.Second)
+	defer ticker.Stop()
+
+	for finished := false; !finished; {
+		t.Log("...")
+		select {
+		case <-ctx.Done():
+			t.Fatalf("Stack deployment run %q not deploying at deadline", stackDeploymentRunID)
+		case <-ticker.C:
+			var err error
+			sdr, err := client.StackDeploymentRuns.Read(ctx, stackDeploymentRunID)
+			if err != nil {
+				t.Fatalf("Failed to read stack deployment run %q: %s", stackDeploymentRunID, err)
+			}
+
+			if sdr.Status == "deploying" {
+				finished = true
+			}
+		}
+	}
+}

stack_integration_test.go

@@ -307,7 +307,7 @@ func pollStackDeployments(t *testing.T, ctx context.Context, client *Client, sta
 	defer cancel()
 
 	deadline, _ := ctx.Deadline()
-	t.Logf("Polling stack %q for deployments with deadline of %s", stackID, deadline)
+	t.Logf("Polling stack %q for deployment groups with deadline of %s", stackID, deadline)
 
 	ticker := time.NewTicker(2 * time.Second)
 	defer ticker.Stop()
@@ -316,16 +316,22 @@ func pollStackDeployments(t *testing.T, ctx context.Context, client *Client, sta
 		t.Log("...")
 		select {
 		case <-ctx.Done():
-			t.Fatalf("Stack %q had no deployments at deadline", stackID)
+			t.Fatalf("Stack %q had no deployment groups at deadline", stackID)
 		case <-ticker.C:
 			var err error
-			stack, err = client.Stacks.Read(ctx, stackID, nil)
+			stack, err = client.Stacks.Read(ctx, stackID, &StackReadOptions{
+				Include: []StackIncludeOpt{StackIncludeLatestStackConfiguration},
+			})
 			if err != nil {
 				t.Fatalf("Failed to read stack %q: %s", stackID, err)
 			}
+			groups, err := client.StackDeploymentGroups.List(ctx, stack.LatestStackConfiguration.ID, nil)
+			if err != nil {
+				t.Fatalf("Failed to read deployment groups %q: %s", stackID, err)
+			}
 
-			t.Logf("Stack %q had %d deployments", stack.ID, len(stack.DeploymentNames))
-			if len(stack.DeploymentNames) > 0 {
+			t.Logf("Stack %q had %d deployment groups", stack.ID, len(stack.DeploymentNames))
+			if groups.TotalCount > 0 {
 				finished = true
 			}
 		}