Test (non-nested) input object codegen

Author: tomhoule

graphql_query_derive/src/field_type.rs

@@ -5,7 +5,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 use schema::DEFAULT_SCALARS;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Hash)]
 pub enum FieldType {
     Named(Ident),
     Optional(Box<FieldType>),
@@ -15,6 +15,11 @@ pub enum FieldType {
 impl FieldType {
     /// Takes a field type with its name
     pub fn to_rust(&self, context: &QueryContext, prefix: &str) -> TokenStream {
+        let prefix: String = if prefix.is_empty() {
+            self.inner_name_string()
+        } else {
+            prefix.to_string()
+        };
         match &self {
             FieldType::Named(name) => {
                 let name_string = name.to_string();
@@ -32,17 +37,20 @@ impl FieldType {
                         Span::call_site(),
                     )
                 } else {
-                    Ident::new(prefix, Span::call_site())
+                    if prefix.is_empty() {
+                        panic!("Empty prefix for {:?}", self);
+                    }
+                    Ident::new(&prefix, Span::call_site())
                 };
 
                 quote!(#name)
             }
             FieldType::Optional(inner) => {
-                let inner = inner.to_rust(context, prefix);
+                let inner = inner.to_rust(context, &prefix);
                 quote!( Option<#inner>)
             }
             FieldType::Vector(inner) => {
-                let inner = inner.to_rust(context, prefix);
+                let inner = inner.to_rust(context, &prefix);
                 quote!( Vec<#inner>)
             }
         }
@@ -133,6 +141,12 @@ impl ::std::convert::From<introspection_response::FullTypeFieldsType> for FieldT
     }
 }
 
+impl ::std::convert::From<introspection_response::InputValueType> for FieldType {
+    fn from(schema_type: introspection_response::InputValueType) -> FieldType {
+        from_json_type_inner(&schema_type.type_ref, false)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

graphql_query_derive/src/inputs.rs

@@ -1,43 +1,81 @@
-use query::QueryContext;
+use failure;
+use graphql_parser;
+use introspection_response;
 use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
-use introspection_response;
-use graphql_parser;
+use query::QueryContext;
+use std::collections::HashMap;
 
 #[derive(Debug, PartialEq)]
 pub struct GqlInput {
     pub name: String,
-    pub fields: Vec<GqlObjectField>,
+    pub fields: HashMap<String, GqlObjectField>,
 }
 
 impl GqlInput {
-    pub fn to_rust(&self, context: &QueryContext) -> TokenStream {
+    pub fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, failure::Error> {
         let name = Ident::new(&self.name, Span::call_site());
-        let fields = self.fields.iter().map(|field| {
+        let mut fields: Vec<&GqlObjectField> = self.fields.values().collect();
+        fields.sort_unstable_by(|a, b| a.name.cmp(&b.name));
+        let fields = fields.iter().map(|field| {
             let ty = field.type_.to_rust(&context, "");
             let name = Ident::new(&field.name, Span::call_site());
-            quote!(#ty: #name)
+            quote!(#name: #ty)
         });
 
-        quote!{
+        Ok(quote! {
             #[derive(Debug, Serialize)]
             #[serde(rename_all = "camelCase")]
             pub struct #name {
                 #(#fields,)*
             }
-        }
+        })
     }
 }
 
 impl ::std::convert::From<graphql_parser::schema::InputObjectType> for GqlInput {
     fn from(schema_input: graphql_parser::schema::InputObjectType) -> GqlInput {
-        unimplemented!();
+        GqlInput {
+            name: schema_input.name,
+            fields: schema_input
+                .fields
+                .into_iter()
+                .map(|field| {
+                    let name = field.name.clone();
+                    let field = GqlObjectField {
+                        name: field.name,
+                        type_: field.value_type.into(),
+                    };
+                    (name, field)
+                })
+                .collect(),
+        }
     }
 }
 
 impl ::std::convert::From<introspection_response::FullType> for GqlInput {
     fn from(schema_input: introspection_response::FullType) -> GqlInput {
-        unimplemented!();
+        GqlInput {
+            name: schema_input.name.expect("unnamed input object"),
+            fields: schema_input
+                .input_fields
+                .expect("fields on input object")
+                .into_iter()
+                .filter_map(|a| a)
+                .map(|f| {
+                    let name = f.input_value.name.expect("unnamed input object field");
+                    let field = GqlObjectField {
+                        name: name.clone(),
+                        type_: f
+                            .input_value
+                            .type_
+                            .expect("type on input object field")
+                            .into(),
+                    };
+                    (name, field)
+                })
+                .collect(),
+        }
     }
 }
 
@@ -49,30 +87,66 @@ mod tests {
 
     #[test]
     fn gql_input_to_rust() {
-        let input = GqlInput {
+        let cat = GqlInput {
             name: "Cat".to_string(),
             fields: vec![
-                GqlObjectField {
-                    name: "pawsCount".to_string(),
-                    type_: FieldType::Named(float_type())
-                },
-                GqlObjectField {
-                    name: "offsprings".to_string(),
-                    type_: FieldType::Vector(Box::new(FieldType::Named(Ident::new("Cat", Span::call_site())))),
-                },
-                GqlObjectField {
-                    name: "requirements".to_string(),
-                    type_: FieldType::Optional(Box::new(FieldType::Named(Ident::new("CatRequirements", Span::call_site())))),
-                },
-            ],
+                (
+                    "pawsCount".to_string(),
+                    GqlObjectField {
+                        name: "pawsCount".to_string(),
+                        type_: FieldType::Named(float_type()),
+                    },
+                ),
+                (
+                    "offsprings".to_string(),
+                    GqlObjectField {
+                        name: "offsprings".to_string(),
+                        type_: FieldType::Vector(Box::new(FieldType::Named(Ident::new(
+                            "Cat",
+                            Span::call_site(),
+                        )))),
+                    },
+                ),
+                (
+                    "requirements".to_string(),
+                    GqlObjectField {
+                        name: "requirements".to_string(),
+                        type_: FieldType::Optional(Box::new(FieldType::Named(Ident::new(
+                            "CatRequirements",
+                            Span::call_site(),
+                        )))),
+                    },
+                ),
+            ].into_iter()
+                .collect(),
         };
 
-
         let expected: String = vec![
-            "",
-            "",
-        ].into_iter().collect();
+            "# [ derive ( Debug , Serialize ) ] ",
+            "# [ serde ( rename_all = \"camelCase\" ) ] ",
+            "pub struct Cat { ",
+            "offsprings : Vec < Cat > , ",
+            "pawsCount : Float , ",
+            "requirements : Option < CatRequirements > , ",
+            "}",
+        ].into_iter()
+            .collect();
+
+        let mut context = QueryContext::new_empty();
+        context.schema.inputs.insert(cat.name.clone(), cat);
 
-        assert_eq!(format!("{:?}", input.to_rust()), expected);
+        assert_eq!(
+            format!(
+                "{}",
+                context
+                    .schema
+                    .inputs
+                    .get("Cat")
+                    .unwrap()
+                    .to_rust(&context)
+                    .unwrap()
+            ),
+            expected
+        );
     }
 }

graphql_query_derive/src/introspection_response.rs

@@ -169,7 +169,7 @@ pub struct FullTypeFields {
 #[serde(rename_all = "camelCase")]
 pub struct FullTypeInputFields {
     #[serde(flatten)]
-    input_value: InputValue,
+    pub input_value: InputValue,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -198,11 +198,11 @@ pub struct FullTypePossibleTypes {
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct InputValue {
-    name: Option<String>,
-    description: Option<String>,
+    pub name: Option<String>,
+    pub description: Option<String>,
     #[serde(rename = "type")]
-    type_: Option<InputValueType>,
-    default_value: Option<String>,
+    pub type_: Option<InputValueType>,
+    pub default_value: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize)]

graphql_query_derive/src/objects.rs

@@ -14,7 +14,7 @@ pub struct GqlObject {
     pub fields: Vec<GqlObjectField>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Hash)]
 pub struct GqlObjectField {
     pub name: String,
     pub type_: FieldType,

graphql_query_derive/src/schema.rs

@@ -235,7 +235,9 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                         );
                     }
                     schema::TypeDefinition::InputObject(input) => {
-                        schema.inputs.insert(input.name.clone(), GqlInput::from(input));
+                        schema
+                            .inputs
+                            .insert(input.name.clone(), GqlInput::from(input));
                     }
                 },
                 schema::Definition::DirectiveDefinition(_) => (),

graphql_query_derive/src/tests/github.rs

@@ -25,7 +25,10 @@ fn ast_from_graphql_and_json_produce_the_same_schema() {
     assert_eq!(json.query_type, gql.query_type);
     assert_eq!(json.mutation_type, gql.mutation_type);
     assert_eq!(json.subscription_type, gql.subscription_type);
-    assert_eq!(json.inputs, gql.inputs);
+    for (json, gql) in json.inputs.iter().zip(gql.inputs.iter()) {
+        assert_eq!(json, gql);
+    }
+    assert_eq!(json.inputs, gql.inputs, "inputs differ");
     for ((json_name, json_value), (gql_name, gql_value)) in json.enums.iter().zip(gql.enums.iter())
     {
         assert_eq!(json_name, gql_name);

tests/input_object_variables/input_object_variables.rs

@@ -0,0 +1,42 @@
+#[macro_use]
+extern crate graphql_client;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
+extern crate serde_json;
+
+#[derive(GraphQLQuery)]
+#[GraphQLQuery(
+    query_path = "tests/scalar_variables_query.graphql",
+    schema_path = "tests/scalar_variables_schema.graphql"
+)]
+#[allow(dead_code)]
+struct ScalarVariablesQuery;
+
+#[test]
+fn scalar_variables_query_variables_struct() {
+    scalar_variables_query::Variables {
+        msg: "hello".to_string(),
+        reps: Some(32),
+    };
+}
+
+#[derive(GraphQLQuery)]
+#[GraphQLQuery(
+    query_path = "tests/scalar_variables_query_defaults.graphql",
+    schema_path = "tests/scalar_variables_schema.graphql"
+)]
+#[allow(dead_code)]
+struct DefaultScalarVariablesQuery;
+
+#[test]
+fn scalar_variables_default() {
+    let variables = default_scalar_variables_query::Variables {
+        msg: default_scalar_variables_query::Variables::default_msg(),
+        reps: default_scalar_variables_query::Variables::default_reps(),
+    };
+
+    let out = serde_json::to_string(&variables).unwrap();
+
+    assert_eq!(out, r#"{"msg":"o, hai","reps":3}"#);
+}

tests/input_object_variables/input_object_variables_defaults.graphql

@@ -0,0 +1,5 @@
+query VariablesQuery($msg: String = "o, hai", $reps: Int = 3) {
+  echo(message: $msg, repetitions: $reps) {
+    result
+  }
+}

tests/input_object_variables/input_object_variables_query.graphql

@@ -0,0 +1,5 @@
+query VariablesQuery($msg: String!, $reps: Int) {
+    echo(message: $msg, repetitions: $reps) {
+        result
+    }
+}

tests/input_object_variables/input_object_variables_schema.graphql

@@ -0,0 +1,12 @@
+
+schema {
+    query: ScalarVariablesQuery
+}
+
+type ScalarVariablesQuery {
+    echo(message: String!, repetitions: Int): EchoResult
+}
+
+type EchoResult {
+    result: String!
+}