graphql 1.4.5 → 1.5.3

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -2,162 +2,196 @@
 require "spec_helper"
 
 describe GraphQL::InternalRepresentation::Rewrite do
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema) }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-  let(:rewrite_result) {
-    validator.validate(query)[:irep]
-  }
-  describe "plain queries" do
-    let(:query_string) {%|
-    query getCheeses {
-      cheese1: cheese(id: 1) {
-        id1: id
-        id2: id
-        id3: id
-      }
-      cheese2: cheese(id: 2) {
-        id
-      }
+  let(:schema) {
+    GraphQL::Schema.from_definition <<-GRAPHQL
+    type Query {
+      plant(id: ID!): Plant
     }
-    |}
 
-    it "produces a tree of nodes" do
-      op_node = rewrite_result["getCheeses"]
-
-      root_children = op_node.typed_children[Dummy::DairyAppQueryType]
-      assert_equal 2, root_children.length
-      assert_equal Dummy::DairyAppQueryType, op_node.return_type
-      first_field = root_children.values.first
-      assert_equal 3, first_field.typed_children[Dummy::CheeseType].length
-      assert_equal Dummy::DairyAppQueryType, first_field.owner_type
-      assert_equal Dummy::CheeseType, first_field.return_type
-
-      second_field = root_children.values.last
-      assert_equal 1, second_field.typed_children[Dummy::CheeseType].length
-      assert_equal Dummy::DairyAppQueryType.get_field("cheese"), second_field.definition
-      assert_equal Dummy::CheeseType, second_field.return_type
-      assert second_field.inspect.is_a?(String)
-    end
-  end
+    union Plant = Grain | Fruit | Vegetable | Nut
 
-  describe "dynamic fields" do
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          typename: __typename
-        }
-      }
-    |}
+    interface Tree {
+      name: String!
+      leafType: LeafType
+      habitats: [Habitat]
+    }
 
-    it "gets dynamic field definitions" do
-      cheese_field = rewrite_result[nil].typed_children[Dummy::DairyAppQueryType]["cheese"]
-      typename_field = cheese_field.typed_children[Dummy::CheeseType]["typename"]
-      assert_equal "__typename", typename_field.definition.name
-      assert_equal "__typename", typename_field.definition_name
-    end
-  end
+    enum LeafType {
+      NEEDLE
+      LEAF
+    }
 
