feat: initial copy of v0.1.0

stackit/internal/wait/postgresflexalpha/wait.go

@@ -0,0 +1,331 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math"
+	"net/http"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/wait"
+)
+
+// "READY" "PENDING" "PROGRESSING" "FAILURE" "UNKNOWN" "TERMINATING"
+const (
+	InstanceStateEmpty       = ""
+	InstanceStateProgressing = "PROGRESSING"
+	InstanceStateSuccess     = "READY"
+	InstanceStateFailed      = "FAILURE"
+	InstanceStateTerminating = "TERMINATING"
+	InstanceStateUnknown     = "UNKNOWN"
+	InstanceStatePending     = "PENDING"
+	InstanceStateDeleted     = "DELETED"
+)
+
+// APIClientInstanceInterface Interface needed for tests
+type APIClientInstanceInterface interface {
+	GetInstanceRequest(ctx context.Context, projectId, region, instanceId string) v3alpha1api.ApiGetInstanceRequestRequest
+
+	ListUsersRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) v3alpha1api.ApiListUsersRequestRequest
+}
+
+// APIClientUserInterface Interface needed for tests
+type APIClientUserInterface interface {
+	GetUserRequest(ctx context.Context, projectId, region, instanceId string, userId int32) v3alpha1api.ApiGetUserRequestRequest
+}
+
+// APIClientDatabaseInterface Interface needed for tests
+type APIClientDatabaseInterface interface {
+	GetDatabaseRequest(ctx context.Context, projectId string, region string, instanceId string, databaseId int32) v3alpha1api.ApiGetDatabaseRequestRequest
+}
+
+// CreateInstanceWaitHandler will wait for instance creation
+func CreateInstanceWaitHandler(
+	ctx context.Context, a APIClientInstanceInterface, projectId, region,
+	instanceId string,
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
+	instanceCreated := false
+	var instanceGetResponse *v3alpha1api.GetInstanceResponse
+	maxWait := time.Minute * 45
+	startTime := time.Now()
+	extendedTimeout := 0
+
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
+			if !instanceCreated {
+				s, err := a.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+				if err != nil {
+					return false, nil, err
+				}
+				if s == nil || s.Id != instanceId {
+					return false, nil, nil
+				}
+				tflog.Debug(
+					ctx, "waiting for instance ready", map[string]interface{}{
+						"status": s.Status,
+					},
+				)
+				switch s.Status {
+				default:
+					return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceId, s.Status)
+				case InstanceStateEmpty:
+					return false, nil, nil
+				case InstanceStatePending:
+					return false, nil, nil
+				case InstanceStateUnknown:
+					return false, nil, nil
+				case InstanceStateProgressing:
+					if time.Since(startTime) < maxWait {
+						return false, nil, nil
+					}
+					tflog.Warn(
+						ctx,
+						fmt.Sprintf(
+							"Wait handler still got status %s after %v for instance: %s",
+							InstanceStateProgressing,
+							maxWait,
+							instanceId,
+						),
+					)
+					if extendedTimeout < 3 {
+						maxWait += time.Minute * 5
+						extendedTimeout++
+						if *s.Network.AccessScope == "SNA" {
+							ready := true
+							if s.Network.InstanceAddress == nil {
+								tflog.Warn(ctx, "Waiting for instance_address")
+								ready = false
+							}
+							if s.Network.RouterAddress == nil {
+								tflog.Warn(ctx, "Waiting for router_address")
+								ready = false
+							}
+							if !ready {
+								return false, nil, nil
+							}
+						}
+					}
+
+					instanceCreated = true
+					instanceGetResponse = s
+				case InstanceStateSuccess:
+					if s.Network.AccessScope != nil && *s.Network.AccessScope == "SNA" {
+						if s.Network.InstanceAddress == nil {
+							tflog.Warn(ctx, "Waiting for instance_address")
+							return false, nil, nil
+						}
+						if s.Network.RouterAddress == nil {
+							tflog.Warn(ctx, "Waiting for router_address")
+							return false, nil, nil
+						}
+					}
+					instanceCreated = true
+					instanceGetResponse = s
+				case InstanceStateFailed:
+					tflog.Warn(ctx, fmt.Sprintf("Wait handler got status FAILURE for instance: %s", instanceId))
+					return false, nil, nil
+					// API responds with FAILURE for some seconds and then the instance goes to READY
+					// return true, s, fmt.Errorf("create failed for instance with id %s", instanceId)
+				}
+			}
+
+			tflog.Info(ctx, "Waiting for instance (calling list users")
+			// 	// User operations aren't available right after an instance is deemed successful
+			//			// To check if they are, perform a users request
+			_, err = a.ListUsersRequest(ctx, projectId, region, instanceId).Execute()
+			if err == nil {
+				return true, instanceGetResponse, nil
+			}
+			oapiErr, ok := err.(*oapierror.GenericOpenAPIError) // nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
+			if !ok {
+				return false, nil, err
+			}
+			// TODO: refactor and cooperate with api guys to mitigate
+			if oapiErr.StatusCode < 500 {
+				return true, instanceGetResponse, fmt.Errorf(
+					"users request after instance creation returned %d status code",
+					oapiErr.StatusCode,
+				)
+			}
+			return false, nil, nil
+		},
+	)
+	// Sleep before wait is set because sometimes API returns 404 right after creation request
+	handler.SetTimeout(90 * time.Minute).SetSleepBeforeWait(30 * time.Second)
+	return handler
+}
+
+// PartialUpdateInstanceWaitHandler will wait for instance update
+func PartialUpdateInstanceWaitHandler(
+	ctx context.Context, a APIClientInstanceInterface, projectID, region,
+	instanceID string,
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequest(ctx, projectID, region, instanceID).Execute()
+			if err != nil {
+				return false, nil, err
+			}
+			if s == nil || s.Id != instanceID {
+				return false, nil, nil
+			}
+			switch s.Status {
+			default:
+				return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceID, s.Status)
+			case InstanceStateEmpty:
+				return false, nil, nil
+			case InstanceStatePending:
+				return false, nil, nil
+			case InstanceStateProgressing:
+				return false, nil, nil
+			case InstanceStateSuccess:
+				return true, s, nil
+			case InstanceStateTerminating:
+				return false, nil, nil
+			case InstanceStateUnknown:
+				return false, nil, nil
+			case InstanceStateFailed:
+				return true, s, fmt.Errorf("update got status FAILURE for instance with id %s", instanceID)
+			}
+		},
+	)
+	handler.SetTimeout(45 * time.Minute).SetSleepBeforeWait(30 * time.Second)
+	return handler
+}
+
+// GetUserByIdWaitHandler will wait for instance creation
+func GetUserByIdWaitHandler(
+	ctx context.Context,
+	a APIClientUserInterface,
+	projectID, instanceID, region string,
+	userID int64,
+) *wait.AsyncActionHandler[v3alpha1api.GetUserResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetUserResponse, err error) {
+			if userID > math.MaxInt32 {
+				return false, nil, fmt.Errorf("userID too large for int32")
+			}
+			userID32 := int32(userID) //nolint:gosec // checked above
+			s, err := a.GetUserRequest(ctx, projectID, region, instanceID, userID32).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+				}
+				switch oapiErr.StatusCode {
+				case http.StatusBadGateway, http.StatusGatewayTimeout, http.StatusServiceUnavailable:
+				case http.StatusNotFound:
+					tflog.Warn(
+						ctx, "api responded with status", map[string]interface{}{
+							"status": oapiErr.StatusCode,
+						},
+					)
+					return false, nil, nil
+				default:
+					return false, nil, err
+				}
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// GetDatabaseByIdWaitHandler will wait for instance creation
+func GetDatabaseByIdWaitHandler(
+	ctx context.Context,
+	a APIClientDatabaseInterface,
+	projectID, instanceID, region string,
+	databaseID int64,
+) *wait.AsyncActionHandler[v3alpha1api.GetDatabaseResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetDatabaseResponse, err error) {
+			if databaseID > math.MaxInt32 {
+				return false, nil, fmt.Errorf("databaseID too large for int32")
+			}
+			dbId32 := int32(databaseID) //nolint:gosec // is checked above
+			s, err := a.GetDatabaseRequest(ctx, projectID, region, instanceID, dbId32).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+				}
+				switch oapiErr.StatusCode {
+				case http.StatusBadGateway, http.StatusGatewayTimeout, http.StatusServiceUnavailable:
+					tflog.Warn(
+						ctx, "api responded with 50[2,3,4] status", map[string]interface{}{
+							"status": oapiErr.StatusCode,
+						},
+					)
+					return false, nil, nil
+				case http.StatusNotFound:
+					tflog.Warn(
+						ctx, "api responded with 404 status", map[string]interface{}{
+							"status": oapiErr.StatusCode,
+						},
+					)
+					return false, nil, nil
+				default:
+					return false, nil, err
+				}
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+func DeleteInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInstanceInterface,
+	projectID,
+	region,
+	instanceID string,
+	timeout, sleepBeforeWait time.Duration,
+) error {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequest(ctx, projectID, region, instanceID).Execute()
+			if err != nil {
+				oapiErr, ok := err.(*oapierror.GenericOpenAPIError) // nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
+				if !ok {
+					return false, nil, fmt.Errorf("received error is no oapierror: %w", err)
+				}
+				if oapiErr.StatusCode == 404 {
+					return true, nil, nil
+				}
+				return false, nil, fmt.Errorf("api returned error: %w", err)
+			}
+			switch s.Status {
+			case InstanceStateDeleted:
+				return true, nil, nil
+			case InstanceStateEmpty, InstanceStatePending, InstanceStateUnknown, InstanceStateProgressing, InstanceStateSuccess:
+				return false, nil, nil
+			case InstanceStateFailed:
+				return true, nil, fmt.Errorf("wait handler got status FAILURE for instance: %s", instanceID)
+			default:
+				return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceID, s.Status)
+			}
+		},
+	).
+		SetTimeout(timeout).
+		SetSleepBeforeWait(sleepBeforeWait)
+
+	_, err := handler.WaitWithContext(ctx)
+	if err != nil {
+		return err
+	}
+	return nil
+}

