feat: refactor testing

stackit/internal/services/postgresflexalpha/instance/resource_test.go

@@ -1,12 +1,233 @@
 package postgresflexalpha
 
 import (
-	"reflect"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/terraform"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/testutil"
 )
 
+var (
+	validFlavor   = "2.4"
+	kekKeyRingId  = ""
+	kekKeyVersion = ""
+	kekKeySA      = ""
+)
+
+func testAccPreCheck(t *testing.T) {
+	// TODO: if needed ...
+}
+
+//func TestAccResourceExample_parallel(t *testing.T) {
+//	t.Parallel()
+//
+//	exData := resData{
+//		Region:                 "eu01",
+//		ServiceAccountFilePath: sa_file,
+//		ProjectID:              project_id,
+//		Name:                   acctest.RandomWithPrefix("tf-acc"),
+//	}
+//
+//	resource.Test(t, resource.TestCase{
+//		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+//		Steps: []resource.TestStep{
+//			{
+//				Config: testAccResourceEncryptionExampleConfig(exData),
+//				Check:  resource.TestCheckResourceAttrSet("example_resource.test", "id"),
+//			},
+//		},
+//	})
+//}
+
+type resData struct {
+	ServiceAccountFilePath string
+	ProjectID              string
+	Region                 string
+	Name                   string
+	Flavor                 string
+	BackupSchedule         string
+	RetentionDays          uint32
+}
+
+func getExample() resData {
+	return resData{
+		Region:                 testutil.Region,
+		ServiceAccountFilePath: testutil.ServiceAccountFile,
+		ProjectID:              testutil.ProjectId,
+		Name:                   acctest.RandomWithPrefix("tf-acc"),
+		Flavor:                 "2.4",
+		BackupSchedule:         "0 0 * * *",
+		RetentionDays:          33,
+	}
+}
+
+func TestAccResourceExample_basic(t *testing.T) {
+	exData := getExample()
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { testAccPreCheck(t) },
+		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceNoEncryptionExampleConfig(exData),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttr("example_resource.test", "name", exData.Name),
+					resource.TestCheckResourceAttrSet("example_resource.test", "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
+			{
+				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]
+		if !ok {
+			return fmt.Errorf("resource not found: %s", resourceName)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("resource ID not set")
+		}
+
+		// Verify resource exists in the API
+		//client := testAccProvider.Meta().(*APIClient)
+		//_, err := client.GetResource(rs.Primary.ID)
+		//if err != nil {
+		//	return fmt.Errorf("error fetching resource: %w", err)
+		//}
+
+		return nil
+	}
+}
+
+func setupMockServer() *httptest.Server {
+	mux := http.NewServeMux()
+
+	mux.HandleFunc("/api/resources", func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodPost:
+			w.WriteHeader(http.StatusCreated)
+			json.NewEncoder(w).Encode(map[string]string{
+				"id":   "mock-id-123",
+				"name": "test-resource",
+			})
+		case http.MethodGet:
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode([]map[string]string{})
+		}
+	})
+
+	return httptest.NewServer(mux)
+}
+
+func TestUnitResourceCreate(t *testing.T) {
+	server := setupMockServer()
+	defer server.Close()
+
+	// Configure provider to use mock server URL
+	os.Setenv("API_ENDPOINT", server.URL)
+
+	// Run unit tests against mock
+}
+
 // type postgresFlexClientMocked struct {
 //	returnError    bool
 //	getFlavorsResp *postgresflex.GetFlavorsResponse
