chore: refactor tests

internal/testutil/testutil.go.bak

@@ -1,5 +1,3 @@
-// Copyright (c) STACKIT
-
 package testutil
 
 import (

internal/testutils/functions.go

@@ -0,0 +1,125 @@
+package testutils
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"text/template"
+)
+
+// GetHomeEnvVariableName Helper function to obtain the home directory on different systems.
+// Based on os.UserHomeDir().
+func GetHomeEnvVariableName() string {
+	env := "HOME"
+	switch runtime.GOOS {
+	case "windows":
+		env = "USERPROFILE"
+	case "plan9":
+		env = "home"
+	}
+	return env
+}
+
+// CreateTemporaryHome create temporary home and initialize the credentials file as well
+func CreateTemporaryHome(createValidCredentialsFile bool, t *testing.T) string {
+	// create a temporary file
+	tempHome, err := os.MkdirTemp("", "tempHome")
+	if err != nil {
+		t.Fatalf("Failed to create temporary home directory: %v", err)
+	}
+
+	// create credentials file in temp directory
+	stackitFolder := path.Join(tempHome, ".stackit")
+	if err := os.Mkdir(stackitFolder, 0o750); err != nil {
+		t.Fatalf("Failed to create stackit folder: %v", err)
+	}
+
+	filePath := path.Join(stackitFolder, "credentials.json")
+	file, err := os.Create(filePath)
+	if err != nil {
+		t.Fatalf("Failed to create credentials file: %v", err)
+	}
+	defer func() {
+		if err := file.Close(); err != nil {
+			t.Fatalf("Error while closing the file: %v", err)
+		}
+	}()
+
+	// Define content, default = invalid token
+	token := "foo_token"
+	if createValidCredentialsFile {
+		token = GetTestProjectServiceAccountJson("")
+	}
+	if _, err = file.WriteString(token); err != nil {
+		t.Fatalf("Error writing to file: %v", err)
+	}
+
+	return tempHome
+}
+
+// SetTemporaryHome Function to overwrite the home folder
+func SetTemporaryHome(tempHomePath string) {
+	env := GetHomeEnvVariableName()
+	if err := os.Setenv(env, tempHomePath); err != nil {
+		fmt.Printf("Error setting temporary home directory %v", err)
+	}
+}
+
+// CleanupTemporaryHome cleanup the temporary home and reset the environment variable
+func CleanupTemporaryHome(tempHomePath string, t *testing.T) {
+	if err := os.RemoveAll(tempHomePath); err != nil {
+		t.Fatalf("Error cleaning up temporary folder: %v", err)
+	}
+	originalHomeDir, err := os.UserHomeDir()
+	if err != nil {
+		t.Fatalf("Failed to restore home directory back to normal: %v", err)
+	}
+	// revert back to original home folder
+	env := GetHomeEnvVariableName()
+	if err := os.Setenv(env, originalHomeDir); err != nil {
+		fmt.Printf("Error resetting temporary home directory %v", err)
+	}
+}
+
+func ucFirst(s string) string {
+	if len(s) == 0 {
+		return ""
+	}
+	return strings.ToUpper(s[:1]) + s[1:]
+}
+
+func StringFromTemplateMust(tplFile string, data any) string {
+	res, err := StringFromTemplate(tplFile, data)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	return res
+}
+
+func StringFromTemplate(tplFile string, data any) (string, error) {
+	fn := template.FuncMap{
+		"ucfirst": ucFirst,
+	}
+
+	file := filepath.Base(tplFile)
+
+	tmpl, err := template.New(file).Funcs(fn).ParseFiles(tplFile)
+	if err != nil {
+		return "", err
+	}
+
+	tplBuf := &bytes.Buffer{}
+
+	err = tmpl.Execute(tplBuf, data)
+	if err != nil {
+		return "", err
+	}
+
+	return tplBuf.String(), nil
+}

internal/testutils/helpers.go

