graphql 0.12.1 → 0.13.0

data/spec/graphql/list_type_spec.rb

@@ -1,31 +1,31 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::ListType do
   let(:float_list) { GraphQL::ListType.new(of_type: GraphQL::FLOAT_TYPE) }
 
-  it 'coerces elements in the list' do
+  it "coerces elements in the list" do
     assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_input([1, 2, 3]).inspect)
   end
 
-  describe 'validate_input with bad input' do
-    let(:bad_num) { 'bad_num' }
+  describe "validate_input with bad input" do
+    let(:bad_num) { "bad_num" }
     let(:result) { float_list.validate_input([bad_num, 2.0, 3.0]) }
 
-    it 'returns an invalid result' do
+    it "returns an invalid result" do
       assert(!result.valid?)
     end
 
-    it 'has one problem' do
+    it "has one problem" do
       assert_equal(result.problems.length, 1)
     end
 
-    it 'has path [0]' do
-      assert_equal(result.problems[0]['path'], [0])
+    it "has path [0]" do
+      assert_equal(result.problems[0]["path"], [0])
     end
 
-    it 'has the correct explanation' do
-      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num).problems[0]['explanation']
-      actual = result.problems[0]['explanation']
+    it "has the correct explanation" do
+      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num).problems[0]["explanation"]
+      actual = result.problems[0]["explanation"]
       assert_equal(actual, expected)
     end
   end

data/spec/graphql/object_type_spec.rb

@@ -1,40 +1,40 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::ObjectType do
   let(:type) { CheeseType }
 
-  it 'has a name' do
+  it "has a name" do
     assert_equal("Cheese", type.name)
     type.name = "Fromage"
     assert_equal("Fromage", type.name)
     type.name = "Cheese"
   end
 
-  it 'has a description' do
+  it "has a description" do
     assert_equal(22, type.description.length)
   end
 
-  it 'may have interfaces' do
+  it "may have interfaces" do
     assert_equal([EdibleInterface, AnimalProductInterface], type.interfaces)
   end
 
   describe '#get_field ' do
-    it 'exposes fields' do
+    it "exposes fields" do
       field = type.get_field("id")
       assert_equal(GraphQL::TypeKinds::NON_NULL, field.type.kind)
       assert_equal(GraphQL::TypeKinds::SCALAR, field.type.of_type.kind)
     end
 
-    it 'exposes defined field property' do
-      field_without_prop = CheeseType.get_field('flavor')
-      field_with_prop = CheeseType.get_field('fatContent')
+    it "exposes defined field property" do
+      field_without_prop = CheeseType.get_field("flavor")
+      field_with_prop = CheeseType.get_field("fatContent")
       assert_equal(field_without_prop.property, nil)
       assert_equal(field_with_prop.property, :fat_content)
     end
 
     it "looks up from interfaces" do
-      field_from_self = CheeseType.get_field('fatContent')
-      field_from_iface = MilkType.get_field('fatContent')
+      field_from_self = CheeseType.get_field("fatContent")
+      field_from_iface = MilkType.get_field("fatContent")
       assert_equal(field_from_self.property, :fat_content)
       assert_equal(field_from_iface.property, nil)
     end

data/spec/graphql/query/arguments_spec.rb

@@ -3,23 +3,23 @@ require "spec_helper"
 describe GraphQL::Query::Arguments do
   let(:arguments) { GraphQL::Query::Arguments.new({ a: 1, b: 2, c: GraphQL::Query::Arguments.new({ d: 3, e: 4}) }) }
 
-  it 'returns keys as strings' do
-    assert_equal(['a', 'b', 'c'], arguments.keys)
+  it "returns keys as strings" do
+    assert_equal(["a", "b", "c"], arguments.keys)
   end
 
-  it 'delegates values to values hash' do
-    assert_equal([1, 2, {'d' => 3, 'e' => 4}], arguments.values)
+  it "delegates values to values hash" do
+    assert_equal([1, 2, {"d" => 3, "e" => 4}], arguments.values)
   end
 
-  it 'delegates each to values hash' do
+  it "delegates each to values hash" do
     pairs = []
     arguments.each do |key, value|
       pairs << [key, value]
     end
-    assert_equal([['a', 1], ['b', 2], ['c', {'d' => 3, 'e' => 4}]], pairs)
+    assert_equal([["a", 1], ["b", 2], ["c", {"d" => 3, "e" => 4}]], pairs)
   end
 
-  it 'returns original Ruby hash values with to_h' do
+  it "returns original Ruby hash values with to_h" do
     assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
   end
 end

