graphql 1.9.6 → 1.9.7

data/spec/graphql/execution/instrumentation_spec.rb

@@ -62,23 +62,45 @@ describe GraphQL::Schema do
       end
     end
 
+    # This is how you might add queries from a persisted query backend
+
+    class QueryStringInstrumenter
+      def before_query(query)
+        if query.context[:extra_query_string] && query.query_string.nil?
+          query.query_string = query.context[:extra_query_string]
+        end
+      end
+
+      def after_query(query)
+      end
+    end
+
     let(:query_type) {
-      GraphQL::ObjectType.define do
-        name "Query"
-        field :int, types.Int do
-          argument :value, types.Int
-          resolve ->(obj, args, ctx) { args.value }
+      Class.new(GraphQL::Schema::Object) do
+        graphql_name "Query"
+        field :int, Integer, null: true do
+          argument :value, Integer, required: false
+        end
+
+        def int(value:)
+          value
         end
       end
     }
 
     let(:schema) {
       spec = self
-      GraphQL::Schema.define do
+      Class.new(GraphQL::Schema) do
         query(spec.query_type)
         instrument(:query, FirstInstrumenter.new)
         instrument(:query, SecondInstrumenter.new)
         instrument(:query, ExecutionErrorInstrumenter.new)
+        instrument(:query, QueryStringInstrumenter.new)
+
+        if TESTING_INTERPRETER
+          use GraphQL::Analysis::AST
+          use GraphQL::Execution::Interpreter
+        end
       end
     }
 
@@ -114,6 +136,12 @@ describe GraphQL::Schema do
         assert_equal "Raised from instrumenter before_query", res["errors"].first["message"]
         refute res.key?("data"), "The query doesn't run"
       end
+
+      it "can assign a query string there" do
+        context = { extra_query_string: "{ __typename }"}
+        res = schema.execute(nil, context: context)
+        assert_equal "Query", res["data"]["__typename"]
+      end
     end
 
     describe "within a multiplex" do

data/spec/graphql/execution/multiplex_spec.rb

@@ -134,6 +134,17 @@ describe GraphQL::Execution::Multiplex do
     end
   end
 
+  describe "max_complexity" do
+    it "can successfully calculate complexity" do
+      message = "Query has complexity of 11, which exceeds max complexity of 10"
+      results = multiplex(queries, max_complexity: 10)
+
+      results.each do |res|
+        assert_equal message, res["errors"][0]["message"]
+      end
+    end
+  end
+
   describe "after_query when errors are raised" do
     class InspectQueryInstrumentation
       class << self

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -125,7 +125,12 @@ describe GraphQL::InternalRepresentation::Rewrite do
       nut_selections = plant_selection.typed_children[schema.types["Nut"]]
       # `... on Tree`, `... on Nut`, and `NutFields`, but not `... on Fruit { ... on Tree }`
 
-      assert_equal 3, nut_selections["leafType"].ast_nodes.size
+      if RUBY_VERSION < "2.5"
+        # Ruby 2.5 changed how hash key collisions worked a little bit.
+        # This test is "broken", but honestly, it doesn't matter.
+        # Apparently nobody uses `IrepNode#ast_nodes`, and that's for the best.
+        assert_equal 3, nut_selections["leafType"].ast_nodes.size
+      end
 
       # Multi-level merging when including fragments:
       habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]

data/spec/graphql/schema/input_object_spec.rb

@@ -40,7 +40,7 @@ describe GraphQL::Schema::InputObject do
       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 }
@@ -87,8 +87,32 @@ describe GraphQL::Schema::InputObject do
         end
       end
 
+      class Mutation < GraphQL::Schema::Object
+        class TouchInstrument < GraphQL::Schema::Mutation
+          class InstrumentInput < GraphQL::Schema::InputObject
+            argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
+          end
+
+          argument :input_obj, InstrumentInput, required: true
+          field :instrument_name_method, String, null: false
+          field :instrument_name_key, String, null: false
+
+          def resolve(input_obj:)
+            # Make sure both kinds of access work the same:
+            {
+              instrument_name_method: input_obj.instrument.name,
+              instrument_name_key: input_obj[:instrument].name,
+            }
+          end
+        end
+
+        field :touch_instrument, mutation: TouchInstrument
+      end
+
+
       class Schema < GraphQL::Schema
         query(Query)
