test(iaas): rewrite mock-based test to use resource.UnitTest instead

Relates to STACKITTPR-782

Author: SerseusWasTaken

stackit/internal/services/iaas/volume/resource_create_test.go

@@ -1,202 +1,135 @@
-package volume
+package volume_test
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
-	"net/http/httptest"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-framework/resource"
-	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-go/tftypes"
-	sdkConfig "github.com/stackitcloud/stackit-sdk-go/core/config"
-	iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api"
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-)
+	iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api"
 
-const (
-	testProjectId        = "4e684f79-a12c-449d-aa89-bcd9d8aafaf2"
-	testRegion           = "eu01"
-	testVolumeId         = "3dee3fb9-59f0-4f97-8eeb-a4da37d05a00"
-	testKeyPayloadBase64 = "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIDEzIGxhenkgZG9ncy4="
+	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/testutil"
 )
 
-// buildCreateRequest builds a resource.CreateRequest from a plan and a config model.
-// Terraform populates write-only attribute values only in the config model - never in the plan or state model.
-// That's why we need both, the plan model AND config model to build the request.
-func buildCreateRequest(ctx context.Context, t *testing.T, schemaResp *resource.SchemaResponse, planModel, configModel *Model) resource.CreateRequest {
-	t.Helper()
-
-	req := resource.CreateRequest{}
-	req.Plan = tfsdk.Plan{
-		Schema: schemaResp.Schema,
-		Raw:    tftypes.NewValue(tftypes.DynamicPseudoType, nil),
-	}
-	if diags := req.Plan.Set(ctx, planModel); diags.HasError() {
-		t.Fatalf("Failed to set plan: %v", diags.Errors())
-	}
-
-	configScratch := tfsdk.Plan{
-		Schema: schemaResp.Schema,
-		Raw:    tftypes.NewValue(tftypes.DynamicPseudoType, nil),
-	}
-	if diags := configScratch.Set(ctx, configModel); diags.HasError() {
-		t.Fatalf("Failed to set config: %v", diags.Errors())
-	}
-	req.Config = tfsdk.Config{
-		Schema: schemaResp.Schema,
-		Raw:    configScratch.Raw,
-	}
-
-	return req
-}
-
-type volumeFixture struct {
-	server             *httptest.Server
-	capturedKeyPayload *string
-	createCalled       bool
-}
-
-// newVolumeFixture spins up a mock IaaS API server handling volume creation and the subsequent
-// polling of the wait handler. The create handler decodes the request body and records the
-// encryption key payload that the provider sent to the API.
-func newVolumeFixture(t *testing.T) *volumeFixture {
-	t.Helper()
-	fixture := &volumeFixture{}
-
-	mux := http.NewServeMux()
-	// Create volume
-	mux.HandleFunc(fmt.Sprintf("POST /v2/projects/%s/regions/%s/volumes", testProjectId, testRegion), func(w http.ResponseWriter, r *http.Request) {
-		fixture.createCalled = true
-		body, err := io.ReadAll(r.Body)
-		if err != nil {
-			t.Errorf("Failed to read create request body: %v", err)
-			w.WriteHeader(http.StatusBadRequest)
-			return
-		}
-		var payload iaas.CreateVolumePayload
-		if err := json.Unmarshal(body, &payload); err != nil {
-			t.Errorf("Failed to unmarshal create request body: %v", err)
-			w.WriteHeader(http.StatusBadRequest)
-			return
-		}
-		if payload.EncryptionParameters != nil {
-			fixture.capturedKeyPayload = payload.EncryptionParameters.KeyPayload
-		}
-
-		w.Header().Set("content-type", "application/json")
-		volumeId := testVolumeId
-		_ = json.NewEncoder(w).Encode(iaas.Volume{Id: &volumeId})
-	})
-	// Get volume (used by the create wait handler and by mapFields via the response of the wait handler)
-	mux.HandleFunc(fmt.Sprintf("GET /v2/projects/%s/regions/%s/volumes/%s", testProjectId, testRegion, testVolumeId), func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("content-type", "application/json")
-		volumeId := testVolumeId
-		status := "AVAILABLE"
-		_ = json.NewEncoder(w).Encode(iaas.Volume{
-			Id:               &volumeId,
-			Status:           &status,
-			AvailabilityZone: "eu01-1",
-		})
-	})
-
-	fixture.server = httptest.NewServer(mux)
-	t.Cleanup(fixture.server.Close)
-	return fixture
-}
-
-// newTestVolumeResource builds a volumeResource with the client's URL being set to the mock URL
-func newTestVolumeResource(t *testing.T, server *httptest.Server) *volumeResource {
-	t.Helper()
-	client, err := iaas.NewAPIClient(
-		sdkConfig.WithEndpoint(server.URL),
-		sdkConfig.WithoutAuthentication(),
+// TestCreateWriteOnlyKeyPayload is a regression test for the bug where the write-only key payload
+// was read from the plan model instead of the config model.
+// The test asserts that the value configured via key_payload_base64_wo is actually
+// sent to the API in the create request.
+func TestCreateWriteOnlyKeyPayload(t *testing.T) {
+	projectId := uuid.NewString()
+	volumeId := uuid.NewString()
+	kekKeyId := uuid.NewString()
+	kekKeyringId := uuid.NewString()
+	const (
+		region              = "eu01"
+		availabilityZone    = "eu01-1"
+		name                = "test-volume"
+		size                = 16
+		serviceAccount      = "test-sa@sa.stackit.cloud"
+		testKeyPayload      = "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIDEzIGxhenkgZG9ncy4="
+		volumeStatusCreated = "AVAILABLE"
 	)
-	if err != nil {
-		t.Fatalf("Failed to initialize client: %v", err)
-	}
-	return &volumeResource{
-		client: client,
-		providerData: core.ProviderData{
-			DefaultRegion: testRegion,
-		},
-	}
+	s := testutil.NewMockServer(t)
+	t.Cleanup(s.Server.Close)
+	tfConfig := fmt.Sprintf(`
+provider "stackit" {
+	default_region = "%s"
+	iaas_custom_endpoint = "%s"
+	service_account_token = "mock-server-needs-no-auth"
 }
 
-func encryptionParametersTestModel() *encryptionParametersModel {
-	return &encryptionParametersModel{
-		KekKeyId:                         types.StringValue("11111111-1111-1111-1111-111111111111"),
-		KekKeyVersion:                    types.Int64Value(1),
-		KekKeyringId:                     types.StringValue("22222222-2222-2222-2222-222222222222"),
-		KeyPayloadBase64:                 types.StringNull(),
-		KeyPayloadBase64WriteOnly:        types.StringNull(), // will be set manually for the config model
-		KeyPayloadBase64WriteOnlyVersion: types.Int64Value(1),
-		ServiceAccount:                   types.StringValue("test-sa@sa.stackit.cloud"),
+resource "stackit_volume" "volume" {
+	project_id = "%s"
+	availability_zone = "%s"
+	name = "%s"
+	size = %d
+	encryption_parameters = {
+		kek_key_id = "%s"
+		kek_key_version = 1
+		kek_keyring_id = "%s"
+		key_payload_base64_wo = "%s"
+		key_payload_base64_wo_version = 1
+		service_account = "%s"
 	}
 }
-
-func baseTestModel() Model {
-	return Model{
-		ProjectId:        types.StringValue(testProjectId),
-		Region:           types.StringValue(testRegion),
-		AvailabilityZone: types.StringValue("eu01-1"),
-		Name:             types.StringValue("test-volume"),
-		Size:             types.Int64Value(16),
-		Labels:           types.MapNull(types.StringType),
-		Source:           types.ObjectNull(sourceTypes),
+`, region, s.Server.URL, projectId, availabilityZone, name, size, kekKeyId, kekKeyringId, testKeyPayload, serviceAccount)
+
+	volumeName := name
+	volumeSize := int64(size)
+	volume := iaas.Volume{
+		Id:               &volumeId,
+		Status:           new(volumeStatusCreated),
+		AvailabilityZone: availabilityZone,
+		Name:             &volumeName,
+		Size:             &volumeSize,
 	}
-}
 
-// TestCreate_WriteOnlyKeyPayload is a regression test for the bug where the write-only key payload
-// was read from the plan model instead of the config model.
-// The test asserts that the value configured via key_payload_base64_wo is actually
-// sent to the API in the create request.
-func TestCreate_WriteOnlyKeyPayload(t *testing.T) {
-	ctx := context.Background()
-
-	// Usually terraform will only ever write write-only fields in the config model, not the plan.
-	// Since we're setting the models manually here, we have to ensure this is done correctly.
-	// Ensuring that the write-only fields never go into the state/plan model is not part of this test's scope here
-	planModel := baseTestModel()
-	planModel.EncryptionParameters = encryptionParametersTestModel()
-
-	configModel := baseTestModel()
-	configEncryptionParams := encryptionParametersTestModel()
-	configEncryptionParams.KeyPayloadBase64WriteOnly = types.StringValue(testKeyPayloadBase64)
-	configModel.EncryptionParameters = configEncryptionParams
-
-	fixture := newVolumeFixture(t)
-	iaasRessource := newTestVolumeResource(t, fixture.server)
-
-	schemaResp := &resource.SchemaResponse{}
-	iaasRessource.Schema(ctx, resource.SchemaRequest{}, schemaResp)
-
-	req := buildCreateRequest(ctx, t, schemaResp, &planModel, &configModel)
-	// we have to set an initial empty state so it is != nil
-	resp := &resource.CreateResponse{}
-	resp.State = tfsdk.State{
-		Schema: schemaResp.Schema,
-		Raw:    tftypes.NewValue(tftypes.DynamicPseudoType, nil),
+	var capturedKeyPayload *string
+	createCalled := false
+	createVolume := testutil.MockResponse{
+		Description: "create",
+		Handler: func(w http.ResponseWriter, req *http.Request) {
+			expected := fmt.Sprintf("/v2/projects/%s/regions/%s/volumes", projectId, region)
+			if req.URL.Path != expected {
+				t.Errorf("expected request to %s, got %s", expected, req.URL.Path)
+			}
+			createCalled = true
+			body, err := io.ReadAll(req.Body)
+			if err != nil {
+				t.Errorf("failed to read create request body: %v", err)
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			var payload iaas.CreateVolumePayload
+			if err := json.Unmarshal(body, &payload); err != nil {
+				t.Errorf("failed to unmarshal create request body: %v", err)
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			if payload.EncryptionParameters != nil {
+				capturedKeyPayload = payload.EncryptionParameters.KeyPayload
+			}
+
+			w.Header().Set("content-type", "application/json")
+			_ = json.NewEncoder(w).Encode(iaas.Volume{Id: &volumeId})
+		},
 	}
 
-	iaasRessource.Create(ctx, req, resp)
+	resource.UnitTest(t, resource.TestCase{
+		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			{
+				PreConfig: func() {
+					s.Reset(
+						createVolume,
+						testutil.MockResponse{Description: "create waiter", ToJsonBody: volume},
+						testutil.MockResponse{Description: "get", ToJsonBody: volume},
+						testutil.MockResponse{Description: "delete", StatusCode: http.StatusAccepted},
+						testutil.MockResponse{Description: "delete waiter", StatusCode: http.StatusNotFound},
+					)
+				},
+				Config: tfConfig,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("stackit_volume.volume", "volume_id", volumeId),
+					resource.TestCheckResourceAttr("stackit_volume.volume", "region", region),
+					resource.TestCheckNoResourceAttr("stackit_volume.volume", "encryption_parameters.key_payload_base64_wo"),
+					resource.TestCheckResourceAttr("stackit_volume.volume", "encryption_parameters.key_payload_base64_wo_version", "1"),
+				),
+			},
+		},
+	})
 
-	if resp.Diagnostics.HasError() {
-		t.Fatalf("Create should succeed, but got errors: %v", resp.Diagnostics.Errors())
-	}
-	if !fixture.createCalled {
+	if !createCalled {
 		t.Fatalf("Expected the create endpoint to be called")
 	}
-
-	if fixture.capturedKeyPayload == nil {
-		t.Fatalf("Expected key payload %q to be sent to the API, but none was sent", testKeyPayloadBase64)
+	if capturedKeyPayload == nil {
+		t.Fatalf("Expected key payload %q to be sent to the API, but none was sent", testKeyPayload)
 	}
-	if *fixture.capturedKeyPayload != testKeyPayloadBase64 {
-		t.Fatalf("Wrong key payload sent to the API: expected %q, got %q", testKeyPayloadBase64, *fixture.capturedKeyPayload)
+	if *capturedKeyPayload != testKeyPayload {
+		t.Fatalf("Wrong key payload sent to the API: expected %q, got %q", testKeyPayload, *capturedKeyPayload)
 	}
 }