data/spec/graphql/query/context_spec.rb

@@ -22,7 +22,7 @@ describe GraphQL::Query::Context do
       query getCtx { context(key: "some_key") }
     |}
 
-    it 'passes context to fields' do
+    it "passes context to fields" do
       expected = {"data" => {"context" => "some value"}}
       assert_equal(expected, result)
     end
@@ -33,7 +33,7 @@ describe GraphQL::Query::Context do
       query getCtx { contextAstNodeName }
     |}
 
-    it 'provides access to the AST node' do
+    it "provides access to the AST node" do
       expected = {"data" => {"contextAstNodeName" => "GraphQL::Language::Nodes::Field"}}
       assert_equal(expected, result)
     end
@@ -44,9 +44,17 @@ describe GraphQL::Query::Context do
       query getCtx { queryName }
     |}
 
-    it 'provides access to the AST node' do
+    it "provides access to the AST node" do
       expected = {"data" => {"queryName" => "GraphQL::Query"}}
       assert_equal(expected, result)
     end
   end
+
+  describe "empty values" do
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
+
+    it "returns nil for any key" do
+      assert_equal(nil, context[:some_key])
+    end
+  end
 end

data/spec/graphql/query/executor_spec.rb

@@ -1,16 +1,18 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Query::Executor do
   let(:debug) { true }
   let(:operation_name) { nil }
   let(:schema) { DummySchema }
   let(:variables) { {"cheeseId" => 2} }
