coerce_value: Simplify path printing

Replicates graphql/graphql-js@dae9f87

Author: Cito

src/graphql/utilities/coerce_value.py

@@ -108,8 +108,9 @@ def coerce_value(
             coerced_value_list: List[Any] = []
             append_item = coerced_value_list.append
             for index, item_value in enumerate(value):
+                item_path = Path(path, index)
                 coerced_item = coerce_value(
-                    item_value, item_type, blame_node, at_path(path, index)
+                    item_value, item_type, blame_node, item_path
                 )
                 if coerced_item.errors:
                     errors = add(errors, *coerced_item.errors)
@@ -136,6 +137,7 @@ def coerce_value(
 
         # Ensure every defined field is valid.
         for field_name, field in fields.items():
+            field_path = Path(path, field_name)
             field_value = value.get(field_name, INVALID)
             if field_value is INVALID:
                 if field.default_value is not INVALID:
@@ -147,14 +149,15 @@ def coerce_value(
                     errors = add(
                         errors,
                         coercion_error(
-                            f"Field {print_path(at_path(path, field_name))}"
-                            f" of required type {field.type} was not provided",
+                            f"Field of required type {inspect(field.type)}"
+                            " was not provided",
                             blame_node,
+                            field_path,
                         ),
                     )
             else:
                 coerced_field = coerce_value(
-                    field_value, field.type, blame_node, at_path(path, field_name)
+                    field_value, field.type, blame_node, field_path
                 )
                 if coerced_field.errors:
                     errors = add(errors, *coerced_field.errors)
@@ -201,37 +204,26 @@ def add(
     return (errors or []) + list(more_errors)
 
 
-def at_path(prev: Optional[Path], key: Union[str, int]) -> Path:
-    return Path(prev, key)
-
-
 def coercion_error(
     message: str,
     blame_node: Node = None,
     path: Path = None,
     sub_message: str = None,
     original_error: Exception = None,
 ) -> GraphQLError:
-    """Return a GraphQLError instance"""
-    path_str = print_path(path)
-    if path_str:
-        message += f" at {path_str}"
-    message += "."
-    if sub_message:
-        message += sub_message
-    # noinspection PyArgumentEqualDefault
-    return GraphQLError(message, blame_node, None, None, None, original_error)
-
-
-def print_path(path: Optional[Path]) -> str:
-    """Build string describing the path into the value where error was found"""
-    path_str = ""
-    current_path: Optional[Path] = path
-    while current_path:
-        path_str = (
-            f".{current_path.key}"
-            if isinstance(current_path.key, str)
-            else f"[{current_path.key}]"
-        ) + path_str
-        current_path = current_path.prev
-    return f"value{path_str}" if path_str else ""
+    """Return a coercion error with the given message describing the given path"""
+    full_message = message
+    # Build a string describing the path into the value where the error was found
+    if path:
+        segment_strings: List[str] = []
+        current_path: Optional[Path] = path
+        while current_path:
+            key = current_path.key
+            segment_strings.insert(0, f".{key}" if isinstance(key, str) else f"[{key}]")
+            current_path = current_path.prev
+        full_message += " at value" + "".join(segment_strings)
+
+    full_message += "." + sub_message if sub_message else "."
+
+    # Return a GraphQLError instance
+    return GraphQLError(full_message, blame_node, None, None, None, original_error)

tests/execution/test_variables.py

@@ -395,8 +395,8 @@ def errors_on_omission_of_nested_non_null():
                     [
                         {
                             "message": "Variable '$input' got invalid value"
-                            " {'a': 'foo', 'b': 'bar'}; Field value.c"
-                            " of required type String! was not provided.",
+                            " {'a': 'foo', 'b': 'bar'}; Field of required type String!"
+                            " was not provided at value.c.",
                             "locations": [(2, 24)],
                         }
                     ],
@@ -415,14 +415,14 @@ def errors_on_deep_nested_errors_and_with_many_errors():
                     [
                         {
                             "message": "Variable '$input' got invalid value"
-                            " {'na': {'a': 'foo'}}; Field value.na.c"
-                            " of required type String! was not provided.",
+                            " {'na': {'a': 'foo'}}; Field of required type String!"
+                            " was not provided at value.na.c.",
                             "locations": [(2, 28)],
                         },
                         {
                             "message": "Variable '$input' got invalid value"
-                            " {'na': {'a': 'foo'}}; Field value.nb"
-                            " of required type String! was not provided.",
+                            " {'na': {'a': 'foo'}}; Field of required type String!"
+                            " was not provided at value.nb.",
                             "locations": [(2, 28)],
                         },
                     ],

tests/utilities/test_coerce_value.py

@@ -140,7 +140,7 @@ def returns_multiple_errors_for_multiple_invalid_fields():
         def returns_error_for_a_missing_required_field():
             result = coerce_value({"bar": 123}, TestInputObject)
             assert expect_errors(result) == [
-                "Field value.foo of required type Int! was not provided."
+                "Field of required type Int! was not provided at value.foo."
             ]
 
         def returns_error_for_an_unknown_field():