test_value_from_ast: improve readability

Replicates graphql/graphql-js@f462347

Author: Cito

tests/utilities/test_value_from_ast.py

@@ -18,64 +18,56 @@
 
 
 def describe_value_from_ast():
-    def _test_case(type_, value_text, expected):
-        value_node = parse_value(value_text)
-        value = value_from_ast(value_node, type_)
-        if isinstance(expected, float) and isnan(expected):
-            assert isnan(value)
-        else:
-            assert value == expected
-
-    def _test_case_with_vars(variables, type_, value_text, expected):
-        value_node = parse_value(value_text)
-        assert value_from_ast(value_node, type_, variables) == expected
+    def _value_from(value_text, type_, variables=None):
+        ast = parse_value(value_text)
+        return value_from_ast(ast, type_, variables)
 
     def rejects_empty_input():
         # noinspection PyTypeChecker
         assert value_from_ast(None, GraphQLBoolean) is Undefined
 
     def converts_according_to_input_coercion_rules():
-        _test_case(GraphQLBoolean, "true", True)
-        _test_case(GraphQLBoolean, "false", False)
-        _test_case(GraphQLInt, "123", 123)
-        _test_case(GraphQLFloat, "123", 123)
-        _test_case(GraphQLFloat, "123.456", 123.456)
-        _test_case(GraphQLString, '"abc123"', "abc123")
-        _test_case(GraphQLID, "123456", "123456")
-        _test_case(GraphQLID, '"123456"', "123456")
+        assert _value_from("true", GraphQLBoolean) is True
+        assert _value_from("false", GraphQLBoolean) is False
+        assert _value_from("123", GraphQLInt) == 123
+        assert _value_from("123", GraphQLFloat) == 123
+        assert _value_from("123.456", GraphQLFloat) == 123.456
+        assert _value_from('"abc123"', GraphQLString) == "abc123"
+        assert _value_from("123456", GraphQLID) == "123456"
+        assert _value_from('"123456"', GraphQLID) == "123456"
 
     def does_not_convert_when_input_coercion_rules_reject_a_value():
-        _test_case(GraphQLBoolean, "123", Undefined)
-        _test_case(GraphQLInt, "123.456", Undefined)
-        _test_case(GraphQLInt, "true", Undefined)
-        _test_case(GraphQLInt, '"123"', Undefined)
-        _test_case(GraphQLFloat, '"123"', Undefined)
-        _test_case(GraphQLString, "123", Undefined)
-        _test_case(GraphQLString, "true", Undefined)
-        _test_case(GraphQLID, "123.456", Undefined)
-
-    test_enum = GraphQLEnumType(
-        "TestColor",
-        {
-            "RED": 1,
-            "GREEN": 2,
-            "BLUE": 3,
-            "NULL": None,
-            "NAN": nan,
-            "NO_CUSTOM_VALUE": Undefined,
-        },
-    )
+        assert _value_from("123", GraphQLBoolean) is Undefined
+        assert _value_from("123.456", GraphQLInt) is Undefined
+        assert _value_from("true", GraphQLInt) is Undefined
+        assert _value_from('"123"', GraphQLInt) is Undefined
+        assert _value_from('"123"', GraphQLFloat) is Undefined
+        assert _value_from("123", GraphQLString) is Undefined
+        assert _value_from("true", GraphQLString) is Undefined
+        assert _value_from("123.456", GraphQLID) is Undefined
 
     def converts_enum_values_according_to_input_coercion_rules():
-        _test_case(test_enum, "RED", 1)
-        _test_case(test_enum, "BLUE", 3)
-        _test_case(test_enum, "YELLOW", Undefined)
-        _test_case(test_enum, "3", Undefined)
-        _test_case(test_enum, '"BLUE"', Undefined)
-        _test_case(test_enum, "null", None)
-        _test_case(test_enum, "NULL", None)
-        _test_case(test_enum, "NAN", nan)
-        _test_case(test_enum, "NO_CUSTOM_VALUE", Undefined)
+        test_enum = GraphQLEnumType(
+            "TestColor",
+            {
+                "RED": 1,
+                "GREEN": 2,
+                "BLUE": 3,
+                "NULL": None,
+                "NAN": nan,
+                "NO_CUSTOM_VALUE": Undefined,
+            },
+        )
+
+        assert _value_from("RED", test_enum) == 1
+        assert _value_from("BLUE", test_enum) == 3
+        assert _value_from("YELLOW", test_enum) is Undefined
+        assert _value_from("3", test_enum) is Undefined
+        assert _value_from('"BLUE"', test_enum) is Undefined
+        assert _value_from("null", test_enum) is None
+        assert _value_from("NULL", test_enum) is None
+        assert isnan(_value_from("NAN", test_enum))
+        assert _value_from("NO_CUSTOM_VALUE", test_enum) is Undefined
 
     # Boolean!
     non_null_bool = GraphQLNonNull(GraphQLBoolean)
