fix: fix sqlserverflexalpha (#61)

## Description

<!-- **Please link some issue here describing what you are trying to achieve.**

In case there is no issue present for your PR, please consider creating one.
At least please give us some description what you are trying to achieve and why your change is needed. -->

relates to #1234

## Checklist

- [ ] Issue was linked above
- [ ] Code format was applied: `make fmt`
- [ ] Examples were added / adjusted (see `examples/` directory)
- [x] Docs are up-to-date: `make generate-docs` (will be checked by CI)
- [ ] Unit tests got implemented or updated
- [ ] Acceptance tests got implemented or updated (see e.g. [here](f5f99d1709/stackit/internal/services/dns/dns_acc_test.go))
- [x] Unit tests are passing: `make test` (will be checked by CI)
- [x] No linter issues: `make lint` (will be checked by CI)

Reviewed-on: #61
Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
Co-committed-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>

stackit/internal/wait/sqlserverflexalpha/wait.go

@@ -1,5 +1,3 @@
-// Copyright (c) STACKIT
-
 package sqlserverflexalpha
 
 import (
@@ -28,145 +26,355 @@ const (
 	InstanceStateTerminating = "TERMINATING"
 )
 
-// APIClientInstanceInterface Interface needed for tests
-type APIClientInstanceInterface interface {
-	GetInstanceRequestExecute(ctx context.Context, projectId, region, instanceId string) (*sqlserverflex.GetInstanceResponse, error)
+// 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
+	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 APIClientInstanceInterface, 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 {
-			// TODO: catch 502, 503 and 504
-			return false, nil, err
-		}
-		if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
-			return false, nil, nil
-		}
-		switch strings.ToLower(string(*s.Status)) {
-		case strings.ToLower(InstanceStateSuccess):
-			if *s.Network.AccessScope == "SNA" {
-				if s.Network.InstanceAddress == nil {
-					tflog.Info(ctx, "Waiting for instance_address")
-					return false, nil, nil
-				}
-				if s.Network.RouterAddress == nil {
-					tflog.Info(ctx, "Waiting for router_address")
-					return false, nil, nil
-				}
+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
 			}
-			return true, s, nil
-		case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
-			return true, s, fmt.Errorf("create failed for instance with id %s", instanceId)
-		case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
-			tflog.Info(ctx, "request is being handled", map[string]interface{}{
-				"status": *s.Status,
-			})
-			return false, nil, nil
-		default:
-			tflog.Info(ctx, "Wait (create) received unknown status", map[string]interface{}{
-				"instanceId": instanceId,
-				"status":     s.Status,
-			})
-			return false, s, nil
-		}
-	})
+			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 APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
-	handler := wait.New(func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
-		s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-		if err != nil {
-			return false, nil, err
-		}
-		if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
-			return false, nil, nil
-		}
-		switch strings.ToLower(string(*s.Status)) {
-		case strings.ToLower(InstanceStateSuccess):
-			return true, s, nil
-		case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
-			return true, s, fmt.Errorf("update failed for instance with id %s", instanceId)
-		case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
-			tflog.Info(ctx, "request is being handled", map[string]interface{}{
-				"status": *s.Status,
-			})
-			return false, nil, nil
-		default:
-			tflog.Info(ctx, "Wait (update) received unknown status", map[string]interface{}{
-				"instanceId": instanceId,
-				"status":     s.Status,
-			})
-			return false, s, nil
-		}
-	})
-	handler.SetSleepBeforeWait(15 * time.Second)
-	handler.SetTimeout(45 * time.Minute)
+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
 }
 
-// PartialUpdateInstanceWaitHandler will wait for instance update
-func PartialUpdateInstanceWaitHandler(ctx context.Context, a APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
-	return UpdateInstanceWaitHandler(ctx, a, projectId, instanceId, region)
+// 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
 }
 
