actions on/off/terminate OK, server state is now computed

Author: Mia-Cross

internal/services/instance/action_server_action.go

@@ -136,7 +136,7 @@ func (a *ServerAction) Invoke(ctx context.Context, req action.InvokeRequest, res
 		}
 
 		_, errWait := a.instanceAPI.WaitForServer(waitReq)
-		if errWait != nil {
+		if errWait != nil && data.Action.ValueString() != instance.ServerActionTerminate.String() {
 			resp.Diagnostics.AddError(
 				"error in wait server",
 				fmt.Sprintf("%s", err))

internal/services/instance/action_server_action_test.go

@@ -2,13 +2,17 @@ package instance_test
 
 import (
 	"errors"
+	"fmt"
 	"regexp"
 	"strings"
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
+	instanceSDK "github.com/scaleway/scaleway-sdk-go/api/instance/v1"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/acctest"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/services/instance"
+	instancechecks "github.com/scaleway/terraform-provider-scaleway/v2/internal/services/instance/testfuncs"
 )
 
 func TestAccActionServer_Basic(t *testing.T) {
@@ -21,6 +25,7 @@ func TestAccActionServer_Basic(t *testing.T) {
 
 	resource.ParallelTest(t, resource.TestCase{
 		ProtoV6ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:             instancechecks.IsServerDestroyed(tt),
 		Steps: []resource.TestStep{
 			{
 				Config: `
@@ -97,6 +102,169 @@ func TestAccActionServer_Basic(t *testing.T) {
 	})
 }
 
+func TestAccActionServer_On_Off(t *testing.T) {
+	if acctest.IsRunningOpenTofu() {
+		t.Skip("Skipping TestAccActionServer_Basic because action are not yet supported on OpenTofu")
+	}
+
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+
+	resource.ParallelTest(t, resource.TestCase{
+		ProtoV6ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:             instancechecks.IsServerDestroyed(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_instance_server" "main" {
+						name = "test-terraform-action-server-on-off"
+						type = "DEV1-S"
+						image = "ubuntu_jammy"
+
+					  	lifecycle {
+							action_trigger {
+						  		events  = [after_create]
+						  		actions = [action.scaleway_instance_server_action.stop]
+							}
+					  	}
+					}
+
+					action "scaleway_instance_server_action" "stop" {
+						config {
+						  	action = "%s"
+							server_id = scaleway_instance_server.main.id
+							wait = true
+						}
+					}`, instanceSDK.ServerActionStopInPlace),
+			},
+			{
+				RefreshState: true,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("scaleway_instance_server.main", "state", instance.InstanceServerStateStandby),
+					readActualServerState(tt, "scaleway_instance_server.main", instanceSDK.ServerStateStoppedInPlace.String()),
+				),
+			},
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_instance_server" "main" {
+						name = "should-be-powered-off"
+						type = "DEV1-S"
+						image = "ubuntu_jammy"
+
+					  	lifecycle {
+							action_trigger {
+						  		events  = [after_update]
+						  		actions = [action.scaleway_instance_server_action.poweroff]
+							}
+					  	}
+					}
+
+					action "scaleway_instance_server_action" "poweroff" {
+						config {
+						  	action = "%s"
+							server_id = scaleway_instance_server.main.id
+							wait = true
+						}
+					}`, instanceSDK.ServerActionPoweroff),
+			},
+			{
+				RefreshState: true,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("scaleway_instance_server.main", "state", instance.InstanceServerStateStopped),
+					readActualServerState(tt, "scaleway_instance_server.main", instanceSDK.ServerStateStopped.String()),
+				),
+			},
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_instance_server" "main" {
+						name = "should-be-started"
+						type = "DEV1-S"
+						image = "ubuntu_jammy"
+
+					  	lifecycle {
+							action_trigger {
+						  		events  = [after_update]
+						  		actions = [action.scaleway_instance_server_action.start]
+							}
+					  	}
+					}
+
+					action "scaleway_instance_server_action" "start" {
+						config {
+						  	action = "%s"
+							server_id = scaleway_instance_server.main.id
+							wait = true
+						}
+					}`, instanceSDK.ServerActionPoweron),
+			},
+			{
+				RefreshState: true,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("scaleway_instance_server.main", "state", instance.InstanceServerStateStarted),
+					readActualServerState(tt, "scaleway_instance_server.main", instanceSDK.ServerStateRunning.String()),
+				),
+			},
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_instance_server" "main" {
+						name = "should-be-terminated"
+						type = "DEV1-S"
+						image = "ubuntu_jammy"
+
+					  	lifecycle {
+							action_trigger {
+						  		events  = [after_update]
+						  		actions = [action.scaleway_instance_server_action.terminate]
+							}
+					  	}
+					}
+
+					action "scaleway_instance_server_action" "terminate" {
+						config {
+						  	action = "%s"
+							server_id = scaleway_instance_server.main.id
+							wait = false
+						}
+					}`, instanceSDK.ServerActionTerminate),
+				ExpectNonEmptyPlan: true,
+			},
+			{
+				RefreshState:       true,
+				Check:              instancechecks.IsServerDestroyed(tt),
+				ExpectNonEmptyPlan: true,
+			},
+		},
+	})
+}
+
+func readActualServerState(tt *acctest.TestTools, n string, expectedState string) resource.TestCheckFunc {
+	return func(state *terraform.State) error {
+		rs, ok := state.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("resource not found: %s", n)
+		}
+
+		api, zone, id, err := instance.NewAPIWithZoneAndID(tt.Meta, rs.Primary.ID)
+		if err != nil {
+			return err
+		}
+
+		server, err := api.GetServer(&instanceSDK.GetServerRequest{
+			Zone:     zone,
+			ServerID: id,
+		})
+		if err != nil {
+			return err
+		}
+
+		if server.Server.State.String() != expectedState {
+			return fmt.Errorf("expected server state to be %q, got %q", expectedState, server.Server.State)
+		}
+
+		return nil
+	}
+}
+
 func TestAccActionServer_UnknownVerb(t *testing.T) {
 	if acctest.IsRunningOpenTofu() {
 		t.Skip("Skipping TestAccActionServer_Basic because action are not yet supported on OpenTofu")

internal/services/instance/helpers_instance.go

@@ -135,6 +135,9 @@ func serverStateFlatten(fromState instance.ServerState) (string, error) {
 
 // serverStateExpand converts terraform state to an API state or return an error.
 func serverStateExpand(rawState string) (instance.ServerState, error) {
+	if rawState == "" {
+		return instance.ServerStateRunning, nil
+	}
 	apiState, exist := map[string]instance.ServerState{
 		InstanceServerStateStopped: instance.ServerStateStopped,
 		InstanceServerStateStandby: instance.ServerStateStoppedInPlace,

internal/services/instance/server.go

@@ -255,7 +255,7 @@ func serverSchema() map[string]*schema.Schema {
 		"state": {
 			Type:        schema.TypeString,
 			Optional:    true,
-			Default:     InstanceServerStateStarted,
+			Computed:    true,
 			Description: "The state of the server should be: started, stopped, standby",
 			ValidateFunc: validation.StringInSlice([]string{
 				InstanceServerStateStarted,