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

chore: add tests #48

Merged
marcel.henselin merged 1 commit from feat/add_testings into alpha 2026-02-11 14:20:41 +00:00
Conversation 1 Commits 1 Files changed 6 +469 -2
6 changed files with 469 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

2
examples/resources/stackitprivatepreview_postgresflexalpha_user/resource.tf
View file

@ -1,7 +1,7 @@
resource "stackitprivatepreview_postgresflexalpha_user" "example" {
project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
username = "username"
name = "username"
roles = ["role"]
}

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

@ -110,6 +110,20 @@ type resData struct {
AccessScope string
RetentionDays uint32
Version string
Users []User
Databases []Database
}
type User struct {
Name string
ProjectId string
Roles []string
}
type Database struct {
Name string
ProjectId string
Owner string
}
func getExample() resData {
@ -133,7 +147,7 @@ func getExample() resData {
}
}
func TestAccResourceExample_basic(t *testing.T) {
func TestAccInstance(t *testing.T) {
exData := getExample()
resName := fmt.Sprintf(
"stackitprivatepreview_postgresflexalpha_instance.%s",
@ -195,6 +209,107 @@ func TestAccResourceExample_basic(t *testing.T) {
})
}
func TestAccInstanceWithUsers(t *testing.T) {
data := getExample()
userName := "testUser"
data.Users = []User{
{
Name: userName,
ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
Roles: []string{"login"},
},
}
resName := fmt.Sprintf(
"stackitprivatepreview_postgresflexalpha_instance.%s",
data.TfName,
)
resUserName := fmt.Sprintf(
"stackitprivatepreview_postgresflexalpha_user.%s",
userName,
)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
Steps: []resource.TestStep{
// Create and verify
{
Config: testutils.StringFromTemplateMust(
"testdata/instance_template.gompl",
data,
),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr(resName, "name", data.Name),
resource.TestCheckResourceAttrSet(resName, "id"),
resource.TestCheckResourceAttr(resUserName, "name", userName),
resource.TestCheckResourceAttrSet(resUserName, "id"),
),
},
},
})
}
func TestAccInstanceWithDatabases(t *testing.T) {
data := getExample()
dbName := "testDb"
userName := "testUser"
data.Users = []User{
{
Name: userName,
ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
Roles: []string{"login"},
},
}
data.Databases = []Database{
{
Name: dbName,
ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
Owner: userName,
},
}
resName := fmt.Sprintf(
"stackitprivatepreview_postgresflexalpha_instance.%s",
data.TfName,
)
resUserName := fmt.Sprintf(
"stackitprivatepreview_postgresflexalpha_user.%s",
userName,
)
resDbName := fmt.Sprintf(
"stackitprivatepreview_postgresflexalpha_database.%s",
dbName,
)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
Steps: []resource.TestStep{
// Create and verify
{
Config: testutils.StringFromTemplateMust(
"testdata/instance_template.gompl",
data,
),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr(resName, "name", data.Name),
resource.TestCheckResourceAttrSet(resName, "id"),
resource.TestCheckResourceAttr(resUserName, "name", userName),
resource.TestCheckResourceAttrSet(resUserName, "id"),
resource.TestCheckResourceAttr(resDbName, "name", dbName),
resource.TestCheckResourceAttr(resDbName, "owner", userName),
resource.TestCheckResourceAttrSet(resDbName, "id"),
),
},
},
})
}
//func setupMockServer() *httptest.Server {
// mux := http.NewServeMux()
//

24
stackit/internal/services/postgresflexalpha/testdata/instance_template.gompl vendored
View file

@ -28,3 +28,27 @@ resource "stackitprivatepreview_postgresflexalpha_instance" "{{ .TfName }}" {
}
version = {{ .Version }}
}
{{ if .Users }}
{{ $tfName := .TfName }}
{{ range $user := .Users }}
resource "stackitprivatepreview_postgresflexalpha_user" "{{ $user.Name }}" {
project_id = "{{ $user.ProjectId }}"
instance_id = stackitprivatepreview_postgresflexalpha_instance.{{ $tfName }}.instance_id
name = "{{ $user.Name }}"
roles = [{{ range $i, $v := $user.Roles }}{{if $i}},{{end}}"{{$v}}"{{end}}]
}
{{ end }}
{{ end }}
{{ if .Databases }}
{{ $tfName := .TfName }}
{{ range $db := .Databases }}
resource "stackitprivatepreview_postgresflexalpha_database" "{{ $db.Name }}" {
project_id = "{{ $db.ProjectId }}"
instance_id = stackitprivatepreview_postgresflexalpha_instance.{{ $tfName }}.instance_id
name = "{{ $db.Name }}"
owner = "{{ $db.Owner }}"
}
{{ end }}
{{ end }}

