feat: add sqlserver beta resources (instance, database)

2026-02-04 21:18:43 +01:00 · 2026-02-04 21:18:43 +01:00 · 318b58339f
commit 318b58339f
parent 3eb256bd08
65 changed files with 14318 additions and 1311 deletions
--- a/stackit/internal/wait/sqlserverflexbeta/wait.go
+++ b/stackit/internal/wait/sqlserverflexbeta/wait.go
@ -0,0 +1,159 @@
+package sqlserverflexbeta
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/wait"
+	sqlserverflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
+)
+
+// READY, PENDING, PROGRESSING, FAILURE, UNKNOWN,
+const (
+	InstanceStateEmpty       = ""
+	InstanceStateSuccess     = "READY"
+	InstanceStatePending     = "PENDING"
+	InstanceStateProcessing  = "PROGRESSING"
+	InstanceStateFailed      = "FAILURE"
+	InstanceStateUnknown     = "UNKNOWN"
+	InstanceStateTerminating = "TERMINATING"
+)
+
+// APIClientInterface Interface needed for tests
+type APIClientInterface interface {
+	GetInstanceRequestExecute(ctx context.Context, projectId, region, instanceId string) (*sqlserverflex.GetInstanceResponse, error)
+	GetDatabaseRequestExecute(ctx context.Context, projectId string, region string, instanceId string, databaseName string) (*sqlserverflex.GetDatabaseResponse, error)
+	GetUserRequestExecute(ctx context.Context, projectId string, region string, instanceId string, userId int64) (*sqlserverflex.GetUserResponse, error)
+}
+
+// CreateInstanceWaitHandler will wait for instance creation
+func CreateInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
+	handler := wait.New(func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
+		s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+		if err != nil {
+			return false, nil, err
+		}
+		if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
+			return false, nil, nil
+		}
+		switch strings.ToLower(string(*s.Status)) {
+		case strings.ToLower(InstanceStateSuccess):
+			if *s.Network.AccessScope == "SNA" {
+				if s.Network.InstanceAddress == nil {
+					tflog.Info(ctx, "Waiting for instance_address")
+					return false, nil, nil
+				}
+				if s.Network.RouterAddress == nil {
+					tflog.Info(ctx, "Waiting for router_address")
+					return false, nil, nil
+				}
+			}
+			return true, s, nil
+		case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
+			return true, s, fmt.Errorf("create failed for instance with id %s", instanceId)
+		case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
+			tflog.Info(ctx, "request is being handled", map[string]interface{}{
+				"status": *s.Status,
+			})
+			return false, nil, nil
+		default:
+			tflog.Info(ctx, "Wait (create) received unknown status", map[string]interface{}{
+				"instanceId": instanceId,
+				"status":     s.Status,
+			})
+			return false, s, nil
+		}
+	})
+	return handler
+}
+
+// UpdateInstanceWaitHandler will wait for instance update
+func UpdateInstanceWaitHandler(ctx context.Context, a APIClientInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
+	handler := wait.New(func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
+		s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+		if err != nil {
+			return false, nil, err
+		}
+		if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
+			return false, nil, nil
+		}
+		switch strings.ToLower(string(*s.Status)) {
+		case strings.ToLower(InstanceStateSuccess):
+			return true, s, nil
+		case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
+			return true, s, fmt.Errorf("update failed for instance with id %s", instanceId)
+		case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
+			tflog.Info(ctx, "request is being handled", map[string]interface{}{
+				"status": *s.Status,
+			})
+			return false, nil, nil
+		default:
+			tflog.Info(ctx, "Wait (update) received unknown status", map[string]interface{}{
+				"instanceId": instanceId,
+				"status":     s.Status,
+			})
+			return false, s, nil
+		}
+	})
+	handler.SetSleepBeforeWait(15 * time.Second)
+	handler.SetTimeout(45 * time.Minute)
+	return handler
+}
+
+// DeleteInstanceWaitHandler will wait for instance deletion
+func DeleteInstanceWaitHandler(ctx context.Context, a APIClientInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[struct{}] {
+	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
+		_, err = a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+		if err == nil {
+			return false, nil, nil
+		}
+		var oapiErr *oapierror.GenericOpenAPIError
+		ok := errors.As(err, &oapiErr)
+		if !ok {
+			return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+		}
+		if oapiErr.StatusCode != http.StatusNotFound {
+			return false, nil, err
+		}
+		return true, nil, nil
+	})
+	handler.SetTimeout(15 * time.Minute)
+	return handler
+}
+
+// CreateDatabaseWaitHandler will wait for instance creation
+func CreateDatabaseWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region, databaseName string,
+) *wait.AsyncActionHandler[sqlserverflex.GetDatabaseResponse] {
+	handler := wait.New(func() (waitFinished bool, response *sqlserverflex.GetDatabaseResponse, err error) {
+		s, err := a.GetDatabaseRequestExecute(ctx, projectId, region, instanceId, databaseName)
+		if err != nil {
+			return false, nil, err
+		}
+		if s == nil || s.Name == nil || *s.Name != databaseName {
+			return false, nil, nil
+		}
+		var oapiErr *oapierror.GenericOpenAPIError
+		ok := errors.As(err, &oapiErr)
+		if !ok {
+			return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+		}
+		if oapiErr.StatusCode != http.StatusNotFound {
+			return false, nil, err
+		}
+		return true, nil, nil
+	})
+	return handler
+}
--- a/stackit/internal/wait/sqlserverflexbeta/wait_test.go
+++ b/stackit/internal/wait/sqlserverflexbeta/wait_test.go
@ -0,0 +1,258 @@
+package sqlserverflexbeta
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	sqlserverflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
+)
+
+// Used for testing instance operations
+type apiClientInstanceMocked struct {
+	instanceId        string
+	instanceState     string
+	instanceNetwork   sqlserverflex.InstanceNetwork
+	instanceIsDeleted bool
+	instanceGetFails  bool
+}
+
+func (a *apiClientInstanceMocked) GetInstanceRequestExecute(_ context.Context, _, _, _ string) (*sqlserverflex.GetInstanceResponse, error) {
+	if a.instanceGetFails {
+		return nil, &oapierror.GenericOpenAPIError{
+			StatusCode: 500,
+		}
+	}
+
+	if a.instanceIsDeleted {
+		return nil, &oapierror.GenericOpenAPIError{
+			StatusCode: 404,
+		}
+	}
+
+	return &sqlserverflex.GetInstanceResponse{
+		Id:      &a.instanceId,
+		Status:  sqlserverflex.GetInstanceResponseGetStatusAttributeType(&a.instanceState),
+		Network: &a.instanceNetwork,
+	}, nil
+}
+func TestCreateInstanceWaitHandler(t *testing.T) {
+	t.Skip("skipping - needs refactoring")
+	tests := []struct {
+		desc                string
+		instanceGetFails    bool
+		instanceState       string
+		instanceNetwork     sqlserverflex.InstanceNetwork
+		usersGetErrorStatus int
+		wantErr             bool
+		wantRes             *sqlserverflex.GetInstanceResponse
+	}{
+		{
+			desc:             "create_succeeded",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: sqlserverflex.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.2"),
+			},
+			wantErr: false,
+			wantRes: &sqlserverflex.GetInstanceResponse{
+				BackupSchedule: nil,
+				Edition:        nil,
+				Encryption:     nil,
+				FlavorId:       nil,
+				Id:             nil,
+				IsDeletable:    nil,
+				Name:           nil,
+				Network: &sqlserverflex.InstanceNetwork{
+					AccessScope:     nil,
+					Acl:             nil,
+					InstanceAddress: utils.Ptr("10.0.0.1"),
+					RouterAddress:   utils.Ptr("10.0.0.2"),
+				},
+				Replicas:      nil,
+				RetentionDays: nil,
+				Status:        nil,
+				Storage:       nil,
+				Version:       nil,
+			},
+		},
+		{
+			desc:             "create_failed",
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "create_failed_2",
+			instanceGetFails: false,
+			instanceState:    InstanceStateEmpty,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "instance_get_fails",
+			instanceGetFails: true,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "timeout",
+			instanceGetFails: false,
+			instanceState:    InstanceStateProcessing,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			instanceId := "foo-bar"
+
+			apiClient := &apiClientInstanceMocked{
+				instanceId:       instanceId,
+				instanceState:    tt.instanceState,
+				instanceGetFails: tt.instanceGetFails,
+			}
+
+			handler := CreateInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
+
+			gotRes, err := handler.SetTimeout(10 * time.Millisecond).SetSleepBeforeWait(1 * time.Millisecond).WaitWithContext(context.Background())
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			if !cmp.Equal(gotRes, tt.wantRes) {
+				t.Fatalf("handler gotRes = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestUpdateInstanceWaitHandler(t *testing.T) {
+	t.Skip("skipping - needs refactoring")
+	tests := []struct {
+		desc             string
+		instanceGetFails bool
+		instanceState    string
+		wantErr          bool
+		wantResp         bool
+	}{
+		{
+			desc:             "update_succeeded",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			wantErr:          false,
+			wantResp:         true,
+		},
+		{
+			desc:             "update_failed",
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			wantErr:          true,
+			wantResp:         true,
+		},
+		{
+			desc:             "update_failed_2",
+			instanceGetFails: false,
+			instanceState:    InstanceStateEmpty,
+			wantErr:          true,
+			wantResp:         true,
+		},
+		{
+			desc:             "get_fails",
+			instanceGetFails: true,
+			wantErr:          true,
+			wantResp:         false,
+		},
+		{
+			desc:             "timeout",
+			instanceGetFails: false,
+			instanceState:    InstanceStateProcessing,
+			wantErr:          true,
+			wantResp:         true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			instanceId := "foo-bar"
+
+			apiClient := &apiClientInstanceMocked{
+				instanceId:       instanceId,
+				instanceState:    tt.instanceState,
+				instanceGetFails: tt.instanceGetFails,
+			}
+
+			var wantRes *sqlserverflex.GetInstanceResponse
+			if tt.wantResp {
+				wantRes = &sqlserverflex.GetInstanceResponse{
+					Id:     &instanceId,
+					Status: sqlserverflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr(tt.instanceState)),
+				}
+			}
+
+			handler := UpdateInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
+
+			gotRes, err := handler.SetTimeout(10 * time.Millisecond).SetSleepBeforeWait(1 * time.Millisecond).WaitWithContext(context.Background())
+
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !cmp.Equal(gotRes, wantRes) {
+				t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes)
+			}
+		})
+	}
+}
+
+func TestDeleteInstanceWaitHandler(t *testing.T) {
+	tests := []struct {
+		desc             string
+		instanceGetFails bool
+		instanceState    string
+		wantErr          bool
+	}{
+		{
+			desc:             "delete_succeeded",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			wantErr:          false,
+		},
+		{
+			desc:             "delete_failed",
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			wantErr:          true,
+		},
+		{
+			desc:             "get_fails",
+			instanceGetFails: true,
+			wantErr:          true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			instanceId := "foo-bar"
+
+			apiClient := &apiClientInstanceMocked{
+				instanceGetFails:  tt.instanceGetFails,
+				instanceIsDeleted: tt.instanceState == InstanceStateSuccess,
+				instanceId:        instanceId,
+				instanceState:     tt.instanceState,
+			}
+
+			handler := DeleteInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
+
+			_, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background())
+
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}