graphql 1.6.8 → 1.7.0

data/spec/graphql/define/assign_argument_spec.rb

@@ -37,6 +37,18 @@ describe GraphQL::Define::AssignArgument do
     assert_equal "GraphQL::Argument can't define 'blah'", err.message
   end
 
+  it "accepts an existing argument" do
+    existing = GraphQL::Argument.define do
+      name "bar"
+      type GraphQL::STRING_TYPE
+    end
+
+    arg = define_argument(:foo, existing)
+
+    assert_equal "foo", arg.name
+    assert_equal GraphQL::STRING_TYPE, arg.type
+  end
+
   def define_argument(*args)
     type = GraphQL::ObjectType.define do
       field :a, types.String do

data/spec/graphql/enum_type_spec.rb

@@ -39,7 +39,7 @@ describe GraphQL::EnumType do
 
   describe "invalid names" do
     it "rejects names with a space" do
-      assert_raises(GraphQL::EnumType::InvalidEnumNameError) {
+      assert_raises(GraphQL::InvalidNameError) {
         InvalidEnumTest = GraphQL::EnumType.define do
           name "InvalidEnumTest"
 

data/spec/graphql/execution/execute_spec.rb

@@ -137,4 +137,70 @@ describe GraphQL::Execution::Execute do
       assert_equal "👻", res["errors"].first["message"]
     end
   end
+
+  describe "tracing" do
+    if rails_should_be_installed?
+      it "emits traces" do
+        query_string = <<-GRAPHQL
+        query Bases($id1: ID!, $id2: ID!){
+          b1: batchedBase(id: $id1) { name }
+          b2: batchedBase(id: $id2) { name }
+        }
+        GRAPHQL
+        first_id = StarWars::Base.first.id
+        last_id = StarWars::Base.last.id
+
+        traces = TestTracing.with_trace do
+          star_wars_query(query_string, {
+            "id1" => first_id,
+            "id2" => last_id,
+          })
+        end
+
+        exec_traces = traces[5..-1]
+        expected_traces = [
+          "execute_field",
+          "execute_field",
+          "execute_query",
+          "lazy_loader",
+          "execute_field",
+          "execute_field_lazy",
+          "execute_field",
+          "execute_field_lazy",
+          "execute_field_lazy",
+          "execute_field_lazy",
+          "execute_query_lazy",
+          "execute_multiplex",
+        ]
+        assert_equal expected_traces, exec_traces.map { |t| t[:key] }
+
+        field_1_eager, field_2_eager,
+          query_eager, lazy_loader,
+          # field 3 is eager-resolved _during_ field 1's lazy resolve
+          field_3_eager, field_1_lazy,
+          field_4_eager, field_2_lazy,
+          # field 3 didn't finish above, it's resolved in the next round
+          field_3_lazy, field_4_lazy,
+          query_lazy, multiplex = exec_traces
+
+        assert_equal ["b1"], field_1_eager[:context].path
+        assert_equal ["b2"], field_2_eager[:context].path
+        assert_instance_of GraphQL::Query, query_eager[:query]
+
+        assert_equal [first_id.to_s, last_id.to_s], lazy_loader[:ids]
+        assert_equal StarWars::Base, lazy_loader[:model]
+
+        assert_equal ["b1", "name"], field_3_eager[:context].path
+        assert_equal ["b1"], field_1_lazy[:context].path
+        assert_equal ["b2", "name"], field_4_eager[:context].path
+        assert_equal ["b2"], field_2_lazy[:context].path
+
+        assert_equal ["b1", "name"], field_3_lazy[:context].path
+        assert_equal ["b2", "name"], field_4_lazy[:context].path
+        assert_instance_of GraphQL::Query, query_lazy[:query]
+
+        assert_instance_of GraphQL::Execution::Multiplex, multiplex[:multiplex]
+      end
+    end
+  end
 end

data/spec/graphql/execution/lazy_spec.rb

@@ -70,7 +70,7 @@ describe GraphQL::Execution::Lazy do
       assert_equal expected_data, res["data"]
     end
 
-    it "propagates nulls" do
+    it "propagates nulls to the root" do
       res = run_query %|
       {
         nestedSum(value: 1) {
@@ -85,14 +85,15 @@ describe GraphQL::Execution::Lazy do
 
       assert_equal(nil, res["data"])
       assert_equal 1, res["errors"].length
+    end
 
-
+    it "propagates partial nulls" do
       res = run_query %|
       {
         nullableNestedSum(value: 1) {
           value
           nullableNestedSum(value: 2) {
-            nestedSum(value: 13) {
+            ns: nestedSum(value: 13) {
               value
             }
           }

data/spec/graphql/language/parser_spec.rb

@@ -71,4 +71,20 @@ describe GraphQL::Language::Parser do
 
     end
   end
+
+  it "serves traces" do
+    traces = TestTracing.with_trace do
+      GraphQL.parse("{ t: __typename }")
+    end
+    assert_equal 2, traces.length
+    lex_trace, parse_trace = traces
+
+    assert_equal "{ t: __typename }", lex_trace[:query_string]
+    assert_equal "lex", lex_trace[:key]
+    assert_instance_of Array, lex_trace[:result]
+
+    assert_equal "{ t: __typename }", parse_trace[:query_string]
+    assert_equal "parse", parse_trace[:key]
+    assert_instance_of GraphQL::Language::Nodes::Document, parse_trace[:result]
+  end
 end

data/spec/graphql/object_type_spec.rb

@@ -17,6 +17,20 @@ describe GraphQL::ObjectType do
     }
   end
 
+  it "doesn't allow invalid name" do
+    exception = assert_raises(GraphQL::InvalidNameError) {
+      InvalidNameObject = GraphQL::ObjectType.define do
+        name "Three Word Query"
+
+        field :id, !types.Int, "id field"
+      end
+
+      # Force evaluation
+      InvalidNameObject.name
+    }
+    assert_equal("Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but 'Three Word Query' does not", exception.message)
+  end
+
   it "has a name" do
     assert_equal("Cheese", type.name)
     type.name = "Fromage"

data/spec/graphql/query/context_spec.rb

@@ -5,35 +5,102 @@ describe GraphQL::Query::Context do
   CTX = []
   before { CTX.clear }
 
-  let(:query_type) { GraphQL::ObjectType.define {
-    name "Query"
-    field :context, types.String do
-      argument :key, !types.String
-      resolve ->(target, args, ctx) { ctx[args[:key]] }
-    end
-    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 }
+  let(:parent_info_type) {
+    GraphQL::ObjectType.define {
+      name "ParentInfo"
+      field :object, types.String do
+        resolve ->(o, a, c) { c.parent.parent.object }
+      end
+      field :objectClassName, types.String do
+        resolve ->(o, a, c) { c.parent.parent.object.class.name }
+      end
+      field :valueClassName, types.String do
+        resolve ->(o, a, c) { c.parent.parent.value.class.name }
+      end
+      field :value, types.String do
+        resolve ->(o, a, c) { c.parent.parent.value.to_s }
+      end
+    }
+  }
+  let(:backtrace_type) {
+    GraphQL::ObjectType.define do
+      name "Backtrace"
+      field :backtraceEntry, types.String do
+        argument :idx, !types.Int
+        resolve ->(o, a, c) { c.backtrace[a[:idx]] }
+      end
+      field :backtraceArray, types[types.String] do
+        resolve ->(o, a, c) { c.backtrace.to_a }
+      end
+      field :backtraceTable, types.String do
+        resolve ->(o, a, c) { c.backtrace.inspect }
+      end
     end
+  }
+  let(:query_type) {
+    parent_info = parent_info_type
+    backtrace = backtrace_type
+    GraphQL::ObjectType.define {
+      name "Query"
+      field :context, types.String do
+        argument :key, !types.String
+        resolve ->(target, args, ctx) { ctx[args[:key]] }
+      end
+      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
 
-    field :pushContext, types.Int do
-      resolve ->(t,a,c) { CTX << c; 1 }
-    end
+      field :pushContext, types.Int do
+        resolve ->(t,a,c) { CTX << c; 1 }
+      end
+
+      field :pushQueryError, types.Int do
+        resolve ->(t,a,c) {
+          c.query.context.add_error(GraphQL::ExecutionError.new("Query-level error"))
+          1
+        }
+      end
 
-    field :pushQueryError, types.Int do
-      resolve ->(t,a,c) {
-        c.query.context.add_error(GraphQL::ExecutionError.new("Query-level error"))
-        1
+      field :parentInfo, parent_info, resolve: ->(o,a,c) { :noop }
+      field :backtrace, backtrace, resolve: Proc.new { :noop }
+    }
+  }
+
+  let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}
+  let(:result) { schema.execute(query_string, root_value: "rootval", context: {"some_key" => "some value"})}
+
+  describe "access to parent context" do
+    let(:query_string) { %|
+      {
+        parentInfo {
+          value
+          valueClassName
+          object
+          objectClassName
+        }
       }
+    |}
+
+    it "exposes the parent object" do
+      expected = {
+        "data" => {
+          "parentInfo" => {
+            "objectClassName" => "String",
+            "object" => "rootval",
+            "value" => "{}",
+            "valueClassName" => "Hash",
+          }
+        }
+      }
+      assert_equal(expected, result)
     end
-  }}
-  let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}
-  let(:result) { schema.execute(query_string, context: {"some_key" => "some value"})}
+  end
 
   describe "access to passed-in values" do
     let(:query_string) { %|
@@ -57,6 +124,46 @@ describe GraphQL::Query::Context do
     end
   end
 
+  describe "#backtrace" do
+    let(:query_string) { %|
+      query {
+        backtrace {
+          b1: backtraceEntry(idx: 0)
+          b2: backtraceEntry(idx: 1)
+          b3: backtraceEntry(idx: 2)
+          backtraceArray
+          backtraceTable
+        }
+        pushContext
+      }
+    |}
+
+    it "exposes the GraphQL backtrace" do
+      backtrace_result = result.fetch("data").fetch("backtrace")
+      assert_equal "4:11: Backtrace.backtraceEntry as b1", backtrace_result.fetch("b1")
+      assert_equal "3:9: Query.backtrace", backtrace_result.fetch("b2")
+      assert_equal "2:7: query", backtrace_result.fetch("b3")
+      assert_equal ["7:11: Backtrace.backtraceArray", "3:9: Query.backtrace", "2:7: query"], backtrace_result.fetch("backtraceArray")
+      expected_table = [
+        'Loc  | Field                    | Object    | Arguments | Result',
+        '8:11 | Backtrace.backtraceTable | :noop     | {}        | nil',
+        '3:9  | Query.backtrace          | "rootval" | {}        | {b1: "4:11: Backtrace.backtraceEntry as b1", b2: "3:9: Query.backtrace", b3: "2:7: query", backtr...',
+        '2:7  | query                    | "rootval" | {}        | {}',
+        '',
+      ].join("\n")
+      assert_equal expected_table, backtrace_result.fetch("backtraceTable")
+
+      expected_table_2 = <<-TABLE
+Loc  | Field             | Object    | Arguments | Result
+10:9 | Query.pushContext | "rootval" | {}        | 1
+2:7  | query             | "rootval" | {}        | {backtrace: {...}, pushContext: 1}
+TABLE
+
+      ctx = CTX.last
+      assert_equal expected_table_2, ctx.backtrace.to_s
+    end
+  end
+
   describe "access to the InternalRepresentation node" do
     let(:query_string) { %|
       query getCtx { contextIrepNodeName }
@@ -80,7 +187,7 @@ describe GraphQL::Query::Context do
   end
 
   describe "empty values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil) }
 
     it "returns returns nil and reports key? => false" do
       assert_equal(nil, context[:some_key])
@@ -90,7 +197,7 @@ describe GraphQL::Query::Context do
   end
 
   describe "assigning values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil) }
 
     it "allows you to assign new contexts" do
       assert_equal(nil, context[:some_key])
@@ -99,7 +206,7 @@ describe GraphQL::Query::Context do
     end
 
     describe "namespaces" do
-      let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: 1}) }
+      let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: 1}, object: nil) }
 
       it "doesn't conflict with base values" do
         ns = context.namespace(:stuff)

