793 lines
21 KiB
Rust
793 lines
21 KiB
Rust
use std::sync::Arc;
|
|
|
|
use async_graphql::*;
|
|
use futures_util::{Stream, StreamExt};
|
|
|
|
#[tokio::test]
|
|
pub async fn test_all_validator() {
|
|
struct Query;
|
|
|
|
#[Object]
|
|
#[allow(unreachable_code, unused_variables)]
|
|
impl Query {
|
|
async fn multiple_of(&self, #[graphql(validator(multiple_of = 10))] n: i32) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn maximum(&self, #[graphql(validator(maximum = 10))] n: i32) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn minimum(&self, #[graphql(validator(minimum = 10))] n: i32) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn max_length(&self, #[graphql(validator(max_length = 10))] n: String) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn min_length(&self, #[graphql(validator(min_length = 10))] n: String) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn max_items(&self, #[graphql(validator(max_items = 10))] n: Vec<String>) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn min_items(&self, #[graphql(validator(min_items = 10))] n: Vec<String>) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn chars_max_length(
|
|
&self,
|
|
#[graphql(validator(chars_max_length = 10))] n: String,
|
|
) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn chars_length(
|
|
&self,
|
|
#[graphql(validator(chars_min_length = 10))] n: String,
|
|
) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn email(&self, #[graphql(validator(email))] n: String) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn url(&self, #[graphql(validator(url))] n: String) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn ip(&self, #[graphql(validator(ip))] n: String) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn regex(&self, #[graphql(validator(regex = "^[0-9]+$"))] n: String) -> i32 {
|
|
todo!()
|
|
}
|
|
|
|
async fn list_email(&self, #[graphql(validator(list, email))] n: Vec<String>) -> i32 {
|
|
todo!()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_validator_on_object_field_args() {
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn value(&self, #[graphql(validator(maximum = 10))] n: i32) -> i32 {
|
|
n
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: 5) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 5 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: 11) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 11, must be less than or equal to 10"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 12
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_validator_on_input_object_field() {
|
|
#[derive(InputObject)]
|
|
struct MyInput {
|
|
#[graphql(validator(maximum = 10))]
|
|
a: i32,
|
|
#[graphql(validator(maximum = 10))]
|
|
b: Option<i32>,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn value(&self, input: MyInput) -> i32 {
|
|
input.a + input.b.unwrap_or_default()
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(input: {a: 5}) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 5 })
|
|
);
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(input: {a: 5, b: 7}) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 12 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(input: {a: 11}) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 11, must be less than or equal to 10 (occurred while parsing "MyInput")"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 16
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(input: {a: 5, b: 20}) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 20, must be less than or equal to 10 (occurred while parsing "MyInput")"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 16
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_validator_on_complex_object_field_args() {
|
|
#[derive(SimpleObject)]
|
|
#[graphql(complex)]
|
|
struct Query {
|
|
a: i32,
|
|
}
|
|
|
|
#[ComplexObject]
|
|
impl Query {
|
|
async fn value(&self, #[graphql(validator(maximum = 10))] n: i32) -> i32 {
|
|
n
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query { a: 10 }, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: 5) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 5 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: 11) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 11, must be less than or equal to 10"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 12
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_validator_on_subscription_field_args() {
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn value(&self) -> i32 {
|
|
1
|
|
}
|
|
}
|
|
|
|
struct Subscription;
|
|
|
|
#[Subscription]
|
|
impl Subscription {
|
|
async fn value(
|
|
&self,
|
|
#[graphql(validator(maximum = 10))] n: i32,
|
|
) -> impl Stream<Item = i32> {
|
|
futures_util::stream::iter(vec![n])
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, Subscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute_stream("subscription { value(n: 5) }")
|
|
.collect::<Vec<_>>()
|
|
.await
|
|
.remove(0)
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 5 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute_stream("subscription { value(n: 11) }")
|
|
.collect::<Vec<_>>()
|
|
.await
|
|
.remove(0)
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 11, must be less than or equal to 10"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 25
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_custom_validator() {
|
|
struct MyValidator {
|
|
expect: i32,
|
|
}
|
|
|
|
impl MyValidator {
|
|
pub fn new(n: i32) -> Self {
|
|
MyValidator { expect: n }
|
|
}
|
|
}
|
|
|
|
impl CustomValidator<i32> for MyValidator {
|
|
fn check(&self, value: &i32) -> Result<(), String> {
|
|
if *value == self.expect {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("expect 100, actual {}", value))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(InputObject)]
|
|
struct MyInput {
|
|
#[graphql(validator(custom = "MyValidator::new(100)"))]
|
|
n: i32,
|
|
}
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn value(
|
|
&self,
|
|
#[graphql(validator(custom = "MyValidator::new(100)"))] n: i32,
|
|
) -> i32 {
|
|
n
|
|
}
|
|
|
|
async fn input(&self, input: MyInput) -> i32 {
|
|
input.n
|
|
}
|
|
|
|
async fn value2(
|
|
&self,
|
|
#[graphql(validator(list, custom = "MyValidator::new(100)"))] values: Vec<i32>,
|
|
) -> i32 {
|
|
values.into_iter().sum()
|
|
}
|
|
|
|
async fn value3(
|
|
&self,
|
|
#[graphql(validator(list, custom = "MyValidator::new(100)"))] values: Option<Vec<i32>>,
|
|
) -> i32 {
|
|
values.into_iter().flatten().sum()
|
|
}
|
|
}
|
|
|
|
struct Subscription;
|
|
|
|
#[Subscription]
|
|
impl Subscription {
|
|
async fn value(
|
|
&self,
|
|
#[graphql(validator(custom = "MyValidator::new(100)"))] n: i32,
|
|
) -> impl Stream<Item = i32> {
|
|
futures_util::stream::iter(vec![n])
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, Subscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: 100) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 100 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: 11) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": expect 100, actual 11"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 12
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ input(input: {n: 100} ) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "input": 100 })
|
|
);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ input(input: {n: 11} ) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message:
|
|
r#"Failed to parse "Int": expect 100, actual 11 (occurred while parsing "MyInput")"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 16
|
|
}],
|
|
path: vec![PathSegment::Field("input".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute_stream("subscription { value(n: 100 ) }")
|
|
.next()
|
|
.await
|
|
.unwrap()
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 100 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute_stream("subscription { value(n: 11 ) }")
|
|
.next()
|
|
.await
|
|
.unwrap()
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": expect 100, actual 11"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 25
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value2(values: [77, 88] ) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "[Int!]": expect 100, actual 77"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 18
|
|
}],
|
|
path: vec![PathSegment::Field("value2".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value3(values: [77, 88] ) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "[Int!]": expect 100, actual 77"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 18
|
|
}],
|
|
path: vec![PathSegment::Field("value3".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value3(values: null ) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"value3": 0
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_list_validator() {
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn value(&self, #[graphql(validator(maximum = 3, list))] n: Vec<i32>) -> i32 {
|
|
n.into_iter().sum()
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: [1, 2, 3]) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({ "value": 6 })
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ value(n: [1, 2, 3, 4]) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 4, must be less than or equal to 3"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos {
|
|
line: 1,
|
|
column: 12
|
|
}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_validate_wrapper_types() {
|
|
#[derive(NewType)]
|
|
struct Size(i32);
|
|
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn a(&self, #[graphql(validator(maximum = 10))] n: Option<i32>) -> i32 {
|
|
n.unwrap_or_default()
|
|
}
|
|
|
|
async fn b(&self, #[graphql(validator(maximum = 10))] n: Option<Option<i32>>) -> i32 {
|
|
n.unwrap_or_default().unwrap_or_default()
|
|
}
|
|
|
|
async fn c(&self, #[graphql(validator(maximum = 10))] n: MaybeUndefined<i32>) -> i32 {
|
|
n.take().unwrap_or_default()
|
|
}
|
|
|
|
async fn d(&self, #[graphql(validator(maximum = 10))] n: Box<i32>) -> i32 {
|
|
*n
|
|
}
|
|
|
|
async fn e(&self, #[graphql(validator(maximum = 10))] n: Arc<i32>) -> i32 {
|
|
*n
|
|
}
|
|
|
|
async fn f(&self, #[graphql(validator(maximum = 10))] n: Json<i32>) -> i32 {
|
|
n.0
|
|
}
|
|
|
|
async fn g(&self, #[graphql(validator(maximum = 10))] n: Option<Json<i32>>) -> i32 {
|
|
n.map(|n| n.0).unwrap_or_default()
|
|
}
|
|
|
|
async fn h(&self, #[graphql(validator(maximum = 10))] n: Size) -> i32 {
|
|
n.0
|
|
}
|
|
|
|
async fn i(&self, #[graphql(validator(list, maximum = 10))] n: Vec<i32>) -> i32 {
|
|
n.into_iter().sum()
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
|
|
let successes = [
|
|
("{ a(n: 5) }", value!({ "a": 5 })),
|
|
("{ a }", value!({ "a": 0 })),
|
|
("{ b(n: 5) }", value!({ "b": 5 })),
|
|
("{ b }", value!({ "b": 0 })),
|
|
("{ c(n: 5) }", value!({ "c": 5 })),
|
|
("{ c(n: null) }", value!({ "c": 0 })),
|
|
("{ c }", value!({ "c": 0 })),
|
|
("{ d(n: 5) }", value!({ "d": 5 })),
|
|
("{ e(n: 5) }", value!({ "e": 5 })),
|
|
("{ f(n: 5) }", value!({ "f": 5 })),
|
|
("{ g(n: 5) }", value!({ "g": 5 })),
|
|
("{ g }", value!({ "g": 0 })),
|
|
("{ h(n: 5) }", value!({ "h": 5 })),
|
|
("{ i(n: [1, 2, 3]) }", value!({ "i": 6 })),
|
|
];
|
|
|
|
for (query, res) in successes {
|
|
assert_eq!(schema.execute(query).await.into_result().unwrap().data, res);
|
|
}
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ a(n:20) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 20, must be less than or equal to 10"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { line: 1, column: 7 }],
|
|
path: vec![PathSegment::Field("a".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ b(n:20) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 20, must be less than or equal to 10"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { line: 1, column: 7 }],
|
|
path: vec![PathSegment::Field("b".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute("{ f(n:20) }")
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "Int": the value is 20, must be less than or equal to 10"#
|
|
.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { line: 1, column: 7 }],
|
|
path: vec![PathSegment::Field("f".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
pub async fn test_list_both_max_items_and_max_length() {
|
|
struct Query;
|
|
|
|
#[Object]
|
|
impl Query {
|
|
async fn value(
|
|
&self,
|
|
#[graphql(validator(list, max_length = 3, max_items = 2))] values: Vec<String>,
|
|
) -> String {
|
|
values.into_iter().collect()
|
|
}
|
|
|
|
async fn value2(
|
|
&self,
|
|
#[graphql(validator(list, max_length = 3, max_items = 2))] values: Option<Vec<String>>,
|
|
) -> String {
|
|
values.into_iter().flatten().collect()
|
|
}
|
|
}
|
|
|
|
let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value(values: ["a", "b", "cdef"])}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "[String!]": the value length is 3, must be less than or equal to 2"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { column: 17, line: 1}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value(values: ["a", "cdef"])}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "String": the string length is 4, must be less than or equal to 3"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { column: 17, line: 1}],
|
|
path: vec![PathSegment::Field("value".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value(values: ["a", "b"])}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"value": "ab"
|
|
})
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value2(values: ["a", "b", "cdef"])}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "[String!]": the value length is 3, must be less than or equal to 2"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { column: 18, line: 1}],
|
|
path: vec![PathSegment::Field("value2".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value2(values: ["a", "cdef"])}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "String": the string length is 4, must be less than or equal to 3"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { column: 18, line: 1}],
|
|
path: vec![PathSegment::Field("value2".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value2(values: ["a", "b", "cdef"])}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap_err(),
|
|
vec![ServerError {
|
|
message: r#"Failed to parse "[String!]": the value length is 3, must be less than or equal to 2"#.to_string(),
|
|
source: None,
|
|
locations: vec![Pos { column: 18, line: 1}],
|
|
path: vec![PathSegment::Field("value2".to_string())],
|
|
extensions: None
|
|
}]
|
|
);
|
|
|
|
assert_eq!(
|
|
schema
|
|
.execute(r#"{ value2(values: null)}"#)
|
|
.await
|
|
.into_result()
|
|
.unwrap()
|
|
.data,
|
|
value!({
|
|
"value2": ""
|
|
})
|
|
);
|
|
}
|