create_basic_test.go

package provider

import (
	"context"
	"fmt"
	"time"

	"github.com/gardener/machine-controller-manager/pkg/apis/machine/v1alpha1"
	"github.com/gardener/machine-controller-manager/pkg/util/provider/driver"
	"github.com/gardener/machine-controller-manager/pkg/util/provider/machinecodes/codes"
	"github.com/gardener/machine-controller-manager/pkg/util/provider/machinecodes/status"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	"github.com/stackitcloud/machine-controller-manager-provider-stackit/pkg/client"
	"github.com/stackitcloud/machine-controller-manager-provider-stackit/pkg/client/mock"
	api "github.com/stackitcloud/machine-controller-manager-provider-stackit/pkg/provider/apis"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
)

var _ = Describe("CreateMachine", func() {
	var (
		ctx          context.Context
		provider     *Provider
		mockClient   *mock.StackitClient
		req          *driver.CreateMachineRequest
		secret       *corev1.Secret
		machineClass *v1alpha1.MachineClass
		machine      *v1alpha1.Machine
	)

	BeforeEach(func() {
		ctx = context.Background()
		mockClient = &mock.StackitClient{}
		provider = &Provider{
			client:          mockClient,
			pollingInterval: 10 * time.Millisecond,
			pollingTimeout:  5 * time.Second,
		}

		secret = &corev1.Secret{
			Data: map[string][]byte{
				"project-id":          []byte("11111111-2222-3333-4444-555555555555"),
				"serviceaccount.json": []byte(`{"credentials":{"iss":"test"}}`),
			},
		}

		// Create ProviderSpec
		providerSpec := &api.ProviderSpec{
			MachineType: "c2i.2",
			ImageID:     "12345678-1234-1234-1234-123456789abc",
			Region:      "eu01",
			Networking: &api.NetworkingSpec{
				NetworkID: "770e8400-e29b-41d4-a716-446655440000",
			},
		}
		providerSpecRaw, _ := mock.EncodeProviderSpec(providerSpec)

		// Create MachineClass
		machineClass = &v1alpha1.MachineClass{
			ObjectMeta: metav1.ObjectMeta{
				Name: "test-machine-class",
			},
			Provider: "stackit",
			ProviderSpec: runtime.RawExtension{
				Raw: providerSpecRaw,
			},
		}

		// Create Machine
		machine = &v1alpha1.Machine{
			ObjectMeta: metav1.ObjectMeta{
				Name:      "test-machine",
				Namespace: "default",
			},
		}

		// Create request
		req = &driver.CreateMachineRequest{
			Machine:      machine,
			MachineClass: machineClass,
			Secret:       secret,
		}
	})

	Context("with valid inputs", func() {
		It("should successfully create a machine", func() {
			resp, err := provider.CreateMachine(ctx, req)

			Expect(err).NotTo(HaveOccurred())
			Expect(resp).NotTo(BeNil())
			Expect(resp.ProviderID).To(Equal("stackit://11111111-2222-3333-4444-555555555555/550e8400-e29b-41d4-a716-446655440000"))
			Expect(resp.NodeName).To(Equal("test-machine"))
		})

		It("should call STACKIT API with correct parameters", func() {
			var capturedReq *client.CreateServerRequest
			var capturedProjectID string

			mockClient.CreateServerFunc = func(_ context.Context, projectID, _ string, req *client.CreateServerRequest) (*client.Server, error) {
				capturedProjectID = projectID
				capturedReq = req
				return &client.Server{
					ID:     "test-server-id",
					Name:   req.Name,
					Status: "CREATING",
				}, nil
			}

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).NotTo(HaveOccurred())
			Expect(capturedProjectID).To(Equal("11111111-2222-3333-4444-555555555555"))
			Expect(capturedReq).NotTo(BeNil())
			Expect(capturedReq.Name).To(Equal("test-machine"))
			Expect(capturedReq.MachineType).To(Equal("c2i.2"))
			Expect(capturedReq.ImageID).To(Equal("12345678-1234-1234-1234-123456789abc"))
		})

		It("should return internal IPs from NICs in Addresses", func() {
			mockClient.GetNICsFunc = func(_ context.Context, _, _, _ string) ([]*client.NIC, error) {
				return []*client.NIC{
					{ID: "nic-1", NetworkID: "net-1", IPv4: "10.0.0.5", IPv6: "fd00::1"},
					{ID: "nic-2", NetworkID: "net-2", IPv4: "10.0.1.5"},
				}, nil
			}

			resp, err := provider.CreateMachine(ctx, req)

			Expect(err).NotTo(HaveOccurred())
			Expect(resp.Addresses).To(ConsistOf(
				corev1.NodeAddress{Type: corev1.NodeInternalIP, Address: "10.0.0.5"},
				corev1.NodeAddress{Type: corev1.NodeInternalIP, Address: "fd00::1"},
				corev1.NodeAddress{Type: corev1.NodeInternalIP, Address: "10.0.1.5"},
			))
		})

		It("should poll GetServer until server is ACTIVE", func() {
			getServerCallCount := 0

			mockClient.CreateServerFunc = func(_ context.Context, _, _ string, req *client.CreateServerRequest) (*client.Server, error) {
				return &client.Server{
					ID:     "550e8400-e29b-41d4-a716-446655440000",
					Name:   req.Name,
					Status: "CREATING",
				}, nil
			}
			mockClient.GetServerFunc = func(_ context.Context, _, _, _ string) (*client.Server, error) {
				getServerCallCount++
				// First call returns CREATING, second call returns ACTIVE
				if getServerCallCount == 1 {
					return &client.Server{
						ID:     "550e8400-e29b-41d4-a716-446655440000",
						Name:   "test-machine",
						Status: "CREATING",
					}, nil
				}
				return &client.Server{
					ID:     "550e8400-e29b-41d4-a716-446655440000",
					Name:   "test-machine",
					Status: "ACTIVE",
				}, nil
			}

			resp, err := provider.CreateMachine(ctx, req)

			Expect(err).NotTo(HaveOccurred())
			Expect(resp).NotTo(BeNil())
			Expect(resp.ProviderID).To(Equal("stackit://11111111-2222-3333-4444-555555555555/550e8400-e29b-41d4-a716-446655440000"))
			Expect(getServerCallCount).To(BeNumerically(">=", 2))
		})
	})

	Context("with invalid ProviderSpec", func() {
		It("should fail when MachineType is missing", func() {
			providerSpec := &api.ProviderSpec{
				MachineType: "",
				ImageID:     "12345678-1234-1234-1234-123456789abc",
			}
			providerSpecRaw, _ := mock.EncodeProviderSpec(providerSpec)
			req.MachineClass.ProviderSpec.Raw = providerSpecRaw

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			statusErr, ok := status.FromError(err)
			Expect(ok).To(BeTrue())
			Expect(statusErr.Code()).To(Equal(codes.InvalidArgument))
		})

		It("should fail when ImageID is missing", func() {
			providerSpec := &api.ProviderSpec{
				MachineType: "c2i.2",
				ImageID:     "",
			}
			providerSpecRaw, _ := mock.EncodeProviderSpec(providerSpec)
			req.MachineClass.ProviderSpec.Raw = providerSpecRaw

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			statusErr, ok := status.FromError(err)
			Expect(ok).To(BeTrue())
			Expect(statusErr.Code()).To(Equal(codes.InvalidArgument))
		})

		It("should fail when Provider is wrong", func() {
			req.MachineClass.Provider = "openstack"

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			Expect(err.Error()).To(ContainSubstring("requested for Provider 'openstack', we only support 'stackit'"))
		})
	})

	Context("with invalid Secret", func() {
		It("should fail when projectId is missing", func() {
			req.Secret.Data = map[string][]byte{}

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			statusErr, ok := status.FromError(err)
			Expect(ok).To(BeTrue())
			Expect(statusErr.Code()).To(Equal(codes.InvalidArgument))
		})
	})

	Context("when server has no NICs", func() {
		It("should return Unavailable error", func() {
			mockClient.GetNICsFunc = func(_ context.Context, _, _, _ string) ([]*client.NIC, error) {
				return []*client.NIC{}, nil
			}

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			statusErr, ok := status.FromError(err)
			Expect(ok).To(BeTrue())
			Expect(statusErr.Code()).To(Equal(codes.Unavailable))
			Expect(err.Error()).To(ContainSubstring("no NICs found"))
		})
	})

	Context("when STACKIT API fails", func() {
		It("should return Internal error on API failure", func() {
			mockClient.CreateServerFunc = func(_ context.Context, _, _ string, _ *client.CreateServerRequest) (*client.Server, error) {
				return nil, fmt.Errorf("API connection failed")
			}

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			statusErr, ok := status.FromError(err)
			Expect(ok).To(BeTrue())
			Expect(statusErr.Code()).To(Equal(codes.Unavailable))
		})

		It("should return ResourceExhausted when server enters ERROR state with 'no valid host'", func() {
			mockClient.CreateServerFunc = func(_ context.Context, _, _ string, req *client.CreateServerRequest) (*client.Server, error) {
				return &client.Server{
					ID:     "550e8400-e29b-41d4-a716-446655440000",
					Name:   req.Name,
					Status: "CREATING",
				}, nil
			}
			mockClient.GetServerFunc = func(_ context.Context, _, _, _ string) (*client.Server, error) {
				return &client.Server{
					ID:           "550e8400-e29b-41d4-a716-446655440000",
					Name:         "test-machine",
					Status:       "ERROR",
					ErrorMessage: "No valid host was found. There are not enough hosts available.",
				}, nil
			}

			_, err := provider.CreateMachine(ctx, req)

			Expect(err).To(HaveOccurred())
			statusErr, ok := status.FromError(err)
			Expect(ok).To(BeTrue())
			Expect(statusErr.Code()).To(Equal(codes.ResourceExhausted))
			Expect(err.Error()).To(ContainSubstring("No valid host"))
		})
	})
})