graphql 0.15.3 → 0.16.0

data/spec/graphql/analysis/query_depth_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe GraphQL::Analysis::QueryDepth do
+  let(:depths) { [] }
+  let(:query_depth) { GraphQL::Analysis::QueryDepth.new { |query, max_depth|  depths << query << max_depth } }
+  let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [query_depth]) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
+  let(:variables) { {} }
+
+  describe "simple queries" do
+    let(:query_string) {%|
+      query cheeses($isIncluded: Boolean = true){
+        # depth of 2
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+
+        # depth of 4
+        cheese2: cheese(id: 2) @include(if: $isIncluded) {
+          similarCheese(source: SHEEP) {
+            ... on Cheese {
+              similarCheese(source: SHEEP) {
+                id
+              }
+            }
+          }
+        }
+      }
+    |}
+
+    it "finds the max depth" do
+      reduce_result
+      assert_equal depths, [query, 4]
+    end
+
+    describe "with directives" do
+      let(:variables) { { "isIncluded" => false } }
+      it "doesn't count skipped fields" do
+        reduce_result
+        assert_equal depths.last, 2
+      end
+    end
+  end
+
+  describe "query with fragments" do
+    let(:query_string) {%|
+      {
+        # depth of 2
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+
+        # depth of 4
+        cheese2: cheese(id: 2) {
+          ... cheeseFields1
+        }
+      }
+
+      fragment cheeseFields1 on Cheese {
+        similarCheese(source: COW) {
+          id
+          ... cheeseFields2
+        }
+      }
+
+      fragment cheeseFields2 on Cheese {
+        similarCheese(source: SHEEP) {
+          id
+        }
+      }
+    |}
+
+    it "finds the max depth" do
+      reduce_result
+      assert_equal depths, [query, 4]
+    end
+  end
+end

data/spec/graphql/directive_spec.rb

@@ -25,6 +25,7 @@ describe GraphQL::Directive do
       fragment dontSkipIdField on Cheese { dontSkipId: id @skip(if: false) }
     |
     }
+
     it "intercepts fields" do
       expected = { "data" =>{
         "cheese" => {

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe GraphQL::InternalRepresentation::Rewrite do
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema) }
+  let(:query) { GraphQL::Query.new(DummySchema, 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
+      }
+    }
+    |}
+    it "produces a tree of nodes" do
+      op_node = rewrite_result["getCheeses"]
+
+      assert_equal 2, op_node.children.length
+      assert_equal QueryType, op_node.return_type
+      first_field = op_node.children.values.first
+      assert_equal 3, first_field.children.length
+      assert_equal [QueryType], first_field.on_types.to_a
+      assert_equal CheeseType, first_field.return_type
+
+      second_field = op_node.children.values.last
+      assert_equal 1, second_field.children.length
+      assert_equal [QueryType], second_field.on_types.to_a
+      assert_equal CheeseType, second_field.return_type
+    end
+  end
+
+  describe "dynamic fields" do
+    let(:query_string) {%|
+      {
+        cheese(id: 1) {
+          typename: __typename
+        }
+      }
+    |}
+
+    it "gets dynamic field definitions" do
+      cheese_field = rewrite_result[nil].children["cheese"]
+      typename_field = cheese_field.children["typename"]
+      assert_equal "__typename", typename_field.definition.name
+    end
+  end
+
+  describe "merging fragments" do
+    let(:query_string) {%|
+    {
+      cheese(id: 1) {
+        id1: id
+        ... {
+          id2: id
+        }
+
+        fatContent
+        ... on Edible {
+          fatContent
+          origin
+        }
+        ... cheeseFields
+
+        ... similarCheeseField
+      }
+    }
+
+    fragment cheeseFields on Cheese {
+      fatContent
+      flavor
+      similarCow: similarCheese(source: COW) {
+        similarCowSource: source,
+        id
+        ... similarCowFields
+      }
+    }
+
+    fragment similarCowFields on Cheese {
+      similarCheese(source: SHEEP) {
+        source
+      }
+    }
+
+    fragment similarCheeseField on Cheese {
+      # deep fragment merge
+      similarCow: similarCheese(source: COW) {
+        similarCowSource: source,
+        fatContent
+        similarCheese(source: SHEEP) {
+          flavor
+        }
+      }
+    }
+    |}
+
+    it "puts all fragment members as children" do
+      op_node = rewrite_result[nil]
+
+      cheese_field = op_node.children["cheese"]
+      assert_equal ["id1", "id2", "fatContent", "origin", "similarCow", "flavor"], cheese_field.children.keys
+      # Merge:
+      similar_cow_field = cheese_field.children["similarCow"]
+      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.children.keys
+      # Deep merge:
+      similar_sheep_field = similar_cow_field.children["similarCheese"]
+      assert_equal ["flavor", "source"], similar_sheep_field.children.keys
+
+      assert_equal Set.new([EdibleInterface]), cheese_field.children["origin"].on_types
+      assert_equal Set.new([CheeseType, EdibleInterface]), cheese_field.children["fatContent"].on_types
+      assert_equal Set.new([CheeseType]), cheese_field.children["flavor"].on_types
+    end
+  end
+end

