Fix filtering in schema.Array for scalar values

Filtering on `schema.Array` for a single array match on MongoDB
can be done with query like `{arr: value}`, where it will return
all documents whose `arr` field, contains the value
(and may cointain other values as well).

Relates to #5003f4f5, where support in `rest-layer-mem` was added.

Author: Dragomir-Ivanov

rest/method_get_test.go

@@ -345,6 +345,73 @@ func TestGetListFilter(t *testing.T) {
 }
 
 func TestGetListArray(t *testing.T) {
+	sharedInit := func() *requestTestVars {
+		s := mem.NewHandler()
+		s.Insert(context.TODO(), []*resource.Item{
+			{ID: "1", Payload: map[string]interface{}{"id": 1,
+				"foo": []interface{}{"bar", "baz"}},
+			},
+			{ID: "2", Payload: map[string]interface{}{"id": 2,
+				"foo": []interface{}{"bar"}},
+			},
+			{ID: "3", Payload: map[string]interface{}{"id": 3,
+				"foo": []interface{}{"baz"}},
+			},
+		})
+
+		idx := resource.NewIndex()
+		idx.Bind("foo", schema.Schema{
+			Fields: schema.Fields{
+				"foo": {
+					Filterable: true,
+					Validator: &schema.Array{
+						Values: schema.Field{
+							Validator: &schema.String{},
+						},
+					},
+				},
+			},
+		}, s, resource.DefaultConf)
+
+		return &requestTestVars{
+			Index:   idx,
+			Storers: map[string]resource.Storer{"foo": s},
+		}
+	}
+
+	tests := map[string]requestTest{
+		`filter/array:foo:not-found`: {
+			Init: sharedInit,
+			NewRequest: func() (*http.Request, error) {
+				return http.NewRequest("GET", `/foo?filter={foo:"mar"}`, nil)
+			},
+			ResponseCode: http.StatusOK,
+			ResponseBody: `[]`,
+		},
+		`filter/array:foo:try-object`: {
+			Init: sharedInit,
+			NewRequest: func() (*http.Request, error) {
+				return http.NewRequest("GET", `/foo?filter={foo:{bar:"mar"}}`, nil)
+			},
+			ResponseCode: 422,
+			ResponseBody: `{"code":422,"issues":{"filter":["foo: invalid query expression: invalid value at #1: not a string"]},"message":"URL parameters contain error(s)"}`,
+		},
+		`filter/array:foo:find`: {
+			Init: sharedInit,
+			NewRequest: func() (*http.Request, error) {
+				return http.NewRequest("GET", `/foo?filter={foo:"bar"}`, nil)
+			},
+			ResponseCode: http.StatusOK,
+			ResponseBody: `[{"foo":["bar","baz"],"id":1},{"foo":["bar"],"id":2}]`,
+		},
+	}
+	for n, tc := range tests {
+		tc := tc // capture range variable
+		t.Run(n, tc.Test)
+	}
+}
+
+func TestGetListArrayOfObjects(t *testing.T) {
 	sharedInit := func() *requestTestVars {
 		s := mem.NewHandler()
 		s.Insert(context.TODO(), []*resource.Item{
@@ -573,14 +640,6 @@ func TestGetListArray(t *testing.T) {
 				{"id":2,"foo":[{"a":"bar","b":20}]}
 			]`,
 		},
-		`filter/array:foo:not-an-array`: {
-			Init: sharedInit,
-			NewRequest: func() (*http.Request, error) {
-				return http.NewRequest("GET", `/foo?filter={foo:"mar"}`, nil)
-			},
-			ResponseCode: http.StatusUnprocessableEntity,
-			ResponseBody: `{"code":422,"issues":{"filter":["foo: invalid query expression: not an array"]},"message":"URL parameters contain error(s)"}`,
-		},
 		`filter/array:foo:invalid-elemMatch`: {
 			Init: sharedInit,
 			NewRequest: func() (*http.Request, error) {

schema/array.go

@@ -50,14 +50,19 @@ func (v Array) validateValues(values []interface{}, query bool) ([]interface{},
 
 // ValidateQuery implements FieldQueryValidator.
 func (v Array) ValidateQuery(value interface{}) (interface{}, error) {
-	values, ok := value.([]interface{})
-	if !ok {
-		return nil, errors.New("not an array")
+	values, isArray := value.([]interface{})
+	if !isArray {
+		values = append(values, value)
 	}
+
 	arr, err := v.validateValues(values, true)
 	if err != nil {
 		return nil, err
 	}
+
+	if !isArray {
+		return arr[0], nil
+	}
 	return arr, nil
 }
 

schema/array_test.go

@@ -119,7 +119,7 @@ func TestArrayQueryValidator(t *testing.T) {
 			Name:      `Values.Validator=&String{},ValidateQuery("value")`,
 			Validator: &schema.Array{Values: schema.Field{Validator: &schema.String{}}},
 			Input:     "value",
-			Error:     "not an array",
+			Expect:    "value",
 		},
 		{
 			Name:      `MinLen=2,ValidateQuery([]interface{}{true,false})`,