@@ -0,0 +1,465 @@
+package testutils
+
+import (
+	"fmt"
+	"os"
+)
+
+var (
+	CdnCustomEndpoint             = os.Getenv("TF_ACC_CDN_CUSTOM_ENDPOINT")
+	DnsCustomEndpoint             = os.Getenv("TF_ACC_DNS_CUSTOM_ENDPOINT")
+	GitCustomEndpoint             = os.Getenv("TF_ACC_GIT_CUSTOM_ENDPOINT")
+	IaaSCustomEndpoint            = os.Getenv("TF_ACC_IAAS_CUSTOM_ENDPOINT")
+	KMSCustomEndpoint             = os.Getenv("TF_ACC_KMS_CUSTOM_ENDPOINT")
+	LoadBalancerCustomEndpoint    = os.Getenv("TF_ACC_LOADBALANCER_CUSTOM_ENDPOINT")
+	LogMeCustomEndpoint           = os.Getenv("TF_ACC_LOGME_CUSTOM_ENDPOINT")
+	MariaDBCustomEndpoint         = os.Getenv("TF_ACC_MARIADB_CUSTOM_ENDPOINT")
+	ModelServingCustomEndpoint    = os.Getenv("TF_ACC_MODELSERVING_CUSTOM_ENDPOINT")
+	AuthorizationCustomEndpoint   = os.Getenv("TF_ACC_authorization_custom_endpoint")
+	MongoDBFlexCustomEndpoint     = os.Getenv("TF_ACC_MONGODBFLEX_CUSTOM_ENDPOINT")
+	OpenSearchCustomEndpoint      = os.Getenv("TF_ACC_OPENSEARCH_CUSTOM_ENDPOINT")
+	ObservabilityCustomEndpoint   = os.Getenv("TF_ACC_OBSERVABILITY_CUSTOM_ENDPOINT")
+	ObjectStorageCustomEndpoint   = os.Getenv("TF_ACC_OBJECTSTORAGE_CUSTOM_ENDPOINT")
+	PostgresFlexCustomEndpoint    = os.Getenv("TF_ACC_POSTGRESFLEX_CUSTOM_ENDPOINT")
+	RabbitMQCustomEndpoint        = os.Getenv("TF_ACC_RABBITMQ_CUSTOM_ENDPOINT")
+	RedisCustomEndpoint           = os.Getenv("TF_ACC_REDIS_CUSTOM_ENDPOINT")
+	ResourceManagerCustomEndpoint = os.Getenv("TF_ACC_RESOURCEMANAGER_CUSTOM_ENDPOINT")
+	ScfCustomEndpoint             = os.Getenv("TF_ACC_SCF_CUSTOM_ENDPOINT")
+	SecretsManagerCustomEndpoint  = os.Getenv("TF_ACC_SECRETSMANAGER_CUSTOM_ENDPOINT")
+	SQLServerFlexCustomEndpoint   = os.Getenv("TF_ACC_SQLSERVERFLEX_CUSTOM_ENDPOINT")
+	ServerBackupCustomEndpoint    = os.Getenv("TF_ACC_SERVER_BACKUP_CUSTOM_ENDPOINT")
+	ServerUpdateCustomEndpoint    = os.Getenv("TF_ACC_SERVER_UPDATE_CUSTOM_ENDPOINT")
+	ServiceAccountCustomEndpoint  = os.Getenv("TF_ACC_SERVICE_ACCOUNT_CUSTOM_ENDPOINT")
+	SKECustomEndpoint             = os.Getenv("TF_ACC_SKE_CUSTOM_ENDPOINT")
+)
+
+func ObservabilityProviderConfig() string {
+	if ObservabilityCustomEndpoint == "" {
+		return `provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			observability_custom_endpoint = "%s"
+		}`,
+		ObservabilityCustomEndpoint,
+	)
+}
+
+func CdnProviderConfig() string {
+	if CdnCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			enable_beta_resources = true
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			cdn_custom_endpoint = "%s"
+			enable_beta_resources = true
+		}`,
+		CdnCustomEndpoint,
+	)
+}
+
+func DnsProviderConfig() string {
+	if DnsCustomEndpoint == "" {
+		return `provider "stackitprivatepreview" {}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			dns_custom_endpoint = "%s"
+		}`,
+		DnsCustomEndpoint,
+	)
+}
+
+func IaaSProviderConfig() string {
+	if IaaSCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			iaas_custom_endpoint = "%s"
+		}`,
+		IaaSCustomEndpoint,
+	)
+}
+
+func IaaSProviderConfigWithBetaResourcesEnabled() string {
+	if IaaSCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			enable_beta_resources = true
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			enable_beta_resources = true
+			iaas_custom_endpoint = "%s"
+		}`,
+		IaaSCustomEndpoint,
+	)
+}
+
+func IaaSProviderConfigWithExperiments() string {
+	if IaaSCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+  			experiments = [ "routing-tables", "network" ]
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			iaas_custom_endpoint = "%s"
+			experiments = [ "routing-tables", "network" ]
+		}`,
+		IaaSCustomEndpoint,
+	)
+}
+
+func KMSProviderConfig() string {
+	if KMSCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			kms_custom_endpoint = "%s"
+		}`,
+		KMSCustomEndpoint,
+	)
+}
+
+func LoadBalancerProviderConfig() string {
+	if LoadBalancerCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			loadbalancer_custom_endpoint = "%s"
+		}`,
+		LoadBalancerCustomEndpoint,
+	)
+}
+
+func LogMeProviderConfig() string {
+	if LogMeCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			logme_custom_endpoint = "%s"
+		}`,
+		LogMeCustomEndpoint,
+	)
+}
+
+func MariaDBProviderConfig() string {
+	if MariaDBCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			mariadb_custom_endpoint = "%s"
+		}`,
+		MariaDBCustomEndpoint,
+	)
+}
+
+func ModelServingProviderConfig() string {
+	if ModelServingCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}
+		`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			modelserving_custom_endpoint = "%s"
+		}`,
+		ModelServingCustomEndpoint,
+	)
+}
+
+func MongoDBFlexProviderConfig() string {
+	if MongoDBFlexCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			mongodbflex_custom_endpoint = "%s"
+		}`,
+		MongoDBFlexCustomEndpoint,
+	)
+}
+
+func ObjectStorageProviderConfig() string {
+	if ObjectStorageCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			objectstorage_custom_endpoint = "%s"
+		}`,
+		ObjectStorageCustomEndpoint,
+	)
+}
+
+func OpenSearchProviderConfig() string {
+	if OpenSearchCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			opensearch_custom_endpoint = "%s"
+		}`,
+		OpenSearchCustomEndpoint,
+	)
+}
+
+func PostgresFlexProviderConfig(saFile string) string {
+	if PostgresFlexCustomEndpoint == "" {
+		return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+            service_account_key_path = "%s"
+		}`, saFile)
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+            service_account_key_path = "%s"
+			postgresflex_custom_endpoint = "%s"
+		}`,
+		saFile,
+		PostgresFlexCustomEndpoint,
+	)
+}
+
+func RabbitMQProviderConfig() string {
+	if RabbitMQCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			rabbitmq_custom_endpoint = "%s"
+		}`,
+		RabbitMQCustomEndpoint,
+	)
+}
+
+func RedisProviderConfig() string {
+	if RedisCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			redis_custom_endpoint = "%s"
+		}`,
+		RedisCustomEndpoint,
+	)
+}
+
+func ResourceManagerProviderConfig() string {
+	key := GetTestProjectServiceAccountJson("")
+	if ResourceManagerCustomEndpoint == "" || AuthorizationCustomEndpoint == "" {
+		return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			service_account_key = "%s"
+		}`,
+			key,
+		)
+	}
+	return fmt.Sprintf(`
+	provider "stackitprivatepreview" {
+		resourcemanager_custom_endpoint = "%s"
+		authorization_custom_endpoint = "%s"
+		service_account_token = "%s"
+	}`,
+		ResourceManagerCustomEndpoint,
+		AuthorizationCustomEndpoint,
+		key,
+	)
+}
+
+func SecretsManagerProviderConfig() string {
+	if SecretsManagerCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			secretsmanager_custom_endpoint = "%s"
+		}`,
+		SecretsManagerCustomEndpoint,
+	)
+}
+
+func SQLServerFlexProviderConfig(saFile string) string {
+	if SQLServerFlexCustomEndpoint == "" {
+		return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+            service_account_key_path = "%s"
+		}`, saFile)
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+            service_account_key_path = "%s"
+			sqlserverflex_custom_endpoint = "%s"
+		}`,
+		saFile,
+		SQLServerFlexCustomEndpoint,
+	)
+}
+
+func ServerBackupProviderConfig() string {
+	if ServerBackupCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+			enable_beta_resources = true
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			server_backup_custom_endpoint = "%s"
+			enable_beta_resources = true
+		}`,
+		ServerBackupCustomEndpoint,
+	)
+}
+
+func ServerUpdateProviderConfig() string {
+	if ServerUpdateCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+			enable_beta_resources = true
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			server_update_custom_endpoint = "%s"
+			enable_beta_resources = true
+		}`,
+		ServerUpdateCustomEndpoint,
+	)
+}
+
+func SKEProviderConfig() string {
+	if SKECustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			ske_custom_endpoint = "%s"
+		}`,
+		SKECustomEndpoint,
+	)
+}
+
+func AuthorizationProviderConfig() string {
+	if AuthorizationCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+			experiments = ["iam"]
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			authorization_custom_endpoint = "%s"
+			experiments = ["iam"]
+		}`,
+		AuthorizationCustomEndpoint,
+	)
+}
+
+func ServiceAccountProviderConfig() string {
+	if ServiceAccountCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+			enable_beta_resources = true
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			service_account_custom_endpoint = "%s"
+			enable_beta_resources = true
+		}`,
+		ServiceAccountCustomEndpoint,
+	)
+}
+
+func GitProviderConfig() string {
+	if GitCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+			enable_beta_resources = true
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			git_custom_endpoint = "%s"
+			enable_beta_resources = true
+		}`,
+		GitCustomEndpoint,
+	)
+}
+
+func ScfProviderConfig() string {
+	if ScfCustomEndpoint == "" {
+		return `
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+		}`
+	}
+	return fmt.Sprintf(`
+		provider "stackitprivatepreview" {
+			default_region = "eu01"
+			scf_custom_endpoint = "%s"
+		}`,
+		ScfCustomEndpoint,
+	)
+}

internal/testutils/testutils.go

@@ -0,0 +1,219 @@
+package testutils
+
+import (
+	"fmt"
+	"log"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-framework/providerserver"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
+	"github.com/hashicorp/terraform-plugin-testing/config"
+	"github.com/hashicorp/terraform-plugin-testing/echoprovider"
+	"github.com/joho/godotenv"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit"
+)
+
+const (
+	// Default location of credentials JSON
+	// credentialsFilePath = ".stackit/credentials.json" //nolint:gosec // linter false positive
+	serviceAccountFilePath = ".stackit/service_account.json"
+)
+
+var (
+	// TestAccProtoV6ProviderFactories is used to instantiate a provider during
+	// acceptance testing. The factory function will be invoked for every Terraform
+	// CLI command executed to create a provider server to which the CLI can
+	// reattach.
+	TestAccProtoV6ProviderFactories = map[string]func() (tfprotov6.ProviderServer, error){
+		"stackitprivatepreview": providerserver.NewProtocol6WithError(stackit.New("test-version")()),
+	}
+
+	// TestEphemeralAccProtoV6ProviderFactories is used to instantiate a provider during
+	// acceptance testing. The factory function will be invoked for every Terraform
+	// CLI command executed to create a provider server to which the CLI can
+	// reattach.
+	//
+	// See the Terraform acceptance test documentation on ephemeral resources for more information:
+	// https://developer.hashicorp.com/terraform/plugin/testing/acceptance-tests/ephemeral-resources
+	TestEphemeralAccProtoV6ProviderFactories = map[string]func() (tfprotov6.ProviderServer, error){
+		"stackitprivatepreview": providerserver.NewProtocol6WithError(stackit.New("test-version")()),
+		"echo":                  echoprovider.NewProviderServer(),
+	}
+
+	// E2ETestsEnabled checks if end-to-end tests should be run.
+	// It is enabled when the TF_ACC environment variable is set to "1".
+	E2ETestsEnabled = os.Getenv("TF_ACC") == "1"
+	// OrganizationId is the id of organization used for tests
+	OrganizationId = os.Getenv("TF_ACC_ORGANIZATION_ID")
+	// ProjectId is the id of project used for tests
+	ProjectId = os.Getenv("TF_ACC_PROJECT_ID")
+	Region    = os.Getenv("TF_ACC_REGION")
+	// ServiceAccountFile is the json file of the service account
+	ServiceAccountFile = os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE")
+	// ServerId is the id of a server used for some tests
+	ServerId = getenv("TF_ACC_SERVER_ID", "")
+	// TestProjectParentContainerID is the container id of the parent resource under which projects are created as part of the resource-manager acceptance tests
+	TestProjectParentContainerID = os.Getenv("TF_ACC_TEST_PROJECT_PARENT_CONTAINER_ID")
+	// TestProjectParentUUID is the uuid of the parent resource under which projects are created as part of the resource-manager acceptance tests
+	TestProjectParentUUID = os.Getenv("TF_ACC_TEST_PROJECT_PARENT_UUID")
+	// TestProjectServiceAccountEmail is the e-mail of a service account with admin permissions on the organization under which projects are created as part of the resource-manager acceptance tests
+	TestProjectServiceAccountEmail = os.Getenv("TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_EMAIL")
+	// TestProjectUserEmail is the e-mail of a user for the project created as part of the resource-manager acceptance tests
+	// Default email: acc-test@sa.stackit.cloud
+	TestProjectUserEmail = getenv("TF_ACC_TEST_PROJECT_USER_EMAIL", "acc-test@sa.stackit.cloud")
+	// TestImageLocalFilePath is the local path to an image file used for image acceptance tests
+	TestImageLocalFilePath = getenv("TF_ACC_TEST_IMAGE_LOCAL_FILE_PATH", "default")
+)
+
+func Setup() {
+	root, err := getRoot()
+	if err != nil {
+		log.Fatalln(err)
+	}
+	err = godotenv.Load(fmt.Sprintf("%s/.env", *root))
+	if err != nil {
+		slog.Info("could not find .env file - not loading .env")
+		return
+	}
+	slog.Info("loaded .env file", "path", *root)
+}
+
+func getRoot() (*string, error) {
+	cmd := exec.Command("git", "rev-parse", "--show-toplevel")
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(out), "\n")
+	return &lines[0], nil
+}
+
+func ResourceNameWithDateTime(name string) string {
+	dateTime := time.Now().Format(time.RFC3339)
+	// Remove timezone to have a smaller datetime
+	dateTimeTrimmed, _, _ := strings.Cut(dateTime, "+")
+	return fmt.Sprintf("tf-acc-%s-%s", name, dateTimeTrimmed)
+}
+
+func GetTestProjectServiceAccountJson(path string) string {
+	var err error
+	token, tokenSet := os.LookupEnv("TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_JSON")
+	if !tokenSet || token == "" {
+		token, err = readTestServiceAccountJsonFromFile(path)
+		if err != nil {
+			return ""
+		}
+	}
+	return token
+}
+
+//func GetTestProjectServiceAccountToken(path string) string {
+//	var err error
+//	token, tokenSet := os.LookupEnv("TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_TOKEN")
+//	if !tokenSet || token == "" {
+//		token, err = readTestTokenFromCredentialsFile(path)
+//		if err != nil {
+//			return ""
+//		}
+//	}
+//	return token
+//}
+//
+//func readTestTokenFromCredentialsFile(path string) (string, error) {
+//	if path == "" {
+//		customPath, customPathSet := os.LookupEnv("STACKIT_CREDENTIALS_PATH")
+//		if !customPathSet || customPath == "" {
+//			path = credentialsFilePath
+//			home, err := os.UserHomeDir()
+//			if err != nil {
+//				return "", fmt.Errorf("getting home directory: %w", err)
+//			}
+//			path = filepath.Join(home, path)
+//		} else {
+//			path = customPath
+//		}
+//	}
+//
+//	credentialsRaw, err := os.ReadFile(path)
+//	if err != nil {
+//		return "", fmt.Errorf("opening file: %w", err)
+//	}
+//
+//	var credentials struct {
+//		TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_TOKEN string `json:"TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_TOKEN"`
+//	}
+//	err = json.Unmarshal(credentialsRaw, &credentials)
+//	if err != nil {
+//		return "", fmt.Errorf("unmarshalling credentials: %w", err)
+//	}
+//	return credentials.TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_TOKEN, nil
+//}
+
+func readTestServiceAccountJsonFromFile(path string) (string, error) {
+	if path == "" {
+		customPath, customPathSet := os.LookupEnv("STACKIT_SERVICE_ACCOUNT_PATH")
+		if !customPathSet || customPath == "" {
+			path = serviceAccountFilePath
+			home, err := os.UserHomeDir()
+			if err != nil {
+				return "", fmt.Errorf("getting home directory: %w", err)
+			}
+			path = filepath.Join(home, path)
+		} else {
+			path = customPath
+		}
+	}
+
+	credentialsRaw, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("opening file: %w", err)
+	}
+	return string(credentialsRaw), nil
+}
+
+func getenv(key, defaultValue string) string {
+	val := os.Getenv(key)
+	if val == "" {
+		return defaultValue
+	}
+	return val
+}
+
+// CreateDefaultLocalFile is a helper for local_file_path. No real data is created
+func CreateDefaultLocalFile() os.File {
+	// Define the file name and size
+	fileName := "test-512k.img"
+	size := 512 * 1024 // 512 KB
+
+	// Create the file
+	file, err := os.Create(fileName)
+	if err != nil {
+		panic(err)
+	}
+
+	// Seek to the desired position (512 KB)
+	_, err = file.Seek(int64(size), 0)
+	if err != nil {
+		panic(err)
+	}
+
+	return *file
+}
+
+func ConvertConfigVariable(variable config.Variable) string {
+	tmpByteArray, _ := variable.MarshalJSON()
+	// In case the variable is a string, the quotes should be removed
+	if tmpByteArray[0] == '"' && tmpByteArray[len(tmpByteArray)-1] == '"' {
+		result := string(tmpByteArray[1 : len(tmpByteArray)-1])
+		// Replace escaped quotes which where added MarshalJSON
+		rawString := strings.ReplaceAll(result, `\"`, `"`)
+		return rawString
+	}
+	return string(tmpByteArray)
+}

internal/testutils/testutils_test.go

@@ -0,0 +1,48 @@
+package testutils
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/config"
+)
+
+func TestConvertConfigVariable(t *testing.T) {
+	tests := []struct {
+		name     string
+		variable config.Variable
+		want     string
+	}{
+		{
+			name:     "string",
+			variable: config.StringVariable("test"),
+			want:     "test",
+		},
+		{
+			name:     "bool: true",
+			variable: config.BoolVariable(true),
+			want:     "true",
+		},
+		{
+			name:     "bool: false",
+			variable: config.BoolVariable(false),
+			want:     "false",
+		},
+		{
+			name:     "integer",
+			variable: config.IntegerVariable(10),
+			want:     "10",
+		},
+		{
+			name:     "quoted string",
+			variable: config.StringVariable(`instance =~ ".*"`),
+			want:     `instance =~ ".*"`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := ConvertConfigVariable(tt.variable); got != tt.want {
+				t.Errorf("ConvertConfigVariable() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go

@@ -1,5 +1,3 @@
-// Copyright (c) STACKIT
-
 package postgresflexalpha_test
 
 import (
@@ -8,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -18,13 +15,12 @@ import (
 	"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/joho/godotenv"
 	"github.com/stackitcloud/stackit-sdk-go/core/utils"
 	postgresflexalpha "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance"
 
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/internal/testutils"
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
-	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/testutil"
 
 	postgresflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/postgresflexalpha"
 	// The fwresource import alias is so there is no collision
@@ -56,21 +52,15 @@ func TestInstanceResourceSchema(t *testing.T) {
 }
 
 var (
-	//go:embed testdata/resource-complete.tf
-	resourceSecurityGroupMinConfig string //nolint:unused // needs implementation
+	//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 setup() {
-	err := godotenv.Load()
-	if err != nil {
-		slog.Info("could not find .env file - not loading .env")
-		return
-	}
-	slog.Info("loaded .env file")
-}
-
 func TestMain(m *testing.M) {
-	setup()
+	testutils.Setup()
 	code := m.Run()
 	// shutdown()
 	os.Exit(code)
@@ -84,7 +74,9 @@ func TestMain(m *testing.M) {
 //)
 
 func testAccPreCheck(t *testing.T) {
-	// TODO: if needed ...
+	if _, ok := os.LookupEnv("TF_ACC_PROJECT_ID"); !ok {
+		t.Fatalf("could not find env var TF_ACC_PROJECT_ID")
+	}
 }
 
 //func TestAccResourceExample_parallel(t *testing.T) {
@@ -98,7 +90,7 @@ func testAccPreCheck(t *testing.T) {
 //	}
 //
 //	resource.Test(t, resource.TestCase{
-//		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+//		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 //		Steps: []resource.TestStep{
 //			{
 //				Config: testAccResourceEncryptionExampleConfig(exData),
@@ -110,134 +102,105 @@ func testAccPreCheck(t *testing.T) {
 
 type resData struct {
 	ServiceAccountFilePath string
-	ProjectID              string
+	ProjectId              string
 	Region                 string
 	Name                   string
-	Flavor                 string
+	TfName                 string
+	FlavorId               string
 	BackupSchedule         string
+	UseEncryption          bool
+	KekKeyId               string
+	KekKeyRingId           string
+	KekKeyVersion          uint8
+	KekServiceAccount      string
+	PerformanceClass       string
+	Replicas               uint32
+	Size                   uint32
+	AclString              string
+	AccessScope            string
 	RetentionDays          uint32
+	Version                string
 }
 
 func getExample() resData {
+	name := acctest.RandomWithPrefix("tf-acc")
 	return resData{
-		Region:                 testutil.Region,
-		ServiceAccountFilePath: testutil.ServiceAccountFile,
-		ProjectID:              testutil.ProjectId,
-		Name:                   acctest.RandomWithPrefix("tf-acc"),
-		Flavor:                 "2.4",
+		Region:                 os.Getenv("TF_ACC_REGION"),
+		ServiceAccountFilePath: os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE"),
+		ProjectId:              os.Getenv("TF_ACC_PROJECT_ID"),
+		Name:                   name,
+		TfName:                 name,
+		FlavorId:               "2.4",
 		BackupSchedule:         "0 0 * * *",
+		UseEncryption:          false,
 		RetentionDays:          33,
+		Replicas:               1,
+		PerformanceClass:       "premium-perf2-stackit",
+		Size:                   10,
+		AclString:              "0.0.0.0/0",
+		AccessScope:            "PUBLIC",
+		Version:                "17",
 	}
 }
 
 func TestAccResourceExample_basic(t *testing.T) {
 	exData := getExample()
+	resName := fmt.Sprintf(
+		"stackitprivatepreview_postgresflexalpha_instance.%s",
+		exData.TfName,
+	)
+
+	updNameData := exData
+	updNameData.Name = "name_updated"
+
+	updSizeData := exData
+	updSizeData.Size = 25
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
+			// Create and verify
 			{
-				Config: testAccResourceNoEncryptionExampleConfig(exData),
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					exData,
+				),
 				Check: resource.ComposeAggregateTestCheckFunc(
-					resource.TestCheckResourceAttr("example_resource.test", "name", exData.Name),
-					resource.TestCheckResourceAttrSet("example_resource.test", "id"),
+					resource.TestCheckResourceAttr(resName, "name", exData.Name),
+					resource.TestCheckResourceAttrSet(resName, "id"),
 				),
 			},
-			//// Create and verify
-			//{
-			//	Config: testAccResourceNoEncryptionExampleConfig(exData),
-			//	Check: resource.ComposeTestCheckFunc(
-			//		resource.TestCheckResourceAttr("example_resource.test", "name", exData.Name),
-			//	),
-			//},
-			//// Update and verify
-			//{
-			//	Config: testAccResourceNoEncryptionExampleConfig(exData),
-			//	Check: resource.ComposeTestCheckFunc(
-			//		resource.TestCheckResourceAttr("example_resource.test", "name", exData.Name),
-			//	),
-			//},
-			// Import test
+			// Update name and verify
 			{
-				ResourceName:      "example_resource.test",
-				ImportState:       true,
-				ImportStateVerify: true,
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					updNameData,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(resName, "name", updNameData.Name),
+				),
 			},
+			// Update size and verify
+			{
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					updSizeData,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(resName, "size", updNameData.Name),
+				),
+			},
+			//// Import test
+			//{
+			//	ResourceName:      "example_resource.test",
+			//	ImportState:       true,
+			//	ImportStateVerify: true,
+			//},
 		},
 	})
 }
 
-func testAccResourceNoEncryptionExampleConfig(data resData) string {
-	return fmt.Sprintf(`
-
-%[1]s
-
-resource "stackitprivatepreview_postgresflexalpha_instance" "test" {
-  project_id      = %[2]q
-  name            = %[3]q
-  backup_schedule = %[4]q
-  retention_days  = %[5]d
-  flavor_id       = %[6]q
-  replicas        = 1
-  storage = {
-    performance_class = "premium-perf2-stackit"
-    size              = 10
-  }
-  network = {
-    acl          = ["0.0.0.0/0"]
-    access_scope = "PUBLIC"
-  }
-  version = 17
-}
-
-`,
-		testutil.PostgresFlexProviderConfig(data.ServiceAccountFilePath),
-		data.ProjectID,
-		data.Name,
-		data.BackupSchedule,
-		data.RetentionDays,
-		data.Flavor,
-		data.Name,
-	)
-}
-
-//func testAccResourceEncryptionExampleConfig(data resData) string {
-//	return fmt.Sprintf(`
-//
-//%[1]s
-//
-//resource "stackitprivatepreview_postgresflexalpha_instance" "test" {
-//  project_id      = %[2]q
-//  name            = %[3]q
-//  backup_schedule = "0 0 * * *"
-//  retention_days  = 45
-//  flavor_id       = "2.1"
-//  replicas        = 1
-//  storage = {
-//    performance_class = "premium-perf2-stackit"
-//    size              = 10
-//  }
-//  encryption = {
-//    kek_key_id      = "key01"
-//    kek_key_ring_id = "key_ring_01"
-//    kek_key_version = 1
-//    service_account = "service@account.email"
-//  }
-//  network = {
-//    acl          = ["0.0.0.0/0"]
-//    access_scope = "PUBLIC"
-//  }
-//  version = 14
-//}
-//
-//`,
-//		testutil.PostgresFlexProviderConfig(data.ServiceAccountFilePath),
-//		data.ProjectID,
-//		data.Name,
-//	)
-//}
-
 //func testCheckResourceExists(resourceName string) resource.TestCheckFunc {
 //	return func(s *terraform.State) error {
 //		rs, ok := s.RootModule().Resources[resourceName]
