#![allow(clippy::too_many_arguments)]
#![allow(dead_code, unused_variables, unused_imports)]
#[macro_use]
extern crate juniper;
use assert_json_diff::assert_json_include;
use chrono::prelude::*;
use juniper::{Executor, FieldResult, Variables, ID};
use juniper_from_schema::{graphql_schema, graphql_schema_from_file};
use serde_json::{self, json, Value};
use std::collections::HashMap;
use url::Url;
use uuid::Uuid;
graphql_schema! {
schema {
query: Query
}
type Query {
a: A! @juniper(ownership: "owned")
}
type A {
b: B! @juniper(ownership: "owned")
}
type B {
c: C! @juniper(ownership: "owned")
}
type C {
fieldWithArg(
stringArg: String!
nullableArg: String
nullableArg2: String
intArg: Int!
floatArg: Float!
boolArg: Boolean!
listArg: [Int!]!
enumArg: Color!
objectArg: InputObject!
cursorArg: Cursor!
idArg: ID!
urlArg: Url!
uuidArg: Uuid!
dateArg: Date!
dateTimeArg: DateTimeUtc!
defaultArg: String = "value set in schema"
defaultArg2: String = "error"
): String! @juniper(ownership: "owned")
fieldWithArgReturningType(
stringArg: String!
): D! @juniper(ownership: "owned")
}
type D {
value: String! @juniper(ownership: "owned")
}
input InputObject {
value: String!
}
enum Color {
RED
BLUE
}
scalar Cursor
scalar Url
scalar Uuid
scalar Date
scalar DateTimeUtc
}
pub struct Query;
impl QueryFields for Query {
fn field_a(
&self,
executor: &Executor<'_, Context>,
trail: &QueryTrail<'_, A, Walked>,
) -> FieldResult<A> {
if let Some(c) = trail.b().c().walk() {
assert_eq!("foo".to_string(), c.field_with_arg_args().string_arg());
assert_eq!(None, c.field_with_arg_args().nullable_arg());
assert_eq!(
Some("bar".to_string()),
c.field_with_arg_args().nullable_arg2()
);
assert_eq!(1, c.field_with_arg_args().int_arg());
assert_eq!("2.5", c.field_with_arg_args().float_arg().to_string());
assert_eq!(false, c.field_with_arg_args().bool_arg());
assert_eq!(vec![1, 2, 3], c.field_with_arg_args().list_arg());
assert_eq!(Color::Red, c.field_with_arg_args().enum_arg());
assert_eq!(
"baz".to_string(),
c.field_with_arg_args().object_arg().value
);
assert_eq!(
Cursor("cursor-value".to_string()),
c.field_with_arg_args().cursor_arg()
);
assert_eq!(ID::new("id-value"), c.field_with_arg_args().id_arg());
assert_eq!(
Url::parse("https://example.net").unwrap(),
c.field_with_arg_args().url_arg()
);
assert_eq!(
Uuid::parse_str("46ebd0ee-0e6d-43c9-b90d-ccc35a913f3e").unwrap(),
c.field_with_arg_args().uuid_arg()
);
assert_eq!(
NaiveDate::parse_from_str("2019-01-01", "%Y-%m-%d").unwrap(),
c.field_with_arg_args().date_arg()
);
assert_eq!(
DateTime::parse_from_rfc3339("1996-12-19T16:39:57-08:00").unwrap(),
c.field_with_arg_args().date_time_arg()
);
assert_eq!(
"value set in schema".to_string(),
c.field_with_arg_args().default_arg()
);
assert_eq!(
"value set in query".to_string(),
c.field_with_arg_args().default_arg2()
);
assert_eq!(
"qux".to_string(),
c.field_with_arg_returning_type_args().string_arg()
);
}
Ok(A)
}
}
pub struct A;
impl AFields for A {
fn field_b(
&self,
executor: &Executor<'_, Context>,
trail: &QueryTrail<'_, B, Walked>,
) -> FieldResult<B> {
Ok(B)
}
}
pub struct B;
impl BFields for B {
fn field_c(
&self,
executor: &Executor<'_, Context>,
trail: &QueryTrail<'_, C, Walked>,
) -> FieldResult<C> {
Ok(C)
}
}
pub struct C;
impl CFields for C {
fn field_field_with_arg(
&self,
executor: &Executor<'_, Context>,
_: String,
_: Option<String>,
_: Option<String>,
_: i32,
_: f64,
_: bool,
_: Vec<i32>,
_: Color,
_: InputObject,
_: Cursor,
_: ID,
_: Url,
_: Uuid,
_: NaiveDate,
_: DateTime<Utc>,
_: String,
_: String,
) -> FieldResult<String> {
Ok(String::new())
}
fn field_field_with_arg_returning_type(
&self,
executor: &Executor<'_, Context>,
_: &QueryTrail<'_, D, Walked>,
_: String,
) -> FieldResult<D> {
Ok(D)
}
}
pub struct D;
impl DFields for D {
fn field_value(&self, executor: &Executor<'_, Context>) -> FieldResult<String> {
Ok(String::new())
}
}
#[test]
fn scalar_values() {
let value = run_query(
r#"query {
a {
b {
c {
fieldWithArg(
stringArg: "foo",
nullableArg: null,
nullableArg2: "bar",
intArg: 1,
floatArg: 2.5,
boolArg: false,
listArg: [1, 2, 3],
enumArg: RED,
objectArg: { value: "baz" },
cursorArg: "cursor-value",
idArg: "id-value",
urlArg: "https://example.net",
uuidArg: "46ebd0ee-0e6d-43c9-b90d-ccc35a913f3e",
dateArg: "2019-01-01",
dateTimeArg: "1996-12-19T16:39:57-08:00",
defaultArg2: "value set in query",
)
fieldWithArgReturningType(
stringArg: "qux",
) {
value
}
}
}
}
}"#,
);
assert_json_include!(
actual: value,
expected: json!({
"a": { "b": { "c": {} } }
})
);
}
type Context = ();
fn run_query(query: &str) -> Value {
let (res, _errors) = juniper::execute(
query,
None,
&Schema::new(Query, juniper::EmptyMutation::new()),
&Variables::new(),
&(),
)
.unwrap();
let json = serde_json::from_str(&serde_json::to_string(&res).unwrap()).unwrap();
println!("--- <json> -----------------");
println!("{}", serde_json::to_string_pretty(&json).unwrap());
println!("--- </json> -----------------");
json
}