fix(OneOf): count only known fields for one-of validation

Replicates graphql/graphql-js@c4f7d1b

Author: Cito

src/graphql/utilities/validate_input_value.py

@@ -10,6 +10,7 @@
     ListValueNode,
     Node,
     NullValueNode,
+    ObjectFieldNode,
     ObjectValueNode,
     ValueNode,
     VariableNode,
@@ -139,7 +140,6 @@ def validate_input_value_impl(
         for field_name, field_value in input_value.items():
             if field_value is Undefined:
                 continue
-            fields.append(field_name)
             if field_name not in field_defs:
                 suggestion = (
                     ""
@@ -154,6 +154,8 @@ def validate_input_value_impl(
                     + f": {inspect(input_value)}.",
                     path,
                 )
+                continue
+            fields.append(field_name)
 
         if type_.is_one_of:
             if len(fields) != 1:
@@ -163,14 +165,15 @@ def validate_input_value_impl(
                     path,
                 )
 
-            field_name = fields[0]
-            value = input_value[field_name]
-            if value is None:
-                report_invalid_value(
-                    on_error,
-                    get_one_of_input_object_error_message(type_),
-                    Path(path, field_name, type_.name),
-                )
+            if fields:
+                field_name = fields[0]
+                value = input_value[field_name]
+                if value is None:
+                    report_invalid_value(
+                        on_error,
+                        get_one_of_input_object_error_message(type_),
+                        Path(path, field_name, type_.name),
+                    )
     else:
         assert_leaf_type(type_)
 
@@ -393,6 +396,7 @@ def validate_input_literal_impl(
                 )
 
         fields = value_node.fields
+        known_fields: list[ObjectFieldNode] = []
         # Ensure every provided field is defined.
         for field_node in fields:
             field_name = field_node.name.value
@@ -411,9 +415,11 @@ def validate_input_literal_impl(
                     field_node,
                     path,
                 )
+            else:
+                known_fields.append(field_node)
 
         if type_.is_one_of:
-            is_not_exactly_one_field = len(fields) != 1
+            is_not_exactly_one_field = len(known_fields) != 1
             if is_not_exactly_one_field:
                 report_invalid_literal(
                     context.on_error,
@@ -423,9 +429,9 @@ def validate_input_literal_impl(
                 )
                 return
 
-            field_value_node = fields[0].value
+            field_value_node = known_fields[0].value
             if isinstance(field_value_node, NullValueNode):
-                field_name = fields[0].name.value
+                field_name = known_fields[0].name.value
                 report_invalid_literal(
                     context.on_error,
                     get_one_of_input_object_error_message(type_),

tests/utilities/test_coerce_input_value.py

@@ -569,6 +569,7 @@ def coerces_input_objects_according_to_input_coercion_rules():
         _test("{ a: null }", test_one_of_input_obj, Undefined)
         _test("{ a: 1 }", test_one_of_input_obj, Undefined)
         _test('{ a: "abc", b: "def" }', test_one_of_input_obj, Undefined)
+        _test('{ a: "abc", c: "def" }', test_one_of_input_obj, Undefined)
         _test("{}", test_one_of_input_obj, Undefined)
         _test('{ c: "abc" }', test_one_of_input_obj, Undefined)
 

tests/utilities/test_validate_input_value.py

@@ -478,13 +478,6 @@ def returns_error_for_an_unknown_field():
                         " found: {'foo': 123, 'unknownField': 123}.",
                         "path": [],
                     },
-                    {
-                        "error": "Within OneOf Input Object type"
-                        " 'TestInputObject', exactly one field must be"
-                        " specified, and the value for that field"
-                        " must be non-null.",
-                        "path": [],
-                    },
                 ],
             )
 
@@ -498,7 +491,14 @@ def returns_error_for_a_misspelled_field():
                         " not to include unknown field 'bart'."
                         " Did you mean 'bar'? Found: {'bart': 123}.",
                         "path": [],
-                    }
+                    },
+                    {
+                        "error": "Within OneOf Input Object type"
+                        " 'TestInputObject', exactly one field must be"
+                        " specified, and the value for that field"
+                        " must be non-null.",
+                        "path": [],
+                    },
                 ],
             )
 
@@ -512,7 +512,14 @@ def returns_error_for_a_misspelled_field_no_suggestions():
                         " not to include unknown field 'bart',"
                         " found: {'bart': 123}.",
                         "path": [],
-                    }
+                    },
+                    {
+                        "error": "Within OneOf Input Object type"
+                        " 'TestInputObject', exactly one field must be"
+                        " specified, and the value for that field"
+                        " must be non-null.",
+                        "path": [],
+                    },
                 ],
                 True,
             )
@@ -1128,13 +1135,6 @@ def returns_error_for_an_unknown_field():
                         " found: { foo: 123, unknownField: 123 }.",
                         "path": [],
                     },
-                    {
-                        "error": "Within OneOf Input Object type"
-                        " 'TestInputObject', exactly one field must be"
-                        " specified, and the value for that field"
-                        " must be non-null.",
-                        "path": [],
-                    },
                 ],
             )
 
@@ -1149,13 +1149,6 @@ def returns_error_for_a_misspelled_field():
                         " Did you mean 'bar'? Found: { foo: 123, bart: 123 }.",
                         "path": [],
                     },
-                    {
-                        "error": "Within OneOf Input Object type"
-                        " 'TestInputObject', exactly one field must be"
-                        " specified, and the value for that field"
-                        " must be non-null.",
-                        "path": [],
-                    },
                 ],
             )
 

tests/validation/test_values_of_correct_type.py

@@ -1277,6 +1277,29 @@ def more_than_one_field():
                 ],
             )
 
+        def unknown_field_does_not_add_a_one_of_error():
+            assert_errors(
+                """
+                {
+                  complicatedArgs {
+                    oneOfArgField(oneOfArg: {
+                      stringField: "abc",
+                      invalidField: 123
+                    })
+                  }
+                }
+                """,
+                [
+                    {
+                        "message": "Expected value of type 'OneOfInput'"
+                        " not to include unknown field 'invalidField'."
+                        " Did you mean 'intField'?"
+                        ' Found: { stringField: "abc", invalidField: 123 }.',
+                        "locations": [(6, 23)],
+                    },
+                ],
+            )
+
     def describe_directive_arguments():
         def with_directives_of_valid_types():
             assert_valid(