terraform-provider-stackitprivatepreview/stackit/internal/wait/sqlserverflexalpha/wait_test.go

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
type apiClientInstanceMocked struct {
	instanceID        string
	instanceState     string
	instanceNetwork   v3alpha1api.InstanceNetwork
	instanceIsDeleted bool
	instanceGetFails  bool
}

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)
				}
			},
		)
	}
}