graphql 1.9.3 → 1.9.4

data/spec/graphql/schema/input_object_spec.rb

@@ -37,9 +37,15 @@ describe GraphQL::Schema::InputObject do
         argument :arg3, Integer, required: true
       end
 
+      ensemble_class = Class.new(subclass) do
+        argument :ensemble_id, GraphQL::Types::ID, required: false, loads: Jazz::Ensemble
+      end
+      
       assert_equal 3, subclass.arguments.size
       assert_equal ["arg1", "arg2", "arg3"], subclass.arguments.keys
       assert_equal ["String!", "Int!", "Int!"], subclass.arguments.values.map { |a| a.type.to_type_signature }
+      assert_equal ["String!", "Int!", "Int!", "ID"], ensemble_class.arguments.values.map { |a| a.type.to_type_signature }
+      assert_equal :ensemble, ensemble_class.arguments["ensembleId"].keyword
     end
   end
 
@@ -55,7 +61,7 @@ describe GraphQL::Schema::InputObject do
     end
   end
 
-  describe "prepare: / as:" do
+  describe "prepare: / loads: / as:" do
     module InputObjectPrepareTest
       class InputObj < GraphQL::Schema::InputObject
         argument :a, Integer, required: true
@@ -63,6 +69,8 @@ describe GraphQL::Schema::InputObject do
         argument :c, Integer, required: true, prepare: :prep
         argument :d, Integer, required: true, prepare: :prep, as: :d2
         argument :e, Integer, required: true, prepare: ->(val, ctx) { val * ctx[:multiply_by] * 2 }, as: :e2
+        argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
+        argument :danger, Integer, required: false, prepare: ->(val, ctx) { raise GraphQL::ExecutionError.new('boom!') }
 
         def prep(val)
           val * context[:multiply_by]
@@ -70,12 +78,12 @@ describe GraphQL::Schema::InputObject do
       end
 
       class Query < GraphQL::Schema::Object
-        field :inputs, String, null: false do
+        field :inputs, [String], null: false do
           argument :input, InputObj, required: true
         end
 
         def inputs(input:)
-          input.to_kwargs.inspect
+          [input.to_kwargs.inspect, input.instrument.name]
         end
       end
 
@@ -84,18 +92,115 @@ describe GraphQL::Schema::InputObject do
         if TESTING_INTERPRETER
           use GraphQL::Execution::Interpreter
         end
+
+        def self.object_from_id(id, ctx)
+          Jazz::GloballyIdentifiableType.find(id)
+        end
+
+        def self.resolve_type(type, obj, ctx)
+          type
+        end
       end
     end
 
     it "calls methods on the input object" do
       query_str = <<-GRAPHQL
-      { inputs(input: { a: 1, b: 2, c: 3, d: 4, e: 5 }) }
+      { inputs(input: { a: 1, b: 2, c: 3, d: 4, e: 5, instrumentId: "Instrument/Drum Kit" }) }
       GRAPHQL
 
       res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 })
-      expected_obj = { a: 1, b2: 2, c: 9, d2: 12, e2: 30 }.inspect
+      expected_obj = [{ a: 1, b2: 2, c: 9, d2: 12, e2: 30, instrument: "Instrument/Drum Kit" }.inspect, "Drum Kit"]
       assert_equal expected_obj, res["data"]["inputs"]
     end