+        mutation(Mutation)
         if TESTING_INTERPRETER
           use GraphQL::Execution::Interpreter
         end
@@ -109,7 +133,7 @@ describe GraphQL::Schema::InputObject do
       GRAPHQL
 
       res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 })
-      expected_obj = [{ a: 1, b2: 2, c: 9, d2: 12, e2: 30, instrument: "Instrument/Drum Kit" }.inspect, "Drum Kit"]
+      expected_obj = [{ a: 1, b2: 2, c: 9, d2: 12, e2: 30, instrument: Jazz::Models::Instrument.new("Drum Kit", "PERCUSSION") }.inspect, "Drum Kit"]
       assert_equal expected_obj, res["data"]["inputs"]
     end
 
@@ -127,6 +151,21 @@ describe GraphQL::Schema::InputObject do
       assert_equal("boom!", res["errors"][0]["extensions"]["problems"][0]["explanation"])
       assert_equal(input, res["errors"][0]["extensions"]["value"])
     end
+
+    it "loads input object arguments" do
+      query_str = <<-GRAPHQL
+      mutation {
+        touchInstrument(inputObj: { instrumentId: "Instrument/Drum Kit" }) {
+          instrumentNameMethod
+          instrumentNameKey
+        }
+      }
+      GRAPHQL
+
+      res = InputObjectPrepareTest::Schema.execute(query_str)
+      assert_equal "Drum Kit", res["data"]["touchInstrument"]["instrumentNameMethod"]
+      assert_equal "Drum Kit", res["data"]["touchInstrument"]["instrumentNameKey"]
+    end
   end
 
   describe "loading application object(s)" do
@@ -238,7 +277,7 @@ describe GraphQL::Schema::InputObject do
     end
   end
 
-  describe "#to_h" do
+  describe 'hash conversion behavior' do
     module InputObjectToHTest
       class TestInput1 < GraphQL::Schema::InputObject
         graphql_name "TestInput1"
@@ -258,16 +297,26 @@ describe GraphQL::Schema::InputObject do
       TestInput2.to_graphql
     end
 
-    it "returns a symbolized, aliased, ruby keyword style hash" do
+    before do
       arg_values = {a: 1, b: 2, c: { d: 3, e: 4, instrumentId: "Instrument/Drum Kit"}}
 
