Use graphql_value!() macro in tests asap

Author: tyranron

examples/actix_subscriptions/src/main.rs

@@ -9,9 +9,9 @@ use actix_web::{
 };
 
 use juniper::{
-    graphql_object, graphql_subscription,
+    graphql_object, graphql_subscription, graphql_value,
     tests::fixtures::starwars::schema::{Character as _, Database, Query},
-    DefaultScalarValue, EmptyMutation, FieldError, RootNode, Value,
+    EmptyMutation, FieldError, RootNode,
 };
 use juniper_actix::{graphql_handler, playground_handler, subscriptions::subscriptions_handler};
 use juniper_graphql_ws::ConnectionConfig;
@@ -77,9 +77,7 @@ impl Subscription {
                 if counter == 2 {
                     yield Err(FieldError::new(
                         "some field error from handler",
-                        Value::Scalar(DefaultScalarValue::String(
-                            "some additional string".to_string(),
-                        )),
+                        graphql_value!("some additional string"),
                     ))
                 } else {
                     let random_id = rng.gen_range(1000..1005).to_string();

examples/warp_subscriptions/src/main.rs

@@ -4,8 +4,8 @@ use std::{env, pin::Pin, sync::Arc, time::Duration};
 
 use futures::{FutureExt as _, Stream};
 use juniper::{
-    graphql_object, graphql_subscription, DefaultScalarValue, EmptyMutation, FieldError,
-    GraphQLEnum, RootNode, Value,
+    graphql_object, graphql_subscription, graphql_value, EmptyMutation, FieldError, GraphQLEnum,
+    RootNode,
 };
 use juniper_graphql_ws::ConnectionConfig;
 use juniper_warp::{playground_filter, subscriptions::serve_graphql_ws};
@@ -117,9 +117,7 @@ impl Subscription {
                 if counter == 2 {
                     yield Err(FieldError::new(
                         "some field error from handler",
-                        Value::Scalar(DefaultScalarValue::String(
-                            "some additional string".to_string(),
-                        )),
+                        graphql_value!("some additional string"),
                     ))
                 } else {
                     yield Ok(User {

integration_tests/juniper_tests/src/codegen/derive_scalar.rs

@@ -1,9 +1,10 @@
-use crate::custom_scalar::MyScalarValue;
 use juniper::{
-    execute, EmptyMutation, EmptySubscription, FromInputValue, InputValue, RootNode, ToInputValue,
-    Value, Variables,
+    execute, graphql_value, EmptyMutation, EmptySubscription, FromInputValue, InputValue, RootNode,
+    ToInputValue, Value, Variables,
 };
 
+use crate::custom_scalar::MyScalarValue;
+
 #[derive(Debug, PartialEq, Eq, Hash, juniper::GraphQLScalarValue)]
 #[graphql(transparent, scalar = MyScalarValue)]
 pub struct LargeId(i64);
@@ -56,28 +57,14 @@ async fn test_scalar_value_large_query() {
         EmptySubscription::<()>::new(),
     );
 
-    let doc = r#"
-        query {
-            user { id }
-        }"#;
+    let doc = r#"{
+        user { id }
+    }"#;
 
+    let val = Value::<MyScalarValue>::scalar(0_i64);
     assert_eq!(
         execute(doc, None, &schema, &Variables::<MyScalarValue>::new(), &()).await,
-        Ok((
-            Value::object(
-                vec![(
-                    "user",
-                    Value::object(
-                        vec![("id", Value::<MyScalarValue>::scalar(0_i64)),]
-                            .into_iter()
-                            .collect(),
-                    ),
-                )]
-                .into_iter()
-                .collect()
-            ),
-            vec![]
-        ))
+        Ok((graphql_value!({"user": {"id": val}}), vec![])),
     );
 }
 
@@ -89,51 +76,23 @@ async fn test_scalar_value_large_mutation() {
         EmptySubscription::<()>::new(),
     );
 
-    let doc = r#"
-        mutation {
-            changeUser(id: 1) { id }
-        }"#;
+    let doc = r#"mutation {
+        changeUser(id: 1) { id }
+    }"#;
 
+    let val = Value::<MyScalarValue>::scalar(1_i64);
     assert_eq!(
         execute(doc, None, &schema, &Variables::<MyScalarValue>::new(), &()).await,
-        Ok((
-            Value::object(
-                vec![(
-                    "changeUser",
-                    Value::object(
-                        vec![("id", Value::<MyScalarValue>::scalar(1_i64)),]
-                            .into_iter()
-                            .collect(),
-                    ),
-                )]
-                .into_iter()
-                .collect()
-            ),
-            vec![]
-        ))
+        Ok((graphql_value!({"changeUser": {"id": val}}), vec![])),
     );
 
-    let doc = r#"
-        mutation {
-            changeUser(id: 4294967297) { id }
-        }"#;
+    let doc = r#"mutation {
+        changeUser(id: 4294967297) { id }
+    }"#;
 
+    let val = Value::<MyScalarValue>::scalar(4294967297_i64);
     assert_eq!(
         execute(doc, None, &schema, &Variables::<MyScalarValue>::new(), &()).await,
-        Ok((
-            Value::object(
-                vec![(
-                    "changeUser",
-                    Value::object(
-                        vec![("id", Value::<MyScalarValue>::scalar(4294967297_i64)),]
-                            .into_iter()
-                            .collect(),
-                    ),
-                )]
-                .into_iter()
-                .collect()
-            ),
-            vec![]
-        ))
+        Ok((graphql_value!({"changeUser": {"id": val}}), vec![])),
     );
 }

integration_tests/juniper_tests/src/codegen/impl_scalar.rs

@@ -222,11 +222,11 @@ async fn default_name_introspection() {
     run_type_info_query(doc, |type_info| {
         assert_eq!(
             type_info.get_field_value("name"),
-            Some(&Value::scalar("DefaultName"))
+            Some(&graphql_value!("DefaultName")),
         );
         assert_eq!(
             type_info.get_field_value("description"),
-            Some(&Value::null())
+            Some(&graphql_value!(None)),
         );
     })
     .await;
@@ -246,11 +246,11 @@ async fn other_order_introspection() {
     run_type_info_query(doc, |type_info| {
         assert_eq!(
             type_info.get_field_value("name"),
-            Some(&Value::scalar("OtherOrder"))
+            Some(&graphql_value!("OtherOrder")),
         );
         assert_eq!(
             type_info.get_field_value("description"),
-            Some(&Value::null())
+            Some(&graphql_value!(None)),
         );
     })
     .await;
@@ -270,11 +270,11 @@ async fn named_introspection() {
     run_type_info_query(doc, |type_info| {
         assert_eq!(
             type_info.get_field_value("name"),
-            Some(&Value::scalar("ANamedScalar"))
+            Some(&graphql_value!("ANamedScalar")),
         );
         assert_eq!(
             type_info.get_field_value("description"),
-            Some(&Value::null())
+            Some(&graphql_value!(None)),
         );
     })
     .await;
@@ -294,11 +294,13 @@ async fn scalar_description_introspection() {
     run_type_info_query(doc, |type_info| {
         assert_eq!(
             type_info.get_field_value("name"),
-            Some(&Value::scalar("ScalarDescription"))
+            Some(&graphql_value!("ScalarDescription")),
         );
         assert_eq!(
             type_info.get_field_value("description"),
-            Some(&Value::scalar("A sample scalar, represented as an integer"))
+            Some(&graphql_value!(
+                "A sample scalar, represented as an integer"
+            )),
         );
     })
     .await;
@@ -318,11 +320,11 @@ async fn generated_scalar_introspection() {
     run_type_info_query(doc, |type_info| {
         assert_eq!(
             type_info.get_field_value("name"),
-            Some(&Value::scalar("Generated"))
+            Some(&graphql_value!("Generated")),
         );
         assert_eq!(
             type_info.get_field_value("description"),
-            Some(&Value::null())
+            Some(&graphql_value!(None)),
         );
     })
     .await;

integration_tests/juniper_tests/src/codegen/subscription_attr.rs

@@ -2,14 +2,15 @@
 
 use std::pin::Pin;
 
-use futures::{future, stream, FutureExt as _, StreamExt as _};
+use futures::{future, stream, FutureExt as _};
 use juniper::{
     execute, graphql_object, graphql_subscription, graphql_value, resolve_into_stream,
-    DefaultScalarValue, EmptyMutation, ExecutionError, Executor, FieldError, FieldResult,
-    GraphQLError, GraphQLInputObject, GraphQLType, IntoFieldError, RootNode, ScalarValue, Value,
-    ValuesStream, Variables,
+    DefaultScalarValue, EmptyMutation, Executor, FieldError, FieldResult, GraphQLInputObject,
+    GraphQLType, IntoFieldError, RootNode, ScalarValue, Variables,
 };
 
+use crate::util::extract_next;
+
 struct Query;
 
 #[graphql_object]
@@ -44,29 +45,6 @@ where
 
 type Stream<'a, I> = Pin<Box<dyn futures::Stream<Item = I> + Send + 'a>>;
 
-async fn extract_next<'a, S: ScalarValue>(
-    input: Result<(Value<ValuesStream<'a, S>>, Vec<ExecutionError<S>>), GraphQLError<'a>>,
-) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>> {
-    let (stream, errs) = input?;
-    if !errs.is_empty() {
-        return Ok((Value::Null, errs));
-    }
-
-    if let Value::Object(obj) = stream {
-        for (name, mut val) in obj {
-            if let Value::Scalar(ref mut stream) = val {
-                return match stream.next().await {
-                    Some(Ok(val)) => Ok((graphql_value!({ name: val }), vec![])),
-                    Some(Err(e)) => Ok((Value::Null, vec![e])),
-                    None => Ok((Value::Null, vec![])),
-                };
-            }
-        }
-    }
-
-    panic!("Expected to get Value::Object containing a Stream")
-}
-
 mod trivial {
     use super::*;
 

integration_tests/juniper_tests/src/custom_scalar.rs

@@ -218,7 +218,7 @@ async fn querying_long() {
     run_query("{ longField }", |result| {
         assert_eq!(
             result.get_field_value("longField"),
-            Some(&Value::scalar(i64::from(i32::max_value()) + 1))
+            Some(&Value::scalar(i64::from(i32::MAX) + 1))
         );
     })
     .await;
@@ -227,14 +227,11 @@ async fn querying_long() {
 #[tokio::test]
 async fn querying_long_arg() {
     run_query(
-        &format!(
-            "{{ longWithArg(longArg: {}) }}",
-            i64::from(i32::max_value()) + 3
-        ),
+        &format!("{{ longWithArg(longArg: {}) }}", i64::from(i32::MAX) + 3),
         |result| {
             assert_eq!(
                 result.get_field_value("longWithArg"),
-                Some(&Value::scalar(i64::from(i32::max_value()) + 3))
+                Some(&Value::scalar(i64::from(i32::MAX) + 3))
             );
         },
     )
@@ -247,14 +244,14 @@ async fn querying_long_variable() {
         "query q($test: Long!){ longWithArg(longArg: $test) }",
         vec![(
             "test".to_owned(),
-            InputValue::Scalar(MyScalarValue::Long(i64::from(i32::max_value()) + 42)),
+            InputValue::Scalar(MyScalarValue::Long(i64::from(i32::MAX) + 42)),
         )]
         .into_iter()
         .collect(),
         |result| {
             assert_eq!(
                 result.get_field_value("longWithArg"),
-                Some(&Value::scalar(i64::from(i32::max_value()) + 42))
+                Some(&Value::scalar(i64::from(i32::MAX) + 42))
             );
         },
     )
@@ -263,15 +260,15 @@ async fn querying_long_variable() {
 
 #[test]
 fn deserialize_variable() {
-    let json = format!("{{\"field\": {}}}", i64::from(i32::max_value()) + 42);
+    let json = format!("{{\"field\": {}}}", i64::from(i32::MAX) + 42);
 
     let input_value: InputValue<MyScalarValue> = serde_json::from_str(&json).unwrap();
     assert_eq!(
         input_value,
         InputValue::Object(vec![(
             Spanning::unlocated("field".into()),
             Spanning::unlocated(InputValue::Scalar(MyScalarValue::Long(
-                i64::from(i32::max_value()) + 42
+                i64::from(i32::MAX) + 42
             )))
         )])
     );