+
+    it "handles exceptions preparing variable input objects" do
+      query_str = <<-GRAPHQL
+      query($input: InputObj!){ inputs(input: $input) }
+      GRAPHQL
+
+      input = { "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "instrumentId" => "Instrument/Drum Kit", "danger" => 1 }
+      res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 },
+                                                   variables: { input: input})
+      assert_nil(res["data"])
+      assert_equal("Variable input of type InputObj! was provided invalid value", res["errors"][0]["message"])
+      assert_equal([{ "line" => 1, "column" => 13 }], res["errors"][0]["locations"])
+      assert_equal("boom!", res["errors"][0]["extensions"]["problems"][0]["explanation"])
+      assert_equal(input, res["errors"][0]["extensions"]["value"])
+    end
+  end
+
+  describe "loading application object(s)" do
+    module InputObjectLoadsTest
+      class SingleLoadInputObj < GraphQL::Schema::InputObject
+        argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
+      end
+
+      class MultiLoadInputObj < GraphQL::Schema::InputObject
+        argument :instrument_ids, [ID], required: true, loads: Jazz::InstrumentType
+      end
+
+      class Query < GraphQL::Schema::Object
+        field :single_load_input, Jazz::InstrumentType, null: false do
+          argument :input, SingleLoadInputObj, required: true
+        end
+        field :multi_load_input, [Jazz::InstrumentType], null: false do
+          argument :input, MultiLoadInputObj, required: true
+        end
+
+        def single_load_input(input:)
+          input.instrument
+        end
+
+        def multi_load_input(input:)
+          input.instruments
+        end
+      end
+
+      class Schema < GraphQL::Schema
+        query(Query)
+        if TESTING_INTERPRETER
+          use GraphQL::Execution::Interpreter
+        end
+
+        def self.object_from_id(id, ctx)
+          Jazz::GloballyIdentifiableType.find(id)
+        end
+
+        def self.resolve_type(type, obj, ctx)
+          type
+        end
+      end
+    end
+
+    let(:single_query_str) {
+      <<-GRAPHQL
+        query($id: ID!) {
+          singleLoadInput(input: {instrumentId: $id}) {
+            id
+          }
+        }
+      GRAPHQL
+    }
+
+    let(:multi_query_str) {
+      <<-GRAPHQL
+        query($ids: [ID!]!) {
+          multiLoadInput(input: {instrumentIds: $ids}) {
+            id
+          }
+        }
+      GRAPHQL
+    }
+
+    it "loads arguments as objects of the given type and strips `_id` suffix off argument name" do
+      res = InputObjectLoadsTest::Schema.execute(single_query_str, variables: { id: "Ensemble/Robert Glasper Experiment" })
+      assert_equal "Ensemble/Robert Glasper Experiment", res["data"]["singleLoadInput"]["id"]
+    end
+
+    it "loads arguments as objects of the given type and strips `_ids` suffix off argument name and appends `s`" do
+      res = InputObjectLoadsTest::Schema.execute(multi_query_str, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["multiLoadInput"].map { |e| e["id"] }
+    end
   end
 
   describe "in queries" do
@@ -105,7 +210,8 @@ describe GraphQL::Schema::InputObject do
         inspectInput(input: {
           stringValue: "ABC",
           legacyInput: { intValue: 4 },
-          nestedInput: { stringValue: "xyz"}
+          nestedInput: { stringValue: "xyz"},
+          ensembleId: "Ensemble/Robert Glasper Experiment"
         })
       }
       GRAPHQL
@@ -118,6 +224,8 @@ describe GraphQL::Schema::InputObject do
         "ABC",
         "true",
         "ABC",
+        Jazz::Models::Ensemble.new("Robert Glasper Experiment").to_s,
+        "true",
       ]
       assert_equal expected_info, res["data"]["inspectInput"]
     end
@@ -136,6 +244,7 @@ describe GraphQL::Schema::InputObject do
         graphql_name "TestInput1"
         argument :d, Int, required: true
         argument :e, Int, required: true
+        argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
       end
 
       class TestInput2 < GraphQL::Schema::InputObject
@@ -150,7 +259,7 @@ describe GraphQL::Schema::InputObject do
     end
 
     it "returns a symbolized, aliased, ruby keyword style hash" do
-      arg_values = {a: 1, b: 2, c: { d: 3, e: 4 }}
+      arg_values = {a: 1, b: 2, c: { d: 3, e: 4, instrumentId: "Instrument/Drum Kit"}}
 
       input_object = InputObjectToHTest::TestInput2.new(
         arg_values,
@@ -158,7 +267,7 @@ describe GraphQL::Schema::InputObject do
         defaults_used: Set.new
       )
 
-      assert_equal({ a: 1, b: 2, input_object: { d: 3, e: 4 } }, input_object.to_h)
+      assert_equal({ a: 1, b: 2, input_object: { d: 3, e: 4, instrument: "Instrument/Drum Kit" } }, input_object.to_h)
     end
   end
 
