added unit tests

Author: Jan Sternagel

internal/cmd/beta/kms/key/create/create.go

@@ -40,7 +40,7 @@ type inputModel struct {
 	Backend     string // Keep "backend" as a variable, but set the default to "software" (see UI)
 	Description *string
 	Name        *string
-	ImportOnly  *bool // Default false
+	ImportOnly  bool // Default false
 	Purpose     *string
 }
 
@@ -119,7 +119,7 @@ func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) {
 		Backend:         flags.FlagWithDefaultToStringValue(p, cmd, backendFlag),
 		Name:            flags.FlagToStringPointer(p, cmd, displayNameFlag),
 		Description:     flags.FlagToStringPointer(p, cmd, descriptionFlag),
-		ImportOnly:      flags.FlagToBoolPointer(p, cmd, importOnlyFlag),
+		ImportOnly:      flags.FlagToBoolValue(p, cmd, importOnlyFlag),
 		Purpose:         flags.FlagToStringPointer(p, cmd, purposeFlag),
 	}
 
@@ -149,7 +149,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient kmsKeyClient
 		Algorithm:   kms.CreateKeyPayloadGetAlgorithmAttributeType(model.Algorithm),
 		Backend:     kms.CreateKeyPayloadGetBackendAttributeType(&model.Backend),
 		Purpose:     kms.CreateKeyPayloadGetPurposeAttributeType(model.Purpose),
-		ImportOnly:  model.ImportOnly,
+		ImportOnly:  &model.ImportOnly,
 	})
 	return req, nil
 }

internal/cmd/beta/kms/key/create/create_test.go