@@ -320,7 +283,7 @@ func TestUnitResourceCreate(t *testing.T) {
 //		Name:                   "testRes",
 //	}
 //	resource.Test(t, resource.TestCase{
-//		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+//		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 //		Steps: []resource.TestStep{
 //			{
 //				Config: testAccResourceEncryptionExampleConfig(exData),
@@ -352,7 +315,7 @@ func TestUnitResourceCreate(t *testing.T) {
 
 // Instance resource data
 var instanceResource = map[string]string{
-	"project_id":              testutil.ProjectId,
+	"project_id":              testutils.ProjectId,
 	"region":                  "eu01",
 	"name":                    fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlphaNum)),
 	"acl":                     "192.168.0.0/16",
@@ -378,13 +341,13 @@ var instanceResource = map[string]string{
 var userResource = map[string]string{
 	"username":   fmt.Sprintf("tfaccuser%s", acctest.RandStringFromCharSet(4, acctest.CharSetAlpha)),
 	"role":       "createdb",
-	"project_id": testutil.ProjectId,
+	"project_id": testutils.ProjectId,
 }
 
 // Database resource data
 var databaseResource = map[string]string{
 	"name":       fmt.Sprintf("tfaccdb%s", acctest.RandStringFromCharSet(4, acctest.CharSetAlphaNum)),
-	"project_id": testutil.ProjectId,
+	"project_id": testutils.ProjectId,
 }
 
 func configResources(backupSchedule string, _ *string) string {
@@ -432,7 +395,7 @@ func configResources(backupSchedule string, _ *string) string {
 					owner = stackitprivatepreview_postgresflexalpha_user.user.username
 				}
 				`,
-		testutil.PostgresFlexProviderConfig(
+		testutils.PostgresFlexProviderConfig(
 			utils.GetEnvOrDefault("TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_FILE", "~/service-account.json"),
 		),
 		instanceResource["project_id"],
@@ -464,7 +427,7 @@ func configResources(backupSchedule string, _ *string) string {
 func TestAccPostgresFlexFlexResource(t *testing.T) {
 	resource.Test(
 		t, resource.TestCase{
-			ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 			CheckDestroy:             testAccCheckPostgresFlexDestroy,
 			Steps: []resource.TestStep{
 				// Creation
@@ -474,7 +437,7 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
 
 					// testdata/<Test_Name>/<step_number>
 					// ConfigDirectory: config.TestStepDirectory(),
-					Config: configResources(instanceResource["backup_schedule"], &testutil.Region),
+					Config: configResources(instanceResource["backup_schedule"], &testutils.Region),
 					Check: resource.ComposeAggregateTestCheckFunc(
 						// Instance
 						resource.TestCheckResourceAttr(
@@ -547,7 +510,7 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
 						resource.TestCheckResourceAttr(
 							"stackitprivatepreview_postgresflexalpha_instance.instance",
 							"region",
-							testutil.Region,
+							testutils.Region,
 						),
 
 						// User
@@ -745,7 +708,7 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
 							return "", fmt.Errorf("couldn't find attribute instance_id")
 						}
 
-						return fmt.Sprintf("%s,%s,%s", testutil.ProjectId, testutil.Region, instanceId), nil
+						return fmt.Sprintf("%s,%s,%s", testutils.ProjectId, testutils.Region, instanceId), nil
 					},
 					ImportState:             true,
 					ImportStateVerify:       true,
@@ -767,7 +730,7 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
 							return "", fmt.Errorf("couldn't find attribute user_id")
 						}
 
-						return fmt.Sprintf("%s,%s,%s,%s", testutil.ProjectId, testutil.Region, instanceId, userId), nil
+						return fmt.Sprintf("%s,%s,%s,%s", testutils.ProjectId, testutils.Region, instanceId, userId), nil
 					},
 					ImportState:             true,
 					ImportStateVerify:       true,
@@ -791,8 +754,8 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
 
 						return fmt.Sprintf(
 							"%s,%s,%s,%s",
-							testutil.ProjectId,
-							testutil.Region,
+							testutils.ProjectId,
+							testutils.Region,
 							instanceId,
 							databaseId,
 						), nil
@@ -884,11 +847,11 @@ func testAccCheckPostgresFlexDestroy(s *terraform.State) error {
 	ctx := context.Background()
 	var client *postgresflex.APIClient
 	var err error
-	if testutil.PostgresFlexCustomEndpoint == "" {
+	if testutils.PostgresFlexCustomEndpoint == "" {
 		client, err = postgresflex.NewAPIClient()
 	} else {
 		client, err = postgresflex.NewAPIClient(
-			config.WithEndpoint(testutil.PostgresFlexCustomEndpoint),
+			config.WithEndpoint(testutils.PostgresFlexCustomEndpoint),
 		)
 	}
 	if err != nil {
@@ -905,7 +868,7 @@ func testAccCheckPostgresFlexDestroy(s *terraform.State) error {
 		instancesToDestroy = append(instancesToDestroy, instanceId)
 	}
 
-	instancesResp, err := client.ListInstancesRequest(ctx, testutil.ProjectId, testutil.Region).Execute()
+	instancesResp, err := client.ListInstancesRequest(ctx, testutils.ProjectId, testutils.Region).Execute()
 	if err != nil {
 		return fmt.Errorf("getting instancesResp: %w", err)
 	}
@@ -917,7 +880,7 @@ func testAccCheckPostgresFlexDestroy(s *terraform.State) error {
 		}
 		if utils.Contains(instancesToDestroy, *items[i].Id) {
 			// TODO @mhenselin - does force still exist?
-			err := client.DeleteInstanceRequestExecute(ctx, testutil.ProjectId, testutil.Region, *items[i].Id)
+			err := client.DeleteInstanceRequestExecute(ctx, testutils.ProjectId, testutils.Region, *items[i].Id)
 			if err != nil {
 				return fmt.Errorf("deleting instance %s during CheckDestroy: %w", *items[i].Id, err)
 			}

stackit/internal/services/postgresflexalpha/testdata/instance_template.gompl

@@ -0,0 +1,30 @@
+provider "stackitprivatepreview" {
+    default_region = "{{ .Region }}"
+    service_account_key_path = "{{ .ServiceAccountFilePath }}"
+}
+
+resource "stackitprivatepreview_postgresflexalpha_instance" "{{ .TfName }}" {
+  project_id      = "{{ .ProjectId }}"
+  name            = "{{ .Name }}"
+  backup_schedule = "{{ .BackupSchedule }}"
+  retention_days  = {{ .RetentionDays }}
+  flavor_id       = "{{ .FlavorId }}"
+  replicas        = {{ .Replicas }}
+  storage = {
+    performance_class = "{{ .PerformanceClass }}"
+    size              = {{ .Size }}
+  }
+{{ if .UseEncryption }}
+  encryption = {
+    kek_key_id      = {{ .KekKeyId }}
+    kek_key_ring_id = {{ .KekKeyRingId }}
+    kek_key_version = {{ .KekKeyVersion }}
+    service_account = "{{ .KekServiceAccount }}"
+  }
+{{ end }}
+  network = {
+    acl          = ["{{ .AclString }}"]
+    access_scope = "{{ .AccessScope }}"
+  }
+  version = {{ .Version }}
+}

stackit/internal/services/postgresflexalpha/testdata/resource-enc.tf

@@ -1,23 +1,26 @@
+variable "project_id" {}
+variable "kek_key_id" {}
+variable "kek_key_ring_id" {}
+
 resource "stackitprivatepreview_postgresflexalpha_instance" "msh-instance-only" {
-  project_id      = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+  project_id      = var.project_id
   name            = "example-instance"
-  acl             = ["XXX.XXX.XXX.X/XX", "XX.XXX.XX.X/XX"]
   backup_schedule = "0 0 * * *"
   retention_days  = 30
-  flavor_id       = "flavor.id"
+  flavor_id       = "2.4"
   replicas        = 1
   storage = {
     performance_class = "premium-perf2-stackit"
     size              = 10
   }
   encryption = {
-    kek_key_id      = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-    kek_key_ring_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+    kek_key_id      = var.kek_key_id
+    kek_key_ring_id = var.kek_key_ring_id
     kek_key_version = 1
     service_account = "service@account.email"
   }
   network = {
-    acl             = ["XXX.XXX.XXX.X/XX", "XX.XXX.XX.X/XX"]
+    acl          = ["0.0.0.0/0"]
     access_scope = "PUBLIC"
   }
   version = 17

stackit/internal/services/postgresflexalpha/testdata/resource-no-enc.tf

@@ -0,0 +1,19 @@
+variable "project_id" {}
+
+resource "stackitprivatepreview_postgresflexalpha_instance" "msh-instance-only" {
+  project_id      = var.project_id
+  name            = "example-instance"
+  backup_schedule = "0 0 * * *"
+  retention_days  = 30
+  flavor_id       = "2.4"
+  replicas        = 1
+  storage = {
+    performance_class = "premium-perf2-stackit"
+    size              = 10
+  }
+  network = {
+    acl             = ["0.0.0.0/0"]
+    access_scope = "PUBLIC"
+  }
+  version = 17
+}

stackit/provider_acc_test.go

@@ -1,5 +1,3 @@
-// Copyright (c) STACKIT
-
 package stackit_test
 
 import (
@@ -7,17 +5,15 @@ import (
 	"fmt"
 	"log/slog"
 	"os"
-	"path"
 	"regexp"
-	"runtime"
 	"testing"
 
+	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/joho/godotenv"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/internal/testutils"
 
 	"github.com/hashicorp/terraform-plugin-testing/config"
-	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
-	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/testutil"
 )
 
 //go:embed testdata/provider-credentials.tf
@@ -29,15 +25,7 @@ var providerInvalidAttribute string
 //go:embed testdata/provider-all-attributes.tf
 var providerValidAttributes string
 
-var testConfigProviderCredentials = config.Variables{
-	"project_id": config.StringVariable(testutil.ProjectId),
-	"name": config.StringVariable(
-		fmt.Sprintf(
-			"tf-acc-prov%s",
-			acctest.RandStringFromCharSet(3, acctest.CharSetAlphaNum),
-		),
-	),
-}
+var testConfigProviderCredentials config.Variables
 
 func setup() {
 	err := godotenv.Load()
@@ -46,6 +34,18 @@ func setup() {
 		return
 	}
 	slog.Info("loaded .env file")
+
+	testConfigProviderCredentials = config.Variables{
+		"project_id":               config.StringVariable(os.Getenv("TF_ACC_PROJECT_ID")),
+		"region":                   config.StringVariable(os.Getenv("TF_ACC_REGION")),
+		"service_account_key_path": config.StringVariable(os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE")),
+		"name": config.StringVariable(
+			fmt.Sprintf(
+				"tf-acc-prov%s",
+				acctest.RandStringFromCharSet(3, acctest.CharSetAlphaNum),
+			),
+		),
+	}
 }
 
 func TestMain(m *testing.M) {
@@ -55,86 +55,7 @@ func TestMain(m *testing.M) {
 	os.Exit(code)
 }
 
-// Helper function to obtain the home directory on different systems.
-// Based on os.UserHomeDir().
-func getHomeEnvVariableName() string {
-	env := "HOME"
-	switch runtime.GOOS {
-	case "windows":
-		env = "USERPROFILE"
-	case "plan9":
-		env = "home"
-	}
-	return env
-}
-
-// create temporary home and initialize the credentials file as well
-func createTemporaryHome(createValidCredentialsFile bool, t *testing.T) string {
-	// create a temporary file
-	tempHome, err := os.MkdirTemp("", "tempHome")
-	if err != nil {
-		t.Fatalf("Failed to create temporary home directory: %v", err)
-	}
-
-	// create credentials file in temp directory
-	stackitFolder := path.Join(tempHome, ".stackit")
-	if err := os.Mkdir(stackitFolder, 0o750); err != nil {
-		t.Fatalf("Failed to create stackit folder: %v", err)
-	}
-
-	filePath := path.Join(stackitFolder, "credentials.json")
-	file, err := os.Create(filePath)
-	if err != nil {
-		t.Fatalf("Failed to create credentials file: %v", err)
-	}
-	defer func() {
-		if err := file.Close(); err != nil {
-			t.Fatalf("Error while closing the file: %v", err)
-		}
-	}()
-
-	// Define content, default = invalid token
-	token := "foo_token"
-	if createValidCredentialsFile {
-		token = testutil.GetTestProjectServiceAccountJson("")
-	}
-	content := fmt.Sprintf(`
-		{
-    		"STACKIT_SERVICE_ACCOUNT_TOKEN": "%s"
-		}`, token)
-
-	if _, err = file.WriteString(content); err != nil {
-		t.Fatalf("Error writing to file: %v", err)
-	}
-
-	return tempHome
-}
-
-// Function to overwrite the home folder
-func setTemporaryHome(tempHomePath string) {
-	env := getHomeEnvVariableName()
-	if err := os.Setenv(env, tempHomePath); err != nil {
-		fmt.Printf("Error setting temporary home directory %v", err)
-	}
-}
-
-// cleanup the temporary home and reset the environment variable
-func cleanupTemporaryHome(tempHomePath string, t *testing.T) {
-	if err := os.RemoveAll(tempHomePath); err != nil {
-		t.Fatalf("Error cleaning up temporary folder: %v", err)
-	}
-	originalHomeDir, err := os.UserHomeDir()
-	if err != nil {
-		t.Fatalf("Failed to restore home directory back to normal: %v", err)
-	}
-	// revert back to original home folder
-	env := getHomeEnvVariableName()
-	if err := os.Setenv(env, originalHomeDir); err != nil {
-		fmt.Printf("Error resetting temporary home directory %v", err)
-	}
-}
-
-func TestAccEnvVarTokenValid(t *testing.T) {
+func TestAccEnvVarServiceAccountPathValid(t *testing.T) {
 	// Check if acceptance tests should be run
 	if v := os.Getenv(resource.EnvTfAcc); v == "" {
 		t.Skipf(
@@ -143,14 +64,14 @@ func TestAccEnvVarTokenValid(t *testing.T) {
 		return
 	}
 
-	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
-	tempHomeFolder := createTemporaryHome(false, t)
-	defer cleanupTemporaryHome(tempHomeFolder, t)
+	// t.Setenv("STACKIT_CREDENTIALS_PATH", "")
+	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
+	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
 	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
 			{
-				PreConfig:       func() { setTemporaryHome(tempHomeFolder) },
+				PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
 				ConfigVariables: testConfigProviderCredentials,
 				Config:          providerCredentialConfig,
 			},
@@ -158,16 +79,16 @@ func TestAccEnvVarTokenValid(t *testing.T) {
 	})
 }
 
-func TestAccEnvVarTokenInvalid(t *testing.T) {
+func TestAccEnvVarServiceAccountPathInvalid(t *testing.T) {
+	t.Skip("needs refactoring")
 	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
-	t.Setenv("STACKIT_SERVICE_ACCOUNT_TOKEN", "foo")
-	tempHomeFolder := createTemporaryHome(false, t)
-	defer cleanupTemporaryHome(tempHomeFolder, t)
+	tempHomeFolder := testutils.CreateTemporaryHome(false, t)
+	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
 	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
 			{
-				PreConfig:       func() { setTemporaryHome(tempHomeFolder) },
+				PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
 				ConfigVariables: testConfigProviderCredentials,
 				Config:          providerCredentialConfig,
 				ExpectError:     regexp.MustCompile(`undefined response type, status code 401`),
@@ -177,15 +98,15 @@ func TestAccEnvVarTokenInvalid(t *testing.T) {
 }
 
 func TestAccCredentialsFileValid(t *testing.T) {
+	t.Skip("needs refactoring")
 	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
-	t.Setenv("STACKIT_SERVICE_ACCOUNT_TOKEN", "")
-	tempHomeFolder := createTemporaryHome(true, t)
-	defer cleanupTemporaryHome(tempHomeFolder, t)
+	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
+	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
 	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
 			{
-				PreConfig:       func() { setTemporaryHome(tempHomeFolder) },
+				PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
 				ConfigVariables: testConfigProviderCredentials,
 				Config:          providerCredentialConfig,
 			},
@@ -194,15 +115,15 @@ func TestAccCredentialsFileValid(t *testing.T) {
 }
 
 func TestAccCredentialsFileInvalid(t *testing.T) {
+	t.Skip("needs refactoring")
 	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
-	t.Setenv("STACKIT_SERVICE_ACCOUNT_TOKEN", "")
-	tempHomeFolder := createTemporaryHome(false, t)
-	defer cleanupTemporaryHome(tempHomeFolder, t)
+	tempHomeFolder := testutils.CreateTemporaryHome(false, t)
+	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
 	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
 			{
-				PreConfig:       func() { setTemporaryHome(tempHomeFolder) },
+				PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
 				ConfigVariables: testConfigProviderCredentials,
 				Config:          providerCredentialConfig,
 				ExpectError:     regexp.MustCompile(`Jwt is not in(\r\n|\r|\n)the form of Header.Payload.Signature`),
@@ -212,6 +133,7 @@ func TestAccCredentialsFileInvalid(t *testing.T) {
 }
 
 func TestAccProviderConfigureValidValues(t *testing.T) {
+	t.Skip("needs refactoring")
 	// Check if acceptance tests should be run
 	if v := os.Getenv(resource.EnvTfAcc); v == "" {
 		t.Skipf(
@@ -219,18 +141,11 @@ func TestAccProviderConfigureValidValues(t *testing.T) {
 			resource.EnvTfAcc)
 		return
 	}
-	// use service account token for these tests
-	token, err := getServiceAccountToken()
-	if err != nil {
-		t.Fatalf("Can't get token: %v", err)
-	}
-
 	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
-	t.Setenv("STACKIT_SERVICE_ACCOUNT_TOKEN", token)
-	tempHomeFolder := createTemporaryHome(true, t)
-	defer cleanupTemporaryHome(tempHomeFolder, t)
+	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
+	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
 	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
 			{ // valid provider attributes
 				ConfigVariables: testConfigProviderCredentials,
@@ -248,18 +163,12 @@ func TestAccProviderConfigureAnInvalidValue(t *testing.T) {
 			resource.EnvTfAcc)
 		return
 	}
-	// use service account token for these tests
-	token, err := getServiceAccountToken()
-	if err != nil {
-		t.Fatalf("Can't get token: %v", err)
-	}
 
 	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
-	t.Setenv("STACKIT_SERVICE_ACCOUNT_TOKEN", token)
-	tempHomeFolder := createTemporaryHome(true, t)
-	defer cleanupTemporaryHome(tempHomeFolder, t)
+	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
+	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
 	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
 		Steps: []resource.TestStep{
 			{ // invalid test attribute should throw an error
 				ConfigVariables: testConfigProviderCredentials,

stackit/testdata/provider-all-attributes.tf

@@ -1,8 +1,8 @@
 
 variable "project_id" {}
-variable "name" {}
+variable "region" {}
 
-provider "stackit" {
+provider "stackitprivatepreview" {
   default_region                     = "eu01"
   credentials_path                   = "~/.stackit/credentials.json"
   service_account_token              = ""
@@ -36,7 +36,11 @@ provider "stackit" {
   enable_beta_resources              = "true"
 }
 
-resource "stackit_network" "network" {
-  name       = var.name
-  project_id = var.project_id
+data "stackitprivatepreview_postgresflexalpha_flavor" "flavor" {
+  project_id    = var.project_id
+  region        = var.region
+  cpu           = 2
+  ram           = 4
+  node_type     = "Single"
+  storage_class = "premium-perf2-stackit"
 }

stackit/testdata/provider-credentials.tf

@@ -1,11 +1,18 @@
 
 variable "project_id" {}
-variable "name" {}
+variable "region" {}
 
-provider "stackit" {
+variable "service_account_key_path" {}
+
+provider "stackitprivatepreview" {
+  service_account_key_path = var.service_account_key_path
 }
 
-resource "stackit_network" "network" {
-  name       = var.name
-  project_id = var.project_id
-}
+data "stackitprivatepreview_postgresflexalpha_flavor" "flavor" {
+  project_id    = var.project_id
+  region        = var.region
+  cpu           = 2
+  ram           = 4
+  node_type     = "Single"
+  storage_class = "premium-perf2-stackit"
+}

stackit/testdata/provider-invalid-attribute.tf

@@ -1,12 +1,16 @@
 
 variable "project_id" {}
-variable "name" {}
+variable "region" {}
 
-provider "stackit" {
+provider "stackitprivatepreview" {
   test = "test"
 }
 
-resource "stackit_network" "network" {
-  name       = var.name
-  project_id = var.project_id
-}
+data "stackitprivatepreview_postgresflexalpha_flavor" "flavor" {
+  project_id    = var.project_id
+  region        = var.region
+  cpu           = 2
+  ram           = 4
+  node_type     = "Single"
+  storage_class = "premium-perf2-stackit"
+}