-      input_object = InputObjectToHTest::TestInput2.new(
+      @input_object = InputObjectToHTest::TestInput2.new(
         arg_values,
-        context: nil,
+        context: OpenStruct.new(schema: Jazz::Schema),
         defaults_used: Set.new
       )
+    end
 
-      assert_equal({ a: 1, b: 2, input_object: { d: 3, e: 4, instrument: "Instrument/Drum Kit" } }, input_object.to_h)
+    describe "#to_h" do
+      it "returns a symbolized, aliased, ruby keyword style hash" do
+        assert_equal({ a: 1, b: 2, input_object: { d: 3, e: 4, instrument: Jazz::Models::Instrument.new("Drum Kit", "PERCUSSION") } }, @input_object.to_h)
+      end
+    end
+
+    describe "#to_hash" do
+      it "returns the same results as #to_h (aliased)" do
+        assert_equal(@input_object.to_h, @input_object.to_hash)
+      end
     end
   end
 

data/spec/graphql/schema/introspection_system_spec.rb

@@ -53,4 +53,28 @@ describe GraphQL::Schema::IntrospectionSystem do
       assert_equal [], ensembles_field["args"]
     end
   end
+
+  describe "#disable_introspection_entry_points" do
+    let(:schema) { Jazz::Schema }
+
+    it "allows entry point introspection by default" do
+      res = schema.execute("{ __schema { types { name } } }")
+      assert res
+
+      types = res["data"]["__schema"]["types"]
+      refute_empty types
+    end
+
+    describe "when entry points introspection is disabled" do
+      let(:schema) { Jazz::SchemaWithoutIntrospection }
+
+      it "returns error" do
+        res = schema.execute("{ __schema { types { name } } }")
+        assert res
+
+        assert_nil res["data"]
+        assert_equal ["Field '__schema' doesn't exist on type 'Query'"], res["errors"].map { |e| e["message"] }
+      end
+    end
+  end
 end

data/spec/graphql/schema/subscription_spec.rb

@@ -68,6 +68,12 @@ describe GraphQL::Schema::Subscription do
       end
     end
 
+    class DirectTootWasTooted < BaseSubscription
+      subscription_scope :viewer
+      field :toot, Toot, null: false
+      field :user, User, null: false
+    end
+
     # Test initial response, which returns all users
     class UsersJoined < BaseSubscription
       class UsersJoinedManualPayload < GraphQL::Schema::Object
@@ -97,6 +103,7 @@ describe GraphQL::Schema::Subscription do
     class Subscription < GraphQL::Schema::Object
       extend GraphQL::Subscriptions::SubscriptionRoot
       field :toot_was_tooted, subscription: TootWasTooted
+      field :direct_toot_was_tooted, subscription: DirectTootWasTooted
       field :users_joined, subscription: UsersJoined
       field :new_users_joined, subscription: NewUsersJoined
     end
@@ -437,4 +444,62 @@ describe GraphQL::Schema::Subscription do
       assert_equal 1, in_memory_subscription_count
     end
   end
+
+  describe "`subscription_scope` method" do
+    it "provdes a subscription scope that is recognized in the schema" do
+      scoped_subscription = SubscriptionFieldSchema::get_field("Subscription", "directTootWasTooted")
+  
+      assert_equal :viewer, scoped_subscription.subscription_scope
+    end
+  
+    it "provides a subscription scope that is used in execution" do
+      res = exec_query <<-GRAPHQL, context: { viewer: :me }
+        subscription {
+          directTootWasTooted {
+            toot { body }
+          }
+        }
+      GRAPHQL
+      assert_equal 1, in_memory_subscription_count
+
+      # Only the subscription with scope :me should be in the mailbox
+      obj = OpenStruct.new(toot: { body: "Hello from matz!" }, user: SubscriptionFieldSchema::USERS["matz"])
+      SubscriptionFieldSchema.subscriptions.trigger(:direct_toot_was_tooted, {}, obj, scope: :me)
+      SubscriptionFieldSchema.subscriptions.trigger(:direct_toot_was_tooted, {}, obj, scope: :not_me)
+      mailbox = res.context[:subscription_mailbox]
+
+      assert_equal 1, mailbox.length
+
+      expected_response = {
+        "data" => {
+          "directTootWasTooted" => {
+            "toot" => {
+              "body" => "Hello from matz!"
+            }
+          }
+        }
+      }
+
+      assert_equal expected_response, mailbox.first
+    end
+
+    it "allows for proper inheritance of the class's configuration in subclasses" do
+      # Make a subclass without an explicit configuration
+      class DirectTootSubclass < SubscriptionFieldSchema::DirectTootWasTooted
+      end
+      # Then check if the field options got the inherited value
+      direct_toot_options = DirectTootSubclass.field_options
+      assert_equal :viewer, direct_toot_options[:subscription_scope]
+    end
+
+    it "allows for setting the subscription scope value to nil" do
+      class PrivateSubscription < SubscriptionFieldSchema::BaseSubscription
+        subscription_scope :private
+      end
+
+      PrivateSubscription.subscription_scope nil
+
+      assert_nil PrivateSubscription.subscription_scope
+    end
+  end
 end

data/spec/graphql/schema/timeout_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Timeout do
+  let(:max_seconds) { 1 }
+  let(:timeout_class) { GraphQL::Schema::Timeout }
+  let(:timeout_schema) {
+    nested_sleep_type = Class.new(GraphQL::Schema::Object) do
+      graphql_name "NestedSleep"
+
+      field :seconds, Float, null: true
+
+      def seconds
+        object
+      end
+
+      field :nested_sleep, GraphQL::Schema::LateBoundType.new(graphql_name), null: true do
+        argument :seconds, Float, required: true
+      end
+
+      def nested_sleep(seconds:)
+        sleep(seconds)
+        seconds
+      end
+    end
+
+    query_type = Class.new(GraphQL::Schema::Object) do
+      graphql_name "Query"
+
+      field :sleep_for, Float, null: true do
+        argument :seconds, Float, required: true
+      end
+
+      def sleep_for(seconds:)
+        sleep(seconds)
+        seconds
+      end
+
+      field :nested_sleep, nested_sleep_type, null: true do
+        argument :seconds, Float, required: true
+      end
+
+      def nested_sleep(seconds:)
+        sleep(seconds)
+        seconds
+      end
+    end
+
+    schema = Class.new(GraphQL::Schema) do
+      query query_type
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
+    end
+    schema.use timeout_class, max_seconds: max_seconds
+    schema
+  }
+
+  let(:result) { timeout_schema.execute(query_string) }
+
+  describe "timeout part-way through" do
+    let(:query_string) {%|
+      {
+        a: sleepFor(seconds: 0.4)
+        b: sleepFor(seconds: 0.4)
+        c: sleepFor(seconds: 0.4)
+        d: sleepFor(seconds: 0.4)
+        e: sleepFor(seconds: 0.4)
+      }
+    |}
+    it "returns a partial response and error messages" do
+      expected_data = {
+        "a"=>0.4,
+        "b"=>0.4,
+        "c"=>0.4,
+        "d"=>nil,
+        "e"=>nil,
+      }
+
+      expected_errors =  [
+        {
+          "message"=>"Timeout on Query.sleepFor",
+          "locations"=>[{"line"=>6, "column"=>9}],
+          "path"=>["d"]
+        },
+        {
+          "message"=>"Timeout on Query.sleepFor",
+          "locations"=>[{"line"=>7, "column"=>9}],
+          "path"=>["e"]
+        },
+      ]
+      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: 0.3) {
+        seconds
+        b: nestedSleep(seconds: 0.3) {
+          seconds
+          c: nestedSleep(seconds: 0.3) {
+            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" => 0.3,
+          "b" => {
+            "seconds" => 0.3,
+            "c" => {
+              "seconds"=>0.3,
+              "d" => {
+                "seconds"=>nil,
+                "e"=>nil
+              }
+            }
+          }
+        }
+      }
+      expected_errors = [
+        {
+          "message"=>"Timeout on NestedSleep.seconds",
+          "locations"=>[{"line"=>10, "column"=>15}],
+          "path"=>["a", "b", "c", "d", "seconds"]
+        },
+        {
+          "message"=>"Timeout on NestedSleep.nestedSleep",
+          "locations"=>[{"line"=>11, "column"=>15}],
+          "path"=>["a", "b", "c", "d", "e"]
+        },
+      ]
+
+      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.2)
+        b: sleepFor(seconds: 0.2)
+        c: sleepFor(seconds: 0.8)
+        d: sleepFor(seconds: 0.1)
+      }
+    |}
+    it "doesn't terminate long-running field execution" do
+      expected_data = {
+        "a"=>0.2,
+        "b"=>0.2,
+        "c"=>0.8,
+        "d"=>nil,
+      }
+
+      expected_errors = [
+        {
+          "message"=>"Timeout on Query.sleepFor",
+          "locations"=>[{"line"=>6, "column"=>9}],
+          "path"=>["d"]
+        },
+      ]
+
+      assert_equal expected_data, result["data"]
+      assert_equal expected_errors, result["errors"]
+    end
+  end
+
+  describe "with a custom block" do
+    let(:timeout_class) do
+      Class.new(GraphQL::Schema::Timeout) do
+        def handle_timeout(err, query)
+          raise("Query timed out after 2s: #{err.message}")
+        end
+      end
+    end
+
+    let(:query_string) {%|
+      {
+        a: sleepFor(seconds: 0.4)
+        b: sleepFor(seconds: 0.4)
+        c: sleepFor(seconds: 0.4)
+        d: sleepFor(seconds: 0.4)
+        e: sleepFor(seconds: 0.4)
+      }
+    |}
+
+    it "calls the block" do
+      err = assert_raises(RuntimeError) { result }
+      assert_equal "Query timed out after 2s: Timeout on Query.sleepFor", err.message
+    end
+  end
+end