From 1a2d04f044229a6a3046c86749678d3d4b675553 Mon Sep 17 00:00:00 2001 From: "Marcel S. Henselin" Date: Tue, 10 Feb 2026 16:50:55 +0100 Subject: [PATCH] chore: refactor tests --- .../internal => internal}/testutil/assert.go | 0 .../testutil/testutil.go.bak | 2 - .../testutil/testutil_test.go.bak | 0 internal/testutils/functions.go | 125 +++++ internal/testutils/helpers.go | 465 ++++++++++++++++++ internal/testutils/testutils.go | 219 +++++++++ internal/testutils/testutils_test.go | 48 ++ .../postgresflex_acc_test.go | 231 ++++----- .../testdata/instance_template.gompl | 30 ++ .../{resource-complete.tf => resource-enc.tf} | 15 +- .../testdata/resource-no-enc.tf | 19 + stackit/provider_acc_test.go | 179 ++----- stackit/testdata/provider-all-attributes.tf | 14 +- stackit/testdata/provider-credentials.tf | 19 +- .../testdata/provider-invalid-attribute.tf | 16 +- 15 files changed, 1088 insertions(+), 294 deletions(-) rename {stackit/internal => internal}/testutil/assert.go (100%) rename stackit/internal/testutil/testutil.go => internal/testutil/testutil.go.bak (99%) rename stackit/internal/testutil/testutil_test.go => internal/testutil/testutil_test.go.bak (100%) create mode 100644 internal/testutils/functions.go create mode 100644 internal/testutils/helpers.go create mode 100644 internal/testutils/testutils.go create mode 100644 internal/testutils/testutils_test.go create mode 100644 stackit/internal/services/postgresflexalpha/testdata/instance_template.gompl rename stackit/internal/services/postgresflexalpha/testdata/{resource-complete.tf => resource-enc.tf} (57%) create mode 100644 stackit/internal/services/postgresflexalpha/testdata/resource-no-enc.tf diff --git a/stackit/internal/testutil/assert.go b/internal/testutil/assert.go similarity index 100% rename from stackit/internal/testutil/assert.go rename to internal/testutil/assert.go diff --git a/stackit/internal/testutil/testutil.go b/internal/testutil/testutil.go.bak similarity index 99% rename from stackit/internal/testutil/testutil.go rename to internal/testutil/testutil.go.bak index b678efef..2756677f 100644 --- a/stackit/internal/testutil/testutil.go +++ b/internal/testutil/testutil.go.bak @@ -1,5 +1,3 @@ -// Copyright (c) STACKIT - package testutil import ( diff --git a/stackit/internal/testutil/testutil_test.go b/internal/testutil/testutil_test.go.bak similarity index 100% rename from stackit/internal/testutil/testutil_test.go rename to internal/testutil/testutil_test.go.bak diff --git a/internal/testutils/functions.go b/internal/testutils/functions.go new file mode 100644 index 00000000..e672d57c --- /dev/null +++ b/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 +} diff --git a/internal/testutils/helpers.go b/internal/testutils/helpers.go new file mode 100644 index 00000000..c8d063dc --- /dev/null +++ b/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, + ) +} diff --git a/internal/testutils/testutils.go b/internal/testutils/testutils.go new file mode 100644 index 00000000..c35c332c --- /dev/null +++ b/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) +} diff --git a/internal/testutils/testutils_test.go b/internal/testutils/testutils_test.go new file mode 100644 index 00000000..4e18bd1e --- /dev/null +++ b/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) + } + }) + } +} diff --git a/stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go b/stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go index afafbb89..6c8a6bf5 100644 --- a/stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go +++ b/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// // 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) } diff --git a/stackit/internal/services/postgresflexalpha/testdata/instance_template.gompl b/stackit/internal/services/postgresflexalpha/testdata/instance_template.gompl new file mode 100644 index 00000000..b523868c --- /dev/null +++ b/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 }} +} diff --git a/stackit/internal/services/postgresflexalpha/testdata/resource-complete.tf b/stackit/internal/services/postgresflexalpha/testdata/resource-enc.tf similarity index 57% rename from stackit/internal/services/postgresflexalpha/testdata/resource-complete.tf rename to stackit/internal/services/postgresflexalpha/testdata/resource-enc.tf index 7a708880..65fd46d9 100644 --- a/stackit/internal/services/postgresflexalpha/testdata/resource-complete.tf +++ b/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 diff --git a/stackit/internal/services/postgresflexalpha/testdata/resource-no-enc.tf b/stackit/internal/services/postgresflexalpha/testdata/resource-no-enc.tf new file mode 100644 index 00000000..8e81b998 --- /dev/null +++ b/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 +} diff --git a/stackit/provider_acc_test.go b/stackit/provider_acc_test.go index f520d574..208c5b25 100644 --- a/stackit/provider_acc_test.go +++ b/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, diff --git a/stackit/testdata/provider-all-attributes.tf b/stackit/testdata/provider-all-attributes.tf index 930fc553..9ec02936 100644 --- a/stackit/testdata/provider-all-attributes.tf +++ b/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" } diff --git a/stackit/testdata/provider-credentials.tf b/stackit/testdata/provider-credentials.tf index a0ed79f4..d348939e 100644 --- a/stackit/testdata/provider-credentials.tf +++ b/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 -} \ No newline at end of file +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" +} diff --git a/stackit/testdata/provider-invalid-attribute.tf b/stackit/testdata/provider-invalid-attribute.tf index 524610e6..1c9d1729 100644 --- a/stackit/testdata/provider-invalid-attribute.tf +++ b/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 -} \ No newline at end of file +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" +}