stackit-dev-tools/terraform-provider-stackitprivatepreview
2
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

feat: testing (#34)

Browse source 
## Description

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

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

relates to #1234

## Checklist

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

Reviewed-on: #34
Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
Co-committed-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
This commit is contained in:
Marcel S. Henselin 2026-02-06 09:57:51 +00:00 • committed by Marcel_Henselin
parent c22e758b2c
commit 32e41d8b44
Signed by: tf-provider.git.onstackit.cloud
GPG key ID: 6D7E8A1ED8955A9C
24 changed files with 858 additions and 2431 deletions
Download patch file Download diff file Expand all files Collapse all files

280
stackit/internal/services/postgresflexalpha/instance/resource_test.go
View file

@ -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)
// // }
// // })
// //}
//}

296
stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go
View file

@ -6,12 +6,15 @@ import (
"context"
_ "embed"
"fmt"
"log/slog"
"os"
"strings"
"testing"
"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"
"github.com/stackitcloud/stackit-sdk-go/core/config"
@ -26,13 +29,31 @@ var (
resourceSecurityGroupMinConfig 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()
code := m.Run()
// shutdown()
os.Exit(code)
}
// Instance resource data
var instanceResource = map[string]string{
"project_id": testutil.ProjectId,
"region": "eu01",
"name": fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlphaNum)),
"acl": "192.168.0.0/16",
"backup_schedule": "00 16 * * *",
"backup_schedule_updated": "00 12 * * *",
"retention_days": "33",
"flavor_cpu": "2",
"flavor_ram": "4",
"flavor_description": "Small, Compute optimized",
@ -41,75 +62,96 @@ var instanceResource = map[string]string{
"storage_size": "5",
"version": "14",
"flavor_id": "2.4",
"kek_key_id": "UUID1",
"kek_key_ring_id": "UUID2",
"kek_key_version": "1",
"service_account": "service@account.com",
"access_scope": "SNA",
}
// User resource data
var userResource = map[string]string{
"username": fmt.Sprintf("tfaccuser%s", acctest.RandStringFromCharSet(4, acctest.CharSetAlpha)),
"role": "createdb",
"project_id": instanceResource["project_id"],
"project_id": testutil.ProjectId,
}
// Database resource data
var databaseResource = map[string]string{
"name": fmt.Sprintf("tfaccdb%s", acctest.RandStringFromCharSet(4, acctest.CharSetAlphaNum)),
"name": fmt.Sprintf("tfaccdb%s", acctest.RandStringFromCharSet(4, acctest.CharSetAlphaNum)),
"project_id": testutil.ProjectId,
}
func configResources(backupSchedule string, region *string) string {
var regionConfig string
if region != nil {
regionConfig = fmt.Sprintf(`region = %q`, *region)
}
func configResources(backupSchedule string, _ *string) string {
return fmt.Sprintf(
`
%s
resource "stackit_postgresflex_instance" "instance" {
project_id = "%s"
name = "%s"
acl = ["%s"]
backup_schedule = "%s"
flavor = {
cpu = %s
ram = %s
}
replicas = %s
storage = {
class = "%s"
size = %s
}
version = "%s"
%s
resource "stackitprivatepreview_postgresflexalpha_instance" "instance" {
project_id = "%s"
region = "%s"
name = "%s"
backup_schedule = "%s"
retention_days = %s
flavor_id = %s
replicas = %s
storage = {
performance_class = "%s"
size = %s
}
encryption = {
kek_key_id = "%s"
kek_key_ring_id = "%s"
kek_key_version = "%s"
service_account = "%s"
}
network = {
acl = ["%s"]
access_scope = "%s"
}
version = %s
}
resource "stackit_postgresflex_user" "user" {
project_id = stackit_postgresflex_instance.instance.project_id
instance_id = stackit_postgresflex_instance.instance.instance_id
resource "stackitprivatepreview_postgresflexalpha_user" "user" {
project_id = "%s"
instance_id = stackitprivatepreview_postgresflexalpha_instance.instance.instance_id
username = "%s"
roles = ["%s"]
}
resource "stackit_postgresflex_database" "database" {
project_id = stackit_postgresflex_instance.instance.project_id
instance_id = stackit_postgresflex_instance.instance.instance_id
resource "stackitprivatepreview_postgresflexalpha_database" "database" {
project_id = "%s"
instance_id = stackitprivatepreview_postgresflexalpha_instance.instance.instance_id
name = "%s"
owner = stackit_postgresflex_user.user.username
owner = stackitprivatepreview_postgresflexalpha_user.user.username
}
`,
testutil.PostgresFlexProviderConfig(),
testutil.PostgresFlexProviderConfig(
utils.GetEnvOrDefault("TF_ACC_TEST_PROJECT_SERVICE_ACCOUNT_FILE", "~/service-account.json"),
),
instanceResource["project_id"],
instanceResource["region"],
instanceResource["name"],
instanceResource["acl"],
backupSchedule,
instanceResource["flavor_cpu"],
instanceResource["flavor_ram"],
instanceResource["retention_days"],
instanceResource["flavor_id"],
instanceResource["replicas"],
instanceResource["storage_class"],
instanceResource["storage_size"],
instanceResource["kek_key_id"],
instanceResource["kek_key_ring_id"],
instanceResource["kek_key_version"],
instanceResource["service_account"],
instanceResource["acl"],
instanceResource["access_scope"],
instanceResource["version"],
regionConfig,
userResource["project_id"],
userResource["username"],
userResource["role"],
databaseResource["project_id"],
databaseResource["name"],
)
}
@ -126,107 +168,107 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
Check: resource.ComposeAggregateTestCheckFunc(
// Instance
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"project_id",
instanceResource["project_id"],
),
resource.TestCheckResourceAttrSet(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"instance_id",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"name",
instanceResource["name"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"acl.#",
"1",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"acl.0",
instanceResource["acl"],
),
resource.TestCheckResourceAttrSet(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.id",
),
resource.TestCheckResourceAttrSet(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.description",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"backup_schedule",
instanceResource["backup_schedule"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.cpu",
instanceResource["flavor_cpu"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.ram",
instanceResource["flavor_ram"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"replicas",
instanceResource["replicas"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"storage.class",
instanceResource["storage_class"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"storage.size",
instanceResource["storage_size"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"version",
instanceResource["version"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"region",
testutil.Region,
),
// User
resource.TestCheckResourceAttrPair(
"stackit_postgresflex_user.user", "project_id",
"stackit_postgresflex_instance.instance", "project_id",
"stackitprivatepreview_postgresflexalpha_user.user", "project_id",
"stackitprivatepreview_postgresflexalpha_instance.instance", "project_id",
),
resource.TestCheckResourceAttrPair(
"stackit_postgresflex_user.user", "instance_id",
"stackit_postgresflex_instance.instance", "instance_id",
"stackitprivatepreview_postgresflexalpha_user.user", "instance_id",
"stackitprivatepreview_postgresflexalpha_instance.instance", "instance_id",
),
resource.TestCheckResourceAttrSet("stackit_postgresflex_user.user", "user_id"),
resource.TestCheckResourceAttrSet("stackit_postgresflex_user.user", "password"),
resource.TestCheckResourceAttrSet("stackitprivatepreview_postgresflexalpha_user.user", "user_id"),
resource.TestCheckResourceAttrSet("stackitprivatepreview_postgresflexalpha_user.user", "password"),
// Database
resource.TestCheckResourceAttrPair(
"stackit_postgresflex_database.database", "project_id",
"stackit_postgresflex_instance.instance", "project_id",
"stackitprivatepreview_postgresflexalpha_database.database", "project_id",
"stackitprivatepreview_postgresflexalpha_instance.instance", "project_id",
),
resource.TestCheckResourceAttrPair(
"stackit_postgresflex_database.database", "instance_id",
"stackit_postgresflex_instance.instance", "instance_id",
"stackitprivatepreview_postgresflexalpha_database.database", "instance_id",
"stackitprivatepreview_postgresflexalpha_instance.instance", "instance_id",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_database.database",
"stackitprivatepreview_postgresflexalpha_database.database",
"name",
databaseResource["name"],
),
resource.TestCheckResourceAttrPair(
"stackit_postgresflex_database.database", "owner",
"stackit_postgresflex_user.user", "username",
"stackitprivatepreview_postgresflexalpha_database.database", "owner",
"stackitprivatepreview_postgresflexalpha_user.user", "username",
),
),
},
@ -236,21 +278,21 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
`
%s
data "stackit_postgresflex_instance" "instance" {
project_id = stackit_postgresflex_instance.instance.project_id
instance_id = stackit_postgresflex_instance.instance.instance_id
data "stackitprivatepreview_postgresflexalpha_instance" "instance" {
project_id = stackitprivatepreview_postgresflexalpha_instance.instance.project_id
instance_id = stackitprivatepreview_postgresflexalpha_instance.instance.instance_id
}
data "stackit_postgresflex_user" "user" {
project_id = stackit_postgresflex_instance.instance.project_id
instance_id = stackit_postgresflex_instance.instance.instance_id
user_id = stackit_postgresflex_user.user.user_id
data "stackitprivatepreview_postgresflexalpha_user" "user" {
project_id = stackitprivatepreview_postgresflexalpha_instance.instance.project_id
instance_id = stackitprivatepreview_postgresflexalpha_instance.instance.instance_id
user_id = stackitprivatepreview_postgresflexalpha_user.user.user_id
}
data "stackit_postgresflex_database" "database" {
project_id = stackit_postgresflex_instance.instance.project_id
instance_id = stackit_postgresflex_instance.instance.instance_id
database_id = stackit_postgresflex_database.database.database_id
data "stackitprivatepreview_postgresflexalpha_database" "database" {
project_id = stackitprivatepreview_postgresflexalpha_instance.instance.project_id
instance_id = stackitprivatepreview_postgresflexalpha_instance.instance.instance_id
database_id = stackitprivatepreview_postgresflexalpha_database.database.database_id
}
`,
configResources(instanceResource["backup_schedule"], nil),
@ -258,135 +300,135 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
Check: resource.ComposeAggregateTestCheckFunc(
// Instance data
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"project_id",
instanceResource["project_id"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"name",
instanceResource["name"],
),
resource.TestCheckResourceAttrPair(
"data.stackit_postgresflex_instance.instance", "project_id",
"stackit_postgresflex_instance.instance", "project_id",
"data.stackitprivatepreview_postgresflexalpha_instance.instance", "project_id",
"stackitprivatepreview_postgresflexalpha_instance.instance", "project_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_postgresflex_instance.instance", "instance_id",
"stackit_postgresflex_instance.instance", "instance_id",
"data.stackitprivatepreview_postgresflexalpha_instance.instance", "instance_id",
"stackitprivatepreview_postgresflexalpha_instance.instance", "instance_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_postgresflex_user.user", "instance_id",
"stackit_postgresflex_user.user", "instance_id",
"data.stackitprivatepreview_postgresflexalpha_user.user", "instance_id",
"stackitprivatepreview_postgresflexalpha_user.user", "instance_id",
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"acl.#",
"1",
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"acl.0",
instanceResource["acl"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"backup_schedule",
instanceResource["backup_schedule"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.id",
instanceResource["flavor_id"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.description",
instanceResource["flavor_description"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.cpu",
instanceResource["flavor_cpu"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.ram",
instanceResource["flavor_ram"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_instance.instance",
"data.stackitprivatepreview_postgresflexalpha_instance.instance",
"replicas",
instanceResource["replicas"],
),
// User data
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"project_id",
userResource["project_id"],
),
resource.TestCheckResourceAttrSet(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"user_id",
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"username",
userResource["username"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"roles.#",
"1",
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"roles.0",
userResource["role"],
),
resource.TestCheckResourceAttrSet(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"host",
),
resource.TestCheckResourceAttrSet(
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"port",
),
// Database data
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_database.database",
"data.stackitprivatepreview_postgresflexalpha_database.database",
"project_id",
instanceResource["project_id"],
),
resource.TestCheckResourceAttr(
"data.stackit_postgresflex_database.database",
"data.stackitprivatepreview_postgresflexalpha_database.database",
"name",
databaseResource["name"],
),
resource.TestCheckResourceAttrPair(
"data.stackit_postgresflex_database.database",
"data.stackitprivatepreview_postgresflexalpha_database.database",
"instance_id",
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"instance_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_postgresflex_database.database",
"data.stackitprivatepreview_postgresflexalpha_database.database",
"owner",
"data.stackit_postgresflex_user.user",
"data.stackitprivatepreview_postgresflexalpha_user.user",
"username",
),
),
},
// Import
{
ResourceName: "stackit_postgresflex_instance.instance",
ResourceName: "stackitprivatepreview_postgresflexalpha_instance.instance",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_postgresflex_instance.instance"]
r, ok := s.RootModule().Resources["stackitprivatepreview_postgresflexalpha_instance.instance"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_postgresflex_instance.instance")
return "", fmt.Errorf("couldn't find resource stackitprivatepreview_postgresflexalpha_instance.instance")
}
instanceId, ok := r.Primary.Attributes["instance_id"]
if !ok {
@ -400,11 +442,11 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
ImportStateVerifyIgnore: []string{"password"},
},
{
ResourceName: "stackit_postgresflex_user.user",
ResourceName: "stackitprivatepreview_postgresflexalpha_user.user",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_postgresflex_user.user"]
r, ok := s.RootModule().Resources["stackitprivatepreview_postgresflexalpha_user.user"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_postgresflex_user.user")
return "", fmt.Errorf("couldn't find resource stackitprivatepreview_postgresflexalpha_user.user")
}
instanceId, ok := r.Primary.Attributes["instance_id"]
if !ok {
@ -422,11 +464,11 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
ImportStateVerifyIgnore: []string{"password", "uri"},
},
{
ResourceName: "stackit_postgresflex_database.database",
ResourceName: "stackitprivatepreview_postgresflexalpha_database.database",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_postgresflex_database.database"]
r, ok := s.RootModule().Resources["stackitprivatepreview_postgresflexalpha_database.database"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_postgresflex_database.database")
return "", fmt.Errorf("couldn't find resource stackitprivatepreview_postgresflexalpha_database.database")
}
instanceId, ok := r.Primary.Attributes["instance_id"]
if !ok {
@ -454,69 +496,69 @@ func TestAccPostgresFlexFlexResource(t *testing.T) {
Check: resource.ComposeAggregateTestCheckFunc(
// Instance data
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"project_id",
instanceResource["project_id"],
),
resource.TestCheckResourceAttrSet(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"instance_id",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"name",
instanceResource["name"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"acl.#",
"1",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"acl.0",
instanceResource["acl"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"backup_schedule",
instanceResource["backup_schedule_updated"],
),
resource.TestCheckResourceAttrSet(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.id",
),
resource.TestCheckResourceAttrSet(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.description",
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.cpu",
instanceResource["flavor_cpu"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"flavor.ram",
instanceResource["flavor_ram"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"replicas",
instanceResource["replicas"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"storage.class",
instanceResource["storage_class"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"storage.size",
instanceResource["storage_size"],
),
resource.TestCheckResourceAttr(
"stackit_postgresflex_instance.instance",
"stackitprivatepreview_postgresflexalpha_instance.instance",
"version",
instanceResource["version"],
),
@ -545,7 +587,7 @@ func testAccCheckPostgresFlexDestroy(s *terraform.State) error {
instancesToDestroy := []string{}
for _, rs := range s.RootModule().Resources {
if rs.Type != "stackit_postgresflex_instance" {
if rs.Type != "stackitprivatepreview_postgresflexalpha_instance" {
continue
}
// instance terraform ID: = "[project_id],[region],[instance_id]"

25
stackit/internal/services/postgresflexalpha/testdata/resource-complete.tf vendored
View file

@ -1 +1,24 @@
resource "stackitprivatepreview_postgresflexalpha_instance" "msh-instance-only" {
project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
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"
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_version = 1
service_account = "service@account.email"
}
network = {
acl = ["XXX.XXX.XXX.X/XX", "XX.XXX.XX.X/XX"]
access_scope = "PUBLIC"
}
version = 17
}