fix(iaas): adapt to new sdk labels type

Author: cgoetz-inovex

internal/cmd/project/update/update.go

@@ -34,7 +34,7 @@ type inputModel struct {
 	*globalflags.GlobalFlagModel
 	ParentId *string
 	Name     *string
-	Labels   *map[string]string
+	Labels   *map[string]*string
 }
 
 func NewCmd(params *types.CmdParams) *cobra.Command {
@@ -107,7 +107,7 @@ func parseInput(p *print.Printer, cmd *cobra.Command, _ []string) (*inputModel,
 		return nil, &errors.ProjectIdError{}
 	}
 
-	labels := flags.FlagToStringToStringPointer(p, cmd, labelFlag)
+	labels := flags.FlagToStringToStringPointerPointer(p, cmd, labelFlag)
 	parentId := flags.FlagToStringPointer(p, cmd, parentIdFlag)
 	name := flags.FlagToStringPointer(p, cmd, nameFlag)
 
@@ -126,10 +126,10 @@ func parseInput(p *print.Printer, cmd *cobra.Command, _ []string) (*inputModel,
 				}
 			}
 
-			if !labelValueRegex.MatchString(value) {
+			if value == nil || !labelValueRegex.MatchString(*value) {
 				return nil, &errors.FlagValidationError{
 					Flag:    labelFlag,
-					Details: fmt.Sprintf("label value %s for key %s didn't match the required regex expression %s", value, key, labelValueRegex),
+					Details: fmt.Sprintf("label value %v for key %s didn't match the required regex expression %s", value, key, labelValueRegex),
 				}
 			}
 		}

internal/cmd/project/update/update_test.go

@@ -101,9 +101,9 @@ func TestParseInput(t *testing.T) {
 			labelValues: []string{"key=value", "foo=bar"},
 			expectedModel: fixtureInputModel(
 				func(model *inputModel) {
-					model.Labels = &map[string]string{
-						"key": "value",
-						"foo": "bar",
+					model.Labels = &map[string]*string{
+						"key": utils.Ptr("value"),
+						"foo": utils.Ptr("bar"),
 					}
 				}),
 			isValid: true,
@@ -114,9 +114,9 @@ func TestParseInput(t *testing.T) {
 			labelValues: []string{"key=value,foo=bar"},
 			expectedModel: fixtureInputModel(
 				func(model *inputModel) {
-					model.Labels = &map[string]string{
-						"key": "value",
-						"foo": "bar",
+					model.Labels = &map[string]*string{
+						"key": utils.Ptr("value"),
+						"foo": utils.Ptr("bar"),
 					}
 				}),
 			isValid: true,

internal/pkg/flags/flag_to_value.go

@@ -76,6 +76,26 @@ func FlagToStringToStringPointer(p *print.Printer, cmd *cobra.Command, flag stri
 	return nil
 }
 
+// FlagToStringToStringPointerPointer returns a pointer to the flag's value as a map of string pointers.
+// Returns nil if the flag is not set, cannot be converted, or does not exist.
+func FlagToStringToStringPointerPointer(p *print.Printer, cmd *cobra.Command, flag string) *map[string]*string { //nolint:gocritic //convenient for setting the SDK payload
+	value, err := cmd.Flags().GetStringToString(flag)
+	if err != nil {
+		p.Debug(print.ErrorLevel, "convert flag to string to string pointer pointer: %v", err)
+		return nil
+	}
+	if !cmd.Flag(flag).Changed {
+		return nil
+	}
+
+	pointerValue := make(map[string]*string, len(value))
+	for key, item := range value {
+		item := item
+		pointerValue[key] = &item
+	}
+	return &pointerValue
+}
+
 func FlagToStringToAny(p *print.Printer, cmd *cobra.Command, flag string) map[string]any {
 	value, err := cmd.Flags().GetStringToString(flag)
 	r := make(map[string]any, len(value))

internal/pkg/flags/flag_to_value_test.go

@@ -73,6 +73,43 @@ func TestFlagToStringToStringPointer(t *testing.T) {
 	}
 }
 
+func TestFlagToStringToStringPointerPointer(t *testing.T) {
+	const flagName = "labels"
+
+	tests := []struct {
+		name      string
+		flagValue *string
+		want      *map[string]*string
+	}{
+		{name: "flag unset"},
+		{
+			name:      "flag set",
+			flagValue: utils.Ptr("foo=bar,label1=value1"),
+			want: &map[string]*string{
+				"foo":    utils.Ptr("bar"),
+				"label1": utils.Ptr("value1"),
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			params := testparams.NewTestParams()
+			cmd := &cobra.Command{Use: "test"}
+			cmd.Flags().StringToString(flagName, nil, "Labels")
+			if tt.flagValue != nil {
+				if err := cmd.Flags().Set(flagName, *tt.flagValue); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if got := FlagToStringToStringPointerPointer(params.Printer, cmd, flagName); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("FlagToStringToStringPointerPointer() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 func TestFlagToStringArrayValue(t *testing.T) {
 	const flagName = "geofencing"
 	tests := []struct {