implement new waiters

Author: rubenhoenle

services/resourcemanager/v0api/wait/wait.go

@@ -0,0 +1,52 @@
+package wait
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/wait"
+	resourcemanager "github.com/stackitcloud/stackit-sdk-go/services/resourcemanager/v0api"
+)
+
+// CreateProjectWaitHandler will wait for project creation
+func CreateProjectWaitHandler(ctx context.Context, a resourcemanager.DefaultAPI, containerId string) *wait.AsyncActionHandler[resourcemanager.GetProjectResponse] {
+	handler := wait.New(func() (waitFinished bool, response *resourcemanager.GetProjectResponse, err error) {
+		p, _, err := a.GetProject(ctx, containerId).Execute()
+		if err != nil {
+			return false, nil, err
+		}
+		if p.ContainerId == containerId && p.LifecycleState == resourcemanager.LIFECYCLESTATE_ACTIVE {
+			return true, p, nil
+		}
+		if p.ContainerId == containerId && p.LifecycleState == resourcemanager.LIFECYCLESTATE_CREATING {
+			return false, nil, nil
+		}
+		return true, p, fmt.Errorf("creation failed: received project state '%s'", p.LifecycleState)
+	})
+	handler.SetSleepBeforeWait(1 * time.Minute)
+	handler.SetTimeout(45 * time.Minute)
+	return handler
+}
+
+// DeleteProjectWaitHandler will wait for project deletion
+func DeleteProjectWaitHandler(ctx context.Context, a resourcemanager.DefaultAPI, containerId string) *wait.AsyncActionHandler[struct{}] {
+	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
+		_, _, err = a.GetProject(ctx, containerId).Execute()
+		if err == nil {
+			return false, nil, nil
+		}
+		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
+		if !ok {
+			return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+		}
+		if oapiErr.StatusCode == http.StatusNotFound || oapiErr.StatusCode == http.StatusForbidden {
+			return true, nil, nil
+		}
+		return false, nil, err
+	})
+	handler.SetTimeout(15 * time.Minute)
+	return handler
+}

services/resourcemanager/v0api/wait/wait_test.go

@@ -0,0 +1,155 @@
+package wait
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	resourcemanager "github.com/stackitcloud/stackit-sdk-go/services/resourcemanager/v0api"
+)
+
+type mockSettings struct {
+	getFails     bool
+	getNotFound  bool
+	projectState resourcemanager.LifecycleState
+}
+
+func newAPIMock(settings mockSettings) resourcemanager.DefaultAPI {
+	return &resourcemanager.DefaultAPIServiceMock{
+		GetProjectExecuteMock: utils.Ptr(func(r resourcemanager.ApiGetProjectRequest) (*resourcemanager.GetProjectResponse, *http.Response, error) {
+			if settings.getFails {
+				return nil, &http.Response{}, &oapierror.GenericOpenAPIError{
+					StatusCode: http.StatusInternalServerError,
+				}
+			}
+
+			if settings.getNotFound {
+				return nil, &http.Response{}, &oapierror.GenericOpenAPIError{
+					StatusCode: http.StatusNotFound,
+				}
+			}
+
+			return &resourcemanager.GetProjectResponse{
+				LifecycleState: settings.projectState,
+				ContainerId:    "cid",
+			}, &http.Response{}, nil
+		}),
+	}
+}
+
+func TestCreateProjectWaitHandler(t *testing.T) {
+	tests := []struct {
+		desc         string
+		getFails     bool
+		projectState resourcemanager.LifecycleState
+		wantErr      bool
+		wantResp     bool
+	}{
+		{
+			desc:         "create_succeeded",
+			getFails:     false,
+			projectState: resourcemanager.LIFECYCLESTATE_ACTIVE,
+			wantErr:      false,
+			wantResp:     true,
+		},
+		{
+			desc:         "creating",
+			getFails:     false,
+			projectState: resourcemanager.LIFECYCLESTATE_CREATING,
+			wantErr:      true,
+			wantResp:     false,
+		},
+		{
+			desc:         "get_fails",
+			getFails:     true,
+			projectState: resourcemanager.LifecycleState(""),
+			wantErr:      true,
+			wantResp:     false,
+		},
+		{
+			desc:         "unknown_state",
+			getFails:     false,
+			projectState: resourcemanager.LifecycleState("ANOTHER STATE"),
+			wantErr:      true,
+			wantResp:     true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			apiClient := newAPIMock(mockSettings{
+				getFails:     tt.getFails,
+				projectState: tt.projectState,
+			})
+
+			var wantRes *resourcemanager.GetProjectResponse
+			if tt.wantResp {
+				wantRes = &resourcemanager.GetProjectResponse{
+					LifecycleState: tt.projectState,
+					ContainerId:    "cid",
+				}
+			}
+
+			handler := CreateProjectWaitHandler(context.Background(), apiClient, "cid")
+
+			gotRes, err := handler.SetTimeout(10 * time.Millisecond).SetSleepBeforeWait(10 * time.Millisecond).WaitWithContext(context.Background())
+
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !cmp.Equal(gotRes, wantRes) {
+				t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes)
+			}
+		})
+	}
+}
+
+func TestDeleteProjectWaitHandler(t *testing.T) {
+	tests := []struct {
+		desc         string
+		getFails     bool
+		getNotFound  bool
+		projectState resourcemanager.LifecycleState
+		wantErr      bool
+	}{
+		{
+			desc:         "delete_succeeded",
+			getFails:     false,
+			getNotFound:  true,
+			projectState: resourcemanager.LifecycleState(""),
+			wantErr:      false,
+		},
+		{
+			desc:         "get_fails",
+			getFails:     true,
+			projectState: "",
+			wantErr:      true,
+		},
+		{
+			desc:         "timeout",
+			getFails:     false,
+			projectState: "ANOTHER STATE",
+			wantErr:      true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			apiClient := newAPIMock(mockSettings{
+				getFails:     tt.getFails,
+				getNotFound:  tt.getNotFound,
+				projectState: tt.projectState,
+			})
+
+			handler := DeleteProjectWaitHandler(context.Background(), apiClient, "cid")
+
+			_, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background())
+
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}