-  describe "merging fragments" do
-    let(:query_string) {%|
-    {
-      cheese(id: 1) {
-        id1: id
-        ... {
-          id2: id
-        }
+    type Fruit implements Tree {
+      name: String!
+      color: [Int!]!
+      leafType: LeafType
+      habitats: [Habitat]
+    }
 
-        fatContent
-        ... on Edible {
-          fatContent
-          origin
-        }
+    type Vegetable {
+      name: String!
+      edibleParts: [String!]!
+    }
 
-        ... cheeseFields
+    type Grain {
+      name: String!
+    }
 
-        ... similarCheeseField
-      }
+    type Nut implements Tree {
+      name: String!
+      diameter: Int!
+      leafType: LeafType
+      habitats: [Habitat]
+    }
 
-      cheese2: cheese(id: 2) {
-        similarCheese(source: COW) {
-          id
-        }
-        ... cheese2Fields
-      }
+    type Habitat {
+      residentName: String!
+      averageWeight: Int!
+      seasons: [String]
     }
+    GRAPHQL
 
-    fragment cheeseFields on Cheese {
-      fatContent
-      flavor
-      similarCow: similarCheese(source: COW) {
-        similarCowSource: source,
-        id
-        ... similarCowFields
+  }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: schema) }
+  let(:query) { GraphQL::Query.new(schema, query_string) }
+  let(:rewrite_result) {
+    res = validator.validate(query)
+    res[:errors].any? && raise(res[:errors].map(&:message).join("; "))
+    res[:irep]
+  }
+  # TODO: make sure all rewrite specs are covered
+
+  describe "building a tree over concrete types with fragments" do
+    let(:query_string) {
+      <<-GRAPHQL
+      query getPlant($id: ID!) {
+        plant(id: $id) {
+          __typename
+          ... on Tree {
+            leafType
+            habitats {
+              averageWeight
+            }
+          }
+          ... on Fruit {
+            name
+            color
+            ... on Tree {
+              leafType
+            }
+          }
+          ... on Nut {
+            leafType
+            ...NutFields
+          }
+        }
       }
-    }
 
-    fragment similarCowFields on Cheese {
-      similarCheese(source: SHEEP) {
-        source
+      fragment NutFields on Nut {
+        leafType
+        ... TreeFields
       }
-    }
 
-    fragment similarCheeseField on Cheese {
-      # deep fragment merge
-      similarCow: similarCheese(source: COW) {
-        similarCowSource: source,
-        fatContent
-        similarCheese(source: SHEEP) {
-          flavor
+      fragment TreeFields on Tree {
+        habitats {
+          ... HabitatFields
         }
       }
-    }
-
-    fragment cheese2InnerFields on Cheese {
-      id
-      fatContent
-    }
 
-    fragment cheese2Fields on Cheese {
-      similarCheese(source: COW) {
-        ... cheese2InnerFields
+      fragment HabitatFields on Habitat {
+        seasons
       }
+      GRAPHQL
     }
 
-    |}
+    it "groups selections by object types which they apply to" do
+      doc = rewrite_result["getPlant"]
+
+      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
+      assert_equal ["Fruit", "Grain", "Nut", "Vegetable"], plant_selection.typed_children.keys.map(&:name).sort
+
+      fruit_selections = plant_selection.typed_children[schema.types["Fruit"]]
+      assert_equal ["__typename", "color", "habitats", "leafType", "name"], fruit_selections.keys.sort
+      assert_equal 2, fruit_selections["leafType"].ast_nodes.size
+
+      nut_selections = plant_selection.typed_children[schema.types["Nut"]]
+      # `... on Tree`, `... on Nut`, and `NutFields`, but not `... on Fruit { ... on Tree }`
+      assert_equal 3, nut_selections["leafType"].ast_nodes.size
+      # Multi-level merging when including fragments:
+      habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]
+      assert_equal ["averageWeight", "seasons"], habitats_selections.keys
+    end
+  end
+
+  describe "tracking directives on fragment spreads" do
+    let(:query_string) { <<-GRAPHQL
+      query getPlant($id: ID!) {
+        plant(id: $id) {
+          ... on Nut @skip(if: true) {
+            leafType
+          }
+
+          ... on Tree {
+            leafType @include(if: true)
+          }
 
-    it "puts all fragment members as children" do
-      op_node = rewrite_result[nil]
+          ... on Nut {
+            leafType # no directives
+          }
 
-      cheese_field = op_node.typed_children[Dummy::DairyAppQueryType]["cheese"]
-      assert_equal ["id1", "id2", "fatContent", "similarCow", "flavor"], cheese_field.typed_children[Dummy::CheeseType].keys
-      assert_equal ["fatContent", "origin"], cheese_field.typed_children[Dummy::EdibleInterface].keys
-      # Merge:
-      similar_cow_field = cheese_field.typed_children[Dummy::CheeseType]["similarCow"]
-      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.typed_children[Dummy::CheeseType].keys
-      # Deep merge:
-      similar_sheep_field = similar_cow_field.typed_children[Dummy::CheeseType]["similarCheese"]
-      assert_equal ["flavor", "source"], similar_sheep_field.typed_children[Dummy::CheeseType].keys
+          ... NutFields @include(if: false)
+        }
+      }
+      fragment NutFields on Nut {
+        leafType @skip(if: false)
+      }
+    GRAPHQL
+    }
 
-      edible_origin_node = cheese_field.typed_children[Dummy::EdibleInterface]["origin"]
-      assert_equal Dummy::EdibleInterface.get_field("origin"), edible_origin_node.definition
-      assert_equal Dummy::EdibleInterface, edible_origin_node.owner_type
+    it "applies directives from all contexts" do
+      doc = rewrite_result["getPlant"]
+      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
+      leaf_type_selection = plant_selection.typed_children[schema.types["Nut"]]["leafType"]
+      # Only unskipped occurrences in the AST
+      assert_equal 2, leaf_type_selection.ast_nodes.size
+    end
+  end
 
-      edible_fat_content_node = cheese_field.typed_children[Dummy::EdibleInterface]["fatContent"]
-      assert_equal Dummy::EdibleInterface.get_field("fatContent"), edible_fat_content_node.definition
-      assert_equal Dummy::EdibleInterface, edible_fat_content_node.owner_type
+  describe "deep fragment merging" do
+    let(:query_string) { <<-GRAPHQL
+      {
+        plant(id: 1) {
+          ...TreeFields
+          ...NutFields
+        }
+      }
 
-      cheese_fat_content_node = cheese_field.typed_children[Dummy::CheeseType]["fatContent"]
-      assert_equal Dummy::CheeseType.get_field("fatContent"), cheese_fat_content_node.definition
-      assert_equal Dummy::CheeseType, cheese_fat_content_node.owner_type
+      fragment TreeFields on Tree {
+        habitats {
+          seasons
+        }
+      }
 
-      cheese_flavor_node = cheese_field.typed_children[Dummy::CheeseType]["flavor"]
-      assert_equal Dummy::CheeseType.get_field("flavor"), cheese_flavor_node.definition
-      assert_equal Dummy::CheeseType, cheese_flavor_node.owner_type
+      fragment NutFields on Nut {
+        habitats {
+          residentName
+          ... HabitatFields
+        }
+      }
 
+      fragment HabitatFields on Habitat {
+        averageWeight
+      }
+      GRAPHQL
+    }
 
-      # nested spread inside fragment definition:
-      cheese_2_field = op_node.typed_children[Dummy::DairyAppQueryType]["cheese2"].typed_children[Dummy::CheeseType]["similarCheese"]
-      assert_equal ["id", "fatContent"], cheese_2_field.typed_children[Dummy::CheeseType].keys
+    it "applies spreads to their parents only" do
+      doc = rewrite_result[nil]
+      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
+      nut_habitat_selections = plant_selection.typed_children[schema.types["Nut"]]["habitats"].typed_children[schema.types["Habitat"]]
+      assert_equal ["averageWeight", "residentName", "seasons"], nut_habitat_selections.keys.sort
+      fruit_habitat_selections = plant_selection.typed_children[schema.types["Fruit"]]["habitats"].typed_children[schema.types["Habitat"]]
+      assert_equal ["seasons"], fruit_habitat_selections.keys
     end
   end
 
@@ -219,11 +253,14 @@ describe GraphQL::InternalRepresentation::Rewrite do
       assert_equal 3, cheeses.length
       assert_equal 1, milks.length
 
+      expected_cheese_fields = ["cheeseInlineOrigin", "edibleInlineOrigin", "untypedInlineOrigin", "cheeseFragmentOrigin"]
       cheeses.each do |cheese|
-        assert_equal ["cheeseInlineOrigin", "cheeseFragmentOrigin", "edibleInlineOrigin", "untypedInlineOrigin"], cheese["selfAsEdible"].keys
+        assert_equal expected_cheese_fields, cheese["selfAsEdible"].keys
       end
+
+      expected_milk_fields = ["milkInlineOrigin", "edibleInlineOrigin", "untypedInlineOrigin", "milkFragmentOrigin"]
       milks.each do |milk|
-        assert_equal ["milkInlineOrigin", "milkFragmentOrigin", "edibleInlineOrigin", "untypedInlineOrigin"], milk["selfAsEdible"].keys
+        assert_equal expected_milk_fields, milk["selfAsEdible"].keys
       end
     end
   end

data/spec/graphql/introspection/type_type_spec.rb

@@ -52,7 +52,7 @@ describe GraphQL::Introspection::TypeType do
           {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"ID"}}},
           {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"String"}}},
           {"type"=>{"kind"=>"INTERFACE", "name"=>"Edible", "ofType"=>nil}},
