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___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_parser_node_nodefield___call___with_a_parent(): from tartiflette.parser.nodes.field import NodeField 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 = None exectx = Mock() reqctx = Mock() prm = {} await nf(exectx, reqctx, parent_marshalled=prm) assert nf.marshalled == {} assert prm["B"] == coerced
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
def test_parser_node_nodefield__get_coroutz_from_child_no_cond(): from tartiflette.parser.nodes.field import NodeField nf = NodeField("NtM", None, None, None, None, None, None) child = Mock() child.type_condition = None exectx = Mock() reqctx = Mock() result = Mock() coerce = Mock() nf.children = [child, child, child] crtz = nf._get_coroutz_from_child(exectx, reqctx, result, coerce, None) assert len(crtz) == 3 assert child.call_args_list == [ ( (exectx, reqctx), {"parent_result": result, "parent_marshalled": coerce}, ), ( (exectx, reqctx), {"parent_result": result, "parent_marshalled": coerce}, ), ( (exectx, reqctx), {"parent_result": result, "parent_marshalled": coerce}, ), ]
def test_parser_node_nodefield(): from tartiflette.parser.nodes.field import NodeField nf = NodeField("Roberto", None, None, None, [], None, None) assert nf.name == "Roberto" assert nf.alias == "Roberto" nf = NodeField("Roberto", None, None, None, [], None, "James") assert nf.name == "Roberto" assert nf.alias == "James"
def test_parser_node_nodefield_shall_produce_list(value): from tartiflette.parser.nodes.field import NodeField fe = Mock() fe.shall_produce_list = value nf = NodeField("Rb", None, fe, None, None, None, None) assert nf.shall_produce_list == value
def test_parser_node_nodefield_contains_not_null(value): from tartiflette.parser.nodes.field import NodeField fe = Mock() fe.contains_not_null = value nf = NodeField("Rb", None, fe, None, None, None, None) assert nf.contains_not_null == value
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": [], }
def _on_field_in( self, element: _VisitorElementField, *_args, type_cond_depth: int = -1, directives: List[Dict[str, Any]] = None, **_kwargs, ) -> None: # pylint: disable=too-many-locals type_cond = self._internal_ctx.compute_type_cond(type_cond_depth) parent_type = self._get_parent_type(self._internal_ctx.node) try: field = self.schema.get_field_by_name( str(parent_type) + "." + element.name) except UnknownSchemaFieldResolver as e: try: if type_cond is None: raise field = self.schema.get_field_by_name( str(type_cond) + "." + element.name) except UnknownSchemaFieldResolver as e: e.path = self._internal_ctx.field_path[:] + [element.name] e.locations = [element.get_location()] self._add_exception(e) return if field.is_leaf and element.get_selection_set_size() > 0: self._add_exception( NotAnObjectType( message= f"field < {field.name} > is a leaf and thus can't have a selection set", path=self._internal_ctx.field_path[:] + [element.name], locations=[element.get_location()], )) return if not field.is_leaf and element.get_selection_set_size() < 1: self._add_exception( NotALeafType( message= f"field < {field.name} > is not a leaf and thus must have a selection set", path=self._internal_ctx.field_path[:] + [element.name], locations=[element.get_location()], )) return self._internal_ctx.move_in_field(element, field) node = NodeField( element.name, self.schema, field.resolver, element.get_location(), self._internal_ctx.field_path[:], type_cond, element.get_alias(), subscribe=field.subscribe, ) if self._internal_ctx.inline_fragment_info: for (directive ) in self._internal_ctx.inline_fragment_info.directives: node.add_directive(directive) if directives: for directive in directives: node.add_directive(directive) node.set_parent(self._internal_ctx.node) if self._internal_ctx.node: self._internal_ctx.node.add_child(node) self._internal_ctx.node = node if self._internal_ctx.depth == 1: self.operations[self._internal_ctx.operation.name].children.append( node)
def test_parser_node_nodefield_bubble_error(): from tartiflette.parser.nodes.field import NodeField fe = Mock() fe.cant_be_null = False nf = NodeField("Rb", None, fe, None, None, None, None) nf.marshalled = {} nf.parent = None nf.bubble_error() assert nf.marshalled is None nf.marshalled = {} nf.parent = Mock() nf.parent.marshalled = {"Rb": "Lol"} nf.parent.bubble_error = Mock() nf.bubble_error() assert "Rb" in nf.parent.marshalled assert nf.parent.marshalled["Rb"] is None fe.cant_be_null = True nf.bubble_error() assert nf.parent.bubble_error.called nf.parent = None nf.marshalled = {} nf.bubble_error() assert nf.marshalled is None