Alpha (#4)
Some checks failed
CI Workflow / CI (push) Has been cancelled
CI Workflow / Check GoReleaser config (push) Has been cancelled
CI Workflow / Code coverage report (push) Has been cancelled

* chore: initial push to be able to work together

* chore: add missing wait folder

* chore: add missing folders

* chore: cleanup alpha branch

* feat: mssql alpha instance (#2)

* fix: remove unused attribute types and functions from backup models

* fix: update API client references to use sqlserverflexalpha package

* fix: update package references to use sqlserverflexalpha and modify user data source model

* fix: add sqlserverflexalpha user data source to provider

* fix: add sqlserverflexalpha user resource and update related functionality

* chore: add stackit_sqlserverflexalpha_user resource and instance_id variable

* fix: refactor sqlserverflexalpha user resource and enhance schema with status and default_database

---------

Co-authored-by: Andre Harms <andre.harms@stackit.cloud>
Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>

* feat: add sqlserver instance

* chore: fixing tests

* chore: update docs

---------

Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
Co-authored-by: Andre Harms <andre.harms@stackit.cloud>
This commit is contained in:
Marcel S. Henselin 2025-12-19 11:37:53 +01:00 committed by GitHub
parent 45073a716b
commit 2733834fc9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
351 changed files with 62744 additions and 3 deletions

View file

@ -0,0 +1,59 @@
// Copyright (c) STACKIT
package features
import (
"context"
"fmt"
"os"
"strings"
"github.com/hashicorp/terraform-plugin-framework/diag"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
)
// BetaResourcesEnabled returns whether this provider has beta functionality enabled.
//
// In order of precedence, beta functionality can be managed by:
// - Environment Variable `STACKIT_TF_ENABLE_BETA_RESOURCES` - `true` is enabled, `false` is disabled.
// - Provider configuration feature flag `enable_beta` - `true` is enabled, `false` is disabled.
func BetaResourcesEnabled(ctx context.Context, data *core.ProviderData, diags *diag.Diagnostics) bool {
value, set := os.LookupEnv("STACKIT_TF_ENABLE_BETA_RESOURCES")
if set {
if strings.EqualFold(value, "true") {
return true
}
if strings.EqualFold(value, "false") {
return false
}
warnDetails := fmt.Sprintf(`The value of the environment variable that enables beta functionality must be either "true" or "false", got %q.
Defaulting to the provider feature flag.`, value)
core.LogAndAddWarning(ctx, diags, "Invalid value for STACKIT_TF_ENABLE_BETA_RESOURCES environment variable.", warnDetails)
}
// ProviderData should always be set, but we check just in case
if data == nil {
return false
}
return data.EnableBetaResources
}
// CheckBetaResourcesEnabled is a helper function to log and add a warning or error if the beta functionality is not enabled.
//
// Should be called in the Configure method of a beta resource.
// Then, check for Errors in the diags using the diags.HasError() method.
func CheckBetaResourcesEnabled(ctx context.Context, data *core.ProviderData, diags *diag.Diagnostics, resourceName string, resourceType core.ResourceType) {
if !BetaResourcesEnabled(ctx, data, diags) {
core.LogAndAddErrorBeta(ctx, diags, resourceName, resourceType)
return
}
core.LogAndAddWarningBeta(ctx, diags, resourceName, resourceType)
}
func AddBetaDescription(description string, resourceType core.ResourceType) string {
// Callout block: https://developer.hashicorp.com/terraform/registry/providers/docs#callouts
return fmt.Sprintf("%s\n\n~> %s %s",
description,
fmt.Sprintf("This %s is in beta and may be subject to breaking changes in the future. Use with caution.", resourceType),
"See our [guide](https://registry.terraform.io/providers/stackitcloud/stackit/latest/docs/guides/opting_into_beta_resources) for how to opt-in to use beta resources.",
)
}

View file

@ -0,0 +1,218 @@
// Copyright (c) STACKIT
package features
import (
"context"
"testing"
"github.com/hashicorp/terraform-plugin-framework/diag"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
)
func TestBetaResourcesEnabled(t *testing.T) {
tests := []struct {
description string
data *core.ProviderData
envSet bool
envValue string
expected bool
expectWarn bool
}{
{
description: "Feature flag enabled, env var not set",
data: &core.ProviderData{
EnableBetaResources: true,
},
expected: true,
},
{
description: "Feature flag is disabled, env var not set",
data: &core.ProviderData{
EnableBetaResources: false,
},
expected: false,
},
{
description: "Feature flag, Env var not set",
data: &core.ProviderData{},
expected: false,
},
{
description: "Feature flag not set, Env var is true",
data: &core.ProviderData{},
envSet: true,
envValue: "true",
expected: true,
},
{
description: "Feature flag not set, Env var is false",
data: &core.ProviderData{},
envSet: true,
envValue: "false",
expected: false,
},
{
description: "Feature flag not set, Env var is empty",
data: &core.ProviderData{},
envSet: true,
envValue: "",
expectWarn: true,
expected: false,
},
{
description: "Feature flag not set, Env var is gibberish",
data: &core.ProviderData{},
envSet: true,
envValue: "gibberish",
expectWarn: true,
expected: false,
},
{
description: "Feature flag enabled, Env var is true",
data: &core.ProviderData{
EnableBetaResources: true,
},
envSet: true,
envValue: "true",
expected: true,
},
{
description: "Feature flag enabled, Env var is false",
data: &core.ProviderData{
EnableBetaResources: true,
},
envSet: true,
envValue: "false",
expected: false,
},
{
description: "Feature flag enabled, Env var is empty",
data: &core.ProviderData{
EnableBetaResources: true,
},
envSet: true,
envValue: "",
expectWarn: true,
expected: true,
},
{
description: "Feature flag enabled, Env var is gibberish",
data: &core.ProviderData{
EnableBetaResources: true,
},
envSet: true,
envValue: "gibberish",
expectWarn: true,
expected: true,
},
{
description: "Feature flag disabled, Env var is true",
data: &core.ProviderData{
EnableBetaResources: false,
},
envSet: true,
envValue: "true",
expected: true,
},
{
description: "Feature flag disabled, Env var is false",
data: &core.ProviderData{
EnableBetaResources: false,
},
envSet: true,
envValue: "false",
expected: false,
},
{
description: "Feature flag disabled, Env var is empty",
data: &core.ProviderData{
EnableBetaResources: false,
},
envSet: true,
envValue: "",
expectWarn: true,
expected: false,
},
{
description: "Feature flag disabled, Env var is gibberish",
data: &core.ProviderData{
EnableBetaResources: false,
},
envSet: true,
envValue: "gibberish",
expectWarn: true,
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
if tt.envSet {
t.Setenv("STACKIT_TF_ENABLE_BETA_RESOURCES", tt.envValue)
}
diags := diag.Diagnostics{}
result := BetaResourcesEnabled(context.Background(), tt.data, &diags)
if result != tt.expected {
t.Fatalf("Expected %t, got %t", tt.expected, result)
}
if tt.expectWarn && diags.WarningsCount() == 0 {
t.Fatalf("Expected warning, got none")
}
if !tt.expectWarn && diags.WarningsCount() > 0 {
t.Fatalf("Expected no warning, got %d", diags.WarningsCount())
}
})
}
}
func TestCheckBetaResourcesEnabled(t *testing.T) {
tests := []struct {
description string
betaEnabled bool
expectError bool
expectWarn bool
}{
{
description: "Beta enabled, show warning",
betaEnabled: true,
expectWarn: true,
},
{
description: "Beta disabled, show error",
betaEnabled: false,
expectError: true,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
var envValue string
if tt.betaEnabled {
envValue = "true"
} else {
envValue = "false"
}
t.Setenv("STACKIT_TF_ENABLE_BETA_RESOURCES", envValue)
diags := diag.Diagnostics{}
CheckBetaResourcesEnabled(context.Background(), &core.ProviderData{}, &diags, "stackit_test", "resource")
if tt.expectError && diags.ErrorsCount() == 0 {
t.Fatalf("Expected error, got none")
}
if !tt.expectError && diags.ErrorsCount() > 0 {
t.Fatalf("Expected no error, got %d", diags.ErrorsCount())
}
if tt.expectWarn && diags.WarningsCount() == 0 {
t.Fatalf("Expected warning, got none")
}
if !tt.expectWarn && diags.WarningsCount() > 0 {
t.Fatalf("Expected no warning, got %d", diags.WarningsCount())
}
})
}
}