stackit/internal/wait/postgresflexalpha/wait_test.go

@@ -0,0 +1,332 @@
+// Copyright (c) STACKIT
+
+package postgresflexalpha
+
+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"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+)
+
+func TestCreateInstanceWaitHandler(t *testing.T) {
+	tests := []struct {
+		desc                string
+		instanceGetFails    bool
+		instanceState       string
+		instanceNetwork     v3alpha1api.InstanceNetwork
+		usersGetErrorStatus int
+		wantErr             bool
+		wantRes             *v3alpha1api.GetInstanceResponse
+	}{
+		{
+			desc:             "create_succeeded",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: false,
+			wantRes: &v3alpha1api.GetInstanceResponse{
+				Id:     "foo-bar",
+				Status: InstanceStateSuccess,
+				Network: v3alpha1api.InstanceNetwork{
+					AccessScope:     nil,
+					Acl:             nil,
+					InstanceAddress: utils.Ptr("10.0.0.1"),
+					RouterAddress:   utils.Ptr("10.0.0.1"),
+				},
+			},
+		},
+		{
+			desc:             "create_failed",
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: nil,
+		},
+		{
+			desc:             "create_failed_2",
+			instanceGetFails: false,
+			instanceState:    InstanceStateEmpty,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: nil,
+		},
+		{
+			desc:             "instance_get_fails",
+			instanceGetFails: true,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "users_get_fails",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			usersGetErrorStatus: 500,
+			wantErr:             true,
+			wantRes:             nil,
+		},
+		{
+			desc:             "users_get_fails_2",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			usersGetErrorStatus: 400,
+			wantErr:             true,
+			wantRes: &v3alpha1api.GetInstanceResponse{
+				Id:     "foo-bar",
+				Status: InstanceStateSuccess,
+				Network: v3alpha1api.InstanceNetwork{
+					AccessScope:     nil,
+					Acl:             nil,
+					InstanceAddress: utils.Ptr("10.0.0.1"),
+					RouterAddress:   utils.Ptr("10.0.0.1"),
+				},
+			},
+		},
+		{
+			desc:             "fail when response has no instance address",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     (*v3alpha1api.InstanceNetworkAccessScope)(utils.Ptr("SNA")),
+				Acl:             nil,
+				InstanceAddress: nil,
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: nil,
+		},
+		{
+			desc:             "timeout",
+			instanceGetFails: false,
+			instanceState:    InstanceStateProgressing,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     (*v3alpha1api.InstanceNetworkAccessScope)(utils.Ptr("SNA")),
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.desc, func(t *testing.T) {
+				instanceID := "foo-bar"
+
+				listUsersMock := func(_ v3alpha1api.ApiListUsersRequestRequest) (*v3alpha1api.ListUserResponse, error) {
+					if tt.usersGetErrorStatus != 0 {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: tt.usersGetErrorStatus,
+						}
+					}
+
+					aux := int32(0)
+					return &v3alpha1api.ListUserResponse{
+						Pagination: v3alpha1api.Pagination{
+							TotalRows: aux,
+						},
+						Users: []v3alpha1api.ListUser{},
+					}, nil
+				}
+
+				getInstanceMock := func(_ v3alpha1api.ApiGetInstanceRequestRequest) (*v3alpha1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					return &v3alpha1api.GetInstanceResponse{
+						Id:      instanceID,
+						Status:  v3alpha1api.Status(tt.instanceState),
+						Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClientMock := v3alpha1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &getInstanceMock,
+					ListUsersRequestExecuteMock:   &listUsersMock,
+				}
+
+				handler := CreateInstanceWaitHandler(context.Background(), apiClientMock, "", "", 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) {
+	tests := []struct {
+		desc             string
+		instanceGetFails bool
+		instanceState    string
+		instanceNetwork  v3alpha1api.InstanceNetwork
+		wantErr          bool
+		wantRes          *v3alpha1api.GetInstanceResponse
+	}{
+		{
+			desc:             "update_succeeded",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: false,
+			wantRes: &v3alpha1api.GetInstanceResponse{
+				Id:     "foo-bar",
+				Status: v3alpha1api.Status(InstanceStateSuccess),
+				Network: v3alpha1api.InstanceNetwork{
+					AccessScope:     nil,
+					Acl:             nil,
+					InstanceAddress: utils.Ptr("10.0.0.1"),
+					RouterAddress:   utils.Ptr("10.0.0.1"),
+				},
+			},
+		},
+		{
+			desc:             "update_failed",
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: &v3alpha1api.GetInstanceResponse{
+				Id:     "foo-bar",
+				Status: v3alpha1api.Status(InstanceStateFailed),
+				Network: v3alpha1api.InstanceNetwork{
+					AccessScope:     nil,
+					Acl:             nil,
+					InstanceAddress: utils.Ptr("10.0.0.1"),
+					RouterAddress:   utils.Ptr("10.0.0.1"),
+				},
+			},
+		},
+		{
+			desc:             "update_failed_2",
+			instanceGetFails: false,
+			instanceState:    InstanceStateEmpty,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: nil,
+		},
+		{
+			desc:             "get_fails",
+			instanceGetFails: true,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "timeout",
+			instanceGetFails: false,
+			instanceState:    InstanceStateProgressing,
+			instanceNetwork: v3alpha1api.InstanceNetwork{
+				AccessScope:     nil,
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.1"),
+			},
+			wantErr: true,
+			wantRes: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.desc, func(t *testing.T) {
+				instanceID := "foo-bar"
+
+				listUsersMock := func(_ v3alpha1api.ApiListUsersRequestRequest) (*v3alpha1api.ListUserResponse, error) {
+					aux := int32(0)
+					return &v3alpha1api.ListUserResponse{
+						Pagination: v3alpha1api.Pagination{
+							TotalRows: aux,
+						},
+						Users: []v3alpha1api.ListUser{},
+					}, nil
+				}
+
+				getInstanceMock := func(_ v3alpha1api.ApiGetInstanceRequestRequest) (*v3alpha1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					return &v3alpha1api.GetInstanceResponse{
+						Id:      instanceID,
+						Status:  v3alpha1api.Status(tt.instanceState),
+						Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClientMock := v3alpha1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &getInstanceMock,
+					ListUsersRequestExecuteMock:   &listUsersMock,
+				}
+
+				handler := PartialUpdateInstanceWaitHandler(context.Background(), apiClientMock, "", "", instanceID)
+
+				gotRes, err := handler.SetTimeout(10 * 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)
+				}
+			},
+		)
+	}
+}

stackit/internal/wait/sqlserverflexalpha/wait.go

@@ -0,0 +1,387 @@
+package sqlserverflexalpha
+
+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"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+)
+
+// 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 {
+	GetInstanceRequest(
+		ctx context.Context,
+		projectId, region, instanceId string,
+	) v3alpha1api.ApiGetInstanceRequestRequest
+
+	GetDatabaseRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		databaseName string,
+	) v3alpha1api.ApiGetDatabaseRequestRequest
+
+	GetUserRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		userId int64,
+	) v3alpha1api.ApiGetUserRequestRequest
+
+	ListRolesRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) v3alpha1api.ApiListRolesRequestRequest
+
+	ListUsersRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) v3alpha1api.ApiListUsersRequestRequest
+}
+
+// APIClientUserInterface Interface needed for tests
+type APIClientUserInterface interface {
+	DeleteUserRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		userId int64,
+	) error
+}
+
+// CreateInstanceWaitHandler will wait for instance creation
+func CreateInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+			if err != nil {
+				return false, nil, err
+			}
+			if s == nil || s.Id != instanceId {
+				return false, nil, nil
+			}
+			switch strings.ToLower(string(s.Status)) {
+			case strings.ToLower(InstanceStateSuccess):
+				if s.Network.AccessScope != nil && *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
+					}
+				}
+
+				tflog.Info(ctx, "trying to get roles")
+				time.Sleep(10 * time.Second)
+				_, rolesErr := a.ListRolesRequest(ctx, projectId, region, instanceId).Execute()
+				if rolesErr != nil {
+					var oapiErr *oapierror.GenericOpenAPIError
+					ok := errors.As(rolesErr, &oapiErr)
+					if !ok {
+						return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+					}
+					if oapiErr.StatusCode != http.StatusInternalServerError {
+						tflog.Info(
+							ctx, "got error from api", map[string]interface{}{
+								"error": rolesErr.Error(),
+							},
+						)
+						return false, nil, rolesErr
+					}
+					tflog.Info(
+						ctx, "wait for get-roles to work hack", map[string]interface{}{},
+					)
+					time.Sleep(10 * time.Second)
+					return false, nil, nil
+				}
+
+				tflog.Info(ctx, "trying to get users")
+				time.Sleep(10 * time.Second)
+				_, usersErr := a.ListUsersRequest(ctx, projectId, region, instanceId).Execute()
+				if usersErr != nil {
+					var oapiErr *oapierror.GenericOpenAPIError
+					ok := errors.As(usersErr, &oapiErr)
+					if !ok {
+						return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+					}
+					if oapiErr.StatusCode != http.StatusInternalServerError {
+						tflog.Info(
+							ctx, "got error from api", map[string]interface{}{
+								"error": rolesErr.Error(),
+							},
+						)
+						return false, nil, usersErr
+					}
+					tflog.Info(
+						ctx, "wait for get-users to work hack", map[string]interface{}{},
+					)
+					time.Sleep(10 * time.Second)
+					return false, nil, nil
+				}
+				return true, s, nil
+			case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
+				return true, nil, 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,
+					},
+				)
+				time.Sleep(10 * time.Second)
+				return false, nil, nil
+			default:
+				tflog.Info(
+					ctx, "Wait (create) received unknown status", map[string]interface{}{
+						"instanceId": instanceId,
+						"status":     s.Status,
+					},
+				)
+				return true, nil, errors.New("unknown status received")
+			}
+		},
+	)
+	return handler
+}
+
+// UpdateInstanceWaitHandler will wait for instance update
+func UpdateInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+			if err != nil {
+				return false, nil, err
+			}
+			if s == nil || s.Id != instanceId {
+				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, s, nil
+			default:
+				tflog.Info(
+					ctx, "Wait (update) received unknown status", map[string]interface{}{
+						"instanceId": instanceId,
+						"status":     s.Status,
+					},
+				)
+				return false, s, nil
+			}
+		},
+	)
+	return handler
+}
+
+// DeleteInstanceWaitHandler will wait for instance deletion
+func DeleteInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+			if err == nil {
+				return false, s, 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(30 * time.Minute)
+	return handler
+}
+
+// CreateDatabaseWaitHandler will wait for instance creation
+func CreateDatabaseWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region, databaseName string,
+) *wait.AsyncActionHandler[v3alpha1api.GetDatabaseResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetDatabaseResponse, err error) {
+			s, err := a.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf(
+						"get database - could not convert error to oapierror.GenericOpenAPIError: %s",
+						err.Error(),
+					)
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				return false, nil, nil
+			}
+			if s == nil || s.Name != databaseName {
+				return false, nil, errors.New("response did return different result")
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// CreateUserWaitHandler will wait for instance creation
+func CreateUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+	userId int64,
+) *wait.AsyncActionHandler[v3alpha1api.GetUserResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.GetUserResponse, err error) {
+			s, err := a.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+			if err != 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 false, nil, nil
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// WaitForUserWaitHandler will wait for instance creation
+func WaitForUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region, userName string,
+) *wait.AsyncActionHandler[v3alpha1api.ListUserResponse] {
+	startTime := time.Now()
+	timeOut := 2 * time.Minute
+
+	handler := wait.New(
+		func() (waitFinished bool, response *v3alpha1api.ListUserResponse, err error) {
+			if time.Since(startTime) > timeOut {
+				return false, nil, errors.New("ran into timeout")
+			}
+			s, err := a.ListUsersRequest(ctx, projectId, region, instanceId).Size(100).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf(
+						"wait (list users) could not convert error to oapierror.GenericOpenAPIError: %s",
+						err.Error(),
+					)
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				tflog.Info(
+					ctx, "Wait (list users) still waiting", map[string]interface{}{},
+				)
+
+				return false, nil, nil
+			}
+			users, ok := s.GetUsersOk()
+			if !ok {
+				return false, nil, errors.New("no users found")
+			}
+
+			for _, u := range users {
+				if u.GetUsername() == userName {
+					return true, s, nil
+				}
+			}
+			tflog.Info(
+				ctx, "Wait (list users) user still not present", map[string]interface{}{},
+			)
+			return false, nil, nil
+		},
+	)
+	return handler
+}
+
+// DeleteUserWaitHandler will wait for instance deletion
+func DeleteUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, region, instanceId string,
+	userId int64,
+) *wait.AsyncActionHandler[struct{}] {
+	handler := wait.New(
+		func() (waitFinished bool, response *struct{}, err error) {
+			_, err = a.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+			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")
+			}
+
+			switch oapiErr.StatusCode {
+			case http.StatusNotFound:
+				return true, nil, nil
+			default:
+				return false, nil, err
+			}
+		},
+	)
+	handler.SetTimeout(15 * time.Minute)
+	handler.SetSleepBeforeWait(15 * time.Second)
+	return handler
+}

