def test_filter_filterset_related_results(): class ReporterFilterNode(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) filter_fields = { 'first_name': ['icontains'] } class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterFilterNode) r1 = Reporter.objects.create(first_name='A test user', last_name='Last Name', email='*****@*****.**') r2 = Reporter.objects.create(first_name='Other test user', last_name='Other Last Name', email='*****@*****.**') r3 = Reporter.objects.create(first_name='Random', last_name='RandomLast', email='*****@*****.**') query = ''' query { allReporters(firstName_Icontains: "test") { edges { node { id } } } } ''' schema = Schema(query=Query) result = schema.execute(query) assert not result.errors # We should only get two reporters assert len(result.data['allReporters']['edges']) == 2
def test_filter_filterset_information_on_meta_related(): class ReporterFilterNode(DjangoNode): class Meta: model = Reporter filter_fields = ['first_name', 'articles'] filter_order_by = True class ArticleFilterNode(DjangoNode): class Meta: model = Article filter_fields = ['headline', 'reporter'] filter_order_by = True class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterFilterNode) all_articles = DjangoFilterConnectionField(ArticleFilterNode) reporter = NodeField(ReporterFilterNode) article = NodeField(ArticleFilterNode) schema = Schema(query=Query) schema.schema # Trigger the schema loading articles_field = schema.get_type('ReporterFilterNode')._meta.fields_map['articles'] assert_arguments(articles_field, 'headline', 'reporter') assert_orderable(articles_field)
def test_schema_register(): schema = Schema(name="My own schema") @schema.register class MyType(ObjectType): type = StringField(resolve=lambda *_: "Dog") assert schema.get_type("MyType") == MyType
def test_should_query_filter_node_double_limit_raises(): class ReporterFilter(FilterSet): limit = NumberFilter(method='filter_limit') def filter_limit(self, queryset, name, value): return queryset[:value] class Meta: model = Reporter fields = ['first_name', ] class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) class Query(ObjectType): all_reporters = DjangoFilterConnectionField( ReporterType, filterset_class=ReporterFilter ) def resolve_all_reporters(self, args, context, info): return Reporter.objects.order_by('a_choice')[:2] Reporter.objects.create( first_name='Bob', last_name='Doe', email='*****@*****.**', a_choice=2 ) r = Reporter.objects.create( first_name='John', last_name='Doe', email='*****@*****.**', a_choice=1 ) schema = Schema(query=Query) query = ''' query NodeFilteringQuery { allReporters(limit: 1) { edges { node { id firstName } } } } ''' result = schema.execute(query) assert len(result.errors) == 1 assert str(result.errors[0]) == ( 'Received two sliced querysets (high mark) in the connection, please slice only in one.' )
def test_schema_register_no_query_type(): schema = Schema(name="My own schema") @schema.register class MyType(ObjectType): type = String(resolver=lambda *_: "Dog") with raises(Exception) as excinfo: schema.get_type("MyType") assert "base query type" in str(excinfo.value)
def test_schema_introspect(): schema = Schema(name='My own schema') class MyType(ObjectType): type = String(resolver=lambda *_: 'Dog') schema.query = MyType introspection = schema.introspect() assert '__schema' in introspection
def test_schema_register_no_query_type(): schema = Schema(name='My own schema') @schema.register class MyType(ObjectType): type = String(resolver=lambda *_: 'Dog') with raises(Exception) as excinfo: schema.get_type('MyType') assert 'base query type' in str(excinfo.value)
def test_schema_register(): schema = Schema(name='My own schema') @schema.register class MyType(ObjectType): type = String(resolver=lambda *_: 'Dog') schema.query = MyType assert schema.get_type('MyType') == MyType
def test_schema_introspect(): schema = Schema(name="My own schema") class MyType(ObjectType): type = String(resolver=lambda *_: "Dog") schema.query = MyType introspection = schema.introspect() assert "__schema" in introspection
def test_lazytype(): schema = Schema(name='My own schema') t = LazyType('MyType') @schema.register class MyType(ObjectType): type = String(resolver=lambda *_: 'Dog') schema.query = MyType assert schema.T(t) == schema.T(MyType)
def test_lazytype(): schema = Schema(name="My own schema") t = LazyType("MyType") @schema.register class MyType(ObjectType): type = String(resolver=lambda *_: "Dog") schema.query = MyType assert schema.T(t) == schema.T(MyType)
def test_schema_register_interfaces(): class Query(ObjectType): f = Field(Character) def resolve_f(self, args, info): return Human() schema = Schema(query=Query) schema.register(Human) result = schema.execute("{ f { name } }") assert not result.errors
def test_filter_filterset_related_results(): class ReporterFilterNode(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) filter_fields = ['first_name', 'articles'] filter_order_by = True class ArticleFilterNode(DjangoObjectType): class Meta: interfaces = (Node, ) model = Article filter_fields = ['headline', 'reporter'] filter_order_by = True class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterFilterNode) all_articles = DjangoFilterConnectionField(ArticleFilterNode) reporter = Field(ReporterFilterNode) article = Field(ArticleFilterNode) r1 = Reporter.objects.create(first_name='r1', last_name='r1', email='*****@*****.**') r2 = Reporter.objects.create(first_name='r2', last_name='r2', email='*****@*****.**') Article.objects.create(headline='a1', pub_date=datetime.now(), reporter=r1) Article.objects.create(headline='a2', pub_date=datetime.now(), reporter=r2) query = ''' query { allReporters { edges { node { articles { edges { node { headline } } } } } } } ''' schema = Schema(query=Query) result = schema.execute(query) assert not result.errors # We should only get back a single article for each reporter assert len(result.data['allReporters']['edges'][0]['node']['articles']['edges']) == 1 assert len(result.data['allReporters']['edges'][1]['node']['articles']['edges']) == 1
def test_auto_camelcase_off(): schema = Schema(name="My own schema", auto_camelcase=False) class Query(ObjectType): test_field = String(resolver=lambda *_: "Dog") schema.query = Query query = "query {test_field}" expected = {"test_field": "Dog"} result = graphql(schema.schema, query, root_value=Query(object())) assert not result.errors assert result.data == expected
def test_get_session(): session = 'My SQLAlchemy session' class Query(ObjectType): x = String() def resolve_x(self, args, context, info): return get_session(context) query = ''' query ReporterQuery { x } ''' schema = Schema(query=Query) result = schema.execute(query, context_value={'session': session}) assert not result.errors assert result.data['x'] == session
def test_get_session(): session = "My SQLAlchemy session" schema = Schema(session=session) class Query(ObjectType): x = String() def resolve_x(self, args, info): return get_session(info) query = """ query ReporterQuery { x } """ schema = Schema(query=Query, session=session) result = schema.execute(query) assert not result.errors assert result.data["x"] == session
import graphene from graphene import ObjectType, Schema class QueryRoot(ObjectType): test = graphene.String(who=graphene.String()) def resolve_test(self, info): return "Hello World" schema = Schema(query=QueryRoot)
from invana_engine.server.schemas.query import Gremlin from graphene import Schema import json import os schema = Schema(query=Gremlin) class TestGraphQuery: @staticmethod def test_create_vertex(): # label = "Planet" # properties = json.dumps({ # "name": "Earth", # "human_population": "a lot" # }) results = schema.execute(""" query { vertexCreate(properties: "{\\"name\\": \\"Earth\\"}", label: "Planet") } """) print("results", results) # assert results.data == {"vertexCreate": "{\"name\": \"Earth\"}"}
from graphene import ObjectType, Schema, String class Query(ObjectType): hello = String(required=True, name=String()) hello2 = String(required=True, name=String(default_value='World')) def resolve_hello(parent, info, **kwargs): name = kwargs.get('name', 'World') return f'Hello, {name}!' def resolve_hello2(parent, info, name): return f'Hello2, {name}!' schema = Schema(query=Query) query_string = ''' query { hello hello2 } ''' result = schema.execute(query_string) print(result.data['hello']) print(result.data['hello2'])
from graphene import ObjectType, String, Schema from .schemas.character_schema import Query as QueryCharacter, Mutation as MutationCharacter from .schemas.planet_schema import Query as QueryPlanet, Mutation as MutationPlanet from .schemas.productor_schema import Query as QueryProductor, Mutation as MutationProductor from .schemas.movie_schema import Query as QueryMovie, Mutation as MutationMovie from .schemas.auth_schema import Mutation as AuthMutation class Query(QueryCharacter, QueryPlanet, QueryProductor, QueryMovie): pass class Mutation(AuthMutation, MutationCharacter, MutationPlanet, MutationProductor, MutationMovie): pass ROOT_SCHEMA = Schema(query=Query, mutation=Mutation)
def test_should_query_filter_node_limit(): class ReporterFilter(FilterSet): limit = NumberFilter(method='filter_limit') def filter_limit(self, queryset, name, value): return queryset[:value] class Meta: model = Reporter fields = [ 'first_name', ] class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) class ArticleType(DjangoObjectType): class Meta: model = Article interfaces = (Node, ) filter_fields = ('lang', ) class Query(ObjectType): all_reporters = DjangoFilterConnectionField( ReporterType, filterset_class=ReporterFilter) def resolve_all_reporters(self, info, **args): return Reporter.objects.order_by('a_choice') Reporter.objects.create(first_name='Bob', last_name='Doe', email='*****@*****.**', a_choice=2) r = Reporter.objects.create(first_name='John', last_name='Doe', email='*****@*****.**', a_choice=1) Article.objects.create(headline='Article Node 1', pub_date=datetime.now(), pub_date_time=datetime.now(), reporter=r, editor=r, lang='es') Article.objects.create(headline='Article Node 2', pub_date=datetime.now(), pub_date_time=datetime.now(), reporter=r, editor=r, lang='en') schema = Schema(query=Query) query = ''' query NodeFilteringQuery { allReporters(limit: 1) { edges { node { id firstName articles(lang: "es") { edges { node { id lang } } } } } } } ''' expected = { 'allReporters': { 'edges': [{ 'node': { 'id': 'UmVwb3J0ZXJUeXBlOjI=', 'firstName': 'John', 'articles': { 'edges': [{ 'node': { 'id': 'QXJ0aWNsZVR5cGU6MQ==', 'lang': 'ES' } }] } } }] } } result = schema.execute(query) assert not result.errors assert result.data == expected
# -*- coding: utf-8 -*- from graphene import ObjectType, Schema, relay from main import schema as main class Query(main.Query, ObjectType): """ Main Query class that inherits from Query classes of all other Django apps. """ node = relay.Node.Field() schema = Schema(query=Query)
import api.user.schema import api.trip.schema from graphene import Schema class Mutation(api.user.schema.Mutation, api.trip.schema.Mutation): """Root for politico Graphql queries""" pass class Query(api.user.schema.Query, api.trip.schema.Query): """Root for converge Graphql queries""" pass schema = Schema(mutation=Mutation, query=Query)
# external imports from graphene import ObjectType, Schema, resolve_only_args, List, String # local imports from .query import Query # create the schema based on the query object schema = Schema(name='Product Schema', auto_camelcase=False) schema.query = Query
from flask_restful import Api, Resource from flask_cors import CORS from flask_graphql import GraphQLView from graphene import Schema from resources.election import ElectionList from resources.region import RegionList from resources.constituency import Constituency from resources.candidate import Candidate from graphql_api.schema import Query import tenderServiceRunner TENDER_DATA_FILE = 'common/dataSource/rawData/tenderRepository' tenderServiceRunner.initTenderService(TENDER_DATA_FILE) app = Flask(__name__) api = Api(app) CORS(app) api.add_resource(ElectionList, '/elections') api.add_resource(RegionList, '/<string:electionName>/<int:year>/regions') api.add_resource( Constituency, '/<string:electionName>/<int:year>/constituencies/<string:id>') api.add_resource(Candidate, '/<string:electionName>/<int:year>/candidates/<int:id>') app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=Schema(Query), graphiql=True))
from graphene import Schema from .auto import schema_operations_builder ALL_QUERIES = schema_operations_builder(operationName='Query', operationModule='query', operationBase='BaseQuery', clsName='Query') schema = Schema(query=ALL_QUERIES)
def test_int_in_filter(): """ Test in filter on an integer field. """ Pet.objects.create(name="Brutus", age=12) Pet.objects.create(name="Mimi", age=3) Pet.objects.create(name="Jojo, the rabbit", age=3) schema = Schema(query=Query) query = """ query { pets (age_In: [3]) { edges { node { name } } } } """ result = schema.execute(query) assert not result.errors assert result.data["pets"]["edges"] == [ { "node": { "name": "Mimi" } }, { "node": { "name": "Jojo, the rabbit" } }, ] query = """ query { pets (age_In: [3, 12]) { edges { node { name } } } } """ result = schema.execute(query) assert not result.errors assert result.data["pets"]["edges"] == [ { "node": { "name": "Brutus" } }, { "node": { "name": "Mimi" } }, { "node": { "name": "Jojo, the rabbit" } }, ]
class Query(ObjectType): getListOfPapers = List(Paper, search_query=String(required=True), max_results=Int(required=True), start=Int(required=True), sort_by=String(required=False), sort_order=String(required=False)) def resolve_getListOfPapers(self, info, search_query, max_results, start, sort_by, sort_order): entries = arxiv.query(search_query=search_query, id_list=[], max_results=max_results, start=start, sort_by=sort_by, sort_order=sort_order) return json2obj(json.dumps(entries)) getPaper = Field(Paper, id=ID(required=True)) def resolve_getPaper(self, info, id): entry = arxiv.query(id_list=[id]) return json2obj(json.dumps(entry))[0] my_schema = Schema( query=Query, types=[Paper, TitleDetail, ArxivPrimaryCategory, Tag, AuthorDetail])
# class DocumentMutations(ObjectType): """Document mutations""" create_document = CreateDocument.Field() import_document = ImportDocument.Field() update_document = UpdateDocument.Field() delete_document = DeleteDocument.Field() # # Document GraphQL schema # schema = Schema(query=DocumentQuery, mutation=DocumentMutations) @view_config(route_name=GRAPHQL_API_ROUTE, renderer='json', require_csrf=False) def graphql_view(request): """GraphQL API view""" query = request.json_body.get('query') if not query: raise HTTPBadRequest("Missing request") result = schema.execute(query, context=request, variables=request.json_body.get('variables')) if result.errors: raise HTTPBadRequest(', '.join( (str(error) for error in result.errors))) return result.data
# type: ignore # pylint: disable=no-self-argument import asyncio from datetime import datetime from graphene import ObjectType, String, Schema, Field # All schema require a query. class Query(ObjectType): hello = String() def resolve_hello(root, info): return 'Hello, world!' class Subscription(ObjectType): time = Field(String) async def subscribe_time(root, info): while True: yield datetime.now().isoformat() await asyncio.sleep(1) SCHEMA = Schema(query=Query, subscription=Subscription)
def test_filter_filterset_based_on_mixin(): class ArticleFilterMixin(FilterSet): @classmethod def get_filters(cls): filters = super(FilterSet, cls).get_filters() filters.update({ "viewer__email__in": django_filters.CharFilter(method="filter_email_in", field_name="reporter__email__in") }) return filters def filter_email_in(cls, queryset, name, value): return queryset.filter(**{name: [value]}) class NewArticleFilter(ArticleFilterMixin, ArticleFilter): pass class NewReporterNode(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) class NewArticleFilterNode(DjangoObjectType): viewer = Field(NewReporterNode) class Meta: model = Article interfaces = (Node, ) filterset_class = NewArticleFilter def resolve_viewer(self, info): return self.reporter class Query(ObjectType): all_articles = DjangoFilterConnectionField(NewArticleFilterNode) reporter_1 = Reporter.objects.create(first_name="John", last_name="Doe", email="*****@*****.**") article_1 = Article.objects.create( headline="Hello", reporter=reporter_1, editor=reporter_1, pub_date=datetime.now(), pub_date_time=datetime.now(), ) reporter_2 = Reporter.objects.create(first_name="Adam", last_name="Doe", email="*****@*****.**") article_2 = Article.objects.create( headline="Good Bye", reporter=reporter_2, editor=reporter_2, pub_date=datetime.now(), pub_date_time=datetime.now(), ) schema = Schema(query=Query) query = (""" query NodeFilteringQuery { allArticles(viewer_Email_In: "%s") { edges { node { headline viewer { email } } } } } """ % reporter_1.email) expected = { "allArticles": { "edges": [{ "node": { "headline": article_1.headline, "viewer": { "email": reporter_1.email }, } }] } } result = schema.execute(query) assert not result.errors assert result.data == expected
from graphene import ObjectType, String, Schema import json class Query(ObjectType): # this defines a Field `hello` in our Schema with a single Argument `name` hello = String(name=String(default_value="stranger")) goodbye = String() # our Resolver method takes the GraphQL context (root, info) as well as # Argument (name) for the Field and returns data for the query Response def resolve_hello(root, info, name): return f'Hello {name}!' def resolve_goodbye(root, info): return 'See ya!' schema = Schema(query=Query) result = schema.execute(''' { hello($name) goodbye } ''', variables={'name': 'Payal'}) items = dict(result.data.items()) print(json.dumps(items, indent=4))
class AssayResultsType(DjangoObjectType): class Meta: model = AssayResult fields = "__all__" class Header(ObjectType): name = String() verbose_name = String() class Query(ObjectType): compounds = List(CompoundsType) headers = List(Header) assay_results = List(AssayResultsType, compound_id=ID(), target=String(), result=String()) def resolve_compounds(self, info, **args): return Compound.objects.filter(**args) def resolve_assay_results(self, info, **args): return AssayResult.objects.filter(**args) def resolve_headers(self, info): fields = Compound._meta.get_fields() list = [] for field in fields: if hasattr(field, 'verbose_name'): header = Header(field.name, field.verbose_name) list.append(header) return list schema = Schema(query=Query, auto_camelcase=False)
def test_order_by_is_perserved(): class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) filter_fields = () class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterType, reverse_order=Boolean()) def resolve_all_reporters(self, info, reverse_order=False, **args): reporters = Reporter.objects.order_by('first_name') if reverse_order: return reporters.reverse() return reporters Reporter.objects.create(first_name='b', ) r = Reporter.objects.create(first_name='a', ) schema = Schema(query=Query) query = ''' query NodeFilteringQuery { allReporters(first: 1) { edges { node { firstName } } } } ''' expected = { 'allReporters': { 'edges': [{ 'node': { 'firstName': 'a', } }] } } result = schema.execute(query) assert not result.errors assert result.data == expected reverse_query = ''' query NodeFilteringQuery { allReporters(first: 1, reverseOrder: true) { edges { node { firstName } } } } ''' reverse_expected = { 'allReporters': { 'edges': [{ 'node': { 'firstName': 'b', } }] } } reverse_result = schema.execute(reverse_query) assert not reverse_result.errors assert reverse_result.data == reverse_expected
def test_should_query_filter_node_limit(): class ReporterFilter(FilterSet): limit = NumberFilter(method="filter_limit") def filter_limit(self, queryset, name, value): return queryset[:value] class Meta: model = Reporter fields = ["first_name"] class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) class ArticleType(DjangoObjectType): class Meta: model = Article interfaces = (Node, ) filter_fields = ("lang", ) class Query(ObjectType): all_reporters = DjangoFilterConnectionField( ReporterType, filterset_class=ReporterFilter) def resolve_all_reporters(self, info, **args): return Reporter.objects.order_by("a_choice") Reporter.objects.create(first_name="Bob", last_name="Doe", email="*****@*****.**", a_choice=2) r = Reporter.objects.create(first_name="John", last_name="Doe", email="*****@*****.**", a_choice=1) Article.objects.create( headline="Article Node 1", pub_date=datetime.now(), pub_date_time=datetime.now(), reporter=r, editor=r, lang="es", ) Article.objects.create( headline="Article Node 2", pub_date=datetime.now(), pub_date_time=datetime.now(), reporter=r, editor=r, lang="en", ) schema = Schema(query=Query) query = """ query NodeFilteringQuery { allReporters(limit: 1) { edges { node { id firstName articles(lang: "es") { edges { node { id lang } } } } } } } """ expected = { "allReporters": { "edges": [{ "node": { "id": "UmVwb3J0ZXJUeXBlOjI=", "firstName": "John", "articles": { "edges": [{ "node": { "id": "QXJ0aWNsZVR5cGU6MQ==", "lang": "ES" } }] }, } }] } } result = schema.execute(query) assert not result.errors assert result.data == expected
pet = graphene.Field(AllowAnyPetNode) status = graphene.Int() @classmethod def mutate_and_get_payload(cls, root, info, **input): if cls.has_permission(root, info, input): owner = User.objects.get(pk=from_global_id(input['owner'])[1]) pet = Pet.objects.create(name=input['name'], race=input['race'], owner=owner) return AddPet(pet=pet, status=HTTPStatus.CREATED) return AddPet(pet=None, status=HTTPStatus.BAD_REQUEST) class PetsMutation: superuser_add_pet = SuperUserAddPet.Field() staff_add_pet = StaffAddPet.Field() authenticated_add_pet = AuthenticatedAddPet.Field() add_pet = AddPet.Field() class Query(PetsQuery, ObjectType): pass class Mutation(PetsMutation, ObjectType): pass schema = Schema(query=Query, mutation=Mutation)
def test_order_by(): class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) class Query(ObjectType): all_reporters = DjangoFilterConnectionField( ReporterType, filterset_class=ReporterFilter) Reporter.objects.create(first_name="b") Reporter.objects.create(first_name="a") schema = Schema(query=Query) query = """ query NodeFilteringQuery { allReporters(orderBy: "-firstName") { edges { node { firstName } } } } """ expected = { "allReporters": { "edges": [{ "node": { "firstName": "b" } }, { "node": { "firstName": "a" } }] } } result = schema.execute(query) assert not result.errors assert result.data == expected query = """ query NodeFilteringQuery { allReporters(orderBy: "-first_name") { edges { node { firstName } } } } """ result = schema.execute(query) assert not result.errors assert result.data == expected query = """ query NodeFilteringQuery { allReporters(orderBy: "-firtsnaMe") { edges { node { firstName } } } } """ result = schema.execute(query) assert result.errors
abstract = True class Article(DjangoObjectType): """Article description""" class Meta: model = ArticleModel interfaces = (Node, ) connection_class = ArticleConnection class RootQuery(ObjectType): node = Node.Field() schema = Schema(query=RootQuery, types=[Article, Reporter]) def test_django_interface(): assert issubclass(Node, Interface) assert issubclass(Node, Node) @patch("graphene_django.tests.models.Article.objects.get", return_value=Article(id=1)) def test_django_get_node(get): article = Article.get_node(None, 1) get.assert_called_with(pk=1) assert article.id == 1
from graphql import graphql from py.test import raises from promise import is_thenable from graphene import Interface, List, ObjectType, Schema, String from graphene.core.fields import Field from graphene.core.types.base import LazyType from tests.utils import assert_equal_lists schema = Schema(name="My own schema") class Character(Interface): name = String() class Pet(ObjectType): type = String(resolver=lambda *_: "Dog") class Human(Character): friends = List(Character) pet = Field(Pet) def resolve_name(self, *args): return "Peter" def resolve_friend(self, *args): return Human(object()) def resolve_pet(self, *args):
def test_get_permissions__conditional_list__requires_returned_permissions( self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class UpdateCatMutation(DjangoUpdateMutation): class Meta: model = Cat @classmethod def get_permissions(cls, root, info, id, input, *args, **kwargs): owner_id = int(disambiguate_id(input["owner"])) if info.context.user.id == owner_id: return [] return ["tests.change_cat"] class Mutations(graphene.ObjectType): update_cat = UpdateCatMutation.Field() user = UserFactory.create() new_cat_owner = UserFactory.create() cat = CatFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation UpdateCat( $id: ID!, $input: UpdateCatInput! ){ updateCat(id: $id, input: $input){ cat{ id } } } """ result = schema.execute(mutation, variables={ "id": to_global_id("CatNode", cat.id), "input": { "name": "Name", "owner": to_global_id("UserNode", new_cat_owner.id) } }, context=Dict(user=user)) self.assertEqual(len(result.errors), 1) result = schema.execute(mutation, variables={ "id": to_global_id("CatNode", cat.id), "input": { "name": "Name", "owner": to_global_id("UserNode", new_cat_owner.id) } }, context=Dict(user=new_cat_owner)) self.assertIsNone(result.errors)
def test_many_to_many_extras__add_extra_by_input__adds_by_input(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class CreateCatMutation(DjangoCreateMutation): class Meta: model = Cat class UpdateDogMutation(DjangoUpdateMutation): class Meta: model = Dog many_to_many_extras = { "enemies": { "exact": { "type": "CreateCatInput" } } } class Mutations(graphene.ObjectType): create_cat = CreateCatMutation.Field() update_dog = UpdateDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() # Create some enemies cats = CatFactory.create_batch(5) self.assertEqual(dog.enemies.all().count(), 0) schema = Schema(mutation=Mutations) mutation = """ mutation UpdateDog( $id: ID!, $input: UpdateDogInput! ){ updateDog(id: $id, input: $input){ dog{ id } } } """ result = schema.execute(mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "tag": "tag", "breed": "HUSKY", "owner": to_global_id("UserNode", user.id), "enemies": [{ "name": cat.name, "owner": cat.owner.id } for cat in cats] } }, context=Dict(user=user)) self.assertIsNone(result.errors) dog.refresh_from_db() self.assertEqual(dog.enemies.all().count(), 5)
def test_should_query_filter_node_limit(): class ReporterFilter(FilterSet): limit = NumberFilter(method='filter_limit') def filter_limit(self, queryset, name, value): return queryset[:value] class Meta: model = Reporter fields = ['first_name', ] class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) class ArticleType(DjangoObjectType): class Meta: model = Article interfaces = (Node, ) filter_fields = ('lang', ) class Query(ObjectType): all_reporters = DjangoFilterConnectionField( ReporterType, filterset_class=ReporterFilter ) def resolve_all_reporters(self, args, context, info): return Reporter.objects.order_by('a_choice') Reporter.objects.create( first_name='Bob', last_name='Doe', email='*****@*****.**', a_choice=2 ) r = Reporter.objects.create( first_name='John', last_name='Doe', email='*****@*****.**', a_choice=1 ) Article.objects.create( headline='Article Node 1', pub_date=datetime.now(), reporter=r, editor=r, lang='es' ) Article.objects.create( headline='Article Node 2', pub_date=datetime.now(), reporter=r, editor=r, lang='en' ) schema = Schema(query=Query) query = ''' query NodeFilteringQuery { allReporters(limit: 1) { edges { node { id firstName articles(lang: "es") { edges { node { id lang } } } } } } } ''' expected = { 'allReporters': { 'edges': [{ 'node': { 'id': 'UmVwb3J0ZXJUeXBlOjI=', 'firstName': 'John', 'articles': { 'edges': [{ 'node': { 'id': 'QXJ0aWNsZVR5cGU6MQ==', 'lang': 'ES' } }] } } }] } } result = schema.execute(query) assert not result.errors assert result.data == expected
from graphene import ObjectType, Schema from graphene.relay import NodeField from graphene.contrib.sqlalchemy import SQLAlchemyNode, \ SQLAlchemyConnectionField from test_graphene import models schema = Schema() @schema.register class Note(SQLAlchemyNode): class Meta: model = models.Note class Query(ObjectType): node = NodeField() all_notes = SQLAlchemyConnectionField(Note) schema.query = Query if __name__ == "__main__": import sys import json if len(sys.argv) > 1 and sys.argv[1] == "--json": print(json.dumps(schema.introspect(), indent=2)) else: print(schema)
def test_order_by_is_perserved(): class ReporterType(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) filter_fields = () class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterType, reverse_order=Boolean()) def resolve_all_reporters(self, info, reverse_order=False, **args): reporters = Reporter.objects.order_by("first_name") if reverse_order: return reporters.reverse() return reporters Reporter.objects.create(first_name="b") Reporter.objects.create(first_name="a") schema = Schema(query=Query) query = """ query NodeFilteringQuery { allReporters(first: 1) { edges { node { firstName } } } } """ expected = {"allReporters": {"edges": [{"node": {"firstName": "a"}}]}} result = schema.execute(query) assert not result.errors assert result.data == expected reverse_query = """ query NodeFilteringQuery { allReporters(first: 1, reverseOrder: true) { edges { node { firstName } } } } """ reverse_expected = { "allReporters": { "edges": [{ "node": { "firstName": "b" } }] } } reverse_result = schema.execute(reverse_query) assert not reverse_result.errors assert reverse_result.data == reverse_expected
from graphene import ObjectType, Schema, String from app.modules.news.mutations import NewsMutation from app.modules.news.queries import NewsQuery from app.modules.users.mutations import UserMutation from app.modules.users.queries import UserQuery class RootQuery(NewsQuery, ObjectType): pass class RootMutation(NewsMutation, ObjectType): pass schema = Schema(query=RootQuery, mutation=RootMutation)
set = List(String, description=sstrip(''' Set the value of a Jinja2 template variable in the workflow definition. Values should be valid Python literals so strings must be quoted e.g. `STR="string"`, `INT=43`, `BOOL=True`. This option can be used multiple times on the command line. NOTE: these settings persist across workflow restarts, but can be set again on the `cylc play` command line if they need to be overridden. ''')) set_file = String(description=sstrip(''' Set the value of Jinja2 template variables in the workflow definition from a file containing NAME=VALUE pairs (one per line). As with "set" values should be valid Python literals so strings must be quoted e.g. `STR='string'`. NOTE: these settings persist across workflow restarts, but can be set again on the `cylc play` command line if they need to be overridden. ''')) result = GenericScalar() class UISMutations(Mutations): play = _mut_field(Play) schema = Schema(query=Queries, subscription=Subscriptions, mutation=UISMutations)
from graphene import Schema from .query import Query from .mutation import Mutations from .cart.types import Address from .product.types import Product schema = Schema(query=Query, mutation=Mutations, types=[Product, Address])
# external imports from nautilus import APIGateway from graphene import Schema, ObjectType, String, Mutation, Boolean, Field from nautilus.api import ServiceObjectType from nautilus.api.fields import Connection from nautilus.network import dispatch_action from nautilus.conventions import getCRUDAction # local imports from .recipes import service as RecipeService from .ingredients import service as IngredientService # create the schema based on the query object schema = Schema(name='Product Schema') ## define the schema that encapsulates the cloud class Recipe(ServiceObjectType): class Meta: service = RecipeService # connections are resolved/joined using the appropriate connection service # you can avoid circular/undefined references using strings - nautilus will look # for the corresponding ServiceObjectType ingredients = Connection('Ingredient', description='The ingredients in this recipe.') class Ingredient(ServiceObjectType):
url = '{}v3/internal-reservation/{}'.format(_LEGACY_BASE_URL, reservation_id) req = Request(url=url, headers={'X-INTERNAL-API-KEY': _LEGACY_KEY}, app=app) reservation = req.get() return Reservation(code_hash=reservation['code_hash'], beds=reservation['beds'], checkout=reservation['checkout'], code=reservation['code']) @staticmethod def resolve_getUser(root, info, user_id): # TODO check authorization in the future using the below header # TODO info.context.headers['Authorization'] url = f'{_LEGACY_BASE_URL}v1/internal-users/{user_id}' req = Request(url=url, headers={'X-INTERNAL-API-KEY': _LEGACY_KEY}, app=app) user = req.get() return User(mobile_number=user['mobile_number'], email=user['email'], fullname=user['fullname']) GraphSchema = Schema(query=Query)
def test_filter_filterset_related_results(): class ReporterFilterNode(DjangoObjectType): class Meta: model = Reporter interfaces = (Node, ) filter_fields = ["first_name", "articles"] class ArticleFilterNode(DjangoObjectType): class Meta: interfaces = (Node, ) model = Article filter_fields = ["headline", "reporter"] class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterFilterNode) all_articles = DjangoFilterConnectionField(ArticleFilterNode) reporter = Field(ReporterFilterNode) article = Field(ArticleFilterNode) r1 = Reporter.objects.create(first_name="r1", last_name="r1", email="*****@*****.**") r2 = Reporter.objects.create(first_name="r2", last_name="r2", email="*****@*****.**") Article.objects.create( headline="a1", pub_date=datetime.now(), pub_date_time=datetime.now(), reporter=r1, editor=r1, ) Article.objects.create( headline="a2", pub_date=datetime.now(), pub_date_time=datetime.now(), reporter=r2, editor=r2, ) query = """ query { allReporters { edges { node { articles { edges { node { headline } } } } } } } """ schema = Schema(query=Query) result = schema.execute(query) assert not result.errors # We should only get back a single article for each reporter assert (len(result.data["allReporters"]["edges"][0]["node"]["articles"] ["edges"]) == 1) assert (len(result.data["allReporters"]["edges"][1]["node"]["articles"] ["edges"]) == 1)
def test_resolvers(session): """Test that the correct resolver functions are called""" class ReporterMixin(object): def resolve_id(root, _info): return 'ID' class ReporterType(ReporterMixin, SQLAlchemyObjectType): class Meta: model = Reporter email = ORMField() email_v2 = ORMField(model_attr='email') favorite_pet_kind = Field(String) favorite_pet_kind_v2 = Field(String) def resolve_last_name(root, _info): return root.last_name.upper() def resolve_email_v2(root, _info): return root.email + '_V2' def resolve_favorite_pet_kind_v2(root, _info): return str(root.favorite_pet_kind) + '_V2' class Query(ObjectType): reporter = Field(ReporterType) def resolve_reporter(self, _info): return session.query(Reporter).first() reporter = Reporter(first_name='first_name', last_name='last_name', email='email', favorite_pet_kind='cat') session.add(reporter) session.commit() schema = Schema(query=Query) result = schema.execute(""" query { reporter { id firstName lastName email emailV2 favoritePetKind favoritePetKindV2 } } """) assert not result.errors # Custom resolver on a base class assert result.data['reporter']['id'] == 'ID' # Default field + default resolver assert result.data['reporter']['firstName'] == 'first_name' # Default field + custom resolver assert result.data['reporter']['lastName'] == 'LAST_NAME' # ORMField + default resolver assert result.data['reporter']['email'] == 'email' # ORMField + custom resolver assert result.data['reporter']['emailV2'] == 'email_V2' # Field + default resolver assert result.data['reporter']['favoritePetKind'] == 'cat' # Field + custom resolver assert result.data['reporter']['favoritePetKindV2'] == 'cat_V2'