chore: work save

stackit/internal/wait/postgresflexalpha/wait.go

@@ -4,13 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 	"net/http"
 	"time"
 
 	"github.com/hashicorp/terraform-plugin-log/tflog"
-
-	postgresflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/postgresflexalpha"
+	"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"
@@ -30,64 +28,55 @@ const (
 
 // APIClientInstanceInterface Interface needed for tests
 type APIClientInstanceInterface interface {
-	GetInstanceRequestExecute(ctx context.Context, projectId, region, instanceId string) (
-		*postgresflex.GetInstanceResponse,
-		error,
-	)
+	GetInstanceRequest(ctx context.Context, projectId, region, instanceId string) v3alpha1api.ApiGetInstanceRequestRequest
 
-	ListUsersRequestExecute(
+	ListUsersRequest(
 		ctx context.Context,
 		projectId string,
 		region string,
 		instanceId string,
-	) (*postgresflex.ListUserResponse, error)
+	) v3alpha1api.ApiListUsersRequestRequest
 }
 
 // APIClientUserInterface Interface needed for tests
 type APIClientUserInterface interface {
-	GetUserRequestExecute(ctx context.Context, projectId, region, instanceId string, userId int32) (
-		*postgresflex.GetUserResponse,
-		error,
-	)
+	GetUserRequest(ctx context.Context, projectId, region, instanceId string, userId int32) v3alpha1api.ApiGetUserRequestRequest
+}
 
-	GetDatabaseRequestExecute(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-		databaseId int32,
-	) (*postgresflex.GetDatabaseResponse, error)
+// 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[postgresflex.GetInstanceResponse] {
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
 	instanceCreated := false
-	var instanceGetResponse *postgresflex.GetInstanceResponse
+	var instanceGetResponse *v3alpha1api.GetInstanceResponse
 	maxWait := time.Minute * 45
 	startTime := time.Now()
 	extendedTimeout := 0
 
 	handler := wait.New(
-		func() (waitFinished bool, response *postgresflex.GetInstanceResponse, err error) {
+		func() (waitFinished bool, response *v3alpha1api.GetInstanceResponse, err error) {
 			if !instanceCreated {
-				s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+				s, err := a.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
 				if err != nil {
 					return false, nil, err
 				}
-				if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
+				if s == nil || s.Id != instanceId {
 					return false, nil, nil
 				}
 				tflog.Debug(
 					ctx, "waiting for instance ready", map[string]interface{}{
-						"status": *s.Status,
+						"status": s.Status,
 					},
 				)
-				switch *s.Status {
+				switch s.Status {
 				default:
-					return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceId, *s.Status)
+					return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceId, s.Status)
 				case InstanceStateEmpty:
 					return false, nil, nil
 				case InstanceStatePending:
@@ -112,7 +101,7 @@ func CreateInstanceWaitHandler(
 						extendedTimeout++
 						if *s.Network.AccessScope == "SNA" {
 							ready := true
-							if s.Network == nil || s.Network.InstanceAddress == nil {
+							if s.Network.InstanceAddress == nil {
 								tflog.Warn(ctx, "Waiting for instance_address")
 								ready = false
 							}
@@ -124,16 +113,12 @@ func CreateInstanceWaitHandler(
 								return false, nil, nil
 							}
 						}
-						if s.IsDeletable == nil {
-							tflog.Warn(ctx, "Waiting for is_deletable")
-							return false, nil, nil
-						}
 					}
 
 					instanceCreated = true
 					instanceGetResponse = s
 				case InstanceStateSuccess:
-					if s.Network != nil && s.Network.AccessScope != nil && *s.Network.AccessScope == "SNA" {
+					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
@@ -156,7 +141,7 @@ func CreateInstanceWaitHandler(
 			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.ListUsersRequestExecute(ctx, projectId, region, instanceId)
+			_, err = a.ListUsersRequest(ctx, projectId, region, instanceId).Execute()
 			if err == nil {
 				return true, instanceGetResponse, nil
 			}
@@ -175,7 +160,7 @@ func CreateInstanceWaitHandler(
 		},
 	)
 	// Sleep before wait is set because sometimes API returns 404 right after creation request
-	handler.SetTimeout(90 * time.Minute).SetSleepBeforeWait(30 * time.Second)
+	// handler.SetTimeout(90 * time.Minute).SetSleepBeforeWait(30 * time.Second)
 	return handler
 }
 
@@ -183,19 +168,19 @@ func CreateInstanceWaitHandler(
 func PartialUpdateInstanceWaitHandler(
 	ctx context.Context, a APIClientInstanceInterface, projectId, region,
 	instanceId string,
-) *wait.AsyncActionHandler[postgresflex.GetInstanceResponse] {
+) *wait.AsyncActionHandler[v3alpha1api.GetInstanceResponse] {
 	handler := wait.New(
-		func() (waitFinished bool, response *postgresflex.GetInstanceResponse, err error) {
-			s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+		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 == nil || *s.Id != instanceId || s.Status == nil {
+			if s == nil || s.Id != instanceId {
 				return false, nil, nil
 			}
-			switch *s.Status {
+			switch s.Status {
 			default:
-				return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceId, *s.Status)
+				return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceId, s.Status)
 			case InstanceStateEmpty:
 				return false, nil, nil
 			case InstanceStatePending:
@@ -213,7 +198,7 @@ func PartialUpdateInstanceWaitHandler(
 			}
 		},
 	)
-	handler.SetTimeout(45 * time.Minute).SetSleepBeforeWait(30 * time.Second)
+	// handler.SetTimeout(45 * time.Minute).SetSleepBeforeWait(30 * time.Second)
 	return handler
 }
 
@@ -222,15 +207,12 @@ func GetUserByIdWaitHandler(
 	ctx context.Context,
 	a APIClientUserInterface,
 	projectId, instanceId, region string,
-	userId int64,
-) *wait.AsyncActionHandler[postgresflex.GetUserResponse] {
+	userId int32,
+) *wait.AsyncActionHandler[v3alpha1api.GetUserResponse] {
 	handler := wait.New(
-		func() (waitFinished bool, response *postgresflex.GetUserResponse, err error) {
-			if userId > math.MaxInt32 {
-				return false, nil, fmt.Errorf("userId value is too big for int32")
-			}
-			userId32 := int32(userId) //nolint:gosec // we need to convert databaseId to int32 because API expects int32
-			s, err := a.GetUserRequestExecute(ctx, projectId, region, instanceId, userId32)
+		func() (waitFinished bool, response *v3alpha1api.GetUserResponse, err error) {
+			userId32 := userId
+			s, err := a.GetUserRequest(ctx, projectId, region, instanceId, userId32).Execute()
 			if err != nil {
 				var oapiErr *oapierror.GenericOpenAPIError
 				ok := errors.As(err, &oapiErr)
@@ -259,14 +241,14 @@ func GetUserByIdWaitHandler(
 // GetDatabaseByIdWaitHandler will wait for instance creation
 func GetDatabaseByIdWaitHandler(
 	ctx context.Context,
-	a APIClientUserInterface,
+	a APIClientDatabaseInterface,
 	projectId, instanceId, region string,
-	databaseId int64,
-) *wait.AsyncActionHandler[postgresflex.GetDatabaseResponse] {
+	databaseId int32,
+) *wait.AsyncActionHandler[v3alpha1api.GetDatabaseResponse] {
 	handler := wait.New(
-		func() (waitFinished bool, response *postgresflex.GetDatabaseResponse, err error) {
-			dbId32 := int32(databaseId) //nolint:gosec // we need to convert databaseId to int32 because API expects int32
-			s, err := a.GetDatabaseRequestExecute(ctx, projectId, region, instanceId, dbId32)
+		func() (waitFinished bool, response *v3alpha1api.GetDatabaseResponse, err error) {
+			dbId32 := databaseId
+			s, err := a.GetDatabaseRequest(ctx, projectId, region, instanceId, dbId32).Execute()
 			if err != nil {
 				var oapiErr *oapierror.GenericOpenAPIError
 				ok := errors.As(err, &oapiErr)
@@ -307,8 +289,8 @@ func DeleteInstanceWaitHandler(
 	timeout, sleepBeforeWait time.Duration,
 ) error {
 	handler := wait.New(
-		func() (waitFinished bool, response *postgresflex.GetInstanceResponse, err error) {
-			s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+		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 {
@@ -319,7 +301,7 @@ func DeleteInstanceWaitHandler(
 				}
 				return false, nil, fmt.Errorf("api returned error: %w", err)
 			}
-			switch *s.Status {
+			switch s.Status {
 			case InstanceStateDeleted:
 				return true, nil, nil
 			case InstanceStateEmpty, InstanceStatePending, InstanceStateUnknown, InstanceStateProgressing, InstanceStateSuccess:
@@ -327,7 +309,7 @@ func DeleteInstanceWaitHandler(
 			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)
+				return true, s, fmt.Errorf("instance with id %s has unexpected status %s", instanceId, s.Status)
 			}
 		},
 	).SetTimeout(timeout).SetSleepBeforeWait(sleepBeforeWait)

stackit/internal/wait/postgresflexalpha/wait_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
 	"github.com/stackitcloud/stackit-sdk-go/core/utils"
 
-	postgresflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/postgresflexalpha"
+	postgresflex "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
 )
 
 // Used for testing instance operations
@@ -24,6 +24,12 @@ type apiClientInstanceMocked struct {
 	usersGetErrorStatus    int
 }
 
+func (a *apiClientInstanceMocked) GetInstanceRequest(
+	_ context.Context,
+	_, _, _ string,
+) *postgresflex.ApiGetInstanceRequestRequest {
+}
+
 func (a *apiClientInstanceMocked) GetInstanceRequestExecute(
 	_ context.Context,
 	_, _, _ string,
@@ -41,9 +47,9 @@ func (a *apiClientInstanceMocked) GetInstanceRequestExecute(
 	}
 
 	return &postgresflex.GetInstanceResponse{
-		Id:      &a.instanceId,
-		Status:  postgresflex.GetInstanceResponseGetStatusAttributeType(&a.instanceState),
-		Network: postgresflex.GetInstanceResponseGetNetworkAttributeType(&a.instanceNetwork),
+		Id:      a.instanceId,
+		Status:  postgresflex.Status(a.instanceState),
+		Network: a.instanceNetwork,
 	}, nil
 }
 
@@ -57,12 +63,12 @@ func (a *apiClientInstanceMocked) ListUsersRequestExecute(
 		}
 	}
 
-	aux := int64(0)
+	aux := int32(0)
 	return &postgresflex.ListUserResponse{
-		Pagination: &postgresflex.Pagination{
-			TotalRows: &aux,
+		Pagination: postgresflex.Pagination{
+			TotalRows: aux,
 		},
-		Users: &[]postgresflex.ListUser{},
+		Users: []postgresflex.ListUser{},
 	}, nil
 }
 
@@ -88,9 +94,9 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 			},
 			wantErr: false,
 			wantRes: &postgresflex.GetInstanceResponse{
-				Id:     utils.Ptr("foo-bar"),
-				Status: postgresflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr(InstanceStateSuccess)),
-				Network: &postgresflex.InstanceNetwork{
+				Id:     "foo-bar",
+				Status: InstanceStateSuccess,
+				Network: postgresflex.InstanceNetwork{
 					AccessScope:     nil,
 					Acl:             nil,
 					InstanceAddress: utils.Ptr("10.0.0.1"),
@@ -157,9 +163,9 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 			usersGetErrorStatus: 400,
 			wantErr:             true,
 			wantRes: &postgresflex.GetInstanceResponse{
-				Id:     utils.Ptr("foo-bar"),
-				Status: postgresflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr(InstanceStateSuccess)),
-				Network: &postgresflex.InstanceNetwork{
+				Id:     "foo-bar",
+				Status: InstanceStateSuccess,
+				Network: postgresflex.InstanceNetwork{
 					AccessScope:     nil,
 					Acl:             nil,
 					InstanceAddress: utils.Ptr("10.0.0.1"),
@@ -172,7 +178,7 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 			instanceGetFails: false,
 			instanceState:    InstanceStateSuccess,
 			instanceNetwork: postgresflex.InstanceNetwork{
-				AccessScope:     postgresflex.InstanceNetworkGetAccessScopeAttributeType(utils.Ptr("SNA")),
+				AccessScope:     (*postgresflex.InstanceNetworkAccessScope)(utils.Ptr("SNA")),
 				Acl:             nil,
 				InstanceAddress: nil,
 				RouterAddress:   utils.Ptr("10.0.0.1"),
@@ -185,7 +191,7 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 			instanceGetFails: false,
 			instanceState:    InstanceStateProgressing,
 			instanceNetwork: postgresflex.InstanceNetwork{
-				AccessScope:     postgresflex.InstanceNetworkGetAccessScopeAttributeType(utils.Ptr("SNA")),
+				AccessScope:     (*postgresflex.InstanceNetworkAccessScope)(utils.Ptr("SNA")),
 				Acl:             nil,
 				InstanceAddress: utils.Ptr("10.0.0.1"),
 				RouterAddress:   utils.Ptr("10.0.0.1"),
@@ -199,6 +205,11 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 			tt.desc, func(t *testing.T) {
 				instanceId := "foo-bar"
 
+				apiClientMock := postgresflex.DefaultAPIServiceMock{
+					CreateInstanceRequestExecuteMock: nil,
+					GetInstanceRequestExecuteMock:    nil,
+				}
+
 				apiClient := &apiClientInstanceMocked{
 					instanceId:          instanceId,
 					instanceState:       tt.instanceState,
@@ -207,7 +218,7 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 					usersGetErrorStatus: tt.usersGetErrorStatus,
 				}
 
-				handler := CreateInstanceWaitHandler(context.Background(), apiClient, "", "", instanceId)
+				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 {

stackit/internal/wait/sqlserverflexalpha/wait.go

@@ -1,392 +0,0 @@
-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"
-
-	sqlserverflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexalpha"
-)
-
-// 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)
-
-	ListRolesRequestExecute(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-	) (*sqlserverflex.ListRolesResponse, error)
-
-	ListUsersRequest(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-	) sqlserverflex.ApiListUsersRequestRequest
-
-	ListUsersRequestExecute(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-	) (*sqlserverflex.ListUserResponse, error)
-}
-
-// 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.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 != nil && 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.ListRolesRequestExecute(ctx, projectId, region, instanceId)
-				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.ListUsersRequestExecute(ctx, projectId, region, instanceId)
-				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[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, 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.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-			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.GetDatabaseRequestExecute(ctx, projectId, region, instanceId, databaseName)
-			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 == 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.GetUserRequestExecute(ctx, projectId, region, instanceId, userId)
-			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.GetUserRequestExecute(ctx, projectId, region, instanceId, userId)
-			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

@@ -1,344 +0,0 @@
-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"
-
-	sqlserverflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexalpha"
-)
-
-// Used for testing instance operations
-type apiClientInstanceMocked struct {
-	instanceId        string
-	instanceState     string
-	instanceNetwork   sqlserverflex.InstanceNetwork
-	instanceIsDeleted bool
-	instanceGetFails  bool
-}
-
-type ListUsersRequestRequest struct{}
-
-func (l ListUsersRequestRequest) Page(_ int64) sqlserverflex.ApiListUsersRequestRequest {
-	return l
-}
-
-func (l ListUsersRequestRequest) Size(_ int64) sqlserverflex.ApiListUsersRequestRequest {
-	return l
-}
-
-func (l ListUsersRequestRequest) Sort(_ sqlserverflex.UserSort) sqlserverflex.ApiListUsersRequestRequest {
-	return l
-}
-
-func (l ListUsersRequestRequest) Execute() (*sqlserverflex.ListUserResponse, error) {
-	// TODO implement me
-	panic("implement me")
-}
-
-func (a *apiClientInstanceMocked) ListUsersRequest(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-) sqlserverflex.ApiListUsersRequestRequest {
-	return ListUsersRequestRequest{}
-}
-
-func (a *apiClientInstanceMocked) ListRolesRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-) (*sqlserverflex.ListRolesResponse, error) {
-	return &sqlserverflex.ListRolesResponse{
-		Roles: &[]string{},
-	}, nil
-}
-
-func (a *apiClientInstanceMocked) ListUsersRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-) (*sqlserverflex.ListUserResponse, error) {
-	return &sqlserverflex.ListUserResponse{
-		Pagination: nil,
-		Users:      nil,
-	}, nil
-}
-
-func (a *apiClientInstanceMocked) GetDatabaseRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-	_ string,
-) (*sqlserverflex.GetDatabaseResponse, error) {
-	return nil, nil
-}
-
-func (a *apiClientInstanceMocked) GetUserRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-	_ int64,
-) (*sqlserverflex.GetUserResponse, error) {
-	return nil, nil
-}
-
-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) {
-	instanceId := utils.Ptr("foo")
-	tests := []struct {
-		desc                string
-		instanceId          string
-		instanceGetFails    bool
-		instanceState       string
-		instanceNetwork     sqlserverflex.InstanceNetwork
-		usersGetErrorStatus int
-		wantErr             bool
-		wantRes             *sqlserverflex.GetInstanceResponse
-	}{
-		//{
-		//	desc:             "create_succeeded",
-		//	instanceId:       *instanceId,
-		//	instanceGetFails: false,
-		//	instanceState:    *stateSuccess,
-		//	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:             instanceId,
-		//		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:        sqlserverflex.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) {
-				apiClient := &apiClientInstanceMocked{
-					instanceId:       tt.instanceId,
-					instanceState:    tt.instanceState,
-					instanceGetFails: tt.instanceGetFails,
-				}
-
-				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) {
-	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)
-				}
-			},
-		)
-	}
-}

stackit/internal/wait/sqlserverflexbeta/wait.go

@@ -1,412 +0,0 @@
-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)
-
-	ListRolesRequestExecute(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-	) (*sqlserverflex.ListRolesResponse, error)
-
-	ListUsersRequest(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-	) sqlserverflex.ApiListUsersRequestRequest
-
-	ListUsersRequestExecute(
-		ctx context.Context,
-		projectId string,
-		region string,
-		instanceId string,
-	) (*sqlserverflex.ListUserResponse, error)
-}
-
-// 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.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-			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 == nil || *s.Id != instanceId || s.Status == nil {
-				return false, nil, nil
-			}
-			switch strings.ToLower(string(*s.Status)) {
-			case strings.ToLower(InstanceStateSuccess):
-				if s.Network != nil && 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.ListRolesRequestExecute(ctx, projectId, region, instanceId)
-				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.ListUsersRequestExecute(ctx, projectId, region, instanceId)
-				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.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, 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.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-			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.GetDatabaseRequestExecute(ctx, projectId, region, instanceId, databaseName)
-			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 == 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.GetUserRequestExecute(ctx, projectId, region, instanceId, userId)
-			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.GetUserRequestExecute(ctx, projectId, region, instanceId, userId)
-			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

@@ -1,344 +0,0 @@
-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"
-
-	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
-}
-
-type ListUsersRequestRequest struct{}
-
-func (l ListUsersRequestRequest) Page(_ int64) sqlserverflex.ApiListUsersRequestRequest {
-	return l
-}
-
-func (l ListUsersRequestRequest) Size(_ int64) sqlserverflex.ApiListUsersRequestRequest {
-	return l
-}
-
-func (l ListUsersRequestRequest) Sort(_ sqlserverflex.UserSort) sqlserverflex.ApiListUsersRequestRequest {
-	return l
-}
-
-func (l ListUsersRequestRequest) Execute() (*sqlserverflex.ListUserResponse, error) {
-	// TODO implement me
-	panic("implement me")
-}
-
-func (a *apiClientInstanceMocked) ListUsersRequest(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-) sqlserverflex.ApiListUsersRequestRequest {
-	return ListUsersRequestRequest{}
-}
-
-func (a *apiClientInstanceMocked) ListRolesRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-) (*sqlserverflex.ListRolesResponse, error) {
-	return &sqlserverflex.ListRolesResponse{
-		Roles: &[]string{},
-	}, nil
-}
-
-func (a *apiClientInstanceMocked) ListUsersRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-) (*sqlserverflex.ListUserResponse, error) {
-	return &sqlserverflex.ListUserResponse{
-		Pagination: nil,
-		Users:      nil,
-	}, nil
-}
-
-func (a *apiClientInstanceMocked) GetDatabaseRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-	_ string,
-) (*sqlserverflex.GetDatabaseResponse, error) {
-	return nil, nil
-}
-
-func (a *apiClientInstanceMocked) GetUserRequestExecute(
-	_ context.Context,
-	_ string,
-	_ string,
-	_ string,
-	_ int64,
-) (*sqlserverflex.GetUserResponse, error) {
-	return nil, nil
-}
-
-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) {
-	instanceId := utils.Ptr("foo")
-	tests := []struct {
-		desc                string
-		instanceId          string
-		instanceGetFails    bool
-		instanceState       string
-		instanceNetwork     sqlserverflex.InstanceNetwork
-		usersGetErrorStatus int
-		wantErr             bool
-		wantRes             *sqlserverflex.GetInstanceResponse
-	}{
-		//{
-		//	desc:             "create_succeeded",
-		//	instanceId:       *instanceId,
-		//	instanceGetFails: false,
-		//	instanceState:    *stateSuccess,
-		//	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:             instanceId,
-		//		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:        sqlserverflex.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) {
-				apiClient := &apiClientInstanceMocked{
-					instanceId:       tt.instanceId,
-					instanceState:    tt.instanceState,
-					instanceGetFails: tt.instanceGetFails,
-				}
-
-				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) {
-	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)
-				}
-			},
-		)
-	}
-}