@@ -89,41 +81,44 @@ def converts_enum_values_according_to_input_coercion_rules():
     non_null_list_of_non_mull_bool = GraphQLNonNull(list_of_non_null_bool)
 
     def coerces_to_null_unless_non_null():
-        _test_case(GraphQLBoolean, "null", None)
-        _test_case(non_null_bool, "null", Undefined)
+        assert _value_from("null", GraphQLBoolean) is None
+        assert _value_from("null", non_null_bool) is Undefined
 
     def coerces_lists_of_values():
-        _test_case(list_of_bool, "true", [True])
-        _test_case(list_of_bool, "123", Undefined)
-        _test_case(list_of_bool, "null", None)
-        _test_case(list_of_bool, "[true, false]", [True, False])
-        _test_case(list_of_bool, "[true, 123]", Undefined)
-        _test_case(list_of_bool, "[true, null]", [True, None])
-        _test_case(list_of_bool, "{ true: true }", Undefined)
+        assert _value_from("true", list_of_bool) == [True]
+        assert _value_from("123", list_of_bool) is Undefined
+        assert _value_from("null", list_of_bool) is None
+        assert _value_from("[true, false]", list_of_bool) == [True, False]
+        assert _value_from("[true, 123]", list_of_bool) is Undefined
+        assert _value_from("[true, null]", list_of_bool) == [True, None]
+        assert _value_from("{ true: true }", list_of_bool) is Undefined
 
     def coerces_non_null_lists_of_values():
-        _test_case(non_null_list_of_bool, "true", [True])
-        _test_case(non_null_list_of_bool, "123", Undefined)
-        _test_case(non_null_list_of_bool, "null", Undefined)
-        _test_case(non_null_list_of_bool, "[true, false]", [True, False])
-        _test_case(non_null_list_of_bool, "[true, 123]", Undefined)
-        _test_case(non_null_list_of_bool, "[true, null]", [True, None])
+        assert _value_from("true", non_null_list_of_bool) == [True]
+        assert _value_from("123", non_null_list_of_bool) is Undefined
+        assert _value_from("null", non_null_list_of_bool) is Undefined
+        assert _value_from("[true, false]", non_null_list_of_bool) == [True, False]
+        assert _value_from("[true, 123]", non_null_list_of_bool) is Undefined
+        assert _value_from("[true, null]", non_null_list_of_bool) == [True, None]
 
     def coerces_lists_of_non_null_values():
-        _test_case(list_of_non_null_bool, "true", [True])
-        _test_case(list_of_non_null_bool, "123", Undefined)
-        _test_case(list_of_non_null_bool, "null", None)
-        _test_case(list_of_non_null_bool, "[true, false]", [True, False])
-        _test_case(list_of_non_null_bool, "[true, 123]", Undefined)
-        _test_case(list_of_non_null_bool, "[true, null]", Undefined)
+        assert _value_from("true", list_of_non_null_bool) == [True]
+        assert _value_from("123", list_of_non_null_bool) is Undefined
+        assert _value_from("null", list_of_non_null_bool) is None
+        assert _value_from("[true, false]", list_of_non_null_bool) == [True, False]
+        assert _value_from("[true, 123]", list_of_non_null_bool) is Undefined
+        assert _value_from("[true, null]", list_of_non_null_bool) is Undefined
 
     def coerces_non_null_lists_of_non_null_values():
-        _test_case(non_null_list_of_non_mull_bool, "true", [True])
-        _test_case(non_null_list_of_non_mull_bool, "123", Undefined)
-        _test_case(non_null_list_of_non_mull_bool, "null", Undefined)
-        _test_case(non_null_list_of_non_mull_bool, "[true, false]", [True, False])
-        _test_case(non_null_list_of_non_mull_bool, "[true, 123]", Undefined)
-        _test_case(non_null_list_of_non_mull_bool, "[true, null]", Undefined)
+        assert _value_from("true", non_null_list_of_non_mull_bool) == [True]
+        assert _value_from("123", non_null_list_of_non_mull_bool) is Undefined
+        assert _value_from("null", non_null_list_of_non_mull_bool) is Undefined
+        assert _value_from("[true, false]", non_null_list_of_non_mull_bool) == [
+            True,
+            False,
+        ]
+        assert _value_from("[true, 123]", non_null_list_of_non_mull_bool) is Undefined
+        assert _value_from("[true, null]", non_null_list_of_non_mull_bool) is Undefined
 
     test_input_obj = GraphQLInputObjectType(
         "TestInput",
@@ -135,51 +130,48 @@ def coerces_non_null_lists_of_non_null_values():
     )
 
     def coerces_input_objects_according_to_input_coercion_rules():
