wait_test.go

package wait

import (
	"context"
	"errors"
	"net/http"
	"testing"
	"testing/synctest"

	"github.com/google/go-cmp/cmp"
	"github.com/google/uuid"

	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
	"github.com/stackitcloud/stackit-sdk-go/core/utils"
	alb "github.com/stackitcloud/stackit-sdk-go/services/alb/v2api"
)

const (
	testRegion = "eu01"
	testName   = "testlb"
)

var (
	testProject = uuid.NewString()
)

type response struct {
	loadbalancer *alb.LoadBalancer
	err          error
}

type mockSettings struct {
	n         int
	responses []response
}

func newAPIMock(settings *mockSettings) alb.DefaultAPI {
	return &alb.DefaultAPIServiceMock{
		GetLoadBalancerExecuteMock: utils.Ptr(func(_ alb.ApiGetLoadBalancerRequest) (*alb.LoadBalancer, error) {
			resp := settings.responses[settings.n]
			settings.n++
			settings.n %= len(settings.responses)
			return resp.loadbalancer, resp.err
		}),
	}
}

func TestCreateOrUpdateLoadbalancerWaitHandler(t *testing.T) {
	tests := []struct {
		name      string
		responses []response
		want      *alb.LoadBalancer
		wantErr   bool
	}{
		{
			"create succeeded immediately",
			[]response{
				{
					loadbalancer: &alb.LoadBalancer{
						Status: utils.Ptr(LOADBALANCERSTATUS_READY),
					},
					err: nil,
				},
			},
			&alb.LoadBalancer{
				Status: utils.Ptr(LOADBALANCERSTATUS_READY),
			},
			false,
		},
		{
			"create succeeded delayed",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_READY)}, nil},
			},
			&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_READY)},
			false,
		},
		{
			"create failed delayed",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_ERROR)}, nil},
			},
			&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_ERROR)},
			true,
		},
		{
			"timeout",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
			},
			nil,
			true,
		},
		{
			"broken state",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr("bogus")}, nil},
			},
			&alb.LoadBalancer{Status: utils.Ptr("bogus")},
			false,
		},
		// no special update tests needed as the states are the same
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			synctest.Test(t, func(t *testing.T) {
				ctx := context.Background()
				client := newAPIMock(&mockSettings{
					responses: tt.responses,
				})

				handler := CreateOrUpdateLoadbalancerWaitHandler(ctx, client, testProject, testRegion, testName)
				got, err := handler.WaitWithContext(ctx)

				if (err != nil) != tt.wantErr {
					t.Fatalf("unexpected error response. want %v but got %qe ", tt.wantErr, err)
				}

				if diff := cmp.Diff(tt.want, got); diff != "" {
					t.Errorf("differing loadbalancer %s", diff)
				}
			})
		})
	}
}

func TestDeleteLoadbalancerWaitHandler(t *testing.T) {
	tests := []struct {
		name      string
		responses []response
		wantErr   bool
	}{
		{
			"Delete with '404' succeeded immediately",
			[]response{
				{nil, oapierror.NewError(http.StatusNotFound, "not found")},
			},
			false,
		},
		{
			"Delete with '404' delayed",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{nil, oapierror.NewError(http.StatusNotFound, "not found")},
			},
			false,
		},
		{
			"Delete with 'gone' succeeded immediately",
			[]response{
				{nil, oapierror.NewError(http.StatusGone, "gone")},
			},
			false,
		},
		{
			"Delete with 'gone' delayed",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{nil, oapierror.NewError(http.StatusGone, "not found")},
			},
			false,
		},
		{
			"Delete with error delayed",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_ERROR)}, oapierror.NewError(http.StatusInternalServerError, "kapow")},
			},
			true,
		},
		{
			"Cannot delete",
			[]response{
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_PENDING)}, nil},
				{&alb.LoadBalancer{Status: utils.Ptr(LOADBALANCERSTATUS_ERROR)}, oapierror.NewError(http.StatusOK, "ok")},
			},
			true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			synctest.Test(t, func(t *testing.T) {
				ctx := context.Background()
				client := newAPIMock(&mockSettings{
					responses: tt.responses,
				})

				handler := DeleteLoadbalancerWaitHandler(ctx, client, testProject, testRegion, testName)
				_, err := handler.WaitWithContext(ctx)

				if tt.wantErr != (err != nil) {
					t.Fatalf("wrong error result. want err: %v got %v", tt.wantErr, err)
				}
				if tt.wantErr {
					var apiErr *oapierror.GenericOpenAPIError
					if !errors.As(err, &apiErr) {
						t.Fatalf("expected openapi error, got %v", err)
					}
				}
			})
		})
	}
}