-  let(:result) { schema.execute(
+  let(:query) { GraphQL::Query.new(
+    schema,
     query_string,
     variables: variables,
     debug: debug,
     operation_name: operation_name,
   )}
+  let(:result) { query.result }
 
   describe "multiple operations" do
     let(:query_string) { %|
@@ -46,7 +48,7 @@ describe GraphQL::Query::Executor do
   end
 
 
-  describe 'execution order' do
+  describe "execution order" do
     let(:query_string) {%|
       mutation setInOrder {
         first:  pushValue(value: 1)
@@ -56,7 +58,7 @@ describe GraphQL::Query::Executor do
       }
     |}
 
-    it 'executes mutations in order' do
+    it "executes mutations in order" do
       expected = {"data"=>{
           "first"=> [1],
           "second"=>[1, 5],
@@ -68,7 +70,7 @@ describe GraphQL::Query::Executor do
   end
 
 
-  describe 'fragment resolution' do
+  describe "fragment resolution" do
     let(:schema) {
       # we will raise if the dairy field is resolved more than one time
       resolved = false
@@ -103,7 +105,7 @@ describe GraphQL::Query::Executor do
       }
     |}
 
-    it 'resolves each field only one time, even when present in multiple fragments' do
+    it "resolves each field only one time, even when present in multiple fragments" do
       expected = {"data" => {
         "dairy" => { "id" => "1" }
       }}
@@ -113,28 +115,33 @@ describe GraphQL::Query::Executor do
   end
 
 
-  describe 'runtime errors' do
+  describe "runtime errors" do
     let(:query_string) {%| query noMilk { error }|}
-    describe 'if debug: false' do
+
+    describe "if debug: false" do
       let(:debug) { false }
-      it 'turns into error messages' do
+      let(:errors) { query.context.errors }
+
+      it "turns into error messages" do
         expected = {"errors"=>[
-          {"message"=>"Something went wrong during query execution: This error was raised on purpose"}
+          {"message"=>"Internal error"}
         ]}
         assert_equal(expected, result)
+        assert_equal([RuntimeError], errors.map(&:class))
+        assert_equal("This error was raised on purpose", errors.first.message)
       end
     end
 
-    describe 'if debug: true' do
+    describe "if debug: true" do
       let(:debug) { true }
-      it 'raises error' do
+      it "raises error" do
         assert_raises(RuntimeError) { result }
       end
     end
 
-    describe 'if nil is given for a non-null field' do
+    describe "if nil is given for a non-null field" do
       let(:query_string) {%| query noMilk { cow { name cantBeNullButIs } }|}
-      it 'turns into error message and nulls the entire selection' do
+      it "turns into error message and nulls the entire selection" do
         expected = {
           "data" => { "cow" => nil },
           "errors" => [
@@ -147,9 +154,9 @@ describe GraphQL::Query::Executor do
       end
     end
 
-    describe 'if an execution error is raised for a non-null field' do
+    describe "if an execution error is raised for a non-null field" do
       let(:query_string) {%| query noMilk { cow { name cantBeNullButRaisesExecutionError } }|}
-      it 'uses provided error message and nulls the entire selection' do
+      it "uses provided error message and nulls the entire selection" do
         expected = {
           "data" => { "cow" => nil },
           "errors" => [
@@ -229,7 +236,7 @@ describe GraphQL::Query::Executor do
           "errors"=>[
             {
               "message" => "Variable input of type ReplaceValuesInput! was provided invalid value",
-              "locations" => [{ "line" => 1, "column" => 14 }],
+              "locations" => [{ "line" => 1, "column" => 13 }],
               "value" => nil,
               "problems" => [
                 { "path" => [], "explanation" => "Expected value to not be null" }
@@ -249,7 +256,7 @@ describe GraphQL::Query::Executor do
           "errors"=>[
             {
               "message" => "Variable input of type ReplaceValuesInput! was provided invalid value",
-              "locations" => [{ "line" => 1, "column" => 14 }],
+              "locations" => [{ "line" => 1, "column" => 13 }],
               "value" => {},
               "problems" => [
                 { "path" => ["values"], "explanation" => "Expected value to not be null" }
@@ -269,7 +276,7 @@ describe GraphQL::Query::Executor do
           "errors"=>[
             {
               "message" => "Variable input of type [DairyProductInput] was provided invalid value",
-              "locations" => [{ "line" => 1, "column" => 11 }],
+              "locations" => [{ "line" => 1, "column" => 10 }],
               "value" => [{ "foo" => "bar" }],
               "problems" => [
                 { "path" => [0, "foo"], "explanation" => "Field is not defined on DairyProductInput" },

data/spec/graphql/query/serial_execution/execution_context_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Query::SerialExecution::ExecutionContext do
   let(:query_string) { %|
@@ -34,22 +34,22 @@ describe GraphQL::Query::SerialExecution::ExecutionContext do
 
   describe "get_type" do
     it "returns the respective type from the schema" do
-      type = execution_context.get_type('Dairy')
+      type = execution_context.get_type("Dairy")
       assert_equal(DairyType, type)
     end
   end
 
   describe "get_field" do
     it "returns the respective field from the schema" do
-      field = execution_context.get_field(DairyType, 'cheese')
-      assert_equal('cheese', field.name)
+      field = execution_context.get_field(DairyType, "cheese")
+      assert_equal("cheese", field.name)
     end
   end
 
   describe "get_fragment" do
     it "returns a fragment on the query by name" do
-      fragment = execution_context.get_fragment('cheeseFields')
-      assert_equal('cheeseFields', fragment.name)
+      fragment = execution_context.get_fragment("cheeseFields")
+      assert_equal("cheeseFields", fragment.name)
     end
   end
 end

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Query::SerialExecution::ValueResolution do
   let(:debug) { false }
@@ -17,7 +17,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
       name "Query"
       field :tomorrow, day_of_week_enum do
         argument :today, day_of_week_enum
-        resolve ->(obj, args, ctx) { (args['today'] + 1) % 7 }
+        resolve ->(obj, args, ctx) { (args["today"] + 1) % 7 }
       end
     end
   }

data/spec/graphql/query/type_resolver_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Query::TypeResolver do
-  it 'resolves correcty when child_type is UnionType' do
-    type = GraphQL::Query::TypeResolver.new(MILKS[1], DairyProductUnion, MilkType).type
+  it "resolves correcty when child_type is UnionType" do
+    type = GraphQL::Query::TypeResolver.new(MILKS[1], DairyProductUnion, MilkType, nil).type
     assert_equal(MilkType, type)
   end
 end

data/spec/graphql/query_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Query do
   let(:query_string) { %|
@@ -43,7 +43,7 @@ describe GraphQL::Query do
   )}
   let(:result) { query.result }
   describe '#result' do
-    it 'returns fields on objects' do
+    it "returns fields on objects" do
       expected = {"data"=> {
           "brie" =>   { "flavor" => "Brie", "taste" => "Brie" },
           "cheese" => {
@@ -82,24 +82,8 @@ describe GraphQL::Query do
     end
   end
 
-  it 'exposes fragments' do
-    assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments['cheeseFields'].class)
-  end
-
-  it 'correctly identifies parse error location' do
-    # "Correct" is a bit of an overstatement. All Parslet errors get surfaced
-    # at the beginning of the query they were in, since Parslet sees the query
-    # as invalid. It would be great to have more granularity here.
-    e = assert_raises(GraphQL::ParseError) do
-      GraphQL.parse("
-        query getCoupons {
-          allCoupons: {data{id}}
-        }
-      ")
-    end
-    assert_equal('Extra input after last repetition at line 2 char 9.', e.message)
-    assert_equal(2, e.line)
-    assert_equal(9, e.col)
+  it "exposes fragments" do
+    assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments["cheeseFields"].class)
   end
 
   describe "merging fragments with different keys" do
@@ -167,22 +151,6 @@ describe GraphQL::Query do
     end
   end
 
-  describe "malformed queries" do
-    describe "whitespace-only" do
-      let(:query_string) { " " }
-      it "doesn't blow up" do
-        assert_equal({}, result)
-      end
-    end
-
-    describe "empty string" do
-      let(:query_string) { "" }
-      it "doesn't blow up" do
-        assert_equal({}, result)
-      end
-    end
-  end
-
   describe "field argument default values" do
     let(:query_string) {%|
       query getCheeses(
@@ -250,7 +218,7 @@ describe GraphQL::Query do
           "errors" => [
             {
               "message" => "Variable cheeseId of type Int! was provided invalid value",
-              "locations"=>[{ "line" => 2, "column" => 24 }],
+              "locations"=>[{ "line" => 2, "column" => 23 }],
               "value" => "2",
               "problems" => [{ "path" => [], "explanation" => 'Could not coerce value "2" to Int' }]
             }
@@ -268,7 +236,7 @@ describe GraphQL::Query do
           "errors" => [
             {
               "message" => "Variable cheeseId of type Int! was provided invalid value",
-              "locations" => [{"line" => 2, "column" => 24}],
+              "locations" => [{"line" => 2, "column" => 23}],
               "value" => nil,
               "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
             }

data/spec/graphql/scalar_type_spec.rb

@@ -1,52 +1,61 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::ScalarType do
-  let(:scalar) {
+  let(:custom_scalar) {
     GraphQL::ScalarType.define do
       name "BigInt"
-      coerce_input ->(value) { Integer(value) }
+      coerce_input ->(value) { value =~ /\d+/ ? Integer(value) : nil }
       coerce_result ->(value) { value.to_s }
     end
   }
   let(:bignum) { 2 ** 128 }
 
-  it 'coerces nil into nil' do
-    assert_equal(nil, scalar.coerce_input(nil))
+  it "coerces nil into nil" do
+    assert_equal(nil, custom_scalar.coerce_input(nil))
   end
 
-  it 'coerces input into objects' do
-    assert_equal(bignum, scalar.coerce_input(bignum.to_s))
+  it "coerces input into objects" do
+    assert_equal(bignum, custom_scalar.coerce_input(bignum.to_s))
   end
 
-  it 'coerces result value for serialization' do
-    assert_equal(bignum.to_s, scalar.coerce_result(bignum))
+  it "coerces result value for serialization" do
+    assert_equal(bignum.to_s, custom_scalar.coerce_result(bignum))
   end
 
-  describe 'validate_input with good input' do
+  describe "custom scalar errors" do
+    let(:result) { custom_scalar.validate_input("xyz") }
+
+    it "returns an invalid result" do
+      assert !result.valid?
+      assert_equal 'Could not coerce value "xyz" to BigInt', result.problems[0]["explanation"]
+    end
+  end
+
+  describe "validate_input with good input" do
     let(:result) { GraphQL::INT_TYPE.validate_input(150) }
 
-    it 'returns a valid result' do
+    it "returns a valid result" do
       assert(result.valid?)
     end
   end
 
-  describe 'validate_input with bad input' do
-    let(:result) { GraphQL::INT_TYPE.validate_input('bad num') }
+  describe "validate_input with bad input" do
+    let(:result) { GraphQL::INT_TYPE.validate_input("bad num") }
 
-    it 'returns an invalid result for bad input' do
+    it "returns an invalid result for bad input" do
       assert(!result.valid?)
     end
 
-    it 'has one problem' do
+    it "has one problem" do
       assert_equal(result.problems.length, 1)
     end
 
-    it 'has the correct explanation' do
-      assert(result.problems[0]['explanation'].include?('Could not coerce value'))
+    it "has the correct explanation" do
+      assert(result.problems[0]["explanation"].include?("Could not coerce value"))
     end
 
-    it 'has an empty path' do
-      assert(result.problems[0]['path'].empty?)
+    it "has an empty path" do
+      assert(result.problems[0]["path"].empty?)
     end
   end
 end