graphql 1.5.5 → 1.5.6

data/spec/graphql/int_type_spec.rb

@@ -4,13 +4,13 @@ require "spec_helper"
 describe GraphQL::INT_TYPE do
   describe "coerce_input" do
     it "accepts ints and floats" do
-      assert_equal 1, GraphQL::INT_TYPE.coerce_input(1)
-      assert_equal 6, GraphQL::INT_TYPE.coerce_input(6.1)
+      assert_equal 1, GraphQL::INT_TYPE.coerce_isolated_input(1)
+      assert_equal 6, GraphQL::INT_TYPE.coerce_isolated_input(6.1)
     end
 
     it "rejects other types" do
-      assert_equal nil, GraphQL::INT_TYPE.coerce_input("55")
-      assert_equal nil, GraphQL::INT_TYPE.coerce_input(true)
+      assert_equal nil, GraphQL::INT_TYPE.coerce_isolated_input("55")
+      assert_equal nil, GraphQL::INT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/language/lexer_spec.rb

@@ -39,7 +39,6 @@ describe GraphQL::Language::Lexer do
     end
 
     it "clears the previous_token between runs" do
-      tok_1 = subject.tokenize(query_string)
       tok_2 = subject.tokenize(query_string)
       assert_equal nil, tok_2[0].prev_token
     end

data/spec/graphql/list_type_spec.rb

@@ -5,12 +5,12 @@ describe GraphQL::ListType do
   let(:float_list) { GraphQL::ListType.new(of_type: GraphQL::FLOAT_TYPE) }
 
   it "coerces elements in the list" do
-    assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_input([1, 2, 3]).inspect)
+    assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_isolated_input([1, 2, 3]).inspect)
   end
 
   describe "validate_input with bad input" do
     let(:bad_num) { "bad_num" }
-    let(:result) { float_list.validate_input([bad_num, 2.0, 3.0], PermissiveWarden) }
+    let(:result) { float_list.validate_isolated_input([bad_num, 2.0, 3.0]) }
 
     it "returns an invalid result" do
       assert(!result.valid?)
@@ -25,7 +25,7 @@ describe GraphQL::ListType do
     end
 
     it "has the correct explanation" do
-      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num, PermissiveWarden).problems[0]["explanation"]
+      expected = GraphQL::FLOAT_TYPE.validate_isolated_input(bad_num).problems[0]["explanation"]
       actual = result.problems[0]["explanation"]
       assert_equal(actual, expected)
     end

data/spec/graphql/query/literal_input_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Query::LiteralInput do
+  describe ".from_arguments" do
+    describe "arguments are prepared" do
+      let(:schema) {
+        query = GraphQL::ObjectType.define do
+          name "Query"
+
+          field :addOneToArgumentValue do
+            type !types.Int
+            argument :value do
+              type !types.Int
+              prepare ->(arg) do
+                return GraphQL::ExecutionError.new("Can't return more than 3 digits") if arg > 998
+                arg + 1
+              end
+            end
+            resolve ->(t, a, c) { a[:value] }
+          end
+        end
+
+        GraphQL::Schema.define(query: query)
+      }
+
+      it "prepares values from query literals" do
+        result = schema.execute("{ addOneToArgumentValue(value: 1) }")
+        assert_equal(result["data"]["addOneToArgumentValue"], 2)
+      end
+
+      it "prepares values from variables" do
+        result = schema.execute("query ($value: Int!) { addOneToArgumentValue(value: $value) }", variables: { "value" => 1} )
+        assert_equal(result["data"]["addOneToArgumentValue"], 2)
+      end
+
+      it "prepares values correctly if called multiple times with different arguments" do
+        result = schema.execute("{ first: addOneToArgumentValue(value: 1) second: addOneToArgumentValue(value: 2) }")
+        assert_equal(result["data"]["first"], 2)
+        assert_equal(result["data"]["second"], 3)
+      end
+
+      it "adds message to errors key if an ExecutionError is returned from the prepare function" do
+        result = schema.execute("{ addOneToArgumentValue(value: 999) }")
+        assert_equal(result["errors"][0]["message"], "Can't return more than 3 digits")
+        assert_equal(result["errors"][0]["locations"][0]["line"], 1)
+        assert_equal(result["errors"][0]["locations"][0]["column"], 25)
+      end
+    end
+  end
+end