-          {"type"=>{"kind"=>"ENUM","name"=>"DairyAnimal", "ofType"=>nil}},
+          {"type"=>{"kind"=>"NON_NULL","name"=>nil,"ofType"=>{"name"=>"DairyAnimal"}}},
         ]
       },
       "dairyAnimal"=>{

data/spec/graphql/language/lexer_spec.rb

@@ -16,6 +16,12 @@ describe GraphQL::Language::Lexer do
     |}
     let(:tokens) { subject.tokenize(query_string) }
 
+    it "makes utf-8 comments" do
+      tokens = subject.tokenize("# 不要!\n{")
+      comment_token = tokens.first.prev_token
+      assert_equal "# 不要!", comment_token.to_s
+    end
+
     it "keeps track of previous_token" do
       assert_equal tokens[0], tokens[1].prev_token
     end

data/spec/graphql/object_type_spec.rb

@@ -15,8 +15,19 @@ describe GraphQL::ObjectType do
     assert_equal(22, type.description.length)
   end
 
-  it "may have interfaces" do
-    assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface, Dummy::LocalProductInterface], type.interfaces)
+  describe "interfaces" do
+    it "may have interfaces" do
+      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface, Dummy::LocalProductInterface], type.interfaces)
+    end
+
+    it "raises if the interfaces arent an array" do
+      type = GraphQL::ObjectType.define do
+        name "InvalidInterfaces"
+        interfaces(55)
+      end
+
+      assert_raises(ArgumentError) { type.name }
+    end
   end
 
   it "accepts fields definition" do