-// DeleteInstanceWaitHandler will wait for instance deletion
-func DeleteInstanceWaitHandler(ctx context.Context, a APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[struct{}] {
-	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
-		_, err = a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-		if err == nil {
+// 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
-		}
-		var oapiErr *oapierror.GenericOpenAPIError
-		ok := errors.As(err, &oapiErr)
-		if !ok {
-			return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
-		}
-		if oapiErr.StatusCode != http.StatusNotFound {
-			return false, nil, err
-		}
-		return true, nil, nil
-	})
-	handler.SetTimeout(15 * time.Minute)
+		},
+	)
 	return handler
 }
 
 // DeleteUserWaitHandler will wait for instance deletion
 func DeleteUserWaitHandler(
 	ctx context.Context,
-	a APIClientUserInterface,
-	projectId, instanceId, region string,
+	a APIClientInterface,
+	projectId, region, instanceId string,
 	userId int64,
 ) *wait.AsyncActionHandler[struct{}] {
-	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
-		err = a.DeleteUserRequestExecute(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")
-		}
+	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
-		case http.StatusInternalServerError:
-			tflog.Warn(ctx, "Wait handler got error 500")
-			return false, nil, nil
-		default:
-			return false, nil, err
-		}
-	})
+			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,9 +1,8 @@
-// Copyright (c) STACKIT
-
 package sqlserverflexalpha
 
 import (
 	"context"
+	"reflect"
 	"testing"
 	"time"
 
@@ -23,7 +22,81 @@ type apiClientInstanceMocked struct {
 	instanceGetFails  bool
 }
 
-func (a *apiClientInstanceMocked) GetInstanceRequestExecute(_ context.Context, _, _, _ string) (*sqlserverflex.GetInstanceResponse, error) {
+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,
@@ -43,9 +116,11 @@ func (a *apiClientInstanceMocked) GetInstanceRequestExecute(_ context.Context, _
 	}, nil
 }
 func TestCreateInstanceWaitHandler(t *testing.T) {
-	t.Skip("skipping - needs refactoring")
+	//stateSuccess := utils.Ptr(InstanceStateSuccess)
+	instanceId := utils.Ptr("foo")
 	tests := []struct {
 		desc                string
+		instanceId          string
 		instanceGetFails    bool
 		instanceState       string
 		instanceNetwork     sqlserverflex.InstanceNetwork
@@ -53,40 +128,42 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 		wantErr             bool
 		wantRes             *sqlserverflex.GetInstanceResponse
 	}{
-		{
-			desc:             "create_succeeded",
-			instanceGetFails: false,
-			instanceState:    InstanceStateSuccess,
-			instanceNetwork: sqlserverflex.InstanceNetwork{
-				AccessScope:     nil,
-				Acl:             nil,
-				InstanceAddress: utils.Ptr("10.0.0.1"),
-				RouterAddress:   utils.Ptr("10.0.0.2"),
-			},
-			wantErr: false,
-			wantRes: &sqlserverflex.GetInstanceResponse{
-				BackupSchedule: nil,
-				Edition:        nil,
-				Encryption:     nil,
-				FlavorId:       nil,
-				Id:             nil,
-				IsDeletable:    nil,
-				Name:           nil,
-				Network: &sqlserverflex.InstanceNetwork{
-					AccessScope:     nil,
-					Acl:             nil,
-					InstanceAddress: utils.Ptr("10.0.0.1"),
-					RouterAddress:   utils.Ptr("10.0.0.2"),
-				},
-				Replicas:      nil,
-				RetentionDays: nil,
-				Status:        nil,
-				Storage:       nil,
-				Version:       nil,
-			},
-		},
+		//{
+		//	desc:             "create_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,
@@ -94,6 +171,7 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 		},
 		{
 			desc:             "create_failed_2",
+			instanceId:       *instanceId,
 			instanceGetFails: false,
 			instanceState:    InstanceStateEmpty,
 			wantErr:          true,
@@ -101,12 +179,14 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 		},
 		{
 			desc:             "instance_get_fails",
+			instanceId:       *instanceId,
 			instanceGetFails: true,
 			wantErr:          true,
 			wantRes:          nil,
 		},
 		{
 			desc:             "timeout",
+			instanceId:       *instanceId,
 			instanceGetFails: false,
 			instanceState:    InstanceStateProcessing,
 			wantErr:          true,
@@ -114,26 +194,26 @@ func TestCreateInstanceWaitHandler(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		t.Run(tt.desc, func(t *testing.T) {
-			instanceId := "foo-bar"
+		t.Run(
+			tt.desc, func(t *testing.T) {
+				apiClient := &apiClientInstanceMocked{
+					instanceId:       tt.instanceId,
+					instanceState:    tt.instanceState,
+					instanceGetFails: tt.instanceGetFails,
+				}
 
-			apiClient := &apiClientInstanceMocked{
-				instanceId:       instanceId,
-				instanceState:    tt.instanceState,
-				instanceGetFails: tt.instanceGetFails,
-			}
+				handler := CreateInstanceWaitHandler(context.Background(), apiClient, "", tt.instanceId, "")
 
-			handler := CreateInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
+				gotRes, err := handler.SetTimeout(10 * time.Millisecond).SetSleepBeforeWait(1 * time.Millisecond).WaitWithContext(context.Background())
+				if (err != nil) != tt.wantErr {
+					t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+				}
 
-			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)
-			}
-		})
+				if !reflect.DeepEqual(gotRes, tt.wantRes) {
+					t.Fatalf("handler gotRes = %v, want %v", gotRes, tt.wantRes)
+				}
+			},
+		)
 	}
 }
 
@@ -182,34 +262,36 @@ func TestUpdateInstanceWaitHandler(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		t.Run(tt.desc, func(t *testing.T) {
-			instanceId := "foo-bar"
+		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)),
+				apiClient := &apiClientInstanceMocked{
+					instanceId:       instanceId,
+					instanceState:    tt.instanceState,
+					instanceGetFails: tt.instanceGetFails,
 				}
-			}
 
-			handler := UpdateInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
+				var wantRes *sqlserverflex.GetInstanceResponse
+				if tt.wantResp {
+					wantRes = &sqlserverflex.GetInstanceResponse{
+						Id:     &instanceId,
+						Status: sqlserverflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr(tt.instanceState)),
+					}
+				}
 
-			gotRes, err := handler.SetTimeout(10 * time.Millisecond).SetSleepBeforeWait(1 * time.Millisecond).WaitWithContext(context.Background())
+				handler := UpdateInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
 
-			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)
-			}
-		})
+				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)
+				}
+			},
+		)
 	}
 }
 
@@ -239,23 +321,25 @@ func TestDeleteInstanceWaitHandler(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		t.Run(tt.desc, func(t *testing.T) {
-			instanceId := "foo-bar"
+		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,
-			}
+				apiClient := &apiClientInstanceMocked{
+					instanceGetFails:  tt.instanceGetFails,
+					instanceIsDeleted: tt.instanceState == InstanceStateSuccess,
+					instanceId:        instanceId,
+					instanceState:     tt.instanceState,
+				}
 
-			handler := DeleteInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
+				handler := DeleteInstanceWaitHandler(context.Background(), apiClient, "", instanceId, "")
 
-			_, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background())
+				_, 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 (err != nil) != tt.wantErr {
+					t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+				}
+			},
+		)
 	}
 }