@@ -0,0 +1,323 @@
+package create
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+	"github.com/stackitcloud/stackit-cli/internal/cmd/params"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
+	"github.com/stackitcloud/stackit-sdk-go/services/kms"
+)
+
+const (
+	testRegion = "eu01"
+)
+
+type testCtxKey struct{}
+
+var (
+	testCtx         = context.WithValue(context.Background(), testCtxKey{}, "foo")
+	testClient      = &kms.APIClient{}
+	testProjectId   = uuid.NewString()
+	testKeyRingId   = uuid.NewString()
+	testAlgorithm   = "some_rsa_2048"
+	testDisplayName = "my-key"
+	testPurpose     = "asymmetric_encrypt_decrypt"
+	testDescription = "my key description"
+	testImportOnly  = "true"
+	testBackend     = "notSoftware"
+)
+
+// Flags
+func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string {
+	flagValues := map[string]string{
+		globalflags.ProjectIdFlag: testProjectId,
+		globalflags.RegionFlag:    testRegion,
+		keyRingIdFlag:             testKeyRingId,
+		algorithmFlag:             testAlgorithm,
+		displayNameFlag:           testDisplayName,
+		purposeFlag:               testPurpose,
+		descriptionFlag:           testDescription,
+		importOnlyFlag:            testImportOnly,
+		backendFlag:               testBackend,
+	}
+	for _, mod := range mods {
+		mod(flagValues)
+	}
+	return flagValues
+}
+
+// Input Model
+func fixtureInputModel(mods ...func(model *inputModel)) *inputModel {
+	model := &inputModel{
+		GlobalFlagModel: &globalflags.GlobalFlagModel{
+			ProjectId: testProjectId,
+			Region:    testRegion,
+			Verbosity: globalflags.VerbosityDefault,
+		},
+		KeyRingId:   testKeyRingId,
+		Algorithm:   utils.Ptr(testAlgorithm),
+		Name:        utils.Ptr(testDisplayName),
+		Purpose:     utils.Ptr(testPurpose),
+		Description: utils.Ptr(testDescription),
+		ImportOnly:  true, // Watch out: ImportOnly is not testImportOnly!
+		Backend:     testBackend,
+	}
+	for _, mod := range mods {
+		mod(model)
+	}
+	return model
+}
+
+// Request
+func fixtureRequest(mods ...func(request *kms.ApiCreateKeyRequest)) kms.ApiCreateKeyRequest {
+	request := testClient.CreateKey(testCtx, testProjectId, testRegion, testKeyRingId)
+	request = request.CreateKeyPayload(kms.CreateKeyPayload{
+		Algorithm:   kms.CreateKeyPayloadGetAlgorithmAttributeType(utils.Ptr(testAlgorithm)),
+		DisplayName: utils.Ptr(testDisplayName),
+		Purpose:     kms.CreateKeyPayloadGetPurposeAttributeType(utils.Ptr(testPurpose)),
+		Description: utils.Ptr(testDescription),
+		ImportOnly:  utils.Ptr(true),
+		Backend:     kms.CreateKeyPayloadGetBackendAttributeType(utils.Ptr(testBackend)),
+	})
+
+	for _, mod := range mods {
+		mod(&request)
+	}
+	return request
+}
+
+func TestParseInput(t *testing.T) {
+	tests := []struct {
+		description   string
+		flagValues    map[string]string
+		isValid       bool
+		expectedModel *inputModel
+	}{
+		{
+			description:   "base",
+			flagValues:    fixtureFlagValues(),
+			isValid:       true,
+			expectedModel: fixtureInputModel(),
+		},
+		{
+			description: "optional flags omitted",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, descriptionFlag)
+				delete(flagValues, importOnlyFlag)
+				delete(flagValues, backendFlag)
+			}),
+			isValid: true,
+			expectedModel: fixtureInputModel(func(model *inputModel) {
+				model.Description = nil
+				model.ImportOnly = false
+				model.Backend = "software"
+			}),
+		},
+		{
+			description: "no values provided",
+			flagValues:  map[string]string{},
+			isValid:     false,
+		},
+		{
+			description: "project id missing",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, globalflags.ProjectIdFlag)
+			}),
+			isValid: false,
+		},
+		{
+			description: "project id invalid 1",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				flagValues[globalflags.ProjectIdFlag] = ""
+			}),
+			isValid: false,
+		},
+		{
+			description: "project id invalid 2",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				flagValues[globalflags.ProjectIdFlag] = "invalid-uuid"
+			}),
+			isValid: false,
+		},
+		{
+			description: "key ring id missing (required)",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, keyRingIdFlag)
+			}),
+			isValid: false,
+		},
+		{
+			description: "key ring id invalid",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				flagValues[keyRingIdFlag] = "invalid-uuid"
+			}),
+			isValid: false,
+		},
+		{
+			description: "algorithm missing (required)",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, algorithmFlag)
+			}),
+			isValid: false,
+		},
+		{
+			description: "name missing (required)",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, displayNameFlag)
+			}),
+			isValid: false,
+		},
+		{
+			description: "purpose missing (required)",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, purposeFlag)
+			}),
+			isValid: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			cmd := &cobra.Command{}
+			err := globalflags.Configure(cmd.Flags())
+			if err != nil {
+				t.Fatalf("configure global flags: %v", err)
+			}
+
+			configureFlags(cmd)
+
+			for flag, value := range tt.flagValues {
+				err := cmd.Flags().Set(flag, value)
+				if err != nil {
+					if !tt.isValid {
+						return
+					}
+					t.Fatalf("setting flag --%s=%s: %v", flag, value, err)
+				}
+			}
+
+			err = cmd.ValidateRequiredFlags()
+			if err != nil {
+				if !tt.isValid {
+					return
+				}
+				t.Fatalf("error validating flags: %v", err)
+			}
+
+			p := print.NewPrinter()
+			model, err := parseInput(p, cmd)
+			if err != nil {
+				if !tt.isValid {
+					return
+				}
+				t.Fatalf("error parsing flags: %v", err)
+			}
+
+			if !tt.isValid {
+				t.Fatalf("did not fail on invalid input")
+			}
+			diff := cmp.Diff(tt.expectedModel, model)
+			if diff != "" {
+				t.Fatalf("Data does not match: %s", diff)
+			}
+		})
+	}
+}
+
+func TestBuildRequest(t *testing.T) {
+	tests := []struct {
+		description     string
+		model           *inputModel
+		expectedRequest kms.ApiCreateKeyRequest
+	}{
+		{
+			description:     "base case",
+			model:           fixtureInputModel(),
+			expectedRequest: fixtureRequest(),
+		},
+		{
+			description: "no optional values",
+			model: fixtureInputModel(func(model *inputModel) {
+				model.Description = nil
+				model.ImportOnly = false
+			}),
+			expectedRequest: fixtureRequest().CreateKeyPayload(kms.CreateKeyPayload{
+				Algorithm:   kms.CreateKeyPayloadGetAlgorithmAttributeType(utils.Ptr(testAlgorithm)),
+				DisplayName: utils.Ptr(testDisplayName),
+				Purpose:     kms.CreateKeyPayloadGetPurposeAttributeType(utils.Ptr(testPurpose)),
+				Description: nil,
+				ImportOnly:  utils.Ptr(false),
+				Backend:     kms.CreateKeyPayloadGetBackendAttributeType(utils.Ptr(testBackend)),
+			}),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			request, err := buildRequest(testCtx, tt.model, testClient)
+			if err != nil {
+				t.Fatalf("error building request: %v", err)
+			}
+
+			diff := cmp.Diff(tt.expectedRequest, request,
+				cmp.AllowUnexported(tt.expectedRequest),
+				cmpopts.EquateComparable(testCtx),
+			)
+			if diff != "" {
+				t.Fatalf("Data does not match: %s", diff)
+			}
+		})
+	}
+}
+
+func TestOutputResult(t *testing.T) {
+	tests := []struct {
+		description  string
+		key          *kms.Key
+		outputFormat string
+		projectLabel string
+		wantErr      bool
+	}{
+		{
+			description: "nil response",
+			key:         nil,
+			wantErr:     true,
+		},
+		{
+			description:  "default output",
+			key:          &kms.Key{},
+			projectLabel: "my-project",
+			wantErr:      false,
+		},
+		{
+			description:  "json output",
+			key:          &kms.Key{},
+			outputFormat: print.JSONOutputFormat,
+			wantErr:      false,
+		},
+		{
+			description:  "yaml output",
+			key:          &kms.Key{},
+			outputFormat: print.YAMLOutputFormat,
+			wantErr:      false,
+		},
+	}
+
+	p := print.NewPrinter()
+	p.Cmd = NewCmd(&params.CmdParams{Printer: p})
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			err := outputResult(p, tt.outputFormat, tt.projectLabel, tt.key)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("outputResult() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}