View file

@ -0,0 +1,78 @@
// Copyright (c) STACKIT
package features
import (
"context"
"fmt"
"slices"
"strings"
"github.com/hashicorp/terraform-plugin-framework/diag"
"github.com/hashicorp/terraform-plugin-log/tflog"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
)
const (
RoutingTablesExperiment = "routing-tables"
NetworkExperiment = "network"
IamExperiment = "iam"
)
var AvailableExperiments = []string{IamExperiment, RoutingTablesExperiment, NetworkExperiment}
// Check if an experiment is valid.
func ValidExperiment(experiment string, diags *diag.Diagnostics) bool {
validExperiment := slices.ContainsFunc(AvailableExperiments, func(e string) bool {
return strings.EqualFold(e, experiment)
})
if !validExperiment {
diags.AddError("Invalid Experiment", fmt.Sprintf("The Experiment %s is invalid. This is most likely a bug in the STACKIT Provider. Please open an issue. Available Experiments: %v", experiment, AvailableExperiments))
}
return validExperiment
}
// Check if an experiment is enabled.
func CheckExperimentEnabled(ctx context.Context, data *core.ProviderData, experiment, resourceName string, resourceType core.ResourceType, diags *diag.Diagnostics) {
if CheckExperimentEnabledWithoutError(ctx, data, experiment, resourceName, resourceType, diags) {
return
}
errTitle := fmt.Sprintf("%s is part of the %s experiment, which is currently disabled by default", resourceName, experiment)
errContent := fmt.Sprintf(`Enable the %s experiment by adding it into your provider block.`, experiment)
tflog.Error(ctx, fmt.Sprintf("%s | %s", errTitle, errContent))
diags.AddError(errTitle, errContent)
}
func CheckExperimentEnabledWithoutError(ctx context.Context, data *core.ProviderData, experiment, resourceName string, resourceType core.ResourceType, diags *diag.Diagnostics) bool {
if !ValidExperiment(experiment, diags) {
errTitle := fmt.Sprintf("The experiment %s does not exist.", experiment)
errContent := "This is a bug in the STACKIT Terraform Provider. Please open an issue here: https://github.com/stackitcloud/terraform-provider-stackit/issues"
diags.AddError(errTitle, errContent)
return false
}
experimentActive := slices.ContainsFunc(data.Experiments, func(e string) bool {
return strings.EqualFold(e, experiment)
})
if experimentActive {
warnTitle := fmt.Sprintf("%s is part of the %s experiment.", resourceName, experiment)
warnContent := fmt.Sprintf("This %s is part of the %s experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion.", resourceType, experiment)
tflog.Warn(ctx, fmt.Sprintf("%s | %s", warnTitle, warnContent))
diags.AddWarning(warnTitle, warnContent)
return true
}
return false
}
func AddExperimentDescription(description, experiment string, resourceType core.ResourceType) string {
// Callout block: https://developer.hashicorp.com/terraform/registry/providers/docs#callouts
return fmt.Sprintf("%s\n\n~> %s%s%s%s%s",
description,
"This ",
resourceType,
" is part of the ",
experiment,
" experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion.",
)
}

