bump coverage and lint.

Author: daveshanley

errors/parameter_errors_test.go

@@ -318,6 +318,38 @@ func TestInvalidDeepObjectPathConflict(t *testing.T) {
 	require.Contains(t, err.HowToFix, "testParam[nested][child]")
 }
 
+func TestInvalidDeepObjectPathConflict_NilPaths(t *testing.T) {
+	param := createMockParameterWithDeepObjectStyle()
+
+	err := InvalidDeepObjectPathConflict(param, nil, nil)
+
+	require.NotNil(t, err)
+	require.Contains(t, err.Reason, "property path ''")
+	require.Contains(t, err.HowToFix, "testParam[]")
+}
+
+func TestInvalidDeepObjectPathConflict_PropertyFallback(t *testing.T) {
+	param := createMockParameterWithDeepObjectStyle()
+	prefixParam := &helpers.QueryParam{
+		Key:      "testParam",
+		Values:   []string{"bad"},
+		Property: "nested",
+	}
+	nestedParam := &helpers.QueryParam{
+		Key:      "testParam",
+		Values:   []string{"ok"},
+		Property: "nested.child",
+	}
+
+	err := InvalidDeepObjectPathConflict(param, prefixParam, nestedParam)
+
+	require.NotNil(t, err)
+	require.Contains(t, err.Reason, "property path 'nested'")
+	require.Contains(t, err.Reason, "'nested.child'")
+	require.Contains(t, err.HowToFix, "testParam[nested]")
+	require.Contains(t, err.HowToFix, "testParam[nested.child]")
+}
+
 func createMockParameterForBooleanArray() *v3.Parameter {
 	param := &lowv3.Parameter{
 		Name: low.NodeReference[string]{Value: "testCookieParam"},

helpers/parameter_utilities.go

@@ -388,19 +388,7 @@ func setNestedDeepObjectValue(target map[string]interface{}, propertyPath []stri
 		return true
 	}
 	current := target
-	for i, propertyName := range propertyPath {
-		if i == len(propertyPath)-1 {
-			if existing, exists := current[propertyName]; exists {
-				if _, existingIsMap := existing.(map[string]interface{}); existingIsMap {
-					if _, valueIsMap := value.(map[string]interface{}); !valueIsMap {
-						current[propertyName] = []interface{}{existing, value}
-						return false
-					}
-				}
-			}
-			current[propertyName] = value
-			return true
-		}
+	for _, propertyName := range propertyPath[:len(propertyPath)-1] {
 		next, ok := current[propertyName].(map[string]interface{})
 		if !ok {
 			if existing, exists := current[propertyName]; exists {
@@ -412,6 +400,17 @@ func setNestedDeepObjectValue(target map[string]interface{}, propertyPath []stri
 		}
 		current = next
 	}
+
+	propertyName := propertyPath[len(propertyPath)-1]
+	if existing, exists := current[propertyName]; exists {
+		if _, existingIsMap := existing.(map[string]interface{}); existingIsMap {
+			if _, valueIsMap := value.(map[string]interface{}); !valueIsMap {
+				current[propertyName] = []interface{}{existing, value}
+				return false
+			}
+		}
+	}
+	current[propertyName] = value
 	return true
 }
 

helpers/parameter_utilities_test.go

@@ -718,6 +718,20 @@ func TestDeepObjectPathConflict(t *testing.T) {
 				{Key: "obj", Values: []string{"ok"}, Property: "nested", PropertyPath: []string{"nested", "other"}},
 			},
 		},
+		{
+			name: "different roots",
+			values: []*QueryParam{
+				{Key: "obj", Values: []string{"ok"}, Property: "nested", PropertyPath: []string{"nested"}},
+				{Key: "obj", Values: []string{"ok"}, Property: "other", PropertyPath: []string{"other", "child"}},
+			},
+		},
+		{
+			name: "empty path is ignored",
+			values: []*QueryParam{
+				{Key: "obj", Values: []string{"ignored"}},
+				{Key: "obj", Values: []string{"ok"}, Property: "nested", PropertyPath: []string{"nested", "child"}},
+			},
+		},
 	}
 
 	for _, tc := range tests {
@@ -733,7 +747,24 @@ func TestDeepObjectPathConflict(t *testing.T) {
 	}
 }
 
+func TestQueryParamDeepObjectPath(t *testing.T) {
+	require.Nil(t, queryParamDeepObjectPath(nil))
+	require.Nil(t, queryParamDeepObjectPath(&QueryParam{}))
+	require.Equal(t, []string{"root"}, queryParamDeepObjectPath(&QueryParam{Property: "root"}))
+	require.Equal(t, []string{"root", "child"}, queryParamDeepObjectPath(&QueryParam{
+		Property:     "root",
+		PropertyPath: []string{"root", "child"},
+	}))
+}
+
 func TestSetNestedDeepObjectValue_PreservesConflicts(t *testing.T) {
+	t.Run("empty path", func(t *testing.T) {
+		target := make(map[string]interface{})
+
+		require.True(t, setNestedDeepObjectValue(target, nil, "root"))
+		require.Equal(t, "root", target[""])
+	})
+
 	t.Run("scalar before nested", func(t *testing.T) {
 		target := make(map[string]interface{})
 
@@ -1171,6 +1202,17 @@ func TestConstructParamMapFromDeepObjectEncoding_WithSchema(t *testing.T) {
 		decoded := ConstructParamMapFromDeepObjectEncoding(values, sch)
 		require.Equal(t, "123", decoded["key1"].(map[string]interface{})["prop1"])
 	})
+
+	t.Run("preserves string values when root array items are strings", func(t *testing.T) {
+		sch := &base.Schema{
+			Type: []string{"array"},
+			Items: &base.DynamicValue[*base.SchemaProxy, bool]{
+				A: base.CreateSchemaProxy(&base.Schema{Type: []string{"string"}}),
+			},
+		}
+
+		require.Equal(t, "123", castWithSchema("123", sch, "unknown"))
+	})
 }
 
 func TestConstructParamMapFromPipeEncodingWithSchema(t *testing.T) {

helpers/path_finder.go

@@ -27,7 +27,7 @@ func ExtractJSONPathFromValidationError(e *jsonschema.ValidationError) string {
 		for _, seg := range e.InstanceLocation {
 			switch {
 			case isNumeric(seg):
-				b.WriteString(fmt.Sprintf("[%s]", seg))
+				fmt.Fprintf(&b, "[%s]", seg)
 
 			case isSimpleIdentifier(seg):
 				b.WriteByte('.')
@@ -129,7 +129,7 @@ func ExtractJSONPathFromInstanceLocation(instanceLocation []string) string {
 	for _, seg := range instanceLocation {
 		switch {
 		case isNumeric(seg):
-			b.WriteString(fmt.Sprintf("[%s]", seg))
+			fmt.Fprintf(&b, "[%s]", seg)
 
 		case isSimpleIdentifier(seg):
 			b.WriteByte('.')