@@ -228,11 +337,11 @@ describe GraphQL::Schema::InputObject do
           }
         }')
       # Test __type
-      assert_equal ["stringValue", "nestedInput", "legacyInput"], res["data"]["__type"]["inputFields"].map { |f| f["name"] }
+      assert_equal ["ensembleId", "stringValue", "nestedInput", "legacyInput"], res["data"]["__type"]["inputFields"].map { |f| f["name"] }
       # Test __schema { types }
       # It's upcased to test custom introspection
       input_type = res["data"]["__schema"]["types"].find { |t| t["name"] == "INSPECTABLEINPUT" }
-      assert_equal ["stringValue", "nestedInput", "legacyInput"], input_type["inputFields"].map { |f| f["name"] }
+      assert_equal ["ensembleId", "stringValue", "nestedInput", "legacyInput"], input_type["inputFields"].map { |f| f["name"] }
     end
   end
 end

data/spec/graphql/schema/introspection_system_spec.rb

@@ -18,6 +18,15 @@ describe GraphQL::Schema::IntrospectionSystem do
       assert_equal "Set", res["data"]["__classname"]
     end
 
+    it "calls authorization methods of those types" do
+      res = Jazz::Schema.execute(%|{ __type(name: "Ensemble") { name } }|)
+      assert_equal "ENSEMBLE", res["data"]["__type"]["name"]
+
+      unauth_res = Jazz::Schema.execute(%|{ __type(name: "Ensemble") { name } }|, context: { cant_introspect: true })
+      assert_nil unauth_res["data"].fetch("__type")
+      assert_equal ["You're not allowed to introspect here"], unauth_res["errors"].map { |e| e["message"] }
+    end
+
     it "serves custom dynamic fields" do
       res = Jazz::Schema.execute("{ nowPlaying { __typename __typenameLength __astNodeClass } }")
       assert_equal "Ensemble", res["data"]["nowPlaying"]["__typename"]

data/spec/graphql/schema/resolver_spec.rb

@@ -485,7 +485,7 @@ describe GraphQL::Schema::Resolver do
 
         res = exec_query(query_str)
         assert_nil res["data"].fetch("resolverWithErrorHandler")
-        expected_err = "ResolverWithErrorHandler failed for id: \"failed_to_find\" (nil) (GraphQL::Schema::Resolver::LoadApplicationObjectFailedError)"
+        expected_err = "ResolverWithErrorHandler failed for id: \"failed_to_find\" (nil) (GraphQL::LoadApplicationObjectFailedError)"
         assert_equal [expected_err], res["errors"].map { |e| e["message"] }
       end
     end
@@ -500,7 +500,7 @@ describe GraphQL::Schema::Resolver do
 
         res = exec_query(query_str)
         assert_nil res["data"].fetch("resolverWithErrorHandler")
-        expected_err = "ResolverWithErrorHandler failed for id: \"resolve_type_as_wrong_type\" (:resolve_type_as_wrong_type) (GraphQL::Schema::Resolver::LoadApplicationObjectFailedError)"
+        expected_err = "ResolverWithErrorHandler failed for id: \"resolve_type_as_wrong_type\" (:resolve_type_as_wrong_type) (GraphQL::LoadApplicationObjectFailedError)"
         assert_equal [expected_err], res["errors"].map { |e| e["message"] }
       end
     end

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -47,7 +47,7 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         input_object_field_error = {
           "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
           "locations"=>[{"line"=>6, "column"=>39}],
-          "path"=>["query getCheese", "badSource", "product", "source"],
+          "path"=>["query getCheese", "badSource", "product", 0, "source"],
           "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
         }
         assert_includes(errors, input_object_field_error)
@@ -92,7 +92,7 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         input_object_field_error = {
           "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
           "locations"=>[{"line"=>6, "column"=>39}],
-          "path"=>["query getCheese", "badSource", "product", "source"],
+          "path"=>["query getCheese", "badSource", "product", 0, "source"],
           "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
         }
         assert_includes(errors, input_object_field_error)

data/spec/graphql/static_validation/rules/arguments_are_defined_spec.rb