272
stackit/internal/services/sqlserverflexbeta/sqlserverflex_acc_test.go Normal file
View file

@ -0,0 +1,272 @@
package sqlserverflexbeta_test
import (
"context"
_ "embed"
"fmt"
"os"
"strconv"
"testing"
"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
"github.com/hashicorp/terraform-plugin-testing/helper/resource"
sqlserverflexbeta "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance"
"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/internal/testutils"
// The fwresource import alias is so there is no collision
// with the more typical acceptance testing import:
// "github.com/hashicorp/terraform-plugin-testing/helper/resource"
fwresource "github.com/hashicorp/terraform-plugin-framework/resource"
)
func TestInstanceResourceSchema(t *testing.T) {
t.Parallel()
ctx := context.Background()
schemaRequest := fwresource.SchemaRequest{}
schemaResponse := &fwresource.SchemaResponse{}
// Instantiate the resource.Resource and call its Schema method
sqlserverflexbeta.NewInstanceResource().Schema(ctx, schemaRequest, schemaResponse)
if schemaResponse.Diagnostics.HasError() {
t.Fatalf("Schema method diagnostics: %+v", schemaResponse.Diagnostics)
}
// Validate the schema
diagnostics := schemaResponse.Schema.ValidateImplementation(ctx)
if diagnostics.HasError() {
t.Fatalf("Schema validation diagnostics: %+v", diagnostics)
}
}
func TestMain(m *testing.M) {
testutils.Setup()
code := m.Run()
// shutdown()
os.Exit(code)
}
func testAccPreCheck(t *testing.T) {
if _, ok := os.LookupEnv("TF_ACC_PROJECT_ID"); !ok {
t.Fatalf("could not find env var TF_ACC_PROJECT_ID")
}
}
type resData struct {
ServiceAccountFilePath string
ProjectId string
Region string
Name string
TfName string
FlavorId string
BackupSchedule string
UseEncryption bool
KekKeyId string
KekKeyRingId string
KekKeyVersion uint8
KekServiceAccount string
PerformanceClass string
Size uint32
AclString string
AccessScope string
RetentionDays uint32
Version string
Users []User
Databases []Database
}
type User struct {
Name string
ProjectId string
Roles []string
}
type Database struct {
Name string
ProjectId string
Owner string
}
func getExample() resData {
name := acctest.RandomWithPrefix("tf-acc")
return resData{
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: "4.16-Single",
BackupSchedule: "0 0 * * *",
UseEncryption: false,
RetentionDays: 33,
PerformanceClass: "premium-perf2-stackit",
Size: 10,
AclString: "0.0.0.0/0",
AccessScope: "PUBLIC",
Version: "2022",
}
}
func TestAccInstance(t *testing.T) {
exData := getExample()
resName := fmt.Sprintf(
"stackitprivatepreview_sqlserverflexbeta_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: testutils.TestAccProtoV6ProviderFactories,
Steps: []resource.TestStep{
// Create and verify
{
Config: testutils.StringFromTemplateMust(
"testdata/instance_template.gompl",
exData,
),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr(resName, "name", exData.Name),
resource.TestCheckResourceAttrSet(resName, "id"),
),
},
// Update name and verify
{
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,
"storage.size",
strconv.Itoa(int(updSizeData.Size)),
),
),
},
//// Import test
//{
// ResourceName: "example_resource.test",
// ImportState: true,
// ImportStateVerify: true,
//},
},
})
}
func TestAccInstanceWithUsers(t *testing.T) {
data := getExample()
userName := "testUser"
data.Users = []User{
{
Name: userName,
ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
Roles: []string{"##STACKIT_LoginManager##", "##STACKIT_DatabaseManager##"},
},
}
resName := fmt.Sprintf(
"stackitprivatepreview_sqlserverflexbeta_instance.%s",
data.TfName,
)
resUserName := fmt.Sprintf(
"stackitprivatepreview_sqlserverflexbeta_user.%s",
userName,
)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
Steps: []resource.TestStep{
// Create and verify
{
Config: testutils.StringFromTemplateMust(
"testdata/instance_template.gompl",
data,
),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr(resName, "name", data.Name),
resource.TestCheckResourceAttrSet(resName, "id"),
resource.TestCheckResourceAttr(resUserName, "name", userName),
resource.TestCheckResourceAttrSet(resUserName, "id"),
),
},
},
})
}
func TestAccInstanceWithDatabases(t *testing.T) {
data := getExample()
dbName := "testDb"
userName := "testUser"
data.Users = []User{
{
Name: userName,
ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
Roles: []string{"##STACKIT_LoginManager##", "##STACKIT_DatabaseManager##"},
},
}
data.Databases = []Database{
{
Name: dbName,
ProjectId: os.Getenv("TF_ACC_PROJECT_ID"),
Owner: userName,
},
}
resName := fmt.Sprintf(
"stackitprivatepreview_sqlserverflexbeta_instance.%s",
data.TfName,
)
resUserName := fmt.Sprintf(
"stackitprivatepreview_sqlserverflexbeta_user.%s",
userName,
)
resDbName := fmt.Sprintf(
"stackitprivatepreview_sqlserverflexbeta_database.%s",
dbName,
)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
Steps: []resource.TestStep{
// Create and verify
{
Config: testutils.StringFromTemplateMust(
"testdata/instance_template.gompl",
data,
),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr(resName, "name", data.Name),
resource.TestCheckResourceAttrSet(resName, "id"),
resource.TestCheckResourceAttr(resUserName, "name", userName),
resource.TestCheckResourceAttrSet(resUserName, "id"),
resource.TestCheckResourceAttr(resDbName, "name", dbName),
resource.TestCheckResourceAttr(resDbName, "owner", userName),
resource.TestCheckResourceAttrSet(resDbName, "id"),
),
},
},
})
}

