def test_options_response_excludes_get_if_introspection_is_disabled(schema):
app = GraphQL(schema, introspection=False)
client = TestClient(app)
response = client.options("/")
assert response.status_code == 200
assert response.headers["Allow"] == "OPTIONS, POST"
def test_custom_validation_rule_is_called_by_query_validation(
mocker, schema, validation_rule
):
spy_validation_rule = mocker.spy(validation_rule, "__init__")
app = GraphQL(schema, validation_rules=[validation_rule])
client = TestClient(app)
client.post("/", json={"query": "{ status }"})
spy_validation_rule.assert_called_once()
def test_unsupported_method_response_excludes_get_if_introspection_is_disabled(
schema):
app = GraphQL(schema, introspection=False)
client = TestClient(app)
response = client.patch("/")
assert response.status_code == 405
assert response.headers["Allow"] == "OPTIONS, POST"
def test_custom_root_value_function_is_called_with_context_value(schema):
get_root_value = Mock(return_value=True)
app = GraphQL(schema,
context_value={"test": "TEST-CONTEXT"},
root_value=get_root_value)
client = TestClient(app)
client.post("/", json={"query": "{ status }"})
get_root_value.assert_called_once_with({"test": "TEST-CONTEXT"}, ANY)
def test_custom_validation_rules_function_is_set_and_called_on_query_execution(
schema, validation_rule):
get_validation_rules = Mock(return_value=[validation_rule])
app = GraphQL(schema, validation_rules=get_validation_rules)
client = TestClient(app)
client.post("/", json={"query": "{ status }"})
get_validation_rules.assert_called_once()
validation_rule.assert_called_once()
def test_async_extensions_function_result_is_passed_to_query_executor(schema):
async def get_extensions(*_):
return [CustomExtension]
app = GraphQL(schema, extensions=get_extensions)
client = TestClient(app)
response = client.post("/", json={"query": '{ hello(name: "BOB") }'})
assert response.json() == {"data": {"hello": "hello, bob!"}}
def test_async_middleware_function_result_is_passed_to_query_executor(schema):
async def get_middleware(*_):
return [middleware]
app = GraphQL(schema, middleware=get_middleware)
client = TestClient(app)
response = client.post("/", json={"query": '{ hello(name: "BOB") }'})
assert response.json() == {"data": {"hello": "**Hello, BOB!**"}}
def test_middlewares_and_extensions_are_combined_in_correct_order(schema):
def test_middleware(next_fn, *args, **kwargs):
value = next_fn(*args, **kwargs)
return f"*{value}*"
app = GraphQL(schema, extensions=[CustomExtension], middleware=[test_middleware])
client = TestClient(app)
response = client.post("/", json={"query": '{ hello(name: "BOB") }'})
assert response.json() == {"data": {"hello": "=*Hello, BOB!*="}}
def __init__(self, debug=True):
type_defs = load_schema_from_path("graphql_server/schema/")
schema = make_executable_schema(type_defs, query, mutation, user)
self._server = CORSMiddleware(GraphQL(schema, debug=debug),
allow_origins=["*"],
allow_headers=["*"],
allow_methods=["*"])
def test_async_context_value_function_result_is_awaited_before_passing_to_resolvers(
schema, ):
async def get_context_value(*_):
return {"test": "TEST-ASYNC-CONTEXT"}
app = GraphQL(schema, context_value=get_context_value)
client = TestClient(app)
response = client.post("/", json={"query": "{ testContext }"})
assert response.json() == {"data": {"testContext": "TEST-ASYNC-CONTEXT"}}
def test_benchmark_complex_query_resolved_to_500_dicts(benchmark, schema, raw_data):
app = GraphQL(schema, root_value=raw_data)
client = TestClient(app)
def api_call():
return client.post("/", json={"query": COMPLEX_QUERY})
result = benchmark(api_call)
assert result.status_code == 200
def test_benchmark_complex_query_resolved_to_one_object(
benchmark, schema, hydrated_data_one_item
):
app = GraphQL(schema, root_value={"users": hydrated_data_one_item})
client = TestClient(app)
def api_call():
return client.post("/", json={"query": COMPLEX_QUERY})
result = benchmark(api_call)
assert result.status_code == 200
def test_error_in_custom_websocket_on_connect_is_handled(schema):
def on_connect(websocket, payload):
raise ValueError("Oh No!")
app = GraphQL(schema, on_connect=on_connect)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ERROR
assert response["payload"] == {"message": "Unexpected error has occurred."}
def test_error_in_custom_websocket_on_disconnect_is_handled(schema):
async def on_disconnect(websocket):
raise ValueError("Oh No!")
app = GraphQL(schema, on_disconnect=on_disconnect)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
ws.send_json({"type": GQL_CONNECTION_TERMINATE})
def test_custom_validation_rules_function_is_called_with_context_value(
schema, validation_rule):
get_validation_rules = Mock(return_value=[validation_rule])
app = GraphQL(
schema,
context_value={"test": "TEST-CONTEXT"},
validation_rules=get_validation_rules,
)
client = TestClient(app)
client.post("/", json={"query": "{ status }"})
get_validation_rules.assert_called_once_with({"test": "TEST-CONTEXT"}, ANY,
ANY)
def test_custom_websocket_connection_error_in_custom_websocket_on_connect_is_handled(
schema,
):
def on_connect(websocket, payload):
raise WebSocketConnectionError({"msg": "Token required", "code": "auth_error"})
app = GraphQL(schema, on_connect=on_connect)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ERROR
assert response["payload"] == {"msg": "Token required", "code": "auth_error"}
def test_custom_websocket_on_disconnect_is_awaited_if_its_async(schema):
async def on_disconnect(websocket):
websocket.scope["on_disconnect"] = True
app = GraphQL(schema, on_disconnect=on_disconnect)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
ws.send_json({"type": GQL_CONNECTION_TERMINATE})
assert "on_disconnect" not in ws.scope
assert ws.scope["on_disconnect"] is True
def test_custom_error_formatter_is_used_to_format_subscription_syntax_error(schema):
error_formatter = Mock(return_value=True)
app = GraphQL(schema, error_formatter=error_formatter)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
ws.send_json(
{"type": GQL_START, "id": "test1", "payload": {"query": "subscription {"}}
)
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
response = ws.receive_json()
assert response["type"] == GQL_ERROR
assert response["id"] == "test1"
error_formatter.assert_called_once()
def test_custom_websocket_on_connect_is_awaited_if_its_async(schema):
test_payload = {"test": "ok"}
async def on_connect(websocket, payload):
assert payload == test_payload
websocket.scope["payload"] = payload
app = GraphQL(schema, on_connect=on_connect)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT, "payload": test_payload})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
assert ws.scope["payload"] == test_payload
ws.send_json({"type": GQL_CONNECTION_TERMINATE})
async def setup(self):
schema = make_executable_schema(self.type_defs, self.query,
self.subscription, self.mutations)
app = CORSMiddleware(
GraphQL(schema),
allow_origins=["*"],
allow_methods=("GET", "POST", "OPTIONS"),
)
conf = Config()
conf.bind = ["0.0.0.0:8006"]
conf.loglevel = "fatal" # to suppress lifespan error
LOGGER.info("starting GQL API")
try: # also to suppress lifespan error
await serve(app, conf)
except Exception as e:
print(e)
async def dummy_client(self, ):
"""
Client for a dummy server
"""
type_defs = ariadne.gql("""
scalar JSON
type Query {
headers: JSON
hello: String
value_error_required: String!
value_error: String
type_error: String
unauthenticated_error: String
unauthorized_error: String
}
""")
query = ariadne.QueryType()
@query.field("hello")
def hello(parent: Any, info: GraphQLResolveInfo):
return "👋"
@query.field("value_error")
@query.field("value_error_required")
def value_error(parent: Any, info: GraphQLResolveInfo):
raise ValueError("this is a value error")
@query.field("type_error")
def type_error(parent: Any, info: GraphQLResolveInfo):
raise TypeError("this is a type error")
@query.field("unauthenticated_error")
def unauthenticated_error(parent: Any, info: GraphQLResolveInfo):
raise Unauthenticated("this is an unauthenticated error")
@query.field("unauthorized_error")
def unauthorized_error(parent: Any, info: GraphQLResolveInfo):
raise Unauthorized("this is an unauthorized error")
schema = make_executable_schema(type_defs, query)
app = Starlette()
app.mount("/", GraphQL(schema))
async with httpx.Client(app=app,
base_url="http://prefect.io") as dummy_client:
yield dummy_client
def create_app(
config: Config,
database: Database,
schema: GraphQLSchema,
) -> Starlette:
debug = config("DEBUG", cast=bool, default=False)
app = Starlette(
debug=debug,
routes=[
Mount("/graphql", GraphQL(schema=schema, debug=debug)),
],
on_startup=[database.connect],
on_shutdown=[database.disconnect],
)
return app
def test_custom_root_value_is_passed_to_subscription_resolvers(schema):
app = GraphQL(schema, root_value={"test": "TEST-ROOT"})
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
ws.send_json({
"type": GQL_START,
"id": "test1",
"payload": {
"query": "subscription { testRoot }"
},
})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
response = ws.receive_json()
assert response["type"] == GQL_DATA
assert response["payload"] == {"data": {"testRoot": "TEST-ROOT"}}
def test_custom_root_value_function_is_called_by_subscription(schema):
get_root_value = Mock(return_value=True)
app = GraphQL(schema, root_value=get_root_value)
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
ws.send_json({
"type": GQL_START,
"id": "test1",
"payload": {
"query": "subscription { ping }"
},
})
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
response = ws.receive_json()
assert response["type"] == GQL_DATA
get_root_value.assert_called_once()
def test_custom_logger_is_used_to_log_subscription_resolver_error(schema, mocker):
logging_mock = mocker.patch("ariadne.logger.logging")
app = GraphQL(schema, logger="custom")
client = TestClient(app)
with client.websocket_connect("/", "graphql-ws") as ws:
ws.send_json({"type": GQL_CONNECTION_INIT})
ws.send_json(
{
"type": GQL_START,
"id": "test1",
"payload": {"query": "subscription { resolverError }"},
}
)
response = ws.receive_json()
assert response["type"] == GQL_CONNECTION_ACK
response = ws.receive_json()
assert response["type"] == GQL_DATA
logging_mock.getLogger.assert_called_once_with("custom")
def start(self):
query = QueryType()
query.set_field('echo', self._echo_resolver())
mutation = MutationType()
mutation.set_field('createTable', self._create_table_resolver())
mutation.set_field('addPlayer', self._add_player_resolver())
mutation.set_field('takeAction', self._take_action_resolver())
mutation.set_field('startGame', self._start_game_resolver())
mutation.set_field('stopGame', self._stop_game_resolver())
mutation.set_field('reset', self._reset_resolver())
subscription = SubscriptionType()
subscription.set_field('subscribe', self._subscribe_resolver())
subscription.set_source('subscribe', self._subscribe_generator())
resolvers = [query, mutation, subscription]
executable_schema = make_executable_schema(self._schema_str, resolvers)
self._app = GraphQL(executable_schema, debug=True)
def bootstrap(**dependencies) -> Starlette:
"""
Boostraps a starlette app setting context_value in the GraphQL config
"""
def context_value(request):
return {**dependencies, 'request': request}
gql_app = GraphQL(api.schema,
debug=DEBUG,
context_value=context_value,
middleware=[encode_id_middleware])
routes = [Route("/graphql", gql_app)]
middleware = [
Middleware(CORSMiddleware,
allow_origins=ALLOW_ORIGINS,
allow_methods=['*'],
allow_headers=['*']),
Middleware(request_state_middleware(**dependencies)),
]
return Starlette(routes=routes, debug=DEBUG, middleware=middleware)
def setup(project_settings: str = None, database: bool = False) -> GraphQL:
"""Load Turbulette applications and return the GraphQL route."""
project_settings_module = (get_project_settings_by_env()
if not project_settings else
import_module(project_settings))
# The database connection has to be initialized before the LazySettings object to be setup
# so we have to connect to the database before the registry to be setup
if database:
get_gino_instance()
registry = Registry(project_settings_module=project_settings_module)
conf.registry.__setup__(registry)
schema = registry.setup()
# At this point, settings are now available through `settings` from `turbulette.conf` module
settings = conf.settings
# Now that the database connection is established, we can use `settings`
cache.__setup__(Cache(settings.CACHE))
extensions: List[Type[Extension]] = [PolicyExtension]
for ext in settings.ARIADNE_EXTENSIONS:
module_class = ext.rsplit(".", 1)
extensions.append(
getattr(
import_module(module_class[0]),
module_class[1],
))
graphql_route = GraphQL(
schema,
debug=settings.DEBUG,
extensions=extensions,
error_formatter=error_formatter,
)
return graphql_route
from db import db
from db import models
models.Base.metadata.create_all(bind=db.engine)
def seed():
session = db.Session()
# import pdb; pdb.set_trace()
bram = models.Person(name="Bram")
session.add(bram)
dtc = models.Project(name="dtc")
session.add(dtc)
session.commit()
# seed()
app = FastAPI()
@app.middleware("http")
async def db_session_middleware(request, call_next):
request.state.db = db.Session()
response = await call_next(request)
request.state.db.close()
return response
app.mount("/graphql", GraphQL(schema, debug=True))
from ariadne import make_executable_schema, load_schema_from_path
from ariadne.asgi import GraphQL
from resolvers import query, skill, person
# import schema from GraphQL file
type_defs = load_schema_from_path("./schema.gql")
schema = make_executable_schema(type_defs, query, skill, person)
app = GraphQL(schema, debug=True)