@@ -41,7 +41,7 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
         input_obj_record = {
           "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
           "locations"=>[{"line"=>5, "column"=>30}],
-          "path"=>["query getCheese", "searchDairy", "product", "wacky"],
+          "path"=>["query getCheese", "searchDairy", "product", 0, "wacky"],
           "extensions"=>{
             "code"=>"argumentNotAccepted",
             "name"=>"DairyProductInput",

data/spec/graphql/static_validation/rules/required_input_object_attributes_are_present_spec.rb

@@ -13,6 +13,7 @@ describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
       badSource: searchDairy(product: [{source: 1.1}]) { __typename }
       missingSource: searchDairy(product: [{fatContent: 1.1}]) { __typename }
       missingNestedRequiredInputObjectAttribute: searchDairy(product: [{fatContent: 1.2, order_by: {}}]) { __typename }
+      errorAtIndexOne: searchDairy(product: [{source: COW, fatContent: 1.0}, {fatContent: 1.2, order_by: {}}]) { __typename }
       listCoerce: cheese(id: 1) { similarCheese(source: YAK) { __typename } }
       missingInputField: searchDairy(product: [{source: YAK, wacky: 1}]) { __typename }
     }
@@ -35,7 +36,7 @@ describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
     missing_source_error = {
       "message"=>"Argument 'source' on InputObject 'DairyProductInput' is required. Expected type DairyAnimal!",
       "locations"=>[{"line"=>7, "column"=>44}],
-      "path"=>["query getCheese", "missingSource", "product", "source"],
+      "path"=>["query getCheese", "missingSource", "product", 0, "source"],
       "extensions"=>{
         "code"=>"missingRequiredInputObjectAttribute",
         "argumentName"=>"source",
@@ -46,7 +47,18 @@ describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
     missing_order_by_direction_error = {
       "message"=>"Argument 'direction' on InputObject 'ResourceOrderType' is required. Expected type String!",
       "locations"=>[{"line"=>8, "column"=>100}],
-      "path"=>["query getCheese", "missingNestedRequiredInputObjectAttribute", "product", "order_by", "direction"],
+      "path"=>["query getCheese", "missingNestedRequiredInputObjectAttribute", "product", 0, "order_by", "direction"],
+      "extensions"=>{
+        "code"=>"missingRequiredInputObjectAttribute",
+        "argumentName"=>"direction",
+        "argumentType"=>"String!",
+        "inputObjectType"=>"ResourceOrderType"
+      }
+    }
+    missing_order_by_direction_index_one_error = {
+      "message"=>"Argument 'direction' on InputObject 'ResourceOrderType' is required. Expected type String!",
+      "locations"=>[{"line"=>9, "column"=>106}],
+      "path"=>["query getCheese", "errorAtIndexOne", "product", 1, "order_by", "direction"],
       "extensions"=>{
         "code"=>"missingRequiredInputObjectAttribute",
         "argumentName"=>"direction",
@@ -58,6 +70,7 @@ describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
       without_error_bubbling(schema) do
         assert_includes(errors, missing_source_error)
         assert_includes(errors, missing_order_by_direction_error)
+        assert_includes(errors, missing_order_by_direction_index_one_error)
         refute_includes(errors, missing_required_field_error)
       end
     end
@@ -66,6 +79,7 @@ describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
         assert_includes(errors, missing_required_field_error)
         assert_includes(errors, missing_source_error)
         assert_includes(errors, missing_order_by_direction_error)
+        assert_includes(errors, missing_order_by_direction_index_one_error)
       end
     end
   end

data/spec/graphql/subscriptions_spec.rb

@@ -268,6 +268,44 @@ describe GraphQL::Subscriptions do
         end
       end
 
+      describe "passing a document into #execute" do
+        it "sends the updated data" do
+          query_str = <<-GRAPHQL
+        subscription ($id: ID!){
+          payload(id: $id) { str, int }
+        }
+          GRAPHQL
+
+          document = GraphQL.parse(query_str)
+
+          # Initial subscriptions
+          response = schema.execute(nil, document: document, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
+
+          # This difference is because of how `SKIP` is handled.
+          # Honestly the new way is probably better, since it puts a value there.
+          empty_response = if TESTING_INTERPRETER && schema == ClassBasedInMemoryBackend::Schema
+            {}
+          else
+            nil
+          end
+
+          # Initial response is nil, no broadcasts yet
+          assert_equal(empty_response, response["data"])
+          assert_equal [], deliveries["1"]
+
+          # Application stuff happens.
+          # The application signals graphql via `subscriptions.trigger`:
+          schema.subscriptions.trigger(:payload, {"id" => "100"}, root_object.payload)
+          # Symobls are OK too
+          schema.subscriptions.trigger(:payload, {:id => "100"}, root_object.payload)
+          schema.subscriptions.trigger("payload", {"id" => "300"}, nil)
+
+          # Let's see what GraphQL sent over the wire:
+          assert_equal({"str" => "Update", "int" => 1}, deliveries["1"][0]["data"]["payload"])
+          assert_equal({"str" => "Update", "int" => 2}, deliveries["1"][1]["data"]["payload"])
+        end
+      end
+
       describe "subscribing" do
         it "doesn't call the subscriptions for invalid queries" do
           query_str = <<-GRAPHQL

data/spec/graphql/tracing/new_relic_tracing_spec.rb

@@ -3,7 +3,13 @@ require "spec_helper"
 
 describe GraphQL::Tracing::NewRelicTracing do
   module NewRelicTest
+    class Thing < GraphQL::Schema::Object
+      implements GraphQL::Types::Relay::Node
+    end
+
     class Query < GraphQL::Schema::Object
+      add_field GraphQL::Types::Relay::NodeField
+
       field :int, Integer, null: false
 
       def int
@@ -14,6 +20,16 @@ describe GraphQL::Tracing::NewRelicTracing do
     class SchemaWithoutTransactionName < GraphQL::Schema
       query(Query)
       use(GraphQL::Tracing::NewRelicTracing)
+      orphan_types(Thing)
+
+      def self.object_from_id(_id, _ctx)
+        :thing
+      end
+
+      def self.resolve_type(_type, _obj, _ctx)
+        Thing
+      end
+
       if TESTING_INTERPRETER
         use GraphQL::Execution::Interpreter
       end
@@ -37,6 +53,11 @@ describe GraphQL::Tracing::NewRelicTracing do
     NewRelic.clear_all
   end
 
+  it "works with the built-in node field, even though it doesn't have an @owner" do
+    res = NewRelicTest::SchemaWithoutTransactionName.execute '{ node(id: "1") { __typename } }'
+    assert_equal "Thing", res["data"]["node"]["__typename"]
+  end
+
   it "can leave the transaction name in place" do
     NewRelicTest::SchemaWithoutTransactionName.execute "query X { int }"
     assert_equal [], NewRelic::TRANSACTION_NAMES

data/spec/graphql/types/big_int_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Types::BigInt do
+  it "encodes big and small integers as strings" do
+    big_integer_1 = 99**99
+    expected_str_1 = "369729637649726772657187905628805440595668764281741102430259972423552570455277523421410650010128232727940978889548326540119429996769494359451621570193644014418071060667659301384999779999159200499899"
+    assert_equal expected_str_1, GraphQL::Types::BigInt.coerce_result(big_integer_1, nil)
+    assert_equal big_integer_1, GraphQL::Types::BigInt.coerce_input(expected_str_1, nil)
+
+    big_integer_2 = -(88**88)
+    expected_str_2 = "-1301592834942972055182648307417315364538725075960067827915311484722452340966317215805106820959190833309704934346517741237438752456673499160125624414995891111204155079786496"
+    assert_equal expected_str_2, GraphQL::Types::BigInt.coerce_result(big_integer_2, nil)
+    assert_equal big_integer_2, GraphQL::Types::BigInt.coerce_input(expected_str_2, nil)
+
+    assert_equal "31", GraphQL::Types::BigInt.coerce_result(31, nil)
+    assert_equal -17, GraphQL::Types::BigInt.coerce_input("-17", nil)
+  end
+
+  it "returns `nil` for invalid inputs" do
+    assert_equal nil, GraphQL::Types::BigInt.coerce_input("xyz", nil)
+    assert_equal nil, GraphQL::Types::BigInt.coerce_input("2.2", nil)
+  end
+end