Cleanup value_from_ast(_untyped) tests

Replicates graphql/graphql-js@5579fd2

Author: Cito

tests/utilities/test_value_from_ast.py

@@ -1,4 +1,5 @@
 from math import isnan, nan
+from typing import Any, Dict, Optional
 
 from graphql.language import parse_value, ValueNode
 from graphql.pyutils import Undefined
@@ -9,6 +10,7 @@
     GraphQLID,
     GraphQLInputField,
     GraphQLInputObjectType,
+    GraphQLInputType,
     GraphQLInt,
     GraphQLList,
     GraphQLNonNull,
@@ -19,7 +21,11 @@
 
 
 def describe_value_from_ast():
-    def _value_from(value_text, type_, variables=None):
+    def _value_from(
+        value_text: str,
+        type_: GraphQLInputType,
+        variables: Optional[Dict[str, Any]] = None,
+    ):
         ast = parse_value(value_text)
         return value_from_ast(ast, type_, variables)
 

tests/utilities/test_value_from_ast_untyped.py

@@ -1,12 +1,13 @@
 from math import nan
+from typing import Any, Dict, Optional
 
 from graphql.language import parse_value, FloatValueNode, IntValueNode
 from graphql.pyutils import Undefined
 from graphql.utilities import value_from_ast_untyped
 
 
 def describe_value_from_ast_untyped():
-    def _compare_value(value, expected):
+    def _compare_value(value: Any, expected: Any):
         if expected is None:
             assert value is None
         elif expected is Undefined:
@@ -16,46 +17,50 @@ def _compare_value(value, expected):
         else:
             assert value == expected
 
-    def _test_case(value_text, expected):
-        value_node = parse_value(value_text)
-        _compare_value(value_from_ast_untyped(value_node), expected)
+    def _expect_value_from(value_text: str, expected: Any):
+        ast = parse_value(value_text)
+        value = value_from_ast_untyped(ast)
+        _compare_value(value, expected)
 
-    def _test_case_with_vars(value_text, variables, expected):
-        value_node = parse_value(value_text)
-        _compare_value(value_from_ast_untyped(value_node, variables), expected)
+    def _expect_value_from_vars(
+        value_text: str, variables: Optional[Dict[str, Any]], expected: Any
+    ):
+        ast = parse_value(value_text)
+        value = value_from_ast_untyped(ast, variables)
+        _compare_value(value, expected)
 
     def parses_simple_values():
-        _test_case("null", None)
-        _test_case("true", True)
-        _test_case("false", False)
-        _test_case("123", 123)
-        _test_case("123.456", 123.456)
-        _test_case('"abc123"', "abc123")
+        _expect_value_from("null", None)
+        _expect_value_from("true", True)
+        _expect_value_from("false", False)
+        _expect_value_from("123", 123)
+        _expect_value_from("123.456", 123.456)
+        _expect_value_from('"abc123"', "abc123")
 
     def parses_lists_of_values():
-        _test_case("[true, false]", [True, False])
-        _test_case("[true, 123.45]", [True, 123.45])
-        _test_case("[true, null]", [True, None])
-        _test_case('[true, ["foo", 1.2]]', [True, ["foo", 1.2]])
+        _expect_value_from("[true, false]", [True, False])
+        _expect_value_from("[true, 123.45]", [True, 123.45])
+        _expect_value_from("[true, null]", [True, None])
+        _expect_value_from('[true, ["foo", 1.2]]', [True, ["foo", 1.2]])
 
     def parses_input_objects():
-        _test_case("{ int: 123, bool: false }", {"int": 123, "bool": False})
-        _test_case('{ foo: [ { bar: "baz"} ] }', {"foo": [{"bar": "baz"}]})
+        _expect_value_from("{ int: 123, bool: false }", {"int": 123, "bool": False})
+        _expect_value_from('{ foo: [ { bar: "baz"} ] }', {"foo": [{"bar": "baz"}]})
 
     def parses_enum_values_as_plain_strings():
-        _test_case("TEST_ENUM_VALUE", "TEST_ENUM_VALUE")
-        _test_case("[TEST_ENUM_VALUE]", ["TEST_ENUM_VALUE"])
+        _expect_value_from("TEST_ENUM_VALUE", "TEST_ENUM_VALUE")
+        _expect_value_from("[TEST_ENUM_VALUE]", ["TEST_ENUM_VALUE"])
 
     def parses_variables():
-        _test_case_with_vars("$testVariable", {"testVariable": "foo"}, "foo")
-        _test_case_with_vars("[$testVariable]", {"testVariable": "foo"}, ["foo"])
-        _test_case_with_vars(
+        _expect_value_from_vars("$testVariable", {"testVariable": "foo"}, "foo")
+        _expect_value_from_vars("[$testVariable]", {"testVariable": "foo"}, ["foo"])
+        _expect_value_from_vars(
             "{a:[$testVariable]}", {"testVariable": "foo"}, {"a": ["foo"]}
         )
-        _test_case_with_vars("$testVariable", {"testVariable": None}, None)
-        _test_case_with_vars("$testVariable", {"testVariable": nan}, nan)
-        _test_case_with_vars("$testVariable", {}, Undefined)
-        _test_case_with_vars("$testVariable", None, Undefined)
+        _expect_value_from_vars("$testVariable", {"testVariable": None}, None)
+        _expect_value_from_vars("$testVariable", {"testVariable": nan}, nan)
+        _expect_value_from_vars("$testVariable", {}, Undefined)
+        _expect_value_from_vars("$testVariable", None, Undefined)
 
     def parse_invalid_int_as_nan():
         assert value_from_ast_untyped(IntValueNode(value="invalid")) is nan