53
stackit/internal/services/sqlserverflexbeta/testdata/instance_template.gompl vendored Normal file
View file

@ -0,0 +1,53 @@
provider "stackitprivatepreview" {
default_region = "{{ .Region }}"
service_account_key_path = "{{ .ServiceAccountFilePath }}"
}
resource "stackitprivatepreview_sqlserverflexbeta_instance" "{{ .TfName }}" {
project_id = "{{ .ProjectId }}"
name = "{{ .Name }}"
backup_schedule = "{{ .BackupSchedule }}"
retention_days = {{ .RetentionDays }}
flavor_id = "{{ .FlavorId }}"
storage = {
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 }}"
}
{{ if .Users }}
{{ $tfName := .TfName }}
{{ range $user := .Users }}
resource "stackitprivatepreview_sqlserverflexbeta_user" "{{ $user.Name }}" {
project_id = "{{ $user.ProjectId }}"
instance_id = stackitprivatepreview_sqlserverflexbeta_instance.{{ $tfName }}.instance_id
username = "{{ $user.Name }}"
roles = [{{ range $i, $v := $user.Roles }}{{if $i}},{{end}}"{{$v}}"{{end}}]
}
{{ end }}
{{ end }}
{{ if .Databases }}
{{ $tfName := .TfName }}
{{ range $db := .Databases }}
resource "stackitprivatepreview_sqlserverflexbeta_database" "{{ $db.Name }}" {
project_id = "{{ $db.ProjectId }}"
instance_id = stackitprivatepreview_sqlserverflexbeta_instance.{{ $tfName }}.instance_id
name = "{{ $db.Name }}"
owner = "{{ $db.Owner }}"
}
{{ end }}
{{ end }}

3
stackit/provider.go
View file

@ -36,6 +36,7 @@ import (
sqlserverflexBetaDatabase "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/database"
sqlserverFlexBetaFlavor "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/flavor"
sqlserverflexBetaInstance "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance"
sqlserverFlexBetaUser "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/user"
)
// Ensure the implementation satisfies the expected interfaces
@ -514,6 +515,7 @@ func (p *Provider) DataSources(_ context.Context) []func() datasource.DataSource
sqlserverflexBetaDatabase.NewDatabaseDataSource,
sqlserverflexBetaInstance.NewInstanceDataSource,
sqlserverFlexBetaUser.NewUserDataSource,
sqlserverFlexBetaFlavor.NewFlavorDataSource,
}
}
@ -530,6 +532,7 @@ func (p *Provider) Resources(_ context.Context) []func() resource.Resource {
sqlserverflexalphaDatabase.NewDatabaseResource,
sqlserverflexBetaInstance.NewInstanceResource,
sqlserverFlexBetaUser.NewUserResource,
sqlserverflexBetaDatabase.NewDatabaseResource,
}
return resources