def test_dsl_root_type_not_default():
from graphql import parse, build_ast_schema
schema_str = """
schema {
query: QueryNotDefault
}
type QueryNotDefault {
version: String
}
"""
type_def_ast = parse(schema_str)
schema = build_ast_schema(type_def_ast)
ds = DSLSchema(schema)
query = dsl_gql(DSLQuery(ds.QueryNotDefault.version))
expected_query = """
{
version
}
"""
assert print_ast(query) == expected_query.strip()
with pytest.raises(GraphQLError) as excinfo:
DSLSubscription(ds.QueryNotDefault.version)
assert (
"Invalid field for <DSLSubscription>: <DSLField QueryNotDefault::version>"
) in str(excinfo.value)
def test_multiple_operations(ds):
query = dsl_gql(
GetHeroName=DSLQuery(ds.Query.hero.select(ds.Character.name)),
CreateReviewMutation=DSLMutation(
ds.Mutation.createReview.args(episode=6,
review={
"stars":
5,
"commentary":
"This is a great movie!"
}).select(ds.Review.stars,
ds.Review.commentary)),
)
assert (print_ast(query) == """query GetHeroName {
hero {
name
}
}
mutation CreateReviewMutation {
createReview(episode: JEDI, review: {stars: 5, \
commentary: "This is a great movie!"}) {
stars
commentary
}
}
""")
def test_use_variable_definition_multiple_times(ds):
var = DSLVariableDefinitions()
# `episode` variable is used in both fields
op = DSLMutation(
ds.Mutation.createReview.alias("badReview")
.args(review=var.badReview, episode=var.episode)
.select(ds.Review.stars, ds.Review.commentary),
ds.Mutation.createReview.alias("goodReview")
.args(review=var.goodReview, episode=var.episode)
.select(ds.Review.stars, ds.Review.commentary),
)
op.variable_definitions = var
query = dsl_gql(op)
assert (
print_ast(query)
== """mutation ($badReview: ReviewInput, $episode: Episode, $goodReview: ReviewInput) {
badReview: createReview(review: $badReview, episode: $episode) {
stars
commentary
}
goodReview: createReview(review: $goodReview, episode: $episode) {
stars
commentary
}
}"""
)
def test_fragments(ds):
query = """fragment NameAndAppearances on Character {
name
appearsIn
}
{
hero {
...NameAndAppearances
}
}"""
name_and_appearances = (
DSLFragment("NameAndAppearances")
.on(ds.Character)
.select(ds.Character.name, ds.Character.appearsIn)
)
query_dsl = DSLQuery(ds.Query.hero.select(name_and_appearances))
document = dsl_gql(name_and_appearances, query_dsl)
print(print_ast(document))
assert query == print_ast(document)
async def main():
transport = AIOHTTPTransport(
url="https://countries.trevorblades.com/graphql")
client = Client(transport=transport, fetch_schema_from_transport=True)
# Using `async with` on the client will start a connection on the transport
# and provide a `session` variable to execute queries on this connection.
# Because we requested to fetch the schema from the transport,
# GQL will fetch the schema just after the establishment of the first session
async with client as session:
# Instanciate the root of the DSL Schema as ds
ds = DSLSchema(client.schema)
# Create the query using dynamically generated attributes from ds
query = dsl_gql(
DSLQuery(
ds.Query.continents(filter={
"code": {
"eq": "EU"
}
}).select(ds.Continent.code, ds.Continent.name)))
result = await session.execute(query)
print(result)
# This can also be written as:
# I want to query the continents
query_continents = ds.Query.continents
# I want to get only the continents with code equal to "EU"
query_continents(filter={"code": {"eq": "EU"}})
# I want this query to return the code and name fields
query_continents.select(ds.Continent.code)
query_continents.select(ds.Continent.name)
# I generate a document from my query to be able to execute it
query = dsl_gql(DSLQuery(query_continents))
# Execute the query
result = await session.execute(query)
print(result)
def test_nested_input_2(ds, client):
query = dsl_gql(
DSLQuery(ds.Query.echo.args(nested={
"foo": 1,
"child": {
"foo": 2
}
})))
assert client.execute(query) == {"echo": '{"foo": 1, "child": {"foo": 2}}'}
def test_fragment_without_type_condition_error(ds):
# We create a fragment without using the .on(type_condition) method
name_and_appearances = DSLFragment("NameAndAppearances")
# If we try to use this fragment, gql generates an error
with pytest.raises(
AttributeError,
match=r"Missing type condition. Please use .on\(type_condition\) method",
):
dsl_gql(name_and_appearances)
with pytest.raises(
AttributeError,
match=r"Missing type condition. Please use .on\(type_condition\) method",
):
DSLFragment("NameAndAppearances").select(
ds.Character.name, ds.Character.appearsIn
)
def test_operation_name(ds):
query = dsl_gql(
GetHeroName=DSLQuery(ds.Query.hero.select(ds.Character.name), ))
assert (print_ast(query) == """query GetHeroName {
hero {
name
}
}
""")
def mutation_domain(self, domain: str, lang: str, phrases: list):
ds = DSLSchema(self.client.schema)
mutation = dsl_gql(
DSLMutation(
ds.Mutation.register_domain.args(
domain=domain, lang=lang,
phrases=phrases).select(ds.MatcherResponse.success,
ds.MatcherResponse.errors,
ds.MatcherResponse.domain,
ds.MatcherResponse.errors,
ds.MatcherResponse.lang)))
return mutation
def test_create_review_mutation_result(ds, client):
query = dsl_gql(
DSLMutation(
ds.Mutation.createReview.args(
episode=6, review={"stars": 5, "commentary": "This is a great movie!"}
).select(ds.Review.stars, ds.Review.commentary)
)
)
result = client.execute(query)
expected = {"createReview": {"stars": 5, "commentary": "This is a great movie!"}}
assert result == expected
def test_subscription(ds):
query = dsl_gql(
DSLSubscription(
ds.Subscription.reviewAdded(episode=6).select(
ds.Review.stars, ds.Review.commentary)))
assert (print_ast(query) == """subscription {
reviewAdded(episode: JEDI) {
stars
commentary
}
}
""")
def test_root_fields_aliased(ds, client):
query = dsl_gql(
DSLQuery(
ds.Query.hero.select(ds.Character.name),
hero_of_episode_5=ds.Query.hero(episode=5).select(ds.Character.name),
)
)
result = client.execute(query)
expected = {
"hero": {"name": "R2-D2"},
"hero_of_episode_5": {"name": "Luke Skywalker"},
}
assert result == expected
async def _query_today(self, thumbs=False):
""" Queries the API wrapper with the 'today' query """
async with self._gql_client as session:
schema = self._get_schema()
query = dsl_gql(
DSLQuery(
schema.Query.today(
apiKey=self._config['api_key'], thumbs=thumbs).select(
schema.Apod.copyright, schema.Apod.explanation,
schema.Apod.hdurl, schema.Apod.mediaType,
schema.Apod.title, schema.Apod.url)))
result = await session.execute(query)
return result
def test_arg_serializer_list(ds, client):
query = dsl_gql(
DSLQuery(
ds.Query.characters.args(ids=[1000, 1001, 1003]).select(
ds.Character.name,
)
)
)
result = client.execute(query)
expected = {
"characters": [
{"name": "Luke Skywalker"},
{"name": "Darth Vader"},
{"name": "Leia Organa"},
]
}
assert result == expected
def test_add_variable_definitions_with_default_value_enum(ds):
var = DSLVariableDefinitions()
op = DSLMutation(
ds.Mutation.createReview.args(
review=var.review, episode=var.episode.default(4)
).select(ds.Review.stars, ds.Review.commentary)
)
op.variable_definitions = var
query = dsl_gql(op)
assert (
print_ast(query)
== """mutation ($review: ReviewInput, $episode: Episode = NEWHOPE) {
createReview(review: $review, episode: $episode) {
stars
commentary
}
}"""
)
def test_add_variable_definitions_with_default_value_input_object(ds):
var = DSLVariableDefinitions()
op = DSLMutation(
ds.Mutation.createReview.args(
review=var.review.default({"stars": 5, "commentary": "Wow!"}),
episode=var.episode,
).select(ds.Review.stars, ds.Review.commentary)
)
op.variable_definitions = var
query = dsl_gql(op)
assert (
print_ast(query)
== """
mutation ($review: ReviewInput = {stars: 5, commentary: "Wow!"}, $episode: Episode) {
createReview(review: $review, episode: $episode) {
stars
commentary
}
}""".strip()
)
def test_type_hero_query(ds):
query = """{
__type(name: "Hero") {
kind
name
ofType {
kind
name
}
}
}"""
type_hero = DSLMetaField("__type")(name="Hero")
type_hero.select(
ds.__Type.kind,
ds.__Type.name,
ds.__Type.ofType.select(ds.__Type.kind, ds.__Type.name),
)
query_dsl = DSLQuery(type_hero)
assert query == str(print_ast(dsl_gql(query_dsl))).strip()
def mutation_skill(self, domain: str, call_back: str, lang: str,
matchers: list):
''' Args:
----
call_back: the callback method registered as <domain>/<method>
lang: The language iso code
matchers: A list of Matcher rules on the form [{'ORTH': "vær", 'OP': "?"},
{'ORTH': "været", 'OP': "?"}]
'''
ds = DSLSchema(self.client.schema)
mutation = dsl_gql(
DSLMutation(
ds.Mutation.register_skill.args(
domain=domain,
call_back=call_back,
lang=lang,
matcher=matchers).select(ds.MatcherResponse.success,
ds.MatcherResponse.errors,
ds.MatcherResponse.domain,
ds.MatcherResponse.errors,
ds.MatcherResponse.lang,
ds.MatcherResponse.call_back)))
return mutation
def test_add_variable_definitions_in_input_object(ds):
var = DSLVariableDefinitions()
op = DSLMutation(
ds.Mutation.createReview.args(
review={"stars": var.stars, "commentary": var.commentary},
episode=var.episode,
).select(ds.Review.stars, ds.Review.commentary)
)
op.variable_definitions = var
query = dsl_gql(op)
assert (
print_ast(query)
== """mutation ($stars: Int, $commentary: String, $episode: Episode) {
createReview(
review: {stars: $stars, commentary: $commentary}
episode: $episode
) {
stars
commentary
}
}"""
)
def get_introspection_query_ast(
descriptions: bool = True,
specified_by_url: bool = False,
directive_is_repeatable: bool = False,
schema_description: bool = False,
type_recursion_level: int = 7,
) -> DocumentNode:
"""Get a query for introspection as a document using the DSL module.
Equivalent to the get_introspection_query function from graphql-core
but using the DSL module and allowing to select the recursion level.
Optionally, you can exclude descriptions, include specification URLs,
include repeatability of directives, and specify whether to include
the schema description as well.
"""
ds = DSLSchema(GraphQLSchema())
fragment_FullType = DSLFragment("FullType").on(ds.__Type)
fragment_InputValue = DSLFragment("InputValue").on(ds.__InputValue)
fragment_TypeRef = DSLFragment("TypeRef").on(ds.__Type)
schema = DSLMetaField("__schema")
if descriptions and schema_description:
schema.select(ds.__Schema.description)
schema.select(
ds.__Schema.queryType.select(ds.__Type.name),
ds.__Schema.mutationType.select(ds.__Type.name),
ds.__Schema.subscriptionType.select(ds.__Type.name),
)
schema.select(ds.__Schema.types.select(fragment_FullType))
directives = ds.__Schema.directives.select(ds.__Directive.name)
if descriptions:
directives.select(ds.__Directive.description)
if directive_is_repeatable:
directives.select(ds.__Directive.isRepeatable)
directives.select(
ds.__Directive.locations,
ds.__Directive.args.select(fragment_InputValue),
)
schema.select(directives)
fragment_FullType.select(
ds.__Type.kind,
ds.__Type.name,
)
if descriptions:
fragment_FullType.select(ds.__Type.description)
if specified_by_url:
fragment_FullType.select(ds.__Type.specifiedByURL)
fields = ds.__Type.fields(includeDeprecated=True).select(ds.__Field.name)
if descriptions:
fields.select(ds.__Field.description)
fields.select(
ds.__Field.args.select(fragment_InputValue),
ds.__Field.type.select(fragment_TypeRef),
ds.__Field.isDeprecated,
ds.__Field.deprecationReason,
)
enum_values = ds.__Type.enumValues(includeDeprecated=True).select(
ds.__EnumValue.name
)
if descriptions:
enum_values.select(ds.__EnumValue.description)
enum_values.select(
ds.__EnumValue.isDeprecated,
ds.__EnumValue.deprecationReason,
)
fragment_FullType.select(
fields,
ds.__Type.inputFields.select(fragment_InputValue),
ds.__Type.interfaces.select(fragment_TypeRef),
enum_values,
ds.__Type.possibleTypes.select(fragment_TypeRef),
)
fragment_InputValue.select(ds.__InputValue.name)
if descriptions:
fragment_InputValue.select(ds.__InputValue.description)
fragment_InputValue.select(
ds.__InputValue.type.select(fragment_TypeRef),
ds.__InputValue.defaultValue,
)
fragment_TypeRef.select(
ds.__Type.kind,
ds.__Type.name,
)
if type_recursion_level >= 1:
current_field = ds.__Type.ofType.select(ds.__Type.kind, ds.__Type.name)
fragment_TypeRef.select(current_field)
for _ in repeat(None, type_recursion_level - 1):
new_oftype = ds.__Type.ofType.select(ds.__Type.kind, ds.__Type.name)
current_field.select(new_oftype)
current_field = new_oftype
query = DSLQuery(schema)
query.name = "IntrospectionQuery"
dsl_query = dsl_gql(query, fragment_FullType, fragment_InputValue, fragment_TypeRef)
return dsl_query
def test_dsl_nested_query_with_fragment(ds):
query = """fragment NameAndAppearances on Character {
name
appearsIn
}
query NestedQueryWithFragment {
hero {
...NameAndAppearances
friends {
...NameAndAppearances
friends {
...NameAndAppearances
}
}
}
}"""
name_and_appearances = (
DSLFragment("NameAndAppearances")
.on(ds.Character)
.select(ds.Character.name, ds.Character.appearsIn)
)
query_dsl = DSLQuery(
ds.Query.hero.select(
name_and_appearances,
ds.Character.friends.select(
name_and_appearances, ds.Character.friends.select(name_and_appearances)
),
)
)
document = dsl_gql(name_and_appearances, NestedQueryWithFragment=query_dsl)
print(print_ast(document))
assert query == print_ast(document)
# Same thing, but incrementaly
name_and_appearances = DSLFragment("NameAndAppearances")
name_and_appearances.on(ds.Character)
name_and_appearances.select(ds.Character.name)
name_and_appearances.select(ds.Character.appearsIn)
level_2 = ds.Character.friends
level_2.select(name_and_appearances)
level_1 = ds.Character.friends
level_1.select(name_and_appearances)
level_1.select(level_2)
hero = ds.Query.hero
hero.select(name_and_appearances)
hero.select(level_1)
query_dsl = DSLQuery(hero)
document = dsl_gql(name_and_appearances, NestedQueryWithFragment=query_dsl)
print(print_ast(document))
assert query == print_ast(document)
def test_hero_name_query_result(ds, client):
query = dsl_gql(DSLQuery(ds.Query.hero.select(ds.Character.name)))
result = client.execute(query)
expected = {"hero": {"name": "R2-D2"}}
assert result == expected
from gql.dsl import DSLQuery, DSLSchema, dsl_gql
from gql.transport.requests import RequestsHTTPTransport
transport = RequestsHTTPTransport(
url="https://countries.trevorblades.com/",
verify=True,
retries=3,
)
client = Client(transport=transport, fetch_schema_from_transport=True)
# Using `with` on the sync client will start a connection on the transport
# and provide a `session` variable to execute queries on this connection.
# Because we requested to fetch the schema from the transport,
# GQL will fetch the schema just after the establishment of the first session
with client as session:
# We should have received the schema now that the session is established
assert client.schema is not None
# Instantiate the root of the DSL Schema as ds
ds = DSLSchema(client.schema)
# Create the query using dynamically generated attributes from ds
query = dsl_gql(
DSLQuery(
ds.Query.continents.select(ds.Continent.code, ds.Continent.name)))
result = session.execute(query)
print(result)
def test_dsl_gql_all_arguments_should_be_operations():
with pytest.raises(
TypeError,
match="Operations should be instances of DSLOperation "):
dsl_gql("I am a string")
def test_arg_serializer_enum(ds, client):
query = dsl_gql(
DSLQuery(ds.Query.hero.args(episode=5).select(ds.Character.name)))
result = client.execute(query)
expected = {"hero": {"name": "Luke Skywalker"}}
assert result == expected
