use std::sync::{
Arc, Mutex,
atomic::{AtomicUsize, Ordering},
};
use ::http::{Method, StatusCode, header};
use futures::StreamExt as _;
use suku::{
Context, GraphQLRequest, HttpConfig, HttpError, HttpResult, Server,
http::{ContextRequest, handle},
};
fn schema(bumps: Arc<AtomicUsize>) -> gql::Schema {
let read_bumps = Arc::clone(&bumps);
let write_bumps = Arc::clone(&bumps);
let query = gql::ObjectType::new("Query")
.field(
gql::Field::new("hello", gql::TypeRef::string().non_null())
.resolve(|_| Box::pin(async { Ok(gql::Value::from("world")) })),
)
.field(
gql::Field::new("bumps", gql::TypeRef::int().non_null()).resolve(move |_| {
let bumps = Arc::clone(&read_bumps);
Box::pin(async move {
Ok(gql::Value::Int(
i32::try_from(bumps.load(Ordering::SeqCst)).unwrap_or(i32::MAX),
))
})
}),
);
let mutation = gql::ObjectType::new("Mutation").field(
gql::Field::new("bump", gql::TypeRef::int().non_null()).resolve(move |_| {
let bumps = Arc::clone(&write_bumps);
Box::pin(async move {
let value = bumps.fetch_add(1, Ordering::SeqCst) + 1;
Ok(gql::Value::Int(i32::try_from(value).unwrap_or(i32::MAX)))
})
}),
);
let subscription = gql::ObjectType::new("Subscription").field(
gql::Field::new("countdown", gql::TypeRef::int().non_null())
.resolve(|context| Box::pin(async move { Ok(context.parent.clone()) }))
.subscribe(|_| {
Box::pin(async { Ok(futures::stream::iter(vec![Ok(gql::Value::from(3))]).boxed()) })
}),
);
let mut builder = gql::Schema::builder();
builder.add_type(query.into());
builder.add_type(mutation.into());
builder.add_type(subscription.into());
let builder = builder.mutation("Mutation").subscription("Subscription");
builder.build().expect("valid schema")
}
fn server(bumps: Arc<AtomicUsize>) -> Server {
Server::new(schema(bumps))
}
fn parts(
method: Method,
uri: &str,
headers: &[(header::HeaderName, &str)],
) -> ::http::request::Parts {
let mut builder = ::http::Request::builder().method(method).uri(uri);
for (name, value) in headers {
builder = builder.header(name, *value);
}
builder.body(()).expect("valid request").into_parts().0
}
fn get_uri(query: &str) -> String {
format!(
"/graphql?{}",
serde_urlencoded::to_string([("query", query)]).expect("query string")
)
}
fn buffered(result: HttpResult) -> suku::HttpResponse {
match result {
HttpResult::Response(response) => response,
HttpResult::Stream(_) => panic!("expected a buffered response"),
}
}
fn counting_extractor(
calls: Arc<AtomicUsize>,
) -> impl Fn(ContextRequest) -> futures::future::BoxFuture<'static, Result<Context, HttpError>> {
move |_request| {
calls.fetch_add(1, Ordering::SeqCst);
Box::pin(async { Ok(Context::new("authenticated")) })
}
}
#[tokio::test]
async fn get_requests_cannot_execute_mutations() {
let bumps = Arc::new(AtomicUsize::new(0));
let server = server(Arc::clone(&bumps));
let config = HttpConfig::default();
let request_parts = parts(
Method::GET,
&get_uri("mutation { bump }"),
&[(header::ACCEPT, "application/json")],
);
let response = buffered(
handle(
&server,
&config,
&request_parts,
b"",
counting_extractor(Arc::new(AtomicUsize::new(0))),
)
.await,
);
assert_eq!(response.status, StatusCode::METHOD_NOT_ALLOWED);
assert_eq!(
bumps.load(Ordering::SeqCst),
0,
"a GET request must never run a mutation"
);
}
#[tokio::test]
async fn get_requests_cannot_start_subscriptions() {
let server = server(Arc::new(AtomicUsize::new(0)));
let config = HttpConfig::default();
let request_parts = parts(
Method::GET,
&get_uri("subscription { countdown }"),
&[(header::ACCEPT, "text/event-stream")],
);
let result = handle(
&server,
&config,
&request_parts,
b"",
counting_extractor(Arc::new(AtomicUsize::new(0))),
)
.await;
let response = buffered(result);
assert_eq!(response.status, StatusCode::METHOD_NOT_ALLOWED);
}
#[tokio::test]
async fn graphiql_requires_authentication() {
let calls = Arc::new(AtomicUsize::new(0));
let extractor_calls = Arc::clone(&calls);
let server = server(Arc::new(AtomicUsize::new(0)));
let config = HttpConfig::default();
let request_parts = parts(Method::GET, "/graphql", &[(header::ACCEPT, "text/html")]);
let response = buffered(
handle(&server, &config, &request_parts, b"", move |_| {
extractor_calls.fetch_add(1, Ordering::SeqCst);
Box::pin(async {
Err(HttpError::message(
StatusCode::UNAUTHORIZED,
"missing bearer token",
))
})
})
.await,
);
assert_eq!(response.status, StatusCode::UNAUTHORIZED);
assert!(
!String::from_utf8_lossy(&response.body).contains("GraphiQL"),
"GraphiQL HTML must not be served without authentication"
);
assert_eq!(calls.load(Ordering::SeqCst), 1, "extractor must run");
}
#[tokio::test]
async fn rejected_requests_do_not_execute() {
let bumps = Arc::new(AtomicUsize::new(0));
let server = server(Arc::clone(&bumps));
let config = HttpConfig::default();
let request_parts = parts(
Method::POST,
"/graphql",
&[(header::CONTENT_TYPE, "application/json")],
);
let body = serde_json::to_vec(&GraphQLRequest::new("mutation { bump }")).expect("body");
let response = buffered(
handle(&server, &config, &request_parts, &body, |_| {
Box::pin(async {
Err(HttpError::message(
StatusCode::UNAUTHORIZED,
"missing bearer token",
))
})
})
.await,
);
assert_eq!(response.status, StatusCode::UNAUTHORIZED);
assert_eq!(bumps.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn batch_operations_are_authorized_by_the_shared_context() {
let authorizer = Arc::new(Mutex::new(Vec::new()));
struct Record(Arc<Mutex<Vec<String>>>);
impl gql::Authorizer for Record {
fn authorize(
&self,
context: &gql::AuthorizationContext<'_>,
) -> Result<(), gql::GraphQLError> {
self.0
.lock()
.expect("log")
.push(context.field_name.to_owned());
Ok(())
}
}
let server = Server::new(schema(Arc::new(AtomicUsize::new(0))))
.authorizer(Record(Arc::clone(&authorizer)));
let config = HttpConfig::default();
let request_parts = parts(
Method::POST,
"/graphql",
&[(header::CONTENT_TYPE, "application/json")],
);
let body = serde_json::to_vec(&vec![
GraphQLRequest::new("{ hello }"),
GraphQLRequest::new("{ bumps }"),
])
.expect("body");
let response = buffered(
handle(
&server,
&config,
&request_parts,
&body,
counting_extractor(Arc::new(AtomicUsize::new(0))),
)
.await,
);
assert_eq!(response.status, StatusCode::OK);
let mut seen = authorizer.lock().expect("log").clone();
seen.sort();
assert_eq!(seen, vec!["bumps".to_owned(), "hello".to_owned()]);
}