data/spec/graphql/query/result_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Query::Result do
+  let(:query_string) { '{ __type(name: "Cheese") { name } }' }
+  let(:schema) { Dummy::Schema }
+  let(:result) { schema.execute(query_string, context: { a: :b }) }
+
+  it "exposes hash-like methods" do
+    assert_equal "Cheese", result["data"]["__type"]["name"]
+    refute result.key?("errors")
+    assert_equal ["data"], result.keys
+  end
+
+  it "is equal with hashes" do
+    hash_result = {"data" => { "__type" => { "name" => "Cheese" } } }
+    assert_equal hash_result, result
+  end
+
+  it "tells the kind of operation" do
+    assert result.query?
+    refute result.mutation?
+  end
+
+  it "exposes the context" do
+    assert_instance_of GraphQL::Query::Context, result.context
+    assert_equal({a: :b}, result.context.to_h)
+  end
+end

data/spec/graphql/query/variables_spec.rb

@@ -26,6 +26,19 @@ describe GraphQL::Query::Variables do
     provided_variables)
   }
 
+  describe "#to_h" do
+    let(:provided_variables) { { "animals" => "YAK" } }
+
+    it "returns a hash representation including default values" do
+      expected_hash = {
+        "animals" => ["YAK"],
+        "intDefaultNull" => nil,
+        "intWithDefault" => 10,
+      }
+      assert_equal expected_hash, variables.to_h
+    end
+  end
+
   describe "#initialize" do
     describe "coercing inputs" do
       let(:provided_variables) { { "animals" => "YAK" } }

data/spec/graphql/query_spec.rb

@@ -44,6 +44,28 @@ describe GraphQL::Query do
   )}
   let(:result) { query.result }
 
+  describe "when passed both a query string and a document" do
+    it "returns an error to the client when query kwarg is used" do
+      assert_raises ArgumentError do
+        GraphQL::Query.new(
+          schema,
+          query: "{ fromSource(source: COW) { id } }",
+          document: document
+        )
+      end
+    end
+
+    it "returns an error to the client" do
+      assert_raises ArgumentError do
+        GraphQL::Query.new(
+          schema,
+          "{ fromSource(source: COW) { id } }",
+          document: document
+        )
+      end
+    end
+  end
+
   describe "when passed no query string or document" do
     it 'returns an error to the client' do
       res = GraphQL::Query.new(