stackit/internal/wait/sqlserverflexalpha/wait_test.go

@@ -0,0 +1,282 @@
+package sqlserverflexalpha
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+)
+
+// Used for testing instance operations
+func TestCreateInstanceWaitHandler(t *testing.T) {
+	instanceID := utils.Ptr("foo")
+	tests := []struct {
+		desc                string
+		instanceID          string
+		instanceGetFails    bool
+		instanceState       string
+		instanceNetwork     v3alpha1api.InstanceNetwork
+		usersGetErrorStatus int
+		wantErr             bool
+		wantRes             *v3alpha1api.GetInstanceResponse
+	}{
+		//{
+		//	desc:             "create_succeeded",
+		//	instanceId:       *instanceId,
+		//	instanceGetFails: false,
+		//	instanceState:    *stateSuccess,
+		//	instanceNetwork: v3alpha1api.InstanceNetwork{
+		//		AccessScope:     nil,
+		//		Acl:             nil,
+		//		InstanceAddress: utils.Ptr("10.0.0.1"),
+		//		RouterAddress:   utils.Ptr("10.0.0.2"),
+		//	},
+		//	wantErr: false,
+		//	wantRes: &v3alpha1api.GetInstanceResponse{
+		//		BackupSchedule: nil,
+		//		Edition:        nil,
+		//		Encryption:     nil,
+		//		FlavorId:       nil,
+		//		Id:             instanceId,
+		//		IsDeletable:    nil,
+		//		Name:           nil,
+		//		Network: &v3alpha1api.InstanceNetwork{
+		//			AccessScope:     nil,
+		//			Acl:             nil,
+		//			InstanceAddress: utils.Ptr("10.0.0.1"),
+		//			RouterAddress:   utils.Ptr("10.0.0.2"),
+		//		},
+		//		Replicas:      nil,
+		//		RetentionDays: nil,
+		//		Status:        v3alpha1api.GetInstanceResponseGetStatusAttributeType(stateSuccess),
+		//		Storage:       nil,
+		//		Version:       nil,
+		//	},
+		// },
+		{
+			desc:             "create_failed",
+			instanceID:       *instanceID,
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "create_failed_2",
+			instanceID:       *instanceID,
+			instanceGetFails: false,
+			instanceState:    InstanceStateEmpty,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "instance_get_fails",
+			instanceID:       *instanceID,
+			instanceGetFails: true,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "timeout",
+			instanceID:       *instanceID,
+			instanceGetFails: false,
+			instanceState:    InstanceStateProcessing,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.desc, func(t *testing.T) {
+				mockCall := func(_ v3alpha1api.ApiGetInstanceRequestRequest) (*v3alpha1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					return &v3alpha1api.GetInstanceResponse{
+						Id:      tt.instanceID,
+						Status:  v3alpha1api.Status(tt.instanceState),
+						Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClient := v3alpha1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &mockCall,
+				}
+
+				handler := CreateInstanceWaitHandler(context.Background(), apiClient, "", tt.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 !reflect.DeepEqual(gotRes, tt.wantRes) {
+					t.Fatalf("handler gotRes = %v, want %v", gotRes, tt.wantRes)
+				}
+			},
+		)
+	}
+}
+
+func TestUpdateInstanceWaitHandler(t *testing.T) {
+	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"
+
+				mockCall := func(_ v3alpha1api.ApiGetInstanceRequestRequest) (*v3alpha1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					return &v3alpha1api.GetInstanceResponse{
+						Id:     instanceID,
+						Status: v3alpha1api.Status(tt.instanceState),
+						//Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClient := v3alpha1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &mockCall,
+				}
+
+				var wantRes *v3alpha1api.GetInstanceResponse
+				if tt.wantResp {
+					wantRes = &v3alpha1api.GetInstanceResponse{
+						Id:     instanceID,
+						Status: v3alpha1api.Status(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"
+
+				mockCall := func(_ v3alpha1api.ApiGetInstanceRequestRequest) (*v3alpha1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					if tt.instanceState == InstanceStateSuccess {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 404,
+						}
+					}
+
+					return &v3alpha1api.GetInstanceResponse{
+						Id:     instanceID,
+						Status: v3alpha1api.Status(tt.instanceState),
+						//Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClient := v3alpha1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &mockCall,
+				}
+
+				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)
+				}
+			},
+		)
+	}
+}

stackit/internal/wait/sqlserverflexbeta/wait.go

@@ -0,0 +1,405 @@
+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 "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3beta1api"
+)
+
+// 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 {
+	GetInstanceRequest(
+		ctx context.Context,
+		projectId, region, instanceId string,
+	) sqlserverflex.ApiGetInstanceRequestRequest
+	GetDatabaseRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		databaseName string,
+	) sqlserverflex.ApiGetDatabaseRequestRequest
+	GetUserRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		userId int64,
+	) sqlserverflex.ApiGetUserRequestRequest
+
+	ListRolesRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) sqlserverflex.ApiListRolesRequestRequest
+
+	ListUsersRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) sqlserverflex.ApiListUsersRequestRequest
+}
+
+// APIClientUserInterface Interface needed for tests
+type APIClientUserInterface interface {
+	DeleteUserRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		userId int64,
+	) 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.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError: %w", err)
+				}
+				switch oapiErr.StatusCode {
+				case http.StatusNotFound:
+					return false, nil, nil
+				default:
+					return false, nil, fmt.Errorf("api error: %w", err)
+				}
+			}
+			if s == nil || s.Id != instanceId {
+				return false, nil, nil
+			}
+			switch strings.ToLower(string(s.Status)) {
+			case strings.ToLower(InstanceStateSuccess):
+				if s.Network.AccessScope != nil && *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
+					}
+				}
+
+				tflog.Info(ctx, "trying to get roles")
+				time.Sleep(10 * time.Second)
+				_, rolesErr := a.ListRolesRequest(ctx, projectId, region, instanceId).Execute()
+				if rolesErr != nil {
+					var oapiErr *oapierror.GenericOpenAPIError
+					ok := errors.As(rolesErr, &oapiErr)
+					if !ok {
+						return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+					}
+					if oapiErr.StatusCode != http.StatusInternalServerError {
+						tflog.Info(
+							ctx, "got error from api", map[string]interface{}{
+								"error": rolesErr.Error(),
+							},
+						)
+						return false, nil, rolesErr
+					}
+					tflog.Info(
+						ctx, "wait for get-roles to work hack", map[string]interface{}{},
+					)
+					time.Sleep(10 * time.Second)
+					return false, nil, nil
+				}
+
+				tflog.Info(ctx, "trying to get users")
+				time.Sleep(10 * time.Second)
+				_, usersErr := a.ListUsersRequest(ctx, projectId, region, instanceId).Execute()
+				if usersErr != nil {
+					var oapiErr *oapierror.GenericOpenAPIError
+					ok := errors.As(usersErr, &oapiErr)
+					if !ok {
+						return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+					}
+					if oapiErr.StatusCode != http.StatusInternalServerError {
+						tflog.Info(
+							ctx, "got error from api", map[string]interface{}{
+								"error": rolesErr.Error(),
+							},
+						)
+						return false, nil, usersErr
+					}
+					tflog.Info(
+						ctx, "wait for get-users to work hack", map[string]interface{}{},
+					)
+					time.Sleep(10 * time.Second)
+					return false, nil, nil
+				}
+				return true, s, nil
+			case strings.ToLower(InstanceStateUnknown):
+				return true, nil, fmt.Errorf(
+					"create failed for instance %s with status %s",
+					instanceId,
+					InstanceStateUnknown,
+				)
+			case strings.ToLower(InstanceStateFailed):
+				return true, nil, fmt.Errorf(
+					"create failed for instance %s with status %s",
+					instanceId,
+					InstanceStateFailed,
+				)
+			case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
+				tflog.Info(
+					ctx, "request is being handled", map[string]interface{}{
+						"status": s.Status,
+					},
+				)
+				time.Sleep(10 * time.Second)
+				return false, nil, nil
+			default:
+				tflog.Info(
+					ctx, "Wait (create) received unknown status", map[string]interface{}{
+						"instanceId": instanceId,
+						"status":     s.Status,
+					},
+				)
+				return true, nil, errors.New("unknown status received")
+			}
+		},
+	)
+	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.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+			if err != nil {
+				return false, nil, err
+			}
+			if s == nil || s.Id != instanceId {
+				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, s, nil
+			default:
+				tflog.Info(
+					ctx, "Wait (update) received unknown status", map[string]interface{}{
+						"instanceId": instanceId,
+						"status":     s.Status,
+					},
+				)
+				return false, s, nil
+			}
+		},
+	)
+	return handler
+}
+
+// DeleteInstanceWaitHandler will wait for instance deletion
+func DeleteInstanceWaitHandler(
+	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.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+			if err == nil {
+				return false, s, 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(30 * 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.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf(
+						"get database - could not convert error to oapierror.GenericOpenAPIError: %s",
+						err.Error(),
+					)
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				return false, nil, nil
+			}
+			if s == nil || s.Name != databaseName {
+				return false, nil, errors.New("response did return different result")
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// CreateUserWaitHandler will wait for instance creation
+func CreateUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+	userId int64,
+) *wait.AsyncActionHandler[sqlserverflex.GetUserResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.GetUserResponse, err error) {
+			s, err := a.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+			if err != 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 false, nil, nil
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// WaitForUserWaitHandler will wait for instance creation
+func WaitForUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region, userName string,
+) *wait.AsyncActionHandler[sqlserverflex.ListUserResponse] {
+	startTime := time.Now()
+	timeOut := 2 * time.Minute
+
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.ListUserResponse, err error) {
+			if time.Since(startTime) > timeOut {
+				return false, nil, errors.New("ran into timeout")
+			}
+			s, err := a.ListUsersRequest(ctx, projectId, region, instanceId).Size(100).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf(
+						"wait (list users) could not convert error to oapierror.GenericOpenAPIError: %s",
+						err.Error(),
+					)
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				tflog.Info(
+					ctx, "Wait (list users) still waiting", map[string]interface{}{},
+				)
+
+				return false, nil, nil
+			}
+			users, ok := s.GetUsersOk()
+			if !ok {
+				return false, nil, errors.New("no users found")
+			}
+
+			for _, u := range users {
+				if u.GetUsername() == userName {
+					return true, s, nil
+				}
+			}
+			tflog.Info(
+				ctx, "Wait (list users) user still not present", map[string]interface{}{},
+			)
+			return false, nil, nil
+		},
+	)
+	return handler
+}
+
+// DeleteUserWaitHandler will wait for instance deletion
+func DeleteUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, region, instanceId string,
+	userId int64,
+) *wait.AsyncActionHandler[struct{}] {
+	handler := wait.New(
+		func() (waitFinished bool, response *struct{}, err error) {
+			_, err = a.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+			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")
+			}
+
+			switch oapiErr.StatusCode {
+			case http.StatusNotFound:
+				return true, nil, nil
+			default:
+				return false, nil, err
+			}
+		},
+	)
+	handler.SetTimeout(15 * time.Minute)
+	handler.SetSleepBeforeWait(15 * time.Second)
+	return handler
+}

