test_variables.py

from __future__ import annotations

import gc
import weakref
from importlib import import_module
from math import nan
from typing import Any

import pytest

from graphql import graphql_sync
from graphql.error import GraphQLError
from graphql.execution import ExecutionResult, execute_sync
from graphql.execution.values import get_variable_values, input_is_nested_too_deeply
from graphql.language import OperationDefinitionNode, StringValueNode, ValueNode, parse
from graphql.language.parser import MAX_NESTING_DEPTH
from graphql.pyutils import Undefined
from graphql.type import (
    GraphQLArgument,
    GraphQLDefaultInput,
    GraphQLEnumType,
    GraphQLEnumValue,
    GraphQLField,
    GraphQLFloat,
    GraphQLInputField,
    GraphQLInputObjectType,
    GraphQLInt,
    GraphQLList,
    GraphQLNonNull,
    GraphQLObjectType,
    GraphQLScalarType,
    GraphQLSchema,
    GraphQLString,
)
from graphql.utilities import build_schema
from graphql.utilities.value_from_ast_untyped import value_from_ast_untyped


def make_faulty_scalar_error() -> GraphQLError:
    # Note: unlike GraphQL.js, a fresh error is raised on each call. The runtime
    # argument-coercion fallback now mutates the error message in place, so a
    # shared singleton would otherwise leak the mutated message into other tests
    # (test order is randomized).
    return GraphQLError(
        "FaultyScalarErrorMessage", extensions={"code": "FaultyScalarExtensionCode"}
    )


def faulty_coerce_input_value(_value: str) -> str:
    raise make_faulty_scalar_error()


def faulty_coerce_input_literal(_ast: ValueNode) -> str:
    raise make_faulty_scalar_error()


TestFaultyScalar = GraphQLScalarType(
    name="FaultyScalar",
    coerce_input_value=faulty_coerce_input_value,
    coerce_input_literal=faulty_coerce_input_literal,
)


def coerce_complex_input_value(value: str) -> str:
    assert value == "ExternalValue"
    return "InternalValue"


def coerce_input_literal_value(ast: ValueNode) -> str:
    assert isinstance(ast, StringValueNode)
    assert ast.value == "ExternalValue"
    return coerce_complex_input_value(ast.value)


TestComplexScalar = GraphQLScalarType(
    name="ComplexScalar",
    coerce_input_value=coerce_complex_input_value,
    coerce_input_literal=coerce_input_literal_value,
)


def coerce_json_input_value(value: Any) -> Any:
    return value


def coerce_json_input_literal(value: ValueNode) -> Any:
    return value_from_ast_untyped(value)


TestJSONScalar = GraphQLScalarType(
    name="JSONScalar",
    coerce_input_value=coerce_json_input_value,
    coerce_input_literal=coerce_json_input_literal,
)


TestInputObject = GraphQLInputObjectType(
    "TestInputObject",
    {
        "a": GraphQLInputField(GraphQLString),
        "b": GraphQLInputField(GraphQLList(GraphQLString)),
        "c": GraphQLInputField(GraphQLNonNull(GraphQLString)),
        "d": GraphQLInputField(TestComplexScalar),
        "e": GraphQLInputField(TestFaultyScalar),
    },
)

TestCustomInputObject = GraphQLInputObjectType(
    "TestCustomInputObject",
    {"x": GraphQLInputField(GraphQLFloat), "y": GraphQLInputField(GraphQLFloat)},
    out_type=lambda value: f"(x|y) = ({value['x']}|{value['y']})",
)


TestOneOfInputObject = GraphQLInputObjectType(
    "TestOneOfInputObject",
    {
        "a": GraphQLInputField(GraphQLString),
        "b": GraphQLInputField(GraphQLString),
    },
    is_one_of=True,
)


TestNestedInputObject = GraphQLInputObjectType(
    "TestNestedInputObject",
    {
        "na": GraphQLInputField(GraphQLNonNull(TestInputObject)),
        "nb": GraphQLInputField(GraphQLNonNull(GraphQLString)),
    },
)


TestEnum = GraphQLEnumType(
    "TestEnum",
    {
        "NULL": None,
        "UNDEFINED": Undefined,
        "NAN": nan,
        "FALSE": False,
        "CUSTOM": "custom value",
        "DEFAULT_VALUE": GraphQLEnumValue(),
    },
)