data/spec/graphql/query/variables_spec.rb

@@ -17,8 +17,10 @@ describe GraphQL::Query::Variables do
   let(:ast_variables) { GraphQL.parse(query_string).definitions.first.variables }
   let(:schema) { Dummy::Schema }
   let(:variables) { GraphQL::Query::Variables.new(
-    schema,
-    GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
+    OpenStruct.new({
+      schema: schema,
+      warden: GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
+    }),
     ast_variables,
     provided_variables)
   }
@@ -165,8 +167,10 @@ describe GraphQL::Query::Variables do
       let(:run_query) { schema.execute(query_string, variables: provided_variables) }
 
       let(:variables) { GraphQL::Query::Variables.new(
-        schema,
-        GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
+        OpenStruct.new({
+          schema: schema,
+          warden: GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
+        }),
         ast_variables,
         provided_variables)
       }

data/spec/graphql/relay/array_connection_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe GraphQL::Relay::ArrayConnection do
   def get_names(result)
     ships = result["data"]["rebels"]["ships"]["edges"]
-    names = ships.map { |e| e["node"]["name"] }
+    ships.map { |e| e["node"]["name"] }
   end
 
   def get_last_cursor(result)

data/spec/graphql/relay/page_info_spec.rb

@@ -16,7 +16,7 @@ describe GraphQL::Relay::PageInfo do
 
   let(:cursor_of_last_base) {
     result = star_wars_query(query_string, "first" => 100)
-    last_cursor = get_last_cursor(result)
+    get_last_cursor(result)
   }
 
   let(:query_string) {%|

data/spec/graphql/relay/relation_connection_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe GraphQL::Relay::RelationConnection do
   def get_names(result)
     ships = result["data"]["empire"]["bases"]["edges"]
-    names = ships.map { |e| e["node"]["name"] }
+    ships.map { |e| e["node"]["name"] }
   end
 
   def get_page_info(result)
@@ -253,7 +253,7 @@ describe GraphQL::Relay::RelationConnection do
 
     def get_names(result, field_name)
       bases = result["data"]["empire"][field_name]["edges"]
-      base_names = bases.map { |b| b["node"]["name"] }
+      bases.map { |b| b["node"]["name"] }
     end
 
     it "applies the default value" do
@@ -269,7 +269,7 @@ describe GraphQL::Relay::RelationConnection do
   describe "with a Sequel::Dataset" do
     def get_names(result)
       ships = result["data"]["empire"]["basesAsSequelDataset"]["edges"]
-      names = ships.map { |e| e["node"]["name"] }
+      ships.map { |e| e["node"]["name"] }
     end
 
     def get_page_info(result)

data/spec/graphql/scalar_type_spec.rb

@@ -5,8 +5,8 @@ describe GraphQL::ScalarType do
   let(:custom_scalar) {
     GraphQL::ScalarType.define do
       name "BigInt"
-      coerce_input ->(value) { value =~ /\d+/ ? Integer(value) : nil }
-      coerce_result ->(value) { value.to_s }
+      coerce_input ->(value, _ctx) { value =~ /\d+/ ? Integer(value) : nil }
+      coerce_result ->(value, _ctx) { value.to_s }
     end
   }
   let(:bignum) { 2 ** 128 }
@@ -16,19 +16,19 @@ describe GraphQL::ScalarType do
   end
 
   it "coerces nil into nil" do
-    assert_equal(nil, custom_scalar.coerce_input(nil))
+    assert_equal(nil, custom_scalar.coerce_isolated_input(nil))
   end
 
   it "coerces input into objects" do
-    assert_equal(bignum, custom_scalar.coerce_input(bignum.to_s))
+    assert_equal(bignum, custom_scalar.coerce_isolated_input(bignum.to_s))
   end
 
   it "coerces result value for serialization" do
-    assert_equal(bignum.to_s, custom_scalar.coerce_result(bignum))
+    assert_equal(bignum.to_s, custom_scalar.coerce_isolated_result(bignum))
   end
 
   describe "custom scalar errors" do
-    let(:result) { custom_scalar.validate_input("xyz", PermissiveWarden) }
+    let(:result) { custom_scalar.validate_isolated_input("xyz") }
 
     it "returns an invalid result" do
       assert !result.valid?
@@ -37,7 +37,7 @@ describe GraphQL::ScalarType do
   end
 
   describe "validate_input with good input" do
-    let(:result) { GraphQL::INT_TYPE.validate_input(150, PermissiveWarden) }
+    let(:result) { GraphQL::INT_TYPE.validate_isolated_input(150) }
 
     it "returns a valid result" do
       assert(result.valid?)
@@ -45,7 +45,7 @@ describe GraphQL::ScalarType do
   end
 
   describe "validate_input with bad input" do
-    let(:result) { GraphQL::INT_TYPE.validate_input("bad num", PermissiveWarden) }
+    let(:result) { GraphQL::INT_TYPE.validate_isolated_input("bad num") }
 
     it "returns an invalid result for bad input" do
       assert(!result.valid?)

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -352,8 +352,8 @@ type Root {
 
       built_schema = build_schema_and_compare_output(schema.chop)
       custom_scalar = built_schema.types["CustomScalar"]
-      assert_equal true, custom_scalar.valid_input?("anything", PermissiveWarden)
-      assert_equal true, custom_scalar.valid_input?(12345, PermissiveWarden)
+      assert_equal true, custom_scalar.valid_isolated_input?("anything")
+      assert_equal true, custom_scalar.valid_isolated_input?(12345)
     end
 
     it 'supports input object' do

data/spec/graphql/schema/loader_spec.rb

@@ -23,8 +23,8 @@ describe GraphQL::Schema::Loader do
 
     big_int_type = GraphQL::ScalarType.define do
       name "BigInt"
-      coerce_input ->(value) { value =~ /\d+/ ? Integer(value) : nil }
-      coerce_result ->(value) { value.to_s }
+      coerce_input ->(value, _ctx) { value =~ /\d+/ ? Integer(value) : nil }
+      coerce_result ->(value, _ctx) { value.to_s }
     end
 
     variant_input_type = GraphQL::InputObjectType.define do
@@ -202,8 +202,8 @@ describe GraphQL::Schema::Loader do
 
     it "has no-op coerce functions" do
       custom_scalar = loaded_schema.types["BigInt"]
-      assert_equal true, custom_scalar.valid_input?("anything", PermissiveWarden)
-      assert_equal true, custom_scalar.valid_input?(12345, PermissiveWarden)
+      assert_equal true, custom_scalar.valid_isolated_input?("anything")
+      assert_equal true, custom_scalar.valid_isolated_input?(12345)
     end
 
     it "sets correct default values on custom scalar arguments" do

data/spec/graphql/string_type_spec.rb

@@ -9,21 +9,48 @@ describe GraphQL::STRING_TYPE do
   end
 
   describe "coerce_result" do
+    let(:binary_str) { "\0\0\0foo\255\255\255".dup.force_encoding("BINARY") }
     it "requires string to be encoded as UTF-8" do
-      binary_str = "\0\0\0foo\255\255\255".dup.force_encoding("BINARY")
-      assert_equal nil, string_type.coerce_result(binary_str)
+      err = assert_raises(GraphQL::StringEncodingError) {
+        string_type.coerce_isolated_result(binary_str)
+      }
+
+      assert_equal "String \"#{binary_str}\" was encoded as ASCII-8BIT! GraphQL requires UTF-8 encoding.", err.message
+      assert_equal binary_str, err.string
+    end
+
+    describe "when the schema defines a custom hander" do
+      let(:schema) {
+        GraphQL::Schema.define do
+          query(GraphQL::ObjectType.define(name: "Query"))
+          type_error ->(err, ctx) {
+            ctx.errors << err
+            "🌾"
+          }
+        end
+      }
+
+      let(:context) {
+        OpenStruct.new(schema: schema, errors: [])
+      }
+
+      it "calls the handler" do
+        assert_equal "🌾", string_type.coerce_result(binary_str, context)
+        err = context.errors.last
+        assert_instance_of GraphQL::StringEncodingError, err
+      end
     end
   end
 
   describe "coerce_input" do
     it "accepts strings" do
-      assert_equal "str", string_type.coerce_input("str")
+      assert_equal "str", string_type.coerce_isolated_input("str")
     end
 
     it "doesn't accept other types" do
-      assert_equal nil, string_type.coerce_input(100)
-      assert_equal nil, string_type.coerce_input(true)
-      assert_equal nil, string_type.coerce_input(0.999)
+      assert_equal nil, string_type.coerce_isolated_input(100)
+      assert_equal nil, string_type.coerce_isolated_input(true)
+      assert_equal nil, string_type.coerce_isolated_input(0.999)
     end
   end
 end

data/spec/spec_helper.rb

@@ -27,17 +27,6 @@ GraphQL::Field.accepts_definitions(metadata: assign_metadata_key)
 GraphQL::Argument.accepts_definitions(metadata: assign_metadata_key)
 GraphQL::EnumType::EnumValue.accepts_definitions(metadata: assign_metadata_key)
 
-# Can be used as a GraphQL::Schema::Warden for some purposes, but allows anything
-module PermissiveWarden
-  def self.arguments(input_obj)
-    input_obj.arguments.values
-  end
-
-  def self.enum_values(enum_type)
-    enum_type.values.values
-  end
-end
-
 # Can be used as a GraphQL::Schema::Warden for some purposes, but allows nothing
 module NothingWarden
   def self.enum_values(enum_type)

data/spec/support/dummy/schema.rb

@@ -225,7 +225,7 @@ module Dummy
 
     def call(obj, args, ctx)
       id_string = args["id"].to_s # Cheese has Int type, Milk has ID type :(
-      id, item = @data.find { |id, item| id.to_s == id_string }
+      _id, item = @data.find { |id, item| id.to_s == id_string }
       item
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.5.5
+  version: 1.5.6
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-31 00:00:00.000000000 Z
+date: 2017-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -408,6 +408,7 @@ files:
 - lib/graphql/query/executor.rb
 - lib/graphql/query/input_validation_result.rb
 - lib/graphql/query/literal_input.rb
+- lib/graphql/query/null_context.rb
 - lib/graphql/query/serial_execution.rb
 - lib/graphql/query/serial_execution/field_resolution.rb
 - lib/graphql/query/serial_execution/operation_resolution.rb
@@ -487,6 +488,7 @@ files:
 - lib/graphql/static_validation/type_stack.rb
 - lib/graphql/static_validation/validation_context.rb
 - lib/graphql/static_validation/validator.rb
+- lib/graphql/string_encoding_error.rb
 - lib/graphql/string_type.rb
 - lib/graphql/type_kinds.rb
 - lib/graphql/union_type.rb
@@ -550,6 +552,7 @@ files:
 - spec/graphql/query/arguments_spec.rb
 - spec/graphql/query/context_spec.rb
 - spec/graphql/query/executor_spec.rb
+- spec/graphql/query/literal_input_spec.rb
 - spec/graphql/query/serial_execution/value_resolution_spec.rb
 - spec/graphql/query/variables_spec.rb
 - spec/graphql/query_spec.rb
@@ -695,6 +698,7 @@ test_files:
 - spec/graphql/query/arguments_spec.rb
 - spec/graphql/query/context_spec.rb
 - spec/graphql/query/executor_spec.rb
+- spec/graphql/query/literal_input_spec.rb
 - spec/graphql/query/serial_execution/value_resolution_spec.rb
 - spec/graphql/query/variables_spec.rb
 - spec/graphql/query_spec.rb