feat: Add KeysInValidator for validating fields containing specific keys

lang/default.go

@@ -189,6 +189,8 @@ var enUS = &Language{
 			"unique.element":                     "The :field element value has already been taken.",
 			"exists":                             "The :field does not exist.",
 			"exists.element":                     "The :field element value does not exist.",
+			"keysin":                             "The :field must have the following keys: :values.",
+			"keysin.element":                     "The :field elements must have the following keys: :values.",
 		},
 		fields: map[string]string{
 			"":        "body",

validation/string.go

@@ -124,3 +124,46 @@ func (v *DoesntStartWithValidator) MessagePlaceholders(_ *Context) []string {
 func DoesntStartWith(prefix ...string) *DoesntStartWithValidator {
 	return &DoesntStartWithValidator{Prefix: prefix}
 }
+
+//------------------------------
+
+// KeysInValidator validates the field under validation must only contain the given keys.
+type KeysInValidator struct {
+	BaseValidator
+	Keys []string
+}
+
+// Validate checks the field under validation satisfies this validator's criteria.
+func (v *KeysInValidator) Validate(ctx *Context) bool {
+	obj, ok := ctx.Value.(map[string]interface{})
+	if !ok {
+		return false
+	}
+
+	allowedKeys := make(map[string]struct{})
+	for _, key := range v.Keys {
+		allowedKeys[key] = struct{}{}
+	}
+
+	for key := range obj {
+		if _, ok := allowedKeys[key]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Name returns the string name of the validator.
+func (v *KeysInValidator) Name() string { return "keys_in" }
+
+// MessagePlaceholders returns the ":values" placeholder.
+func (v *KeysInValidator) MessagePlaceholders(_ *Context) []string {
+	return []string{
+		":values", strings.Join(v.Keys, ", "),
+	}
+}
+
+// KeysIn creates a new KeysInValidator.
+func KeysIn(keys ...string) *KeysInValidator {
+	return &KeysInValidator{Keys: keys}
+}

validation/string_test.go

@@ -168,3 +168,34 @@
 		})
 	}
 }
+
+func TestKeysInValidator(t *testing.T) {
+	t.Run("Constructor", func(t *testing.T) {
+		v := KeysIn([]string{"a", "b", "c"}...)
+		assert.NotNil(t, v)
+		assert.Equal(t, "keys_in", v.Name())
+		assert.False(t, v.IsType())
+		assert.False(t, v.IsTypeDependent())
+		assert.Equal(t, []string{":values", "a, b, c"}, v.MessagePlaceholders(&Context{}))
+	})
+
+	cases := []struct {
+		value []string
+		input any
+		want  bool
+	}{
+		{value: []string{"a", "b", "c"}, input: map[string]any{"a": 1, "b": 2, "c": 3}, want: true},
+		{value: []string{"a", "b", "c"}, input: map[string]any{"a": 1, "b": 2, "c": 3, "d": 4}, want: false},
+		{value: []string{"a", "b", "c"}, input: map[string]any{"a": 1, "b": 2}, want: true},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(fmt.Sprintf("Validate_%v_%t", tc.value, tc.want), func(t *testing.T) {
+			v := KeysIn(tc.value...)
+			assert.Equal(t, tc.want, v.Validate(&Context{
+				Value: tc.input,
+			}))
+		})
+	}
+}