fix: builder and sdk changes (#81)

## Description

<!-- **Please link some issue here describing what you are trying to achieve.**

In case there is no issue present for your PR, please consider creating one.
At least please give us some description what you are trying to achieve and why your change is needed. -->

relates to #1234

## Checklist

- [ ] Issue was linked above
- [ ] Code format was applied: `make fmt`
- [ ] Examples were added / adjusted (see `examples/` directory)
- [x] Docs are up-to-date: `make generate-docs` (will be checked by CI)
- [ ] Unit tests got implemented or updated
- [ ] Acceptance tests got implemented or updated (see e.g. [here](f5f99d1709/stackit/internal/services/dns/dns_acc_test.go))
- [x] Unit tests are passing: `make test` (will be checked by CI)
- [x] No linter issues: `make lint` (will be checked by CI)

Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
Co-authored-by: marcel.henselin <marcel.henselin@stackit.cloud>
Reviewed-on: #81

stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go

@@ -5,17 +5,23 @@ import (
 	_ "embed"
 	"fmt"
 	"log"
+	"math"
 	"os"
 	"strconv"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/terraform"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
 
-	postgresflexalpha2 "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/postgresflexalpha"
-	postgresflexalpha "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
+	postgresflexalphaInstance "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/wait/postgresflexalpha"
 
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/internal/testutils"
 	// The fwresource import alias is so there is no collision
@@ -26,61 +32,15 @@ import (
 
 const pfx = "stackitprivatepreview_postgresflexalpha"
 
-var testInstances []string
-
-func init() {
-	sweeperName := fmt.Sprintf("%s_%s", pfx, "sweeper")
-	resource.AddTestSweepers(
-		sweeperName, &resource.Sweeper{
-			Name: sweeperName,
-			F: func(_ string) error { // region is passed by the testing framework
-				ctx := context.Background()
-				apiClientConfigOptions := []config.ConfigurationOption{}
-				apiClient, err := postgresflexalpha2.NewAPIClient(apiClientConfigOptions...)
-				if err != nil {
-					log.Fatalln(err)
-				}
-
-				instances, err := apiClient.ListInstancesRequest(ctx, testutils.ProjectId, testutils.Region).
-					Size(100).
-					Execute()
-				if err != nil {
-					log.Fatalln(err)
-				}
-
-				for _, inst := range instances.GetInstances() {
-					if strings.HasPrefix(inst.GetName(), "tf-acc-") {
-						for _, item := range testInstances {
-							if inst.GetName() == item {
-								delErr := apiClient.DeleteInstanceRequestExecute(
-									ctx,
-									testutils.ProjectId,
-									testutils.Region,
-									inst.GetId(),
-								)
-								if delErr != nil {
-									// TODO: maybe just warn?
-									log.Fatalln(delErr)
-								}
-							}
-						}
-					}
-				}
-				return nil
-			},
-		},
-	)
-}
-
 func TestInstanceResourceSchema(t *testing.T) {
-	t.Parallel()
+	// t.Parallel()
 
 	ctx := context.Background()
 	schemaRequest := fwresource.SchemaRequest{}
 	schemaResponse := &fwresource.SchemaResponse{}
 
 	// Instantiate the resource.Resource and call its Schema method
-	postgresflexalpha.NewInstanceResource().Schema(ctx, schemaRequest, schemaResponse)
+	postgresflexalphaInstance.NewInstanceResource().Schema(ctx, schemaRequest, schemaResponse)
 
 	if schemaResponse.Diagnostics.HasError() {
 		t.Fatalf("Schema method diagnostics: %+v", schemaResponse.Diagnostics)
@@ -94,14 +54,6 @@ func TestInstanceResourceSchema(t *testing.T) {
 	}
 }
 
-var (
-	//go:embed testdata/resource-no-enc.tf
-	resourceConfigNoEnc string //nolint:unused // needs implementation
-
-	//go:embed testdata/resource-enc.tf
-	resourceConfigEnc string //nolint:unused // needs implementation
-)
-
 func TestMain(m *testing.M) {
 	testutils.Setup()
 	code := m.Run()
@@ -115,44 +67,23 @@ func testAccPreCheck(t *testing.T) {
 	}
 }
 
-// func TestAccResourceExample_parallel(t *testing.T) {
-//	t.Parallel()
-//
-//	exData := resData{
-//		Region:                 "eu01",
-//		ServiceAccountFilePath: sa_file,
-//		ProjectID:              project_id,
-//		Name:                   acctest.RandomWithPrefix("tf-acc"),
-//	}
-//
-//	resource.Test(t, resource.TestCase{
-//		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
-//		Steps: []resource.TestStep{
-//			{
-//				Config: testAccResourceEncryptionExampleConfig(exData),
-//				Check:  resource.TestCheckResourceAttrSet("example_resource.test", "id"),
-//			},
-//		},
-//	})
-//}
-
 type resData struct {
 	ServiceAccountFilePath string
-	ProjectId              string
+	ProjectID              string
 	Region                 string
 	Name                   string
 	TfName                 string
-	FlavorId               string
+	FlavorID               string
 	BackupSchedule         string
 	UseEncryption          bool
-	KekKeyId               string
-	KekKeyRingId           string
+	KekKeyID               string
+	KekKeyRingID           string
 	KekKeyVersion          uint8
 	KekServiceAccount      string
 	PerformanceClass       string
 	Replicas               uint32
 	Size                   uint32
-	AclString              string
+	ACLString              string
 	AccessScope            string
 	RetentionDays          uint32
 	Version                string
@@ -162,13 +93,13 @@ type resData struct {
 
 type User struct {
 	Name      string
-	ProjectId string
+	ProjectID string
 	Roles     []string
 }
 
 type Database struct {
 	Name      string
-	ProjectId string
+	ProjectID string
 	Owner     string
 }
 
@@ -177,17 +108,17 @@ func getExample() resData {
 	return resData{
 		Region:                 os.Getenv("TF_ACC_REGION"),
 		ServiceAccountFilePath: os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE"),
-		ProjectId:              os.Getenv("TF_ACC_PROJECT_ID"),
+		ProjectID:              os.Getenv("TF_ACC_PROJECT_ID"),
 		Name:                   name,
 		TfName:                 name,
-		FlavorId:               "2.4",
+		FlavorID:               "2.4",
 		BackupSchedule:         "0 0 * * *",
 		UseEncryption:          false,
 		RetentionDays:          33,
 		Replicas:               1,
 		PerformanceClass:       "premium-perf2-stackit",
 		Size:                   10,
-		AclString:              "0.0.0.0/0",
+		ACLString:              "0.0.0.0/0",
 		AccessScope:            "PUBLIC",
 		Version:                "17",
 	}
@@ -202,28 +133,103 @@ func TestAccInstance(t *testing.T) {
 	updSizeData := exData
 	updSizeData.Size = 25
 
+	updBackupSched := updSizeData
+	// api should complain about more than one daily backup
+	updBackupSched.BackupSchedule = "30 3 * * *"
+
+	/*
+		{
+		  "backupSchedule": "6 6 * * *",
+		  "flavorId": "1.2",
+		  "name": "postgres-instance",
+		  "network": {
+		    "acl": [
+		      "198.51.100.0/24"
+		    ]
+		  },
+		  "replicas": 1,
+		  "retentionDays": 35,
+		  "storage": {
+		    "size": 10
+		  },
+		  "version": "string"
+		}
+	*/
+
+	testItemID := testutils.ResStr(pfx, "instance", exData.TfName)
+
 	resource.ParallelTest(
 		t, resource.TestCase{
 			PreCheck: func() {
 				testAccPreCheck(t)
 				t.Logf("  ... working on instance %s", exData.TfName)
-				testInstances = append(testInstances, exData.TfName)
 			},
+			CheckDestroy:             testAccCheckPostgresFlexDestroy,
 			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 			Steps: []resource.TestStep{
 				// Create and verify
 				{
+					//PreConfig: func() {
+					//	//
+					// },
 					Config: testutils.StringFromTemplateMust(
 						"testdata/instance_template.gompl",
 						exData,
 					),
 					Check: resource.ComposeAggregateTestCheckFunc(
-						resource.TestCheckResourceAttr(
-							testutils.ResStr(pfx, "instance", exData.TfName),
-							"name",
-							exData.Name,
-						),
-						resource.TestCheckResourceAttrSet(testutils.ResStr(pfx, "instance", exData.TfName), "id"),
+						// check params acl count
+						resource.TestCheckResourceAttr(testItemID, "acl.#", "1"),
+
+						// check params are set
+						resource.TestCheckResourceAttrSet(testItemID, "backup_schedule"),
+
+						//// connection_info should contain 1 sub entry
+						// resource.TestCheckResourceAttr(testItemID, "connection_info.%", "1"),
+						//
+						//// connection_info.write should contain 2 sub entries
+						// resource.TestCheckResourceAttr(testItemID, "connection_info.write", "2"),
+						//
+						// resource.TestCheckResourceAttrSet(testItemID, "connection_info.write.host"),
+						// resource.TestCheckResourceAttrSet(testItemID, "connection_info.write.port"),
+
+						resource.TestCheckResourceAttrSet(testItemID, "flavor_id"),
+						resource.TestCheckResourceAttrSet(testItemID, "id"),
+						resource.TestCheckResourceAttrSet(testItemID, "instance_id"),
+						resource.TestCheckResourceAttrSet(testItemID, "is_deletable"),
+						resource.TestCheckResourceAttrSet(testItemID, "name"),
+
+						// network should contain 4 sub entries
+						resource.TestCheckResourceAttr(testItemID, "network.%", "4"),
+
+						resource.TestCheckResourceAttrSet(testItemID, "network.access_scope"),
+
+						// on unencrypted instances we expect this to be empty
+						resource.TestCheckResourceAttr(testItemID, "network.instance_address", ""),
+						resource.TestCheckResourceAttr(testItemID, "network.router_address", ""),
+
+						// only one acl entry should be set
+						resource.TestCheckResourceAttr(testItemID, "network.acl.#", "1"),
+
+						resource.TestCheckResourceAttrSet(testItemID, "replicas"),
+						resource.TestCheckResourceAttrSet(testItemID, "retention_days"),
+						resource.TestCheckResourceAttrSet(testItemID, "status"),
+
+						// storage should contain 2 sub entries
+						resource.TestCheckResourceAttr(testItemID, "storage.%", "2"),
+
+						resource.TestCheckResourceAttrSet(testItemID, "storage.performance_class"),
+						resource.TestCheckResourceAttrSet(testItemID, "storage.size"),
+						resource.TestCheckResourceAttrSet(testItemID, "version"),
+
+						// check absent attr
+						resource.TestCheckNoResourceAttr(testItemID, "encryption"),
+						resource.TestCheckNoResourceAttr(testItemID, "encryption.kek_key_id"),
+						resource.TestCheckNoResourceAttr(testItemID, "encryption.kek_key_ring_id"),
+						resource.TestCheckNoResourceAttr(testItemID, "encryption.kek_key_version"),
+						resource.TestCheckNoResourceAttr(testItemID, "encryption.service_account"),
+
+						// check param values
+						resource.TestCheckResourceAttr(testItemID, "name", exData.Name),
 					),
 				},
 				// Update name and verify
@@ -254,6 +260,20 @@ func TestAccInstance(t *testing.T) {
 						),
 					),
 				},
+				// Update backup schedule
+				{
+					Config: testutils.StringFromTemplateMust(
+						"testdata/instance_template.gompl",
+						updBackupSched,
+					),
+					Check: resource.ComposeTestCheckFunc(
+						resource.TestCheckResourceAttr(
+							testutils.ResStr(pfx, "instance", exData.TfName),
+							"backup_schedule",
+							updBackupSched.BackupSchedule,
+						),
+					),
+				},
 				//// Import test
 				//{
 				//	ResourceName:      "example_resource.test",
@@ -272,7 +292,7 @@ func TestAccInstanceWithUsers(t *testing.T) {
 	data.Users = []User{
 		{
 			Name:      userName,
-			ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
 			Roles:     []string{"login"},
 		},
 	}
@@ -282,8 +302,8 @@ func TestAccInstanceWithUsers(t *testing.T) {
 			PreCheck: func() {
 				testAccPreCheck(t)
 				t.Logf("  ... working on instance %s", data.TfName)
-				testInstances = append(testInstances, data.TfName)
 			},
+			CheckDestroy:             testAccCheckPostgresFlexDestroy,
 			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 			Steps: []resource.TestStep{
 				// Create and verify
@@ -316,7 +336,7 @@ func TestAccInstanceWithDatabases(t *testing.T) {
 	data.Users = []User{
 		{
 			Name:      userName,
-			ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
 			Roles:     []string{"login"},
 		},
 	}
@@ -324,7 +344,7 @@ func TestAccInstanceWithDatabases(t *testing.T) {
 	data.Databases = []Database{
 		{
 			Name:      dbName,
-			ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
 			Owner:     userName,
 		},
 	}
@@ -334,8 +354,95 @@ func TestAccInstanceWithDatabases(t *testing.T) {
 			PreCheck: func() {
 				testAccPreCheck(t)
 				t.Logf("  ... working on instance %s", data.TfName)
-				testInstances = append(testInstances, data.TfName)
 			},
+			CheckDestroy:             testAccCheckPostgresFlexDestroy,
+			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
+			Steps: []resource.TestStep{
+				// Create and verify
+				{
+					Config: testutils.StringFromTemplateMust(
+						"testdata/instance_template.gompl",
+						data,
+					),
+					Check: resource.ComposeAggregateTestCheckFunc(
+						resource.TestCheckResourceAttr(
+							testutils.ResStr(pfx, "instance", data.TfName),
+							"name",
+							data.Name,
+						),
+						resource.TestCheckResourceAttrSet(testutils.ResStr(pfx, "instance", data.TfName), "id"),
+						resource.TestCheckResourceAttr(testutils.ResStr(pfx, "user", userName), "name", userName),
+						resource.TestCheckResourceAttrSet(testutils.ResStr(pfx, "user", userName), "id"),
+						resource.TestCheckResourceAttr(testutils.ResStr(pfx, "database", dbName), "name", dbName),
+						resource.TestCheckResourceAttr(testutils.ResStr(pfx, "database", dbName), "owner", userName),
+						resource.TestCheckResourceAttrSet(testutils.ResStr(pfx, "database", dbName), "id"),
+					),
+				},
+			},
+		},
+	)
+}
+
+func TestAccEncryptedInstanceWithDatabases(t *testing.T) {
+	encKekKeyID, ok := os.LookupEnv("TF_ACC_KEK_KEY_ID")
+	if !ok || encKekKeyID == "" {
+		t.Skip("env var TF_ACC_KEK_KEY_ID needed for encryption test")
+	}
+
+	encKekKeyRingID, ok := os.LookupEnv("TF_ACC_KEK_KEY_RING_ID")
+	if !ok || encKekKeyRingID == "" {
+		t.Skip("env var TF_ACC_KEK_KEY_RING_ID needed for encryption test")
+	}
+
+	encKekKeyVersion, ok := os.LookupEnv("TF_ACC_KEK_KEY_VERSION")
+	if !ok || encKekKeyVersion == "" {
+		t.Skip("env var TF_ACC_KEK_KEY_VERSION needed for encryption test")
+	}
+
+	encSvcAcc, ok := os.LookupEnv("TF_ACC_KEK_SERVICE_ACCOUNT")
+	if !ok || encSvcAcc == "" {
+		t.Skip("env var TF_ACC_KEK_SERVICE_ACCOUNT needed for encryption test")
+	}
+
+	data := getExample()
+	data.UseEncryption = true
+	data.KekKeyID = encKekKeyID
+	data.KekKeyRingID = encKekKeyRingID
+	data.KekServiceAccount = encSvcAcc
+	encKekKeyVersionInt, err := strconv.Atoi(encKekKeyVersion)
+	if err != nil {
+		t.Errorf("error converting string to int")
+	}
+	if encKekKeyVersionInt > math.MaxUint8 {
+		t.Errorf("value too large to convert to uint8")
+	}
+	data.KekKeyVersion = uint8(encKekKeyVersionInt) //nolint:gosec // handled above
+
+	dbName := "testdb"
+	userName := "testUser"
+	data.Users = []User{
+		{
+			Name:      userName,
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
+			Roles:     []string{"login"},
+		},
+	}
+
+	data.Databases = []Database{
+		{
+			Name:      dbName,
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
+			Owner:     userName,
+		},
+	}
+
+	resource.ParallelTest(
+		t, resource.TestCase{
+			PreCheck: func() {
+				testAccPreCheck(t)
+				t.Logf("  ... working on instance %s", data.TfName)
+			},
+			CheckDestroy:             testAccCheckPostgresFlexDestroy,
 			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 			Steps: []resource.TestStep{
 				// Create and verify
@@ -402,19 +509,6 @@ func TestAccInstanceWithDatabases(t *testing.T) {
 //	// Run unit tests against mock
 //}
 
-// type postgresFlexClientMocked struct {
-//	returnError    bool
-//	getFlavorsResp *postgresflex.GetFlavorsResponse
-// }
-//
-// func (c *postgresFlexClientMocked) ListFlavorsExecute(_ context.Context, _, _ string) (*postgresflex.GetFlavorsResponse, error) {
-//	if c.returnError {
-//		return nil, fmt.Errorf("get flavors failed")
-//	}
-//
-//	return c.getFlavorsResp, nil
-// }
-
 // func TestNewInstanceResource(t *testing.T) {
 //	exData := resData{
 //		Region:                 "eu01",
@@ -1028,3 +1122,87 @@ func TestAccInstanceWithDatabases(t *testing.T) {
 //	}
 //	return nil
 //}
+
+func testAccCheckPostgresFlexDestroy(s *terraform.State) error {
+	testutils.Setup()
+
+	pID, ok := os.LookupEnv("TF_ACC_PROJECT_ID")
+	if !ok {
+		log.Fatalln("unable to read TF_ACC_PROJECT_ID")
+	}
+
+	ctx := context.Background()
+	var client *v3alpha1api.APIClient
+	var err error
+
+	var region, projectID string
+	region = testutils.Region
+	if region == "" {
+		region = "eu01"
+	}
+
+	projectID = pID
+	if projectID == "" {
+		return fmt.Errorf("projectID could not be determined in destroy function")
+	}
+
+	apiClientConfigOptions := []config.ConfigurationOption{
+		config.WithServiceAccountKeyPath(os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE")),
+		config.WithRegion(region),
+	}
+	if testutils.PostgresFlexCustomEndpoint != "" {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithEndpoint(testutils.PostgresFlexCustomEndpoint),
+		)
+	}
+	client, err = v3alpha1api.NewAPIClient(apiClientConfigOptions...)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	instancesToDestroy := []string{}
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "stackitprivatepreview_postgresflexalpha_instance" &&
+			rs.Type != "stackitprivatepreview_postgresflexbeta_instance" {
+			continue
+		}
+
+		// instance terraform ID: = "[project_id],[region],[instance_id]"
+		instanceID := strings.Split(rs.Primary.ID, core.Separator)[2]
+		instancesToDestroy = append(instancesToDestroy, instanceID)
+	}
+
+	instancesResp, err := client.DefaultAPI.ListInstancesRequest(ctx, projectID, region).
+		Size(100).
+		Execute()
+	if err != nil {
+		return fmt.Errorf("getting instancesResp: %w", err)
+	}
+
+	items := instancesResp.GetInstances()
+	for i := range items {
+		if items[i].Id == "" {
+			continue
+		}
+		if utils.Contains(instancesToDestroy, items[i].Id) {
+			err := client.DefaultAPI.DeleteInstanceRequest(ctx, testutils.ProjectId, region, items[i].Id).Execute()
+			if err != nil {
+				return fmt.Errorf("deleting instance %s during CheckDestroy: %w", items[i].Id, err)
+			}
+			err = postgresflexalpha.DeleteInstanceWaitHandler(
+				ctx,
+				client.DefaultAPI,
+				testutils.ProjectId,
+				testutils.Region,
+				items[i].Id,
+				15*time.Minute,
+				10*time.Second,
+			)
+			if err != nil {
+				return fmt.Errorf("deleting instance %s during CheckDestroy: waiting for deletion %w", items[i].Id, err)
+			}
+		}
+	}
+	return nil
+}