data/spec/graphql/introspection/schema_type_spec.rb

@@ -21,6 +21,7 @@ describe GraphQL::Introspection::SchemaType do
             {"name"=>"cheese"},
             {"name"=>"cow"},
             {"name"=>"dairy"},
+            {"name"=>"deepNonNull"},
             {"name"=>"error"},
             {"name"=>"executionError"},
             {"name"=>"favoriteEdible"},

data/spec/graphql/language/visitor_spec.rb

@@ -2,13 +2,23 @@ require "spec_helper"
 
 describe GraphQL::Language::Visitor do
   let(:document) { GraphQL.parse("
-    query cheese { cheese(id: 1) { flavor, source, producers(first: 3) { name } } }
+    query cheese {
+      cheese(id: 1) {
+        flavor,
+        source,
+        producers(first: 3) {
+          name
+        }
+        ... cheeseFields
+      }
+    }
+
     fragment cheeseFields on Cheese { flavor }
     ")}
   let(:counts) { {fields_entered: 0, arguments_entered: 0, arguments_left: 0, argument_names: []} }
 
   let(:visitor) do
-    v = GraphQL::Language::Visitor.new
+    v = GraphQL::Language::Visitor.new(document)
     v[GraphQL::Language::Nodes::Field] << -> (node, parent) { counts[:fields_entered] += 1 }
     # two ways to set up enter hooks:
     v[GraphQL::Language::Nodes::Argument] <<       -> (node, parent) { counts[:argument_names] << node.name }
@@ -21,7 +31,7 @@ describe GraphQL::Language::Visitor do
 
   it "calls hooks during a depth-first tree traversal" do
     assert_equal(2, visitor[GraphQL::Language::Nodes::Argument].enter.length)
-    visitor.visit(document)
+    visitor.visit
     assert_equal(6, counts[:fields_entered])
     assert_equal(2, counts[:arguments_entered])
     assert_equal(2, counts[:arguments_left])
@@ -32,7 +42,7 @@ describe GraphQL::Language::Visitor do
   describe "Visitor::SKIP" do
     it "skips the rest of the node" do
       visitor[GraphQL::Language::Nodes::Document] << -> (node, parent) { GraphQL::Language::Visitor::SKIP }
-      visitor.visit(document)
+      visitor.visit
       assert_equal(0, counts[:fields_entered])
     end
   end

data/spec/graphql/non_null_type_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe GraphQL::NonNullType do
+  describe "when a non-null field returns null" do
+    it "nulls out the parent selection" do
+      query_string = %|{ cow { name cantBeNullButIs } }|
+      result = DummySchema.execute(query_string)
+      assert_equal({"cow" => nil }, result["data"])
+      assert_equal([{"message"=>"Cannot return null for non-nullable field cantBeNullButIs"}], result["errors"])
+    end
+
+    it "propagates the null up to the next nullable field" do
+      query_string = %|
+      {
+        nn1: deepNonNull {
+          nni1: nonNullInt(returning: 1)
+          nn2: deepNonNull {
+            nni2: nonNullInt(returning: 2)
+            nn3: deepNonNull {
+              nni3: nonNullInt
+            }
+          }
+        }
+      }
+      |
+      result = DummySchema.execute(query_string)
+      assert_equal(nil, result["data"])
+      assert_equal([{"message"=>"Cannot return null for non-nullable field nonNullInt"}], result["errors"])
+    end
+  end
+end

data/spec/graphql/query/context_spec.rb

@@ -9,7 +9,9 @@ describe GraphQL::Query::Context do
     field :contextAstNodeName, types.String do
       resolve -> (target, args, ctx) { ctx.ast_node.class.name }
     end
-
+    field :contextIrepNodeName, types.String do
+      resolve -> (target, args, ctx) { ctx.irep_node.class.name }
+    end
     field :queryName, types.String do
       resolve -> (target, args, ctx) { ctx.query.class.name }
     end
@@ -39,6 +41,17 @@ describe GraphQL::Query::Context do
     end
   end
 
+  describe "access to the InternalRepresentation node" do
+    let(:query_string) { %|
+      query getCtx { contextIrepNodeName }
+    |}
+
+    it "provides access to the AST node" do
+      expected = {"data" => {"contextIrepNodeName" => "GraphQL::InternalRepresentation::Node"}}
+      assert_equal(expected, result)
+    end
+  end
+
   describe "access to the query" do
     let(:query_string) { %|
       query getCtx { queryName }
@@ -57,4 +70,14 @@ describe GraphQL::Query::Context do
       assert_equal(nil, context[:some_key])
     end
   end
+
+  describe "assigning values" do
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
+
+    it "allows you to assign new contexts" do
+      assert_equal(nil, context[:some_key])
+      context[:some_key] = "wow!"
+      assert_equal("wow!", context[:some_key])
+    end
+  end
 end

data/spec/graphql/query_spec.rb

@@ -45,14 +45,14 @@ describe GraphQL::Query do
 
   describe "when passed no query string or document" do
     it 'fails with an ArgumentError' do
-      -> {
+      assert_raises(ArgumentError) {
         GraphQL::Query.new(
           schema,
           variables: query_variables,
           operation_name: operation_name,
           max_depth: max_depth,
         )
-      }.must_raise ArgumentError
+      }
     end
   end
 
@@ -133,6 +133,10 @@ describe GraphQL::Query do
     assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments["cheeseFields"].class)
   end
 
+  it "exposes the original string" do
+    assert_equal(query_string, query.query_string)
+  end
+
   describe "merging fragments with different keys" do
     let(:query_string) { %|
       query getCheeseFieldsThroughDairy {

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+describe GraphQL::Schema::TimeoutMiddleware do
+  let(:max_seconds) { 2 }
+  let(:timeout_middleware) {  GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2) }
+  let(:timeout_schema) {
+
+    sleep_for_seconds_resolve = -> (obj, args, ctx) {
+      sleep(args[:seconds])
+      args[:seconds]
+    }
+
+    nested_sleep_type = GraphQL::ObjectType.define do
+      name "NestedSleep"
+      field :seconds, types.Float do
+        resolve -> (obj, args, ctx) { obj }
+      end
+
+      field :nestedSleep, -> { nested_sleep_type } do
+        argument :seconds, !types.Float
+        resolve(sleep_for_seconds_resolve)
+      end
+    end
+
+    query_type = GraphQL::ObjectType.define do
+      name "Query"
+      field :sleepFor, types.Float do
+        argument :seconds, !types.Float
+        resolve(sleep_for_seconds_resolve)
+      end
+
+      field :nestedSleep, nested_sleep_type do
+        argument :seconds, !types.Float
+        resolve(sleep_for_seconds_resolve)
+      end
+    end
+
+    schema = GraphQL::Schema.new(query: query_type)
+    schema.middleware << timeout_middleware
+    schema
+  }
+
+  let(:result) { timeout_schema.execute(query_string) }
+
+  describe "timeout part-way through" do
+    let(:query_string) {%|
+      {
+        a: sleepFor(seconds: 0.7)
+        b: sleepFor(seconds: 0.7)
+        c: sleepFor(seconds: 0.7)
+        d: sleepFor(seconds: 0.7)
+        e: sleepFor(seconds: 0.7)
+      }
+    |}
+    it "returns a partial response and error messages" do
+      expected_data = {
+        "a"=>0.7,
+        "b"=>0.7,
+        "c"=>0.7,
+        "d"=>nil,
+        "e"=>nil,
+      }
+
+      expected_errors =  [
+        {
+          "message"=>"Timeout on Query.sleepFor",
+          "locations"=>[{"line"=>6, "column"=>9}]
+        },
+        {
+          "message"=>"Timeout on Query.sleepFor",
+          "locations"=>[{"line"=>7, "column"=>9}]
+        },
+      ]
+      assert_equal expected_data, result["data"]
+      assert_equal expected_errors, result["errors"]
+    end
+  end
+
+  describe "timeout in nested fields" do
+    let(:query_string) {%|
+    {
+      a: nestedSleep(seconds: 1) {
+        seconds
+        b: nestedSleep(seconds: 0.4) {
+          seconds
+          c: nestedSleep(seconds: 0.4) {
+            seconds
+            d: nestedSleep(seconds: 0.4) {
+              seconds
+              e: nestedSleep(seconds: 0.4) {
+                seconds
+              }
+            }
+          }
+        }
+      }
+    }
+    |}
+    it "returns a partial response and error messages" do
+      expected_data = {
+        "a" => {
+          "seconds" => 1.0,
+          "b" => {
+            "seconds" => 0.4,
+            "c" => {
+              "seconds"=>0.4,
+              "d" => {
+                "seconds"=>nil,
+                "e"=>nil
+              }
+            }
+          }
+        }
+      }
+      expected_errors = [
+        {
+          "message"=>"Timeout on NestedSleep.seconds",
+          "locations"=>[{"line"=>10, "column"=>15}]
+        },
+        {
+          "message"=>"Timeout on NestedSleep.nestedSleep",
+          "locations"=>[{"line"=>11, "column"=>15}]
+        },
+      ]
+
+      assert_equal expected_data, result["data"]
+      assert_equal expected_errors, result["errors"]
+    end
+  end
+
+  describe "long-running fields" do
+    let(:query_string) {%|
+      {
+        a: sleepFor(seconds: 0.7)
+        b: sleepFor(seconds: 0.7)
+        c: sleepFor(seconds: 1.5)
+        d: sleepFor(seconds: 0.1)
+      }
+    |}
+    it "doesn't terminate long-running field execution" do
+      expected_data = {
+        "a"=>0.7,
+        "b"=>0.7,
+        "c"=>1.5,
+        "d"=>nil,
+      }
+
+      expected_errors = [
+        {
+          "message"=>"Timeout on Query.sleepFor",
+          "locations"=>[{"line"=>6, "column"=>9}]
+        },
+      ]
+
+      assert_equal expected_data, result["data"]
+      assert_equal expected_errors, result["errors"]
+    end
+  end
+
+  describe "with a custom block" do
+    let(:timeout_middleware) {
+      GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2) do |err, query|
+        raise("Query timed out after 2s: #{query.class.name}")
+      end
+    }
+    let(:query_string) {%|
+      {
+        a: sleepFor(seconds: 0.7)
+        b: sleepFor(seconds: 0.7)
+        c: sleepFor(seconds: 0.7)
+        d: sleepFor(seconds: 0.7)
+        e: sleepFor(seconds: 0.7)
+      }
+    |}
+
+    it "calls the block" do
+      assert_raises(RuntimeError) { result }
+    end
+  end
+end