@@ -25,6 +36,66 @@ describe GraphQL::ObjectType do
     assert_equal([last_produced_dairy], cow_type.fields)
   end
 
+  describe "#implements" do
+    it "adds an interface" do
+      type = GraphQL::ObjectType.define do
+        name 'Hello'
+        implements Dummy::EdibleInterface
+        implements Dummy::AnimalProductInterface
+
+        field :hello, types.String
+      end
+
+      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface], type.interfaces)
+    end
+
+    it "adds many interfaces" do
+      type = GraphQL::ObjectType.define do
+        name 'Hello'
+        implements Dummy::EdibleInterface, Dummy::AnimalProductInterface
+
+        field :hello, types.String
+      end
+
+      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface], type.interfaces)
+    end
+
+    it "preserves existing interfaces and appends a new one" do
+      type = GraphQL::ObjectType.define do
+        name 'Hello'
+        interfaces [Dummy::EdibleInterface]
+        implements Dummy::AnimalProductInterface
+
+        field :hello, types.String
+      end
+
+      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface], type.interfaces)
+    end
+
+    it "can be used to inherit fields from the interface" do
+      type_1 = GraphQL::ObjectType.define do
+        name 'Hello'
+        implements Dummy::EdibleInterface
+        implements Dummy::AnimalProductInterface
+      end
+
+      type_2 = GraphQL::ObjectType.define do
+        name 'Hello'
+        implements Dummy::EdibleInterface
+        implements Dummy::AnimalProductInterface, inherit: true
+      end
+
+      type_3 = GraphQL::ObjectType.define do
+        name 'Hello'
+        implements Dummy::EdibleInterface, Dummy::AnimalProductInterface, inherit: true
+      end
+
+      assert_equal [], type_1.all_fields.map(&:name)
+      assert_equal ["source"], type_2.all_fields.map(&:name)
+      assert_equal ["fatContent", "origin", "selfAsEdible", "source"], type_3.all_fields.map(&:name)
+    end
+  end
+
   describe '#get_field' do
     it "exposes fields" do
       field = type.get_field("id")