feat(scf): Add STACKIT Cloud Foundry (#991)

* onboard STACKIT Cloud Foundry resources/datasource
2025-10-08 11:42:33 +02:00 · 2025-10-08 11:42:33 +02:00 · a8e874699f
commit a8e874699f
parent fcc7a99488
32 changed files with 3700 additions and 0 deletions
--- a/stackit/internal/services/scf/organization/resource_test.go
+++ b/stackit/internal/services/scf/organization/resource_test.go
@ -0,0 +1,177 @@
+package organization
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	"github.com/stackitcloud/stackit-sdk-go/services/scf"
+)
+
+var (
+	testOrgId      = uuid.New().String()
+	testProjectId  = uuid.New().String()
+	testPlatformId = uuid.New().String()
+	testQuotaId    = uuid.New().String()
+	testRegion     = "eu01"
+)
+
+func TestMapFields(t *testing.T) {
+	createdTime, err := time.Parse("2006-01-02 15:04:05 -0700 MST", "2025-01-01 00:00:00 +0000 UTC")
+	if err != nil {
+		t.Fatalf("failed to parse test time: %v", err)
+	}
+
+	tests := []struct {
+		description string
+		input       *scf.Organization
+		expected    *Model
+		isValid     bool
+	}{
+		{
+			description: "minimal_input",
+			input: &scf.Organization{
+				Guid:      utils.Ptr(testOrgId),
+				Name:      utils.Ptr("scf-org-min-instance"),
+				Region:    utils.Ptr(testRegion),
+				CreatedAt: &createdTime,
+				UpdatedAt: &createdTime,
+				ProjectId: utils.Ptr(testProjectId),
+			},
+			expected: &Model{
+				Id:         types.StringValue(fmt.Sprintf("%s,%s,%s", testProjectId, testRegion, testOrgId)),
+				ProjectId:  types.StringValue(testProjectId),
+				Region:     types.StringValue(testRegion),
+				Name:       types.StringValue("scf-org-min-instance"),
+				PlatformId: types.StringNull(),
+				OrgId:      types.StringValue(testOrgId),
+				QuotaId:    types.StringNull(),
+				Status:     types.StringNull(),
+				Suspended:  types.BoolNull(),
+				CreateAt:   types.StringValue("2025-01-01 00:00:00 +0000 UTC"),
+				UpdatedAt:  types.StringValue("2025-01-01 00:00:00 +0000 UTC"),
+			},
+			isValid: true,
+		},
+		{
+			description: "max_input",
+			input: &scf.Organization{
+				CreatedAt:  &createdTime,
+				Guid:       utils.Ptr(testOrgId),
+				Name:       utils.Ptr("scf-full-org"),
+				PlatformId: utils.Ptr(testPlatformId),
+				ProjectId:  utils.Ptr(testProjectId),
+				QuotaId:    utils.Ptr(testQuotaId),
+				Region:     utils.Ptr(testRegion),
+				Status:     nil,
+				Suspended:  utils.Ptr(true),
+				UpdatedAt:  &createdTime,
+			},
+			expected: &Model{
+				Id:         types.StringValue(fmt.Sprintf("%s,%s,%s", testProjectId, testRegion, testOrgId)),
+				ProjectId:  types.StringValue(testProjectId),
+				OrgId:      types.StringValue(testOrgId),
+				Name:       types.StringValue("scf-full-org"),
+				Region:     types.StringValue(testRegion),
+				PlatformId: types.StringValue(testPlatformId),
+				CreateAt:   types.StringValue("2025-01-01 00:00:00 +0000 UTC"),
+				UpdatedAt:  types.StringValue("2025-01-01 00:00:00 +0000 UTC"),
+				QuotaId:    types.StringValue(testQuotaId),
+				Status:     types.StringNull(),
+				Suspended:  types.BoolValue(true),
+			},
+			isValid: true,
+		},
+		{
+			description: "nil_org",
+			input:       nil,
+			expected:    nil,
+			isValid:     false,
+		},
+		{
+			description: "empty_org",
+			input:       &scf.Organization{},
+			expected:    nil,
+			isValid:     false,
+		},
+		{
+			description: "missing_id",
+			input: &scf.Organization{
+				Name: utils.Ptr("scf-missing-id"),
+			},
+			expected: nil,
+			isValid:  false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			state := &Model{}
+			if tt.expected != nil {
+				state.ProjectId = tt.expected.ProjectId
+			}
+			err := mapFields(tt.input, state)
+
+			if tt.isValid && err != nil {
+				t.Fatalf("expected success, got error: %v", err)
+			}
+			if !tt.isValid && err == nil {
+				t.Fatalf("expected error, got nil")
+			}
+			if tt.isValid {
+				if diff := cmp.Diff(tt.expected, state); diff != "" {
+					t.Errorf("unexpected diff (-want +got):\n%s", diff)
+				}
+			}
+		})
+	}
+}
+
+func TestToCreatePayload(t *testing.T) {
+	tests := []struct {
+		description string
+		input       *Model
+		expected    scf.CreateOrganizationPayload
+		expectError bool
+	}{
+		{
+			description: "default values",
+			input: &Model{
+				Name:       types.StringValue("example-org"),
+				PlatformId: types.StringValue(testPlatformId),
+			},
+			expected: scf.CreateOrganizationPayload{
+				Name:       utils.Ptr("example-org"),
+				PlatformId: utils.Ptr(testPlatformId),
+			},
+			expectError: false,
+		},
+		{
+			description: "nil input model",
+			input:       nil,
+			expected:    scf.CreateOrganizationPayload{},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			output, err := toCreatePayload(tt.input)
+
+			if tt.expectError && err == nil {
+				t.Fatalf("expected diagnostics error but got none")
+			}
+
+			if !tt.expectError && err != nil {
+				t.Fatalf("unexpected diagnostics error: %v", err)
+			}
+
+			if diff := cmp.Diff(tt.expected, output); diff != "" {
+				t.Fatalf("unexpected payload (-want +got):\n%s", diff)
+			}
+		})
+	}
+}