def field_with_input_arg(input_arg: GraphQLArgument):
    return GraphQLField(
        GraphQLString,
        args={"input": input_arg},
        resolve=lambda _obj, _info, **args: (
            repr(args["input"]) if "input" in args else None
        ),
    )


NestedType = GraphQLObjectType(
    "NestedType",
    {
        "echo": field_with_input_arg(GraphQLArgument(GraphQLString)),
    },
)


TestType = GraphQLObjectType(
    "TestType",
    {
        "fieldWithEnumInput": field_with_input_arg(GraphQLArgument(TestEnum)),
        "fieldWithNonNullableEnumInput": field_with_input_arg(
            GraphQLArgument(GraphQLNonNull(TestEnum))
        ),
        "fieldWithObjectInput": field_with_input_arg(GraphQLArgument(TestInputObject)),
        "fieldWithOneOfObjectInput": field_with_input_arg(
            GraphQLArgument(TestOneOfInputObject)
        ),
        "fieldWithCustomObjectInput": field_with_input_arg(
            GraphQLArgument(TestCustomInputObject)
        ),
        "fieldWithNullableStringInput": field_with_input_arg(
            GraphQLArgument(GraphQLString)
        ),
        "fieldWithNonNullableStringInput": field_with_input_arg(
            GraphQLArgument(GraphQLNonNull(GraphQLString))
        ),
        "fieldWithDefaultArgumentValue": field_with_input_arg(
            GraphQLArgument(
                GraphQLString, default=GraphQLDefaultInput(value="Hello World")
            )
        ),
        "fieldWithNonNullableStringInputAndDefaultArgValue": field_with_input_arg(
            GraphQLArgument(
                GraphQLNonNull(GraphQLString),
                default=GraphQLDefaultInput(value="Hello World"),
            )
        ),
        "fieldWithNestedInputObject": field_with_input_arg(
            GraphQLArgument(TestNestedInputObject)
        ),
        "fieldWithJSONScalarInput": field_with_input_arg(
            GraphQLArgument(TestJSONScalar)
        ),
        "nested": GraphQLField(NestedType, resolve=lambda *_args: {}),
        "list": field_with_input_arg(GraphQLArgument(GraphQLList(GraphQLString))),
        "nnList": field_with_input_arg(
            GraphQLArgument(GraphQLNonNull(GraphQLList(GraphQLString)))
        ),
        "listNN": field_with_input_arg(
            GraphQLArgument(GraphQLList(GraphQLNonNull(GraphQLString)))
        ),
        "nnListNN": field_with_input_arg(
            GraphQLArgument(GraphQLNonNull(GraphQLList(GraphQLNonNull(GraphQLString))))
        ),
    },
)

TestTypeWithInvalidDefaultArgumentValue = GraphQLObjectType(
    "TestTypeWithInvalidDefaultArgumentValue",
    {
        "fieldWithInvalidDefaultArgumentValue": field_with_input_arg(
            GraphQLArgument(GraphQLString, default=GraphQLDefaultInput(value=123))
        ),
    },
)

TestTypeWithInvalidNestedDefaultArgumentValue = GraphQLObjectType(
    "TestTypeWithInvalidNestedDefaultArgumentValue",
    {
        "fieldWithInvalidNestedDefaultArgumentValue": field_with_input_arg(
            GraphQLArgument(
                GraphQLInputObjectType(
                    "InputWithInvalidNestedFieldDefault",
                    {
                        "foo": GraphQLInputField(
                            GraphQLString,
                            default=GraphQLDefaultInput(value=123),
                        )
                    },
                ),
                default=GraphQLDefaultInput(value={}),
            )
        ),
    },
)

schema = GraphQLSchema(TestType)


def execute_query(
    query: str, variable_values: dict[str, Any] | None = None
) -> ExecutionResult:
    document = parse(query)
    return execute_sync(schema, document, variable_values=variable_values)


def execute_query_with_fragment_arguments(
    query: str, variable_values: dict[str, Any] | None = None
) -> ExecutionResult:
    document = parse(query, experimental_fragment_arguments=True)
    return execute_sync(schema, document, variable_values=variable_values)