stackit/internal/wait/sqlserverflexbeta/wait_test.go

@@ -0,0 +1,305 @@
+package sqlserverflexbeta
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3beta1api"
+)
+
+func TestCreateInstanceWaitHandler(t *testing.T) {
+	instanceID := utils.Ptr("foo")
+	tests := []struct {
+		desc                string
+		instanceID          string
+		instanceGetFails    bool
+		instanceState       string
+		instanceNetwork     v3beta1api.InstanceNetwork
+		usersGetErrorStatus int
+		wantErr             bool
+		wantRes             *v3beta1api.GetInstanceResponse
+	}{
+		{
+			desc:             "create_succeeded_default_values",
+			instanceID:       "instance1",
+			instanceGetFails: false,
+			instanceState:    InstanceStateSuccess,
+			instanceNetwork: v3beta1api.InstanceNetwork{
+				AccessScope:     (*v3beta1api.InstanceNetworkAccessScope)(utils.Ptr("PUBLIC")),
+				Acl:             nil,
+				InstanceAddress: utils.Ptr("10.0.0.1"),
+				RouterAddress:   utils.Ptr("10.0.0.2"),
+			},
+			wantErr: false,
+			wantRes: &v3beta1api.GetInstanceResponse{
+				BackupSchedule: "",
+				Edition:        "",
+				Encryption:     nil,
+				FlavorId:       "",
+				Id:             "instance1",
+				IsDeletable:    false,
+				Name:           "",
+				Network: v3beta1api.InstanceNetwork{
+					AccessScope:     (*v3beta1api.InstanceNetworkAccessScope)(utils.Ptr("PUBLIC")),
+					Acl:             nil,
+					InstanceAddress: utils.Ptr("10.0.0.1"),
+					RouterAddress:   utils.Ptr("10.0.0.2"),
+				},
+				Replicas:      0,
+				RetentionDays: 0,
+				Status:        v3beta1api.Status(InstanceStateSuccess),
+				Storage:       v3beta1api.Storage{},
+				Version:       "",
+			},
+		},
+		{
+			desc:             "create_failed",
+			instanceID:       *instanceID,
+			instanceGetFails: false,
+			instanceState:    InstanceStateFailed,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "create_failed_2",
+			instanceID:       *instanceID,
+			instanceGetFails: false,
+			instanceState:    InstanceStateEmpty,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "instance_get_fails",
+			instanceID:       *instanceID,
+			instanceGetFails: true,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+		{
+			desc:             "timeout",
+			instanceID:       *instanceID,
+			instanceGetFails: false,
+			instanceState:    InstanceStateProcessing,
+			wantErr:          true,
+			wantRes:          nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.desc, func(t *testing.T) {
+				listRolesMock := func(_ v3beta1api.ApiListRolesRequestRequest) (*v3beta1api.ListRolesResponse, error) {
+					return &v3beta1api.ListRolesResponse{
+						Roles: []string{},
+					}, nil
+				}
+
+				listUsersMock := func(_ v3beta1api.ApiListUsersRequestRequest) (*v3beta1api.ListUserResponse, error) {
+					aux := int64(0)
+					return &v3beta1api.ListUserResponse{
+						Pagination: v3beta1api.Pagination{
+							TotalRows: aux,
+						},
+						Users: []v3beta1api.ListUser{},
+					}, nil
+				}
+
+				mockCall := func(_ v3beta1api.ApiGetInstanceRequestRequest) (*v3beta1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					return &v3beta1api.GetInstanceResponse{
+						Id:      tt.instanceID,
+						Status:  v3beta1api.Status(tt.instanceState),
+						Network: tt.instanceNetwork,
+						Storage: v3beta1api.Storage{},
+					}, nil
+				}
+
+				apiClient := v3beta1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &mockCall,
+					ListUsersRequestExecuteMock:   &listUsersMock,
+					ListRolesRequestExecuteMock:   &listRolesMock,
+				}
+
+				handler := CreateInstanceWaitHandler(context.Background(), apiClient, "", tt.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 err == nil {
+					if diff := cmp.Diff(tt.wantRes, gotRes); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+				if !reflect.DeepEqual(gotRes, tt.wantRes) {
+					t.Fatalf("handler gotRes = %v, want %v", gotRes, tt.wantRes)
+				}
+			},
+		)
+	}
+}
+
+func TestUpdateInstanceWaitHandler(t *testing.T) {
+	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"
+
+				mockCall := func(_ v3beta1api.ApiGetInstanceRequestRequest) (*v3beta1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					return &v3beta1api.GetInstanceResponse{
+						Id:     instanceID,
+						Status: v3beta1api.Status(tt.instanceState),
+						//Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClient := v3beta1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &mockCall,
+				}
+
+				var wantRes *v3beta1api.GetInstanceResponse
+				if tt.wantResp {
+					wantRes = &v3beta1api.GetInstanceResponse{
+						Id:     instanceID,
+						Status: v3beta1api.Status(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"
+
+				mockCall := func(_ v3beta1api.ApiGetInstanceRequestRequest) (*v3beta1api.GetInstanceResponse, error) {
+					if tt.instanceGetFails {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 500,
+						}
+					}
+
+					if tt.instanceState == InstanceStateSuccess {
+						return nil, &oapierror.GenericOpenAPIError{
+							StatusCode: 404,
+						}
+					}
+
+					return &v3beta1api.GetInstanceResponse{
+						Id:     instanceID,
+						Status: v3beta1api.Status(tt.instanceState),
+						//Network: tt.instanceNetwork,
+					}, nil
+				}
+
+				apiClient := v3beta1api.DefaultAPIServiceMock{
+					GetInstanceRequestExecuteMock: &mockCall,
+				}
+
+				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)
+				}
+			},
+		)
+	}
+}