-        _test_case(test_input_obj, "null", None)
-        _test_case(test_input_obj, "123", Undefined)
-        _test_case(test_input_obj, "[]", Undefined)
-        _test_case(
-            test_input_obj,
-            "{ int: 123, requiredBool: false }",
-            {"int": 123, "requiredBool": False},
-        )
-        _test_case(
-            test_input_obj,
-            "{ bool: true, requiredBool: false }",
-            {"int": 42, "bool": True, "requiredBool": False},
+        assert _value_from("null", test_input_obj) is None
+        assert _value_from("[]", test_input_obj) is Undefined
+        assert _value_from("123", test_input_obj) is Undefined
+        assert _value_from("{ int: 123, requiredBool: false }", test_input_obj) == {
+            "int": 123,
+            "requiredBool": False,
+        }
+        assert _value_from("{ bool: true, requiredBool: false }", test_input_obj) == {
+            "int": 42,
+            "bool": True,
+            "requiredBool": False,
+        }
+        assert (
+            _value_from("{ int: true, requiredBool: true }", test_input_obj)
+            is Undefined
         )
-        _test_case(test_input_obj, "{ int: true, requiredBool: true }", Undefined)
-        _test_case(test_input_obj, "{ requiredBool: null }", Undefined)
-        _test_case(test_input_obj, "{ bool: true }", Undefined)
+        assert _value_from("{ requiredBool: null }", test_input_obj) is Undefined
+        assert _value_from("{ bool: true }", test_input_obj) is Undefined
 
     def accepts_variable_values_assuming_already_coerced():
-        _test_case_with_vars({}, GraphQLBoolean, "$var", Undefined)
-        _test_case_with_vars({"var": True}, GraphQLBoolean, "$var", True)
-        _test_case_with_vars({"var": None}, GraphQLBoolean, "$var", None)
+        assert _value_from("$var", GraphQLBoolean, {}) is Undefined
+        assert _value_from("$var", GraphQLBoolean, {"var": True}) is True
+        assert _value_from("$var", GraphQLBoolean, {"var": None}) is None
 
     def asserts_variables_are_provided_as_items_in_lists():
-        _test_case_with_vars({}, list_of_bool, "[ $foo ]", [None])
-        _test_case_with_vars({}, list_of_non_null_bool, "[ $foo ]", Undefined)
-        _test_case_with_vars({"foo": True}, list_of_non_null_bool, "[ $foo ]", [True])
+        assert _value_from("[ $foo ]", list_of_bool, {}) == [None]
+        assert _value_from("[ $foo ]", list_of_non_null_bool, {}) is Undefined
+        assert _value_from("[ $foo ]", list_of_non_null_bool, {"foo": True}) == [True]
         # Note: variables are expected to have already been coerced, so we
         # do not expect the singleton wrapping behavior for variables.
-        _test_case_with_vars({"foo": True}, list_of_non_null_bool, "$foo", True)
-        _test_case_with_vars({"foo": [True]}, list_of_non_null_bool, "$foo", [True])
+        assert _value_from("$foo", list_of_non_null_bool, {"foo": True}) is True
+        assert _value_from("$foo", list_of_non_null_bool, {"foo": [True]}) == [True]
 
     def omits_input_object_fields_for_unprovided_variables():
-        _test_case_with_vars(
-            {},
-            test_input_obj,
-            "{ int: $foo, bool: $foo, requiredBool: true }",
-            {"int": 42, "requiredBool": True},
-        )
-        _test_case_with_vars({}, test_input_obj, "{ requiredBool: $foo }", Undefined)
-        _test_case_with_vars(
-            {"foo": True},
-            test_input_obj,
-            "{ requiredBool: $foo }",
-            {"int": 42, "requiredBool": True},
-        )
+        assert _value_from(
+            "{ int: $foo, bool: $foo, requiredBool: true }", test_input_obj, {}
+        ) == {"int": 42, "requiredBool": True}
+        assert _value_from("{ requiredBool: $foo }", test_input_obj, {}) is Undefined
+        assert _value_from("{ requiredBool: $foo }", test_input_obj, {"foo": True}) == {
+            "int": 42,
+            "requiredBool": True,
+        }
 
     def transforms_names_using_out_name():
         # This is an extension of GraphQL.js.
@@ -192,9 +184,10 @@ def transforms_names_using_out_name():
                 ),
             },
         )
-        _test_case(
-            complex_input_obj, "{ realPart: 1 }", {"real_part": 1, "imag_part": 0}
-        )
+        assert _value_from("{ realPart: 1 }", complex_input_obj) == {
+            "real_part": 1,
+            "imag_part": 0,
+        }
 
     def transforms_values_with_out_type():
         # This is an extension of GraphQL.js.
@@ -206,4 +199,4 @@ def transforms_values_with_out_type():
             },
             out_type=lambda value: complex(value["real"], value["imag"]),
         )
-        _test_case(complex_input_obj, "{ real: 1, imag: 2 }", 1 + 2j)
+        assert _value_from("{ real: 1, imag: 2 }", complex_input_obj) == 1 + 2j