def describe_execute_handles_inputs():
    def describe_handles_objects_and_nullability():
        def describe_using_inline_struct():
            def executes_with_complex_input():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(
                        input: {a: "foo", b: ["bar"], c: "baz"})
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": "{'a': 'foo', 'b': ['bar'], 'c': 'baz'}"},
                    None,
                )

            def executes_with_custom_input():
                # This is an extension of GraphQL.js.
                result = execute_query(
                    """
                    {
                      fieldWithCustomObjectInput(
                        input: {x: -3.0, y: 4.5})
                    }
                    """
                )

                assert result == (
                    {"fieldWithCustomObjectInput": "'(x|y) = (-3.0|4.5)'"},
                    None,
                )

            def properly_parses_single_value_to_list():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(input: {a: "foo", b: "bar", c: "baz"})
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": "{'a': 'foo', 'b': ['bar'], 'c': 'baz'}"},
                    None,
                )

            def properly_parses_null_value_to_null():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(
                        input: {a: null, b: null, c: "C", d: null})
                    }
                    """
                )

                assert result == (
                    {
                        "fieldWithObjectInput": "{'a': None, 'b': None,"
                        " 'c': 'C', 'd': None}"
                    },
                    None,
                )

            def properly_parses_null_value_in_list():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(input: {b: ["A",null,"C"], c: "C"})
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": "{'b': ['A', None, 'C'], 'c': 'C'}"},
                    None,
                )

            def does_not_use_incorrect_value():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(input: ["foo", "bar", "baz"])
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": None},
                    [
                        {
                            "message": "Argument 'input' has invalid value:"
                            " Expected value of type 'TestInputObject'"
                            ' to be an object, found: ["foo", "bar", "baz"].',
                            "path": ["fieldWithObjectInput"],
                            "locations": [(3, 51)],
                        }
                    ],
                )

            def properly_runs_coerce_input_literal_on_complex_scalar_types():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(input: {c: "foo", d: "ExternalValue"})
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": "{'c': 'foo', 'd': 'InternalValue'}"},
                    None,
                )

            def errors_on_faulty_scalar_type_input():
                result = execute_query(
                    """
                    {
                      fieldWithObjectInput(input: {c: "foo", e: "bar"})
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": None},
                    [
                        {
                            "message": "Argument 'input' has invalid value at .e:"
                            " FaultyScalarErrorMessage",
                            "path": ["fieldWithObjectInput"],
                            "locations": [(3, 23)],
                            "extensions": {"code": "FaultyScalarExtensionCode"},
                        }
                    ],
                )

        def describe_using_variables():
            doc = """
                query ($input: TestInputObject) {
                  fieldWithObjectInput(input: $input)
                }
                """

            def executes_with_complex_input():
                params = {"input": {"a": "foo", "b": ["bar"], "c": "baz"}}
                result = execute_query(doc, params)

                assert result == (
                    {"fieldWithObjectInput": "{'a': 'foo', 'b': ['bar'], 'c': 'baz'}"},
                    None,
                )

            def uses_undefined_when_variable_not_provided():
                result = execute_query(
                    """
                    query q($input: String) {
                      fieldWithNullableStringInput(input: $input)
                    }
                    """,
                    {},
                )  # Intentionally missing variable values.

                assert result == ({"fieldWithNullableStringInput": None}, None)

            def uses_null_when_variable_provided_explicit_null_value():
                result = execute_query(
                    """
                    query q($input: String) {
                      fieldWithNullableStringInput(input: $input)
                    }
                    """,
                    {"input": None},
                )

                assert result == ({"fieldWithNullableStringInput": "None"}, None)

            def preserves_explicit_null_variables_within_input_object_literals():
                result = execute_query(
                    """
                    query q($input: String) {
                      fieldWithObjectInput(input: { a: $input, c: "baz" })
                    }
                    """,
                    {"input": None},
                )

                assert result == (
                    {"fieldWithObjectInput": "{'a': None, 'c': 'baz'}"},
                    None,
                )

            def uses_default_value_when_not_provided():
                result = execute_query(
                    """
                    query ($input: TestInputObject = {
                      a: "foo", b: ["bar"], c: "baz"}) {
                        fieldWithObjectInput(input: $input)
                    }
                    """
                )

                assert result == (
                    {"fieldWithObjectInput": "{'a': 'foo', 'b': ['bar'], 'c': 'baz'}"},
                    None,
                )

            def reports_invalid_default_values_with_variable_definition_locations():
                result = execute_query(
                    "query ($input: String = 123)"
                    " { fieldWithNullableStringInput(input: $input) }"
                )

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid default value:"
                            " String cannot represent a non string value: 123",
                            "locations": [(1, 8)],
                        }
                    ],
                )

            def includes_suggestions_for_invalid_default_values():
                result = execute_sync(
                    schema,
                    parse(
                        'query ($input: TestInputObject = { c: "ok", aa: "x" })'
                        " { fieldWithObjectInput(input: $input) }"
                    ),
                )

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid default value:"
                            " Expected value of type 'TestInputObject' not to include"
                            " unknown field 'aa'. Did you mean 'a'?"
                            ' Found: { c: "ok", aa: "x" }.',
                            "locations": [(1, 8)],
                        }
                    ],
                )

            def hides_suggestions_for_invalid_default_values_when_specified():
                result = execute_sync(
                    schema,
                    parse(
                        'query ($input: TestInputObject = { c: "ok", aa: "x" })'
                        " { fieldWithObjectInput(input: $input) }"
                    ),
                    hide_suggestions=True,
                )

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid default value:"
                            " Expected value of type 'TestInputObject' not to include"
                            " unknown field 'aa',"
                            ' found: { c: "ok", aa: "x" }.',
                            "locations": [(1, 8)],
                        }
                    ],
                )

            def does_not_use_default_value_when_provided():
                result = execute_query(
                    """
                    query q($input: String = "Default value") {
                      fieldWithNullableStringInput(input: $input)
                    }
                    """,
                    {"input": "Variable value"},
                )

                assert result == (
                    {"fieldWithNullableStringInput": "'Variable value'"},
                    None,
                )

            def uses_explicit_null_value_instead_of_default_value():
                result = execute_query(
                    """
                    query q($input: String = "Default value") {
                      fieldWithNullableStringInput(input: $input)
                    }
                    """,
                    {"input": None},
                )

                assert result == ({"fieldWithNullableStringInput": "None"}, None)

            def treats_explicitly_undefined_variable_values_as_omitted():
                result = execute_query(
                    """
                    query q($input: String = "Default value") {
                      fieldWithNullableStringInput(input: $input)
                    }
                    """,
                    {"input": Undefined},
                )

                assert result == (
                    {"fieldWithNullableStringInput": "'Default value'"},
                    None,
                )

            def uses_null_default_value_when_not_provided():
                result = execute_query(
                    """
                    query q($input: String = null) {
                      fieldWithNullableStringInput(input: $input)
                    }
                    """,
                    {},
                )  # Intentionally missing variable values.

                assert result == ({"fieldWithNullableStringInput": "None"}, None)

            def properly_parses_single_value_to_list():
                params = {"input": {"a": "foo", "b": "bar", "c": "baz"}}
                result = execute_query(doc, params)

                assert result == (
                    {"fieldWithObjectInput": "{'a': 'foo', 'b': ['bar'], 'c': 'baz'}"},
                    None,
                )

            def executes_with_complex_scalar_input():
                params = {"input": {"c": "foo", "d": "ExternalValue"}}
                result = execute_query(doc, params)

                assert result == (
                    {"fieldWithObjectInput": "{'c': 'foo', 'd': 'InternalValue'}"},
                    None,
                )

            def errors_on_faulty_scalar_type_input():
                params = {"input": {"c": "foo", "e": "ExternalValue"}}
                result = execute_query(doc, params)

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid value at .e:"
                            " FaultyScalarErrorMessage",
                            "locations": [(2, 24)],
                            "extensions": {"code": "FaultyScalarExtensionCode"},
                        }
                    ],
                )

            def errors_on_null_for_nested_non_null():
                params = {"input": {"a": "foo", "b": "bar", "c": None}}
                result = execute_query(doc, params)

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid value at .c:"
                            " Expected value of non-null type 'String!'"
                            " not to be None.",
                            "locations": [(2, 24)],
                        }
                    ],
                )

            def errors_on_incorrect_type():
                result = execute_query(doc, {"input": "foo bar"})

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid value:"
                            " Expected value of type 'TestInputObject'"
                            " to be an object, found: 'foo bar'.",
                            "locations": [(2, 24)],
                            "path": None,
                        }
                    ],
                )

            def errors_on_omission_of_nested_non_null():
                result = execute_query(doc, {"input": {"a": "foo", "b": "bar"}})

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid value:"
                            " Expected value of type 'TestInputObject'"
                            " to include required field 'c',"
                            " found: {'a': 'foo', 'b': 'bar'}.",
                            "locations": [(2, 24)],
                        }
                    ],
                )

            def errors_on_deep_nested_errors_and_with_many_errors():
                nested_doc = """
                    query ($input: TestNestedInputObject) {
                      fieldWithNestedObjectInput(input: $input)
                    }
                    """
                result = execute_query(nested_doc, {"input": {"na": {"a": "foo"}}})

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid value at .na:"
                            " Expected value of type 'TestInputObject'"
                            " to include required field 'c',"
                            " found: {'a': 'foo'}.",
                            "locations": [(2, 28)],
                        },
                        {
                            "message": "Variable '$input' has invalid value:"
                            " Expected value of type 'TestNestedInputObject'"
                            " to include required field 'nb',"
                            " found: {'na': {'a': 'foo'}}.",
                            "locations": [(2, 28)],
                        },
                    ],
                )

            def errors_on_addition_of_unknown_input_field():
                params = {"input": {"a": "foo", "b": "bar", "c": "baz", "extra": "dog"}}
                result = execute_query(doc, params)

                assert result == (
                    None,
                    [
                        {
                            "message": "Variable '$input' has invalid value:"
                            " Expected value of type 'TestInputObject'"
                            " not to include unknown field 'extra', found:"
                            " {'a': 'foo', 'b': 'bar', 'c': 'baz', 'extra': 'dog'}.",
                            "locations": [(2, 24)],
                        }
                    ],
                )

    def describe_handles_custom_enum_values():
        def allows_custom_enum_values_as_inputs():
            result = execute_query(
                """
                {
                  null: fieldWithEnumInput(input: NULL)
                  NaN: fieldWithEnumInput(input: NAN)
                  false: fieldWithEnumInput(input: FALSE)
                  customValue: fieldWithEnumInput(input: CUSTOM)
                  defaultValue: fieldWithEnumInput(input: DEFAULT_VALUE)
                }
                """
            )

            assert result == (
                {
                    "null": "None",
                    "NaN": "nan",
                    "false": "False",
                    "customValue": "'custom value'",
                    # different from graphql.js, enum values are always wrapped
                    "defaultValue": "None",
                },
                None,
            )

        def allows_non_nullable_inputs_to_have_null_as_enum_custom_value():
            result = execute_query(
                """
                {
                   fieldWithNonNullableEnumInput(input: NULL)
                }
                """
            )

            assert result == ({"fieldWithNonNullableEnumInput": "None"}, None)

    def describe_handles_nullable_scalars():
        def allows_nullable_inputs_to_be_omitted():
            result = execute_query(
                """
                {
                  fieldWithNullableStringInput
                }
                """
            )

            assert result == ({"fieldWithNullableStringInput": None}, None)

        def allows_nullable_inputs_to_be_omitted_in_a_variable():
            result = execute_query(
                """
                query ($value: String) {
                  fieldWithNullableStringInput(input: $value)
                }
                """
            )

            assert result == ({"fieldWithNullableStringInput": None}, None)

        def allows_nullable_inputs_to_be_omitted_in_an_unlisted_variable():
            result = execute_query(
                """
                query SetsNullable {
                  fieldWithNullableStringInput(input: $value)
                }
                """
            )

            assert result == ({"fieldWithNullableStringInput": None}, None)

        def allows_nullable_inputs_to_be_set_to_null_in_a_variable():
            doc = """
                query SetsNullable($value: String) {
                  fieldWithNullableStringInput(input: $value)
                }
                """
            result = execute_query(doc, {"value": None})

            assert result == ({"fieldWithNullableStringInput": "None"}, None)

        def allows_nullable_inputs_to_be_set_to_a_value_in_a_variable():
            doc = """
                query SetsNullable($value: String) {
                  fieldWithNullableStringInput(input: $value)
                }
                """
            result = execute_query(doc, {"value": "a"})

            assert result == ({"fieldWithNullableStringInput": "'a'"}, None)

        def allows_nullable_inputs_to_be_set_to_a_value_directly():
            result = execute_query(
                """
                {
                  fieldWithNullableStringInput(input: "a")
                }
                """
            )

            assert result == ({"fieldWithNullableStringInput": "'a'"}, None)

    def describe_handles_non_nullable_scalars():
        def allows_non_nullable_variable_to_be_omitted_given_a_default():
            result = execute_query(
                """
                query ($value: String! = "default") {
                  fieldWithNullableStringInput(input: $value)
                }
                """
            )

            assert result == ({"fieldWithNullableStringInput": "'default'"}, None)

        def allows_non_nullable_inputs_to_be_omitted_given_a_default():
            result = execute_query(
                """
                query ($value: String = "default") {
                  fieldWithNonNullableStringInput(input: $value)
                }
                """
            )

            assert result == ({"fieldWithNonNullableStringInput": "'default'"}, None)

        def does_not_allow_non_nullable_inputs_to_be_omitted_in_a_variable():
            result = execute_query(
                """
                query ($value: String!) {
                  fieldWithNonNullableStringInput(input: $value)
                }
                """
            )

            assert result == (
                None,
                [
                    {
                        "message": "Variable '$value' has invalid value:"
                        " Expected a value of non-null type 'String!'"
                        " to be provided.",
                        "locations": [(2, 24)],
                        "path": None,
                    }
                ],
            )

        def does_not_allow_non_nullable_inputs_to_be_set_to_null_in_variable():
            doc = """
                query ($value: String!) {
                  fieldWithNonNullableStringInput(input: $value)
                }
                """
            result = execute_query(doc, {"value": None})

            assert result == (
                None,
                [
                    {
                        "message": "Variable '$value' has invalid value:"
                        " Expected value of non-null type 'String!'"
                        " not to be None.",
                        "locations": [(2, 24)],
                        "path": None,
                    }
                ],
            )

        def allows_non_nullable_inputs_to_be_set_to_a_value_in_a_variable():
            doc = """
                query ($value: String!) {
                  fieldWithNonNullableStringInput(input: $value)
                }
                """
            result = execute_query(doc, {"value": "a"})

            assert result == ({"fieldWithNonNullableStringInput": "'a'"}, None)

        def allows_non_nullable_inputs_to_be_set_to_a_value_directly():
            result = execute_query(
                """
                {
                  fieldWithNonNullableStringInput(input: "a")
                }
                """
            )

            assert result == ({"fieldWithNonNullableStringInput": "'a'"}, None)

        def reports_error_for_missing_non_nullable_inputs():
            result = execute_query("{ fieldWithNonNullableStringInput }")

            assert result == (
                {"fieldWithNonNullableStringInput": None},
                [
                    {
                        "message": "Argument 'input' of required type 'String!'"
                        " was not provided.",
                        "locations": [(1, 3)],
                        "path": ["fieldWithNonNullableStringInput"],
                    }
                ],
            )

        def reports_error_for_array_passed_into_string_input():
            doc = """
                query ($value: String!) {
                  fieldWithNonNullableStringInput(input: $value)
                }
                """
            result = execute_query(doc, {"value": [1, 2, 3]})

            assert result == (
                None,
                [
                    {
                        "message": "Variable '$value' has invalid value:"
                        " String cannot represent a non string value: [1, 2, 3]",
                        "locations": [(2, 24)],
                        "path": None,
                    }
                ],
            )

            errors = result.errors
            assert errors
            assert errors[0].original_error

        def reports_error_for_non_provided_variables_for_non_nullable_inputs():
            # Note: this test would typically fail validation before
            # encountering this execution error, however for queries which
            # previously validated and are being run against a new schema which
            # have introduced a breaking change to make a formerly non-required
            # argument required, this asserts failure before allowing the
            # underlying code to receive a non-null value.
            result = execute_query(
                """
                {
                  fieldWithNonNullableStringInput(input: $foo)
                }
                """
            )

            assert result == (
                {"fieldWithNonNullableStringInput": None},
                [
                    {
                        "message": "Argument 'input' has invalid value:"
                        " Expected variable '$foo' provided to type 'String!'"
                        " to provide a runtime value.",
                        "locations": [(3, 58)],
                        "path": ["fieldWithNonNullableStringInput"],
                    }
                ],
            )

    # Note: the below is non-specified custom graphql-core behavior.
    def describe_handles_custom_scalars_with_embedded_variables():
        expected = "{'a': 'foo', 'b': ['bar'], 'c': 'baz'}"

        def allows_custom_scalars():
            result = execute_query(
                """
                {
                  fieldWithJSONScalarInput(input: { a: "foo", b: ["bar"], c: "baz" })
                }
                """
            )

            assert result == ({"fieldWithJSONScalarInput": expected}, None)

        def allows_custom_scalars_with_non_embedded_variables():
            result = execute_query(
                """
                query ($input: JSONScalar) {
                  fieldWithJSONScalarInput(input: $input)
                }
                """,
                {"input": {"a": "foo", "b": ["bar"], "c": "baz"}},
            )

            assert result == ({"fieldWithJSONScalarInput": expected}, None)

        def allows_custom_scalars_with_embedded_operation_variables():
            result = execute_query(
                """
                query ($input: String) {
                  fieldWithJSONScalarInput(input: { a: $input, b: ["bar"], c: "baz" })