View file

@ -0,0 +1,254 @@
// Copyright (c) STACKIT
package features
import (
"context"
"testing"
"github.com/hashicorp/terraform-plugin-framework/diag"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
)
func TestValidExperiment(t *testing.T) {
type args struct {
experiment string
diags *diag.Diagnostics
}
tests := []struct {
name string
args args
want bool
}{
{
name: "valid",
args: args{
experiment: IamExperiment,
diags: &diag.Diagnostics{},
},
want: true,
},
{
name: "invalid",
args: args{
experiment: "foo",
diags: &diag.Diagnostics{},
},
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := ValidExperiment(tt.args.experiment, tt.args.diags); got != tt.want {
t.Errorf("ValidExperiment() = %v, want %v", got, tt.want)
}
})
}
}
func TestCheckExperimentEnabled(t *testing.T) {
type args struct {
ctx context.Context
data *core.ProviderData
experiment string
resourceName string
resourceType core.ResourceType
diags *diag.Diagnostics
}
tests := []struct {
name string
args args
wantDiagsErr bool
wantDiagsWarning bool
}{
{
name: "enabled",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment},
},
experiment: IamExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantDiagsErr: false,
wantDiagsWarning: true,
},
{
name: "disabled",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{},
},
experiment: IamExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantDiagsErr: true,
wantDiagsWarning: false,
},
{
name: "invalid experiment",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment},
},
experiment: "foobar",
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantDiagsErr: true,
wantDiagsWarning: false,
},
{
name: "enabled multiple experiment",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment, NetworkExperiment, RoutingTablesExperiment},
},
experiment: NetworkExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantDiagsErr: false,
wantDiagsWarning: true,
},
{
name: "enabled multiple experiment - without the required experiment",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment, RoutingTablesExperiment},
},
experiment: NetworkExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantDiagsErr: true,
wantDiagsWarning: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
CheckExperimentEnabled(tt.args.ctx, tt.args.data, tt.args.experiment, tt.args.resourceName, tt.args.resourceType, tt.args.diags)
if got := tt.args.diags.HasError(); got != tt.wantDiagsErr {
t.Errorf("CheckExperimentEnabled() diags.HasError() = %v, want %v", got, tt.wantDiagsErr)
}
if got := tt.args.diags.WarningsCount() > 0; got != tt.wantDiagsWarning {
t.Errorf("CheckExperimentEnabled() diags.WarningsCount() > 0 = %v, want %v", got, tt.wantDiagsErr)
}
})
}
}
func TestCheckExperimentEnabledWithoutError(t *testing.T) {
type args struct {
ctx context.Context
data *core.ProviderData
experiment string
resourceName string
resourceType core.ResourceType
diags *diag.Diagnostics
}
tests := []struct {
name string
args args
wantEnabled bool
wantDiagsErr bool
wantDiagsWarning bool
}{
{
name: "enabled",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment},
},
experiment: IamExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantEnabled: true,
wantDiagsErr: false,
wantDiagsWarning: true,
},
{
name: "disabled - no error",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{},
},
experiment: NetworkExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantEnabled: false,
wantDiagsErr: false,
wantDiagsWarning: false,
},
{
name: "invalid experiment",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment},
},
experiment: "foobar",
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantEnabled: false,
wantDiagsErr: true,
wantDiagsWarning: false,
},
{
name: "enabled multiple experiment",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment, NetworkExperiment, RoutingTablesExperiment},
},
experiment: NetworkExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantEnabled: true,
wantDiagsErr: false,
wantDiagsWarning: true,
},
{
name: "enabled multiple experiment - without the required experiment",
args: args{
ctx: context.Background(),
data: &core.ProviderData{
Experiments: []string{IamExperiment, RoutingTablesExperiment},
},
experiment: NetworkExperiment,
resourceType: core.Resource,
diags: &diag.Diagnostics{},
},
wantEnabled: false,
wantDiagsErr: false,
wantDiagsWarning: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := CheckExperimentEnabledWithoutError(tt.args.ctx, tt.args.data, tt.args.experiment, tt.args.resourceName, tt.args.resourceType, tt.args.diags); got != tt.wantEnabled {
t.Errorf("CheckExperimentEnabledWithoutError() = %v, want %v", got, tt.wantEnabled)
}
if got := tt.args.diags.HasError(); got != tt.wantDiagsErr {
t.Errorf("CheckExperimentEnabled() diags.HasError() = %v, want %v", got, tt.wantDiagsErr)
}
if got := tt.args.diags.WarningsCount() > 0; got != tt.wantDiagsWarning {
t.Errorf("CheckExperimentEnabled() diags.WarningsCount() > 0 = %v, want %v", got, tt.wantDiagsErr)
}
})
}
}