graphql 1.8.6 → 1.8.7

data/spec/graphql/relay/connection_instrumentation_spec.rb

@@ -77,7 +77,7 @@ describe GraphQL::Relay::ConnectionInstrumentation do
       # Before the object is wrapped in a connection, the instrumentation sees `Array`
       assert_equal ["StarWars::FactionRecord", "Array", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
       # After the object is wrapped in a connection, it sees the connection object
-      assert_equal ["StarWars::Faction", "GraphQL::Relay::ArrayConnection", "GraphQL::Types::Relay::PageInfo"], ctx[:after_built_ins]
+      assert_equal ["StarWars::Faction", "StarWars::ShipConnectionWithParentType", "GraphQL::Types::Relay::PageInfo"], ctx[:after_built_ins]
     end
   end
 end

data/spec/graphql/relay/mongo_relation_connection_spec.rb

@@ -18,6 +18,15 @@ describe GraphQL::Relay::MongoRelationConnection do
     ships.map { |e| e["node"]["name"] }
   end
 
+  def get_residents(ship)
+    ship["residents"]["edges"].map { |e| e["node"]["name"] }
+  end
+
+  def get_ships_residents(result)
+    ships = result["data"]["federation"]["bases"]["edges"]
+    Hash[ships.map { |e| [e["node"]["name"], get_residents(e["node"])] }]
+  end
+
   def get_page_info(result)
     result["data"]["federation"]["bases"]["pageInfo"]
   end
@@ -482,4 +491,49 @@ describe GraphQL::Relay::MongoRelationConnection do
     connection = GraphQL::Relay::BaseConnection.connection_for_nodes(relation)
     assert_equal GraphQL::Relay::MongoRelationConnection, connection
   end
+
+  describe "relations" do
+    let(:query_string) {%|
+      query getShips {
+        federation {
+          bases {
+            ... basesConnection
+          }
+        }
+      }
+
+      fragment basesConnection on BasesConnectionWithTotalCount {
+        edges {
+          cursor
+          node {
+            name
+            residents {
+              edges {
+                node {
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    |}
+
+    it "Mongoid::Association::Referenced::HasMany::Targets::Enumerable" do
+      result = star_trek_query(query_string)
+      assert_equal get_ships_residents(result), {
+        "Deep Space Station K-7" => [
+          "Shir th'Talias",
+          "Lurry",
+          "Mackenzie Calhoun"
+        ],
+        "Regula I" => [
+          "V. Madison",
+          "D. March",
+          "C. Marcus"
+        ],
+        "Deep Space Nine" => []
+      }
+    end
+  end
 end

data/spec/graphql/schema/field_spec.rb

@@ -11,6 +11,15 @@ describe GraphQL::Schema::Field do
       assert_equal :ok, arg_defn.metadata[:custom]
     end
 
+    it "can add argument directly with add_argument" do
+      argument = Jazz::Query.fields["instruments"].arguments["family"]
+
+      field.add_argument(argument)
+
+      assert_equal "family", field.arguments["family"].name
+      assert_equal Jazz::Family, field.arguments["family"].type
+    end
+
     it "attaches itself to its graphql_definition as type_class" do
       assert_equal field, field.graphql_definition.metadata[:type_class]
     end

data/spec/graphql/schema/list_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe GraphQL::Schema::List do
+  let(:of_type) { Jazz::Musician }
+  let(:list_type) { GraphQL::Schema::List.new(of_type) }
+
+  it "returns list? to be true" do
+    assert list_type.list?
+  end
+
+  it "returns non_null? to be false" do
+    refute list_type.non_null?
+  end
+
+  it "returns kind to be GraphQL::TypeKinds::LIST" do
+    assert_equal GraphQL::TypeKinds::LIST, list_type.kind
+  end
+
+  it "returns correct type signature" do
+    assert_equal "[Musician]", list_type.to_type_signature
+  end
+
+  describe "comparison operator" do
+    it "will return false if list types 'of_type' are different" do
+      new_of_type = Jazz::InspectableKey
+      new_list_type = GraphQL::Schema::List.new(new_of_type)
+
+      refute_equal list_type, new_list_type
+    end
+
+    it "will return true if list types 'of_type' are the same" do
+      new_of_type = Jazz::Musician
+      new_list_type = GraphQL::Schema::List.new(new_of_type)
+      
+      assert_equal list_type, new_list_type
+    end
+  end
+
+  describe "to_graphql" do
+    it "will return a list type" do
+      assert_kind_of GraphQL::ListType, list_type.to_graphql
+    end
+  end
+end

data/spec/graphql/schema/member/scoped_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Member::Scoped do
+  class ScopeSchema < GraphQL::Schema
+    class BaseObject < GraphQL::Schema::Object
+    end
+
+    class Item < BaseObject
+      def self.scope_items(items, context)
+        if context[:french]
+          items.select { |i| i.name == "Trombone" }
+        elsif context[:english]
+          items.select { |i| i.name == "Paperclip" }
+        else
+          []
+        end
+      end
+
+      field :name, String, null: false
+    end
+
+    class FrenchItem < Item
+      def self.scope_items(items, context)
+        super(items, {french: true})
+      end
+    end
+
+    class Equipment < BaseObject
+      field :designation, String, null: false, method: :name
+    end
+
+    class BaseUnion < GraphQL::Schema::Union
+    end
+
+    class Thing < BaseUnion
+      def self.scope_items(items, context)
+        l = context.fetch(:first_letter)
+        items.select { |i| i.name.start_with?(l) }
+      end
+
+      possible_types Item, Equipment
+
+      def self.resolve_type(item, ctx)
+        if item.name == "Turbine"
+          Equipment
+        else
+          Item
+        end
+      end
+    end
+
+    class Query < BaseObject
+      field :items, [Item], null: false
+      field :unscoped_items, [Item], null: false,
+        scope: false,
+        method: :items
+      field :french_items, [FrenchItem], null: false,
+        method: :items
+      field :items_connection, Item.connection_type, null: false,
+        method: :items
+
+      def items
+        [
+          OpenStruct.new(name: "Trombone"),
+          OpenStruct.new(name: "Paperclip"),
+        ]
+      end
+
+      field :things, [Thing], null: false
+      def things
+        items + [OpenStruct.new(name: "Turbine")]
+      end
+    end
+
+    query(Query)
+  end
+
+  describe ".scope_items(items, ctx)" do
+    def get_item_names_with_context(ctx, field_name: "items")
+      query_str = "
+      {
+        #{field_name} {
+          name
+        }
+      }
+      "
+      res = ScopeSchema.execute(query_str, context: ctx)
+      res["data"][field_name].map { |i| i["name"] }
+    end
+
+    it "applies to lists when scope: true" do
+      assert_equal [], get_item_names_with_context({})
+      assert_equal ["Trombone"], get_item_names_with_context({french: true})
+      assert_equal ["Paperclip"], get_item_names_with_context({english: true})
+    end
+
+    it "is bypassed when scope: false" do
+      assert_equal ["Trombone", "Paperclip"], get_item_names_with_context({}, field_name: "unscopedItems")
+    end
+
+    it "is inherited" do
+      assert_equal ["Trombone"], get_item_names_with_context({}, field_name: "frenchItems")
+    end
+
+    it "is called for connection fields" do
+      query_str = "
+      {
+        itemsConnection {
+          edges {
+            node {
+              name
+            }
+          }
+        }
+      }
+      "
+      res = ScopeSchema.execute(query_str, context: {english: true})
+      names = res["data"]["itemsConnection"]["edges"].map { |e| e["node"]["name"] }
+      assert_equal ["Paperclip"], names
+    end
+
+    it "is called for abstract types" do
+      query_str = "
+      {
+        things {
+          ... on Item {
+            name
+          }
+          ... on Equipment {
+            designation
+          }
+        }
+      }
+      "
+      res = ScopeSchema.execute(query_str, context: {first_letter: "T"})
+      things = res["data"]["things"]
+      assert_equal [{ "name" => "Trombone" }, {"designation" => "Turbine"}], things
+    end
+  end
+
+  describe "Schema::Field.scoped?" do
+    it "prefers the override value" do
+      assert_equal false, ScopeSchema::Query.fields["unscopedItems"].scoped?
+    end
+
+    it "defaults to true for lists" do
+      assert_equal true, ScopeSchema::Query.fields["items"].type.list?
+      assert_equal true, ScopeSchema::Query.fields["items"].scoped?
+    end
+
+    it "defaults to true for connections" do
+      assert_equal true, ScopeSchema::Query.fields["itemsConnection"].connection?
+      assert_equal true, ScopeSchema::Query.fields["itemsConnection"].scoped?
+    end
+
+    it "defaults to false for others" do
+      assert_equal false, ScopeSchema::Item.fields["name"].scoped?
+    end
+  end
+end

data/spec/graphql/schema/non_null_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe GraphQL::Schema::NonNull do
+  let(:of_type) { Jazz::Musician }
+  let(:non_null_type) { GraphQL::Schema::NonNull.new(of_type) }
+
+  it "returns list? to be false" do
+    refute non_null_type.list?
+  end
+
+  it "returns non_null? to be true" do
+    assert non_null_type.non_null?
+  end
+
+  it "returns kind to be GraphQL::TypeKinds::NON_NULL" do
+    assert_equal GraphQL::TypeKinds::NON_NULL, non_null_type.kind
+  end
+
+  it "returns correct type signature" do
+    assert_equal "Musician!", non_null_type.to_type_signature
+  end
+
+  describe "comparison operator" do
+    it "will return false if list types 'of_type' are different" do
+      new_of_type = Jazz::InspectableKey
+      new_non_null_type = GraphQL::Schema::NonNull.new(new_of_type)
+
+      refute_equal non_null_type, new_non_null_type
+    end
+
+    it "will return true if list types 'of_type' are the same" do
+      new_of_type = Jazz::Musician
+      new_non_null_type = GraphQL::Schema::NonNull.new(new_of_type)
+      
+      assert_equal non_null_type, new_non_null_type
+    end
+  end
+
+  describe "to_graphql" do
+    it "will return a non null type" do
+      assert_kind_of GraphQL::NonNullType, non_null_type.to_graphql
+    end
+  end
+end

data/spec/graphql/schema/object_spec.rb

@@ -4,6 +4,7 @@ require "spec_helper"
 describe GraphQL::Schema::Object do
   describe "class attributes" do
     let(:object_class) { Jazz::Ensemble }
+
     it "tells type data" do
       assert_equal "Ensemble", object_class.graphql_name
       assert_equal "A group of musicians playing together", object_class.description
@@ -52,6 +53,20 @@ describe GraphQL::Schema::Object do
         anonymous_class.graphql_name
       end
     end
+
+    class OverrideNameObject < GraphQL::Schema::Object
+      class << self
+        def default_graphql_name
+          "Override"
+        end
+      end
+    end
+
+    it "can override the default graphql_name" do
+      override_name_object = OverrideNameObject
+
+      assert_equal "Override", override_name_object.graphql_name
+    end
   end
 
   describe "implementing interfaces" do

data/spec/graphql/schema/resolver_spec.rb

@@ -76,7 +76,7 @@ describe GraphQL::Schema::Resolver do
 
     class PrepResolver1 < BaseResolver
       argument :int, Integer, required: true
-
+      undef_method :load_int
       def load_int(i)
         i * 10
       end
@@ -127,37 +127,122 @@ describe GraphQL::Schema::Resolver do
     class PrepResolver5 < PrepResolver1
       type Integer, null: true
 
-      def before_prepare(int:)
+      def ready?(int:)
         check_for_magic_number(int)
       end
     end
 
     class PrepResolver6 < PrepResolver5
-      def before_prepare(**args)
+      def ready?(**args)
         LazyBlock.new {
           super
         }
       end
     end
 
-    class PrepResolver7 < PrepResolver1
+    class PrepResolver7 < GraphQL::Schema::Mutation
+      argument :int, Integer, required: true
+      field :errors, [String], null: true
+      field :int, Integer, null: true
+
+      def ready?(int:)
+        if int == 13
+          return false, { errors: ["Bad number!"] }
+        else
+          true
+        end
+      end
+
+      def resolve(int:)
+        { int: int }
+      end
+    end
+
+    module HasValue
+      include GraphQL::Schema::Interface
+      field :value, Integer, null: false
+      def self.resolve_type(obj, ctx)
+        if obj.is_a?(Integer)
+          IntegerWrapper
+        else
+          raise "Unexpected: #{obj.inspect}"
+        end
+      end
+    end
+
+    class IntegerWrapper < GraphQL::Schema::Object
+      implements HasValue
+      field :value, Integer, null: false, method: :object
+    end
+
+    class PrepResolver9 < BaseResolver
+      argument :int_id, ID, required: true, loads: HasValue
+      # Make sure the lazy object is resolved properly:
+      type HasValue, null: false
+      def object_from_id(type, id, ctx)
+        # Make sure a lazy object is handled appropriately
+        LazyBlock.new {
+          # Make sure that the right type ends up here
+          id.to_i + type.graphql_name.length
+        }
+      end
+
+      def resolve(int:)
+        int * 3
+      end
+    end
+
+    class PrepResolver10 < BaseResolver
+      argument :int1, Integer, required: true
+      argument :int2, Integer, required: true
       type Integer, null: true
+      def authorized?(int1:, int2:)
+        if int1 + int2 > context[:max_int]
+          raise GraphQL::ExecutionError, "Inputs too big"
+        elsif context[:min_int] && (int1 + int2 < context[:min_int])
+          false
+        else
+          true
+        end
+      end
 
-      def load_int(int)
-        int
+      def resolve(int1:, int2:)
+        int1 + int2
       end
+    end
 
-      def validate_int(int)
-        check_for_magic_number(int)
+    class PrepResolver11 < PrepResolver10
+      def authorized?(int1:, int2:)
+        LazyBlock.new { super(int1: int1 * 2, int2: int2) }
+      end
+    end
+
+    class PrepResolver12 < GraphQL::Schema::Mutation
+      argument :int1, Integer, required: true
+      argument :int2, Integer, required: true
+      field :error_messages, [String], null: true
+      field :value, Integer, null: true
+      def authorized?(int1:, int2:)
+        if int1 + int2 > context[:max_int]
+          return false, { error_messages: ["Inputs must be less than #{context[:max_int]} (but you provided #{int1 + int2})"] }
+        else
+          true
+        end
+      end
+
+      def resolve(int1:, int2:)
+        { value: int1 + int2 }
       end
     end
 
-    class PrepResolver8 < PrepResolver7
-      def validate_int(int)
-        LazyBlock.new { super }
+    class PrepResolver13 < PrepResolver12
+      def authorized?(int1:, int2:)
+        # Increment the numbers so we can be sure they're passing through here
+        LazyBlock.new { super(int1: int1 + 1, int2: int2 + 1) }
       end
     end
 
+
     class Query < GraphQL::Schema::Object
       class CustomField < GraphQL::Schema::Field
         def resolve_field(*args)
@@ -188,12 +273,17 @@ describe GraphQL::Schema::Resolver do
       field :prep_resolver_5, resolver: PrepResolver5
       field :prep_resolver_6, resolver: PrepResolver6
       field :prep_resolver_7, resolver: PrepResolver7
-      field :prep_resolver_8, resolver: PrepResolver8
+      field :prep_resolver_9, resolver: PrepResolver9
+      field :prep_resolver_10, resolver: PrepResolver10
+      field :prep_resolver_11, resolver: PrepResolver11
+      field :prep_resolver_12, resolver: PrepResolver12
+      field :prep_resolver_13, resolver: PrepResolver13
     end
 
     class Schema < GraphQL::Schema
       query(Query)
       lazy_resolve LazyBlock, :value
+      orphan_types IntegerWrapper
     end
   end
 
@@ -280,17 +370,25 @@ describe GraphQL::Schema::Resolver do
       refute res.key?("errors"), "#{description}: silent auth failure (no top-level error)"
     end
 
-    describe "before_prepare" do
+    describe "ready?" do
       it "can raise errors" do
         res = exec_query("{ int: prepResolver5(int: 5) }")
         assert_equal 50, res["data"]["int"]
-        add_error_assertions("prepResolver5", "before_prepare")
+        add_error_assertions("prepResolver5", "ready?")
       end
 
       it "can raise errors in lazy sync" do
         res = exec_query("{ int: prepResolver6(int: 5) }")
         assert_equal 50, res["data"]["int"]
-        add_error_assertions("prepResolver6", "lazy before_prepare")
+        add_error_assertions("prepResolver6", "lazy ready?")
+      end
+
+      it "can return false and data" do
+        res = exec_query("{ int: prepResolver7(int: 13) { errors int } }")
+        assert_equal ["Bad number!"], res["data"]["int"]["errors"]
+
+        res = exec_query("{ int: prepResolver7(int: 213) { errors int } }")
+        assert_equal 213, res["data"]["int"]["int"]
       end
     end
 
@@ -319,17 +417,59 @@ describe GraphQL::Schema::Resolver do
     end
 
     describe "validating arguments" do
-      test_cases = {
-        "eager" => "prepResolver7",
-        "lazy" => "prepResolver8",
-      }
-
-      test_cases.each do |mode, field_name|
-        it "supports raising #{mode} errors" do
-          res = exec_query("{ validatedInt: #{field_name}(int: 5) }")
-          assert_equal 5, res["data"]["validatedInt"]
-          add_error_assertions(field_name, "#{mode} validation")
+      describe ".authorized?" do
+        it "can raise an error to halt" do
+          res = exec_query("{ prepResolver10(int1: 5, int2: 6) }", context: { max_int: 9 })
+          assert_equal ["Inputs too big"], res["errors"].map { |e| e["message"] }
+
+          res = exec_query("{ prepResolver10(int1: 5, int2: 6) }", context: { max_int: 90 })
+          assert_equal 11, res["data"]["prepResolver10"]
+        end
+
+        it "can return a lazy object" do
+          # This is too big because it's modified in the overridden authorized? hook:
+          res = exec_query("{ prepResolver11(int1: 3, int2: 5) }", context: { max_int: 9 })
+          assert_equal ["Inputs too big"], res["errors"].map { |e| e["message"] }
+
+          res = exec_query("{ prepResolver11(int1: 3, int2: 5) }", context: { max_int: 90 })
+          assert_equal 8, res["data"]["prepResolver11"]
+        end
+
+        it "can return data early" do
+          res = exec_query("{ prepResolver12(int1: 9, int2: 5) { errorMessages } }", context: { max_int: 9 })
+          assert_equal ["Inputs must be less than 9 (but you provided 14)"], res["data"]["prepResolver12"]["errorMessages"]
+          # This works
+          res = exec_query("{ prepResolver12(int1: 2, int2: 5) { value } }", context: { max_int: 9 })
+          assert_equal 7, res["data"]["prepResolver12"]["value"]
         end
+
+        it "can return data early in a promise" do
+          # This is too big because it's modified in the overridden authorized? hook:
+          res = exec_query("{ prepResolver13(int1: 4, int2: 4) { errorMessages } }", context: { max_int: 9 })
+          assert_equal ["Inputs must be less than 9 (but you provided 10)"], res["data"]["prepResolver13"]["errorMessages"]
+          # This works
+          res = exec_query("{ prepResolver13(int1: 2, int2: 5) { value } }", context: { max_int: 9 })
+          assert_equal 7, res["data"]["prepResolver13"]["value"]
+        end
+
+        it "can return false to halt" do
+          str = <<-GRAPHQL
+          {
+            prepResolver10(int1: 5, int2: 10)
+            prepResolver11(int1: 3, int2: 5)
+          }
+          GRAPHQL
+          res = exec_query(str, context: { max_int: 100, min_int: 20 })
+          assert_equal({ "prepResolver10" => nil, "prepResolver11" => nil }, res["data"])
+        end
+      end
+    end
+
+    describe "Loading inputs" do
+      it "calls object_from_id" do
+        res = exec_query('{ prepResolver9(intId: "5") { value } }')
+        # (5 + 8) * 3
+        assert_equal 39, res["data"]["prepResolver9"]["value"]
       end
     end
   end