async def test_parser_node_nodefield___call___fe_is_excepting():
from tartiflette.parser.nodes.field import NodeField
from tests.unit.utils import AsyncMock
raw = Exception("ninja")
coerced = None
class fex:
async def __call__(self, *_, **__):
return raw, coerced
fe = fex()
fe.schema_field = Mock()
fe.cant_be_null = True
nf = NodeField("B", None, fe, None, None, None, None)
nf.children = [Mock()]
nf._execute_children = AsyncMock()
nf.parent = Mock()
nf.parent.bubble_error = Mock()
exectx = Mock()
exectx.add_error = Mock()
reqctx = Mock()
prm = {}
await nf(exectx, reqctx, parent_marshalled=prm)
assert nf.marshalled == {}
assert prm["B"] == coerced
assert nf.parent.bubble_error.called
assert exectx.add_error.called
async def test_parser_node_nodefield__execute_children_a_list():
from tartiflette.parser.nodes.field import NodeField
from tests.unit.utils import AsyncMock
exectx = Mock()
reqctx = Mock()
result = [Mock(), Mock()]
coerce = [Mock(), Mock()]
fe = Mock()
fe.shall_produce_list = True
child = AsyncMock()
child.type_condition = None
nf = NodeField("NtM", None, fe, None, None, None, None)
nf.children = [child]
await nf._execute_children(exectx, reqctx, result, coerce)
assert child.called
assert (
(exectx, reqctx),
{"parent_result": result[0], "parent_marshalled": coerce[0]},
) in child.call_args_list
assert (
(exectx, reqctx),
{"parent_result": result[1], "parent_marshalled": coerce[1]},
) in child.call_args_list
async def test_parser_node_nodefield___call___with_children():
from tartiflette.parser.nodes.field import NodeField
from tests.unit.utils import AsyncMock
raw = Mock()
coerced = Mock()
class fex:
async def __call__(self, *_, **__):
return raw, coerced
fe = fex()
fe.schema_field = Mock()
nf = NodeField("B", None, fe, None, None, None, None)
nf.children = [Mock()]
nf._execute_children = AsyncMock()
exectx = Mock()
reqctx = Mock()
prm = {}
await nf(exectx, reqctx, parent_marshalled=prm)
assert nf.marshalled == {}
assert prm["B"] == coerced
assert nf._execute_children.called
assert nf._execute_children.call_args == (
(exectx, reqctx),
{"result": raw, "coerced": coerced},
)
async def test_utils_coercers__list_coercer_is_alist():
from tartiflette.utils.coercer import _list_coercer
func = AsyncMock(return_value="a")
info = Mock()
ctx = {}
assert await _list_coercer(func, ["r", "d"], ctx, info) == ["a", "a"]
assert func.call_args_list == [(("r", ctx, info), ), (("d", ctx, info), )]
async def test_utils_coercers__not_null_coercer_none_value():
from tartiflette.utils.coercer import _not_null_coercer
from tartiflette.types.exceptions.tartiflette import NullError
func = AsyncMock(return_value="a")
info = Mock()
with pytest.raises(NullError):
assert await _not_null_coercer(func, None, None, {}, info)
assert func.called is False
async def test_utils_coercers__not_null_coercer():
from tartiflette.utils.coercer import _not_null_coercer
func = AsyncMock(return_value="a")
info = Mock()
ctx = {}
fldd = Mock()
assert await _not_null_coercer(func, "T", fldd, ctx, info) == "a"
assert func.call_args_list == [(("T", fldd, ctx, info), )]
async def test_utils_coercers__enum_coercer():
from tartiflette.utils.coercer import _enum_coercer
a = AsyncMock(return_value="TopTop")
info = Mock()
ctx = {}
fldd = Mock()
assert await _enum_coercer([4], a, 4, fldd, ctx, info) == "TopTop"
assert a.call_args_list == [((4, fldd, ctx, info), )]
async def test_parser_node_nodefield__call__custom_exception():
from tartiflette.parser.nodes.field import NodeField
from tests.unit.utils import AsyncMock
class CustomException(Exception):
def coerce_value(self, *_args, path=None, locations=None, **_kwargs):
return {"msg": "error", "type": "bad_request"}
raw = CustomException("ninja")
coerced = None
class fex:
async def __call__(self, *_, **__):
return raw, coerced
fe = fex()
fe.schema_field = Mock()
fe.cant_be_null = True
nf = NodeField("B", None, fe, None, None, None, None)
nf.children = [Mock()]
nf._execute_children = AsyncMock()
nf.parent = Mock()
nf.parent.bubble_error = Mock()
exectx = ExecutionContext()
reqctx = Mock()
prm = {}
assert not bool(exectx.errors)
await nf(exectx, reqctx, parent_marshalled=prm)
assert bool(exectx.errors)
assert exectx.errors[0] is raw
assert exectx.errors[0].coerce_value() == {
"msg": "error",
"type": "bad_request",
}
async def test_parser_node_nodefield__call__exception():
from tartiflette.parser.nodes.field import NodeField
from tests.unit.utils import AsyncMock
raw = Exception("ninja")
coerced = None
class fex:
async def __call__(self, *_, **__):
return raw, coerced
fe = fex()
fe.schema_field = Mock()
fe.cant_be_null = True
nf = NodeField("B", None, fe, None, None, None, None)
nf.children = [Mock()]
nf._execute_children = AsyncMock()
nf.parent = Mock()
nf.parent.bubble_error = Mock()
exectx = ExecutionContext()
reqctx = Mock()
prm = {}
assert not bool(exectx.errors)
await nf(exectx, reqctx, parent_marshalled=prm)
assert bool(exectx.errors)
assert exectx.errors[0] is not raw
assert isinstance(exectx.errors[0], GraphQLError)
assert exectx.errors[0].coerce_value() == {
"message": "ninja",
"path": None,
"locations": [],
}
async def test_utils_coercers__list_coercer_none_val():
from tartiflette.utils.coercer import _list_coercer
func = AsyncMock(return_value="a")
assert await _list_coercer(func, None, None) is None
assert func.called is False
