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'
