697 lines
14 KiB
Rust
697 lines
14 KiB
Rust
use async_graphql::*;
|
|
|
|
#[tokio::test]
|
|
pub async fn test_input_object_default_value() {
|
|
#[derive(InputObject)]
|
|
struct MyInput {
|
|
#[graphql(default = 999)]
|
|
a: i32,
|
|
|
|
#[graphql(default_with = "vec![1, 2, 3]")]
|
|
b: Vec<i32>,
|
|
|
|
#[graphql(default = "abc")]
|
|
c: String,
|
|
|
|
#[graphql(default = 999)]
|
|
d: i32,
|
|
|
|
#[graphql(default = 999)]
|
|
e: i32,
|
|
}
|
|
|
|
struct MyOutput {
|
|
a: i32,
|
|
b: Vec<i32>,
|
|
c: String,
|
|
d: Option<i32>,
|
|
e: Option<i32>,
|
|
}
|
|
|
|
#[Object]
|
|
impl MyOutput {
|
|
async fn a(&self) -> i32 {
|
|
self.a
|
|
}
|
|
|
|
async fn b(&self) -> &Vec<i32> {
|
|
&self.b
|
|
}
|
|
|
|
async fn c(&self) -> &String {
|
|
&self.c
|
|
}
|
|
|
|
async fn d(&self) -> &Option<i32> {
|
|
&self.d
|
|
}
|
|
|
|
async fn e(&self) -> &Option<i32> {
|
|
&self.e
|
|
}
|
|
}
|
|
|
|
struct Root;
|
|
|
|
#[Object]
|
|
impl Root {
|
|
async fn a(&self, input: MyInput) -> MyOutput {
|
|
MyOutput {
|
|
a: input.a,
|
|
b: input.b,
|
|
c: input.c,
|
|
d: Some(input.d),
|
|
e: Some(input.e),
|
|
}
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Root, EmptyMutation, EmptySubscription);
|
|
let query = r#"{
|
|
a(input:{e:777}) {
|
|
a b c d e
|
|
}
|
|
}"#
|
|
.to_owned();
|
|
assert_eq!(
|
|
schema.execute(&query).await.data,
|
|
value!({
|
|
"a": {
|
|
"a": 999,
|
|
"b": [1, 2, 3],
|
|
"c": "abc",
|
|
"d": 999,
|
|
"e": 777,
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_inputobject_derive_and_item_attributes() {
|
|
use serde::Deserialize;
|
|
|
|
#[derive(Deserialize, PartialEq, Debug, InputObject)]
|
|
struct MyInputObject {
|
|
#[serde(alias = "other")]
|
|
real: i32,
|
|
}
|
|
|
|
assert_eq!(
|
|
serde_json::from_str::<MyInputObject>(r#"{ "other" : 100 }"#).unwrap(),
|
|
MyInputObject { real: 100 }
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_inputobject_flatten_recursive() {
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct A {
|
|
a: i32,
|
|
}
|
|
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct B {
|
|
#[graphql(default = 70)]
|
|
b: i32,
|
|
#[graphql(flatten)]
|
|
a_obj: A,
|
|
}
|
|
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct MyInputObject {
|
|
#[graphql(flatten)]
|
|
b_obj: B,
|
|
c: i32,
|
|
}
|
|
|
|
assert_eq!(
|
|
MyInputObject::parse(Some(value!({
|
|
"a": 10,
|
|
"b": 20,
|
|
"c": 30,
|
|
})))
|
|
.unwrap(),
|
|
MyInputObject {
|
|
b_obj: B {
|
|
b: 20,
|
|
a_obj: A { a: 10 }
|
|
},
|
|
c: 30,
|
|
}
|
|
);
|
|
|
|
assert_eq!(
|
|
MyInputObject {
|
|
b_obj: B {
|
|
b: 20,
|
|
a_obj: A { a: 10 }
|
|
},
|
|
c: 30,
|
|
}
|
|
.to_value(),
|
|
value!({
|
|
"a": 10,
|
|
"b": 20,
|
|
"c": 30,
|
|
})
|
|
);
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn test(&self, input: MyInputObject) -> i32 {
|
|
input.c + input.b_obj.b + input.b_obj.a_obj.a
|
|
}
|
|
|
|
async fn test_with_default(
|
|
&self,
|
|
#[graphql(default_with = r#"MyInputObject {
|
|
b_obj: B {
|
|
b: 2,
|
|
a_obj: A { a: 1 }
|
|
},
|
|
c: 3,
|
|
}"#)]
|
|
input: MyInputObject,
|
|
) -> i32 {
|
|
input.c + input.b_obj.b + input.b_obj.a_obj.a
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute(
|
|
r#"{
|
|
test(input:{a:10, b: 20, c: 30})
|
|
}"#
|
|
)
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"test": 60,
|
|
})
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(
|
|
r#"{
|
|
test(input:{a:10, c: 30})
|
|
}"#
|
|
)
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"test": 110,
|
|
})
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(
|
|
r#"{
|
|
testWithDefault
|
|
}"#
|
|
)
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"testWithDefault": 6,
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_inputobject_flatten_multiple() {
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct A {
|
|
a: i32,
|
|
}
|
|
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct B {
|
|
b: i32,
|
|
}
|
|
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct C {
|
|
c: i32,
|
|
}
|
|
|
|
#[derive(InputObject, Debug, Eq, PartialEq)]
|
|
struct Abc {
|
|
#[graphql(flatten)]
|
|
a: A,
|
|
|
|
#[graphql(flatten)]
|
|
b: B,
|
|
|
|
#[graphql(flatten)]
|
|
c: C,
|
|
}
|
|
|
|
assert_eq!(
|
|
Abc::parse(Some(value!({
|
|
"a": 10,
|
|
"b": 20,
|
|
"c": 30,
|
|
})))
|
|
.unwrap(),
|
|
Abc {
|
|
a: A { a: 10 },
|
|
b: B { b: 20 },
|
|
c: C { c: 30 }
|
|
}
|
|
);
|
|
|
|
assert_eq!(
|
|
Abc {
|
|
a: A { a: 10 },
|
|
b: B { b: 20 },
|
|
c: C { c: 30 }
|
|
}
|
|
.to_value(),
|
|
value!({
|
|
"a": 10,
|
|
"b": 20,
|
|
"c": 30,
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_input_object_skip_field() {
|
|
#[derive(InputObject)]
|
|
struct MyInput2 {
|
|
a: i32,
|
|
#[graphql(skip)]
|
|
b: i32,
|
|
}
|
|
|
|
struct Root;
|
|
|
|
#[Object]
|
|
impl Root {
|
|
async fn a(&self, input: MyInput2) -> i32 {
|
|
assert_eq!(input.b, i32::default());
|
|
input.a
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Root, EmptyMutation, EmptySubscription);
|
|
let query = r#"{
|
|
a(input:{a: 777})
|
|
}"#;
|
|
assert_eq!(
|
|
schema.execute(query).await.into_result().unwrap().data,
|
|
value!({
|
|
"a": 777
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_box_input_object() {
|
|
#[derive(InputObject)]
|
|
struct MyInput {
|
|
value: i32,
|
|
input: Option<Box<MyInput>>,
|
|
}
|
|
|
|
struct Root;
|
|
|
|
#[Object]
|
|
impl Root {
|
|
async fn q(&self, input: MyInput) -> i32 {
|
|
input.value
|
|
+ input.input.as_ref().unwrap().value
|
|
+ input.input.as_ref().unwrap().input.as_ref().unwrap().value
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Root, EmptyMutation, EmptySubscription);
|
|
let query = r#"{
|
|
q(input: {value: 100, input: { value: 200, input: { value: 300 } } })
|
|
}"#;
|
|
assert_eq!(
|
|
schema.execute(query).await.into_result().unwrap().data,
|
|
value!({
|
|
"q": 600
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_both_input_output() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(input_name = "MyObjectInput")]
|
|
#[allow(dead_code)]
|
|
struct MyObject {
|
|
#[graphql(default = 10)]
|
|
a: i32,
|
|
b: bool,
|
|
#[graphql(skip)]
|
|
c: String,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn obj(&self, input: MyObject) -> MyObject {
|
|
input
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ obj(input: {a: 1, b: true}) { a b } }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"obj": {
|
|
"a": 1,
|
|
"b": true,
|
|
}
|
|
})
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ obj(input: {b: true}) { a b } }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"obj": {
|
|
"a": 10,
|
|
"b": true,
|
|
}
|
|
})
|
|
);
|
|
|
|
assert_eq!(<MyObject as InputType>::type_name(), "MyObjectInput");
|
|
assert_eq!(<MyObject as OutputType>::type_name(), "MyObject");
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_both_input_output_2() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(name = "MyObj", input_name = "MyObjectInput")]
|
|
#[allow(dead_code)]
|
|
struct MyObject {
|
|
#[graphql(default = 10)]
|
|
a: i32,
|
|
b: bool,
|
|
#[graphql(skip)]
|
|
c: String,
|
|
}
|
|
|
|
assert_eq!(<MyObject as InputType>::type_name(), "MyObjectInput");
|
|
assert_eq!(<MyObject as OutputType>::type_name(), "MyObj");
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
pub fn test_both_input_output_with_same_name() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[allow(dead_code)]
|
|
struct MyObject {
|
|
#[graphql(default = 10)]
|
|
a: i32,
|
|
b: bool,
|
|
#[graphql(skip)]
|
|
c: String,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn obj(&self, input: MyObject) -> MyObject {
|
|
input
|
|
}
|
|
}
|
|
|
|
Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_both_input_output_flatten() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(input_name = "ABCInput")]
|
|
#[graphql(name = "ABC")]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
struct ABC {
|
|
a: i32,
|
|
#[graphql(flatten)]
|
|
bc: BC,
|
|
}
|
|
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(input_name = "BCInput")]
|
|
struct BC {
|
|
b: i32,
|
|
c: i32,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn obj(&self, input: ABC) -> ABC {
|
|
input
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ obj(input: { a: 1, b: 2, c: 3 }) { a b c } }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"obj": {
|
|
"a": 1,
|
|
"b": 2,
|
|
"c": 3
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_skip_input() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(input_name = "MyObjectInput")]
|
|
#[allow(dead_code)]
|
|
struct MyObject {
|
|
a: i32,
|
|
#[graphql(skip_input)]
|
|
b: i32,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn obj(&self, input: MyObject) -> MyObject {
|
|
input
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ obj(input: { a: 1 }) { a b } }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"obj": {
|
|
"a": 1,
|
|
"b": 0,
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_skip_output() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(input_name = "MyObjectInput")]
|
|
#[allow(dead_code)]
|
|
struct MyObject {
|
|
a: i32,
|
|
#[graphql(skip_output)]
|
|
b: i32,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn obj(&self, input: MyObject) -> MyObject {
|
|
input
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ obj(input: { a: 1, b: 2 }) { a } }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"obj": {
|
|
"a": 1,
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_complex_output() {
|
|
#[derive(SimpleObject, InputObject)]
|
|
#[graphql(input_name = "MyObjectInput")]
|
|
#[graphql(complex)]
|
|
#[allow(dead_code)]
|
|
struct MyObject {
|
|
a: i32,
|
|
}
|
|
|
|
#[ComplexObject]
|
|
impl MyObject {
|
|
async fn double(&self) -> i32 {
|
|
self.a * 2
|
|
}
|
|
}
|
|
|
|
struct Query;
|
|
#[Object]
|
|
impl Query {
|
|
async fn obj(&self, input: MyObject) -> MyObject {
|
|
input
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ obj(input: { a: 1 }) { a, double } }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"obj": {
|
|
"a": 1,
|
|
"double": 2,
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_input_object_process_with() {
|
|
mod processor {
|
|
pub fn string(input: &mut String) {
|
|
while let Some(ch) = input.pop() {
|
|
if !ch.is_whitespace() {
|
|
input.push(ch);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[derive(InputObject)]
|
|
struct MyInput {
|
|
// processor does nothing on default value
|
|
#[graphql(default = " ", process_with = "processor::string")]
|
|
a: String,
|
|
|
|
#[graphql(process_with = "processor::string")]
|
|
b: String,
|
|
}
|
|
|
|
struct MyOutput {
|
|
a: String,
|
|
b: String,
|
|
}
|
|
|
|
#[Object]
|
|
impl MyOutput {
|
|
async fn a(&self) -> &String {
|
|
&self.a
|
|
}
|
|
|
|
async fn b(&self) -> &String {
|
|
&self.b
|
|
}
|
|
}
|
|
|
|
struct Root;
|
|
|
|
#[Object]
|
|
impl Root {
|
|
async fn a(&self, input: MyInput) -> MyOutput {
|
|
MyOutput {
|
|
a: input.a,
|
|
b: input.b,
|
|
}
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Root, EmptyMutation, EmptySubscription);
|
|
let query = r#"{
|
|
a(input:{b: "test b "}) {
|
|
a b
|
|
}
|
|
}"#
|
|
.to_owned();
|
|
assert_eq!(
|
|
schema.execute(&query).await.data,
|
|
value!({
|
|
"a": {
|
|
"a": " ",
|
|
"b": "test b",
|
|
}
|
|
})
|
|
);
|
|
|
|
let schema = Schema::new(Root, EmptyMutation, EmptySubscription);
|
|
let query = r#"{
|
|
a(input:{a: "test a ", b: "test"}) {
|
|
a b
|
|
}
|
|
}"#
|
|
.to_owned();
|
|
assert_eq!(
|
|
schema.execute(&query).await.data,
|
|
value!({
|
|
"a": {
|
|
"a": "test a",
|
|
"b": "test",
|
|
}
|
|
})
|
|
);
|
|
}
|