fix: added validation to StringMap scalar (#176)

* fix: added validation to StringMap scalar

On-behalf-of: @SAP [email protected]
Signed-off-by: Artem Shcherbatiuk <[email protected]>

Author: vertex451

gateway/schema/exports_test.go

@@ -0,0 +1,3 @@
+package schema
+
+var StringMapScalar = stringMapScalar

gateway/schema/scalars.go

@@ -12,18 +12,25 @@ var stringMapScalar = graphql.NewScalar(graphql.ScalarConfig{
 		return value
 	},
 	ParseValue: func(value interface{}) interface{} {
-		return value
+		switch val := value.(type) {
+		case map[string]interface{}, map[string]string:
+			return val
+		default:
+			return nil // to tell GraphQL that the value is invalid
+		}
 	},
 	ParseLiteral: func(valueAST ast.Value) interface{} {
-		result := map[string]string{}
 		switch value := valueAST.(type) {
 		case *ast.ObjectValue:
+			result := map[string]string{}
 			for _, field := range value.Fields {
 				if strValue, ok := field.Value.GetValue().(string); ok {
 					result[field.Name.Value] = strValue
 				}
 			}
+			return result
+		default:
+			return nil // to tell GraphQL that the value is invalid
 		}
-		return result
 	},
 })

gateway/schema/scalars_test.go

@@ -0,0 +1,77 @@
+package schema_test
+
+import (
+	"github.com/openmfp/kubernetes-graphql-gateway/gateway/schema"
+	"reflect"
+	"testing"
+
+	"github.com/graphql-go/graphql/language/ast"
+	"github.com/graphql-go/graphql/language/kinds"
+)
+
+func TestStringMapScalar_ParseValue(t *testing.T) {
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{
+			input:    map[string]interface{}{"key": "val"},
+			expected: map[string]interface{}{"key": "val"},
+		},
+		{
+			input:    map[string]string{"a": "b"},
+			expected: map[string]string{"a": "b"},
+		},
+		{
+			input:    "key=val",
+			expected: nil,
+		},
+	}
+
+	for _, test := range tests {
+		out := schema.StringMapScalar.ParseValue(test.input)
+		if !reflect.DeepEqual(out, test.expected) {
+			t.Errorf("ParseValue(%v) = %v; want %v", test.input, out, test.expected)
+		}
+	}
+}
+
+func TestStringMapScalar_ParseLiteral(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    ast.Value
+		expected interface{}
+	}{
+		{
+			name: "valid_object_value",
+			input: &ast.ObjectValue{
+				Kind: kinds.ObjectValue,
+				Fields: []*ast.ObjectField{
+					{
+						Name:  &ast.Name{Value: "key"},
+						Value: &ast.StringValue{Kind: kinds.StringValue, Value: "val"},
+					},
+					{
+						Name:  &ast.Name{Value: "key2"},
+						Value: &ast.StringValue{Kind: kinds.StringValue, Value: "val2"},
+					},
+				},
+			},
+			expected: map[string]string{"key": "val", "key2": "val2"},
+		},
+		{
+			name:     "invalid_string_value",
+			input:    &ast.StringValue{Kind: kinds.StringValue, Value: "key=val"},
+			expected: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			out := schema.StringMapScalar.ParseLiteral(tt.input)
+			if !reflect.DeepEqual(out, tt.expected) {
+				t.Errorf("ParseLiteral() = %v, want %v", out, tt.expected)
+			}
+		})
+	}
+}