@@ -20,21 +241,40 @@ import (
 //	return c.getFlavorsResp, nil
 // }
 
-func TestNewInstanceResource(t *testing.T) {
-	tests := []struct {
-		name string
-		want resource.Resource
-	}{
-		{
-			name: "create empty instance resource",
-			want: &instanceResource{},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := NewInstanceResource(); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("NewInstanceResource() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
+//func TestNewInstanceResource(t *testing.T) {
+//	exData := resData{
+//		Region:                 "eu01",
+//		ServiceAccountFilePath: sa_file,
+//		ProjectID:              project_id,
+//		Name:                   "testRes",
+//	}
+//	resource.Test(t, resource.TestCase{
+//		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
+//		Steps: []resource.TestStep{
+//			{
+//				Config: testAccResourceEncryptionExampleConfig(exData),
+//				Check: resource.ComposeAggregateTestCheckFunc(
+//					resource.TestCheckResourceAttr("example_resource.test", "name", exData.Name),
+//					resource.TestCheckResourceAttrSet("example_resource.test", "id"),
+//				),
+//			},
+//		},
+//	})
+//
+//	//tests := []struct {
+//	//	name string
+//	//	want resource.Resource
+//	//}{
+//	//	{
+//	//		name: "create empty instance resource",
+//	//		want: &instanceResource{},
+//	//	},
+//	//}
+//	//for _, tt := range tests {
+//	//	t.Run(tt.name, func(t *testing.T) {
+//	//		if got := NewInstanceResource(); !reflect.DeepEqual(got, tt.want) {
+//	//			t.Errorf("NewInstanceResource() = %v, want %v", got, tt.want)
+//	//		}
+//	//	})
+//	//}
+//}

stackit/internal/services/sqlserverflexbeta/database/datasource.go

@@ -146,15 +146,11 @@ func (d *databaseDataSource) Read(ctx context.Context, req datasource.ReadReques
 	data.Id = types.Int64Value(dbId)
 	data.TfId = utils.BuildInternalTerraformId(projectId, region, instanceId, databaseName)
 	data.Owner = types.StringValue(databaseResp.GetOwner())
-
-	// TODO: fill remaining fields
-	// data.CollationName = types.Sometype(apiResponse.GetCollationName())
-	// data.CompatibilityLevel = types.Sometype(apiResponse.GetCompatibilityLevel())
-	// data.DatabaseName = types.Sometype(apiResponse.GetDatabaseName())
-	// data.Id = types.Sometype(apiResponse.GetId())
-	// data.InstanceId = types.Sometype(apiResponse.GetInstanceId())
+	data.CollationName = types.StringValue(databaseResp.GetCollationName())
+	data.CompatibilityLevel = types.Int64Value(databaseResp.GetCompatibilityLevel())
+	data.DatabaseName = types.StringValue(databaseResp.GetName())
+	// data.InstanceId = types.StringValue(databaseResp.GetInstanceId())
 	// data.Name = types.Sometype(apiResponse.GetName())
-	// data.Owner = types.Sometype(apiResponse.GetOwner())
 	// data.ProjectId = types.Sometype(apiResponse.GetProjectId())
 	// data.Region = types.Sometype(apiResponse.GetRegion())
 

stackit/internal/testutil/assert.go

@@ -0,0 +1,11 @@
+package testutil
+
+import "testing"
+
+func Equal[V comparable](t *testing.T, got, expected V) {
+	t.Helper()
+
+	if expected != got {
+		t.Errorf("assert equal failed:\ngot: %v \nexpected: %v", got, expected)
+	}
+}

stackit/internal/testutil/testutil.go

@@ -3,7 +3,6 @@
 package testutil
 
 import (
-	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -20,7 +19,8 @@ import (
 
 const (
 	// Default location of credentials JSON
-	credentialsFilePath = ".stackit/credentials.json" //nolint:gosec // linter false positive
+	// credentialsFilePath = ".stackit/credentials.json" //nolint:gosec // linter false positive
+	serviceAccountFilePath = ".stackit/service_account.json"
 )
 
 var (
@@ -52,6 +52,8 @@ var (
 	// 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
@@ -108,6 +110,7 @@ func ObservabilityProviderConfig() string {
 		ObservabilityCustomEndpoint,
 	)
 }
+
 func CdnProviderConfig() string {
 	if CdnCustomEndpoint == "" {
 		return `
@@ -316,8 +319,10 @@ func PostgresFlexProviderConfig(saFile string) string {
 	}
 	return fmt.Sprintf(`
 		provider "stackitprivatepreview" {
+            service_account_key_path = "%s"
 			postgresflex_custom_endpoint = "%s"
 		}`,
+		saFile,
 		PostgresFlexCustomEndpoint,
 	)
 }
@@ -353,13 +358,13 @@ func RedisProviderConfig() string {
 }
 
 func ResourceManagerProviderConfig() string {
-	token := GetTestProjectServiceAccountToken("")
+	key := GetTestProjectServiceAccountJson("")
 	if ResourceManagerCustomEndpoint == "" || AuthorizationCustomEndpoint == "" {
 		return fmt.Sprintf(`
 		provider "stackitprivatepreview" {
-			service_account_token = "%s"
+			service_account_key = "%s"
 		}`,
-			token,
+			key,
 		)
 	}
 	return fmt.Sprintf(`
@@ -370,7 +375,7 @@ func ResourceManagerProviderConfig() string {
 	}`,
 		ResourceManagerCustomEndpoint,
 		AuthorizationCustomEndpoint,
-		token,
+		key,
 	)
 }
 
@@ -389,17 +394,20 @@ func SecretsManagerProviderConfig() string {
 	)
 }
 
-func SQLServerFlexProviderConfig() string {
+func SQLServerFlexProviderConfig(saFile string) string {
 	if SQLServerFlexCustomEndpoint == "" {
-		return `
+		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,
 	)
 }
@@ -531,7 +539,7 @@ func GetTestProjectServiceAccountJson(path string) string {
 	var err error
 	token, tokenSet := os.LookupEnv("TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_JSON")
 	if !tokenSet || token == "" {
-		token, err = readTestTokenFromCredentialsFile(path)
+		token, err = readTestServiceAccountJsonFromFile(path)
 		if err != nil {
 			return ""
 		}
@@ -539,23 +547,53 @@ func GetTestProjectServiceAccountJson(path string) string {
 	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 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 readTestTokenFromCredentialsFile(path string) (string, error) {
+func readTestServiceAccountJsonFromFile(path string) (string, error) {
 	if path == "" {
-		customPath, customPathSet := os.LookupEnv("STACKIT_CREDENTIALS_PATH")
+		customPath, customPathSet := os.LookupEnv("STACKIT_SERVICE_ACCOUNT_PATH")
 		if !customPathSet || customPath == "" {
-			path = credentialsFilePath
+			path = serviceAccountFilePath
 			home, err := os.UserHomeDir()
 			if err != nil {
 				return "", fmt.Errorf("getting home directory: %w", err)
@@ -570,15 +608,7 @@ func readTestTokenFromCredentialsFile(path string) (string, error) {
 	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
+	return string(credentialsRaw), nil
 }
 
 func getenv(key, defaultValue string) string {