Test union codegen

Now it needs to be made correct: require and handle __TypeName, and
probably make the generated type an enum.

Author: tomhoule

.travis.yml

@@ -5,7 +5,6 @@ rust:
   - nightly
 cache: cargo
 script:
-  - cargo test --verbose
-  - cargo test --verbose --manifest-path=./graphql_query_derive/Cargo.toml
+  - cargo test --all
   - cargo build --manifest-path=./examples/github/Cargo.toml
   - cargo build --manifest-path=./graphql_client_cli/Cargo.toml

graphql_query_derive/src/objects.rs

@@ -85,7 +85,7 @@ impl GqlObject {
                         .fields
                         .iter()
                         .find(|field| field.name.as_str() == name.as_str())
-                        .unwrap()
+                        .expect("could not find field")
                         .type_;
                     let ty = ty.to_rust(
                         query_context,

graphql_query_derive/src/query.rs

@@ -53,7 +53,7 @@ impl QueryContext {
         } else if let Some(iface) = self.schema.interfaces.get(ty) {
             Ok(iface.response_for_selection(self, &selection, prefix))
         } else if let Some(unn) = self.schema.unions.get(ty) {
-            Ok(unn.response_for_selection(self, &selection, prefix))
+            unn.response_for_selection(self, &selection, prefix)
         } else {
             Ok(quote!())
         }

graphql_query_derive/src/unions.rs

@@ -3,20 +3,28 @@ use query::QueryContext;
 use std::collections::BTreeSet;
 use selection::{Selection, SelectionItem};
 use heck::SnakeCase;
+use failure;
 
 #[derive(Debug, PartialEq)]
 pub struct GqlUnion(pub BTreeSet<String>);
 
+#[derive(Debug, Fail)]
+#[fail(display = "UnionError")]
+enum UnionError {
+    #[fail(display = "Unknown type: {}", ty)]
+    UnknownType { ty: String },
+}
+
 impl GqlUnion {
     pub fn response_for_selection(
         &self,
         query_context: &QueryContext,
         selection: &Selection,
         prefix: &str,
-    ) -> TokenStream {
+    ) -> Result<TokenStream, failure::Error> {
         let struct_name = Ident::new(prefix, Span::call_site());
-        let mut children_definitions = Vec::new();
-        let fields = selection.0.iter().map(|item| {
+        let mut children_definitions: Vec<TokenStream> = Vec::new();
+        let fields: Result<Vec<TokenStream>, failure::Error> = selection.0.iter().map(|item| {
             match item {
                 SelectionItem::Field(_) => unreachable!("field selection on union"),
                 SelectionItem::FragmentSpread(_) => unreachable!("fragment spread on union"),
@@ -38,35 +46,123 @@ impl GqlUnion {
                     let field_union_type = query_context.schema.unions.get(&frag.on)
                         .map(|f| query_context.maybe_expand_field(&frag.on, &frag.fields, &new_prefix));
 
-                    if let Some(tokens) = field_object_type.or(field_interface).or(field_union_type) {
-                        children_definitions.push(tokens)
-                    }
+                    match field_object_type.or(field_interface).or(field_union_type) {
+                        Some(tokens) => children_definitions.push(tokens?),
+                        None => Err(UnionError::UnknownType { ty: frag.on.to_string() })?,
+                    };
 
-        // query_context.maybe_expand_field(
-
-        // );
-                    quote! {
+                    Ok(quote! {
                         #field_name: #field_type
-                    }
+                    })
                 }
             }
-        });
+        }).collect();
+
+        let fields = fields?;
+
+        Ok(quote!{
+            #(#children_definitions)*
 
-        quote!{
             #[derive(Deserialize)]
             pub struct #struct_name {
                 #(#fields),*
             }
-        }
+        })
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use selection::*;
+    use super::*;
+    use objects::{GqlObject, GqlObjectField};
+    use field_type::FieldType;
 
     #[test]
     fn union_response_for_selection_works() {
-        // unimplemented!()
-    }
+        let fields = vec![
+            SelectionItem::InlineFragment(SelectionInlineFragment {
+                on: "User".to_string(),
+                fields: Selection(vec![SelectionItem::Field(SelectionField {
+                    name: "first_name".to_string(),
+                    fields: Selection(vec![]),
+                })]),
+            }),
+            SelectionItem::InlineFragment(SelectionInlineFragment {
+                on: "Organization".to_string(),
+                fields: Selection(vec![SelectionItem::Field(SelectionField {
+                    name: "title".to_string(),
+                    fields: Selection(vec![]),
+                })]),
+            }),
+        ];
+        let mut context = QueryContext::new_empty();
+        let selection = Selection(fields);
+        let prefix = "Meow";
+        let union = GqlUnion(BTreeSet::new());
+
+        let result = union.response_for_selection(
+            &context,
+            &selection,
+            &prefix,
+        );
+
 
+        assert!(result.is_err());
+
+        context.schema.objects.insert(
+            "User".to_string(), GqlObject {
+                name: "User".to_string(),
+                fields: vec![
+                    GqlObjectField {
+                        name: "first_name".to_string(),
+                        type_: FieldType::Named(Ident::new("String", Span::call_site())),
+                    },
+                    GqlObjectField {
+                        name: "last_name".to_string(),
+                        type_: FieldType::Named(Ident::new("String", Span::call_site())),
+                    },
+                    GqlObjectField {
+                        name: "created_at".to_string(),
+                        type_: FieldType::Named(Ident::new("Date", Span::call_site())),
+                    }
+                ],
+            }
+        );
+
+        context.schema.objects.insert(
+            "Organization".to_string(), GqlObject {
+                name: "Organization".to_string(),
+                fields: vec![
+                    GqlObjectField {
+                        name: "title".to_string(),
+                        type_: FieldType::Named(Ident::new("String", Span::call_site())),
+                    },
+                    GqlObjectField {
+                        name: "created_at".to_string(),
+                        type_: FieldType::Named(Ident::new("Date", Span::call_site())),
+                    }
+                ],
+            }
+        );
+
+        let result = union.response_for_selection(
+            &context,
+            &selection,
+            &prefix,
+        );
+
+        assert!(result.is_ok());
+
+        assert_eq!(
+            result.unwrap().to_string(),
+            vec![
+                "# [ derive ( Debug , Serialize , Deserialize ) ] ",
+                "pub struct MeowOnUser { first_name : String , } ",
+                "# [ derive ( Debug , Serialize , Deserialize ) ] ",
+                "pub struct MeowOnOrganization { title : String , } ",
+                "# [ derive ( Deserialize ) ] pub struct Meow { on_user : MeowOnUser , on_organization : MeowOnOrganization }",
+            ].into_iter().collect::<String>(),
+        );
+    }
 }