graphql 1.8.0.pre10 → 1.8.0.pre11

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

@@ -6,6 +6,29 @@ describe GraphQL::Schema::Member::AcceptsDefinition do
     accepts_definition :set_metadata
     set_metadata :a, 999
 
+    class BaseField < GraphQL::Schema::Field
+      class BaseField < GraphQL::Schema::Argument
+        accepts_definition :metadata
+      end
+      argument_class BaseField
+      accepts_definition :metadata
+    end
+
+    GraphQL::Schema::Object.accepts_definition(:metadata2)
+
+    class BaseObject < GraphQL::Schema::Object
+      field_class BaseField
+      accepts_definition :metadata
+    end
+
+    GraphQL::Schema::Interface.accepts_definition(:metadata2)
+
+    module BaseInterface
+      include GraphQL::Schema::Interface
+      field_class BaseField
+      accepts_definition :metadata
+    end
+
     class Option < GraphQL::Schema::Enum
       class EnumValue < GraphQL::Schema::EnumValue
         accepts_definition :metadata
@@ -17,33 +40,37 @@ describe GraphQL::Schema::Member::AcceptsDefinition do
       value "B"
     end
 
-    class Query < GraphQL::Schema::Object
-      class Field < GraphQL::Schema::Field
-        class Argument < GraphQL::Schema::Argument
-          accepts_definition :metadata
-        end
-        argument_class Argument
-        accepts_definition :metadata
-      end
-      field_class Field
-      accepts_definition :metadata
+    module Thing
+      include BaseInterface
+      metadata :z, 888
+      metadata2 :a, :bc
+    end
+
+    class Query < BaseObject
       metadata :a, :abc
+      metadata2 :xyz, :zyx
 
       field :option, Option, null: false do
         metadata :a, :def
         argument :value, Integer, required: true, metadata: [:a, :ghi]
       end
+
+      field :thing, Thing, null: false
     end
 
     query(Query)
   end
 
-
   it "passes along configs for types" do
     assert_equal [:a, 123], AcceptsDefinitionSchema::Option.metadata
     assert_equal 123, AcceptsDefinitionSchema::Option.graphql_definition.metadata[:a]
     assert_equal [:a, :abc], AcceptsDefinitionSchema::Query.metadata
     assert_equal :abc, AcceptsDefinitionSchema::Query.graphql_definition.metadata[:a]
+    assert_equal :zyx, AcceptsDefinitionSchema::Query.graphql_definition.metadata[:xyz]
+
+    assert_equal [:z, 888], AcceptsDefinitionSchema::Thing.metadata
+    assert_equal 888, AcceptsDefinitionSchema::Thing.graphql_definition.metadata[:z]
+    assert_equal :bc, AcceptsDefinitionSchema::Thing.graphql_definition.metadata[:a]
   end
 
   it "passes along configs for fields and arguments" do

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Member::HasFields do
+  module SuperTest
+    class BaseObject < GraphQL::Schema::Object
+    end
+
+    module BaseInterface
+      include GraphQL::Schema::Interface
+    end
+
+    module InterfaceWithFloatField
+      include BaseInterface
+      field :float, Float, null: false
+      def float
+        # This should call the default implementation
+        super * 0.5
+      end
+    end
+
+    module SubInterfaceWithFloatField
+      include InterfaceWithFloatField
+      def float
+        # This should call `InterfaceWithFloatField#float`
+        super * 0.1
+      end
+    end
+
+    class ObjectWithFloatField < BaseObject
+      implements InterfaceWithFloatField
+    end
+
+    class ObjectWithSubFloatField < BaseObject
+      implements SubInterfaceWithFloatField
+    end
+
+    module InterfaceWithStringField
+      include BaseInterface
+      field :string, String, null: false
+      def string
+        # Return a literal value to ensure this method was called
+        "here's a string"
+      end
+    end
+
+    class ObjectWithStringField < BaseObject
+      implements InterfaceWithStringField
+      def string
+        # This should call to `InterfaceWithStringField#string`
+        super.upcase
+      end
+    end
+
+    class SubObjectWithStringField < ObjectWithStringField
+      def string
+        # This should call to `ObjectWithStringField#string`
+        super.reverse
+      end
+    end
+
+    class SubSubObjectWithStringField < SubObjectWithStringField
+      field :string, String, null: false
+    end
+
+    class Query < BaseObject
+      field :int, Integer, null: false
+      def int
+        # This should call default resolution
+        super * 2
+      end
+
+      field :string1, ObjectWithStringField, null: false, method: :object
+      field :string2, SubObjectWithStringField, null: false, method: :object
+      field :string3, SubSubObjectWithStringField, null: false, method: :object
+      field :float1, ObjectWithFloatField, null: false, method: :object
+      field :float2, ObjectWithSubFloatField, null: false, method: :object
+    end
+
+    class Schema < GraphQL::Schema
+      query(Query)
+    end
+  end
+
+  describe "Calling super in field methods" do
+    # Test that calling `super` in field methods "works", which means:
+    # - If there is a super method in the user-created hierarchy (either a class or module), it is called
+    #   This is tested by putting random transformations in method bodies,
+    #   then asserting that they are called.
+    # - If there's no user-defined super method, it calls the built-in default behavior
+    #   This is tested by putting values in the `root_value` hash.
+    #   The default behavior is to fetch hash values by key, so we assert that
+    #   those values are subject to the specified transformations.
+
+    describe "Object methods" do
+      it "may call super to default implementation" do
+        res = SuperTest::Schema.execute("{ int }", root_value: { int: 4 })
+        assert_equal 8, res["data"]["int"]
+      end
+
+      it "may call super to interface method" do
+        res = SuperTest::Schema.execute(" { string1 { string } }", root_value: {})
+        assert_equal "HERE'S A STRING", res["data"]["string1"]["string"]
+      end
+
+      it "may call super to superclass method" do
+        res = SuperTest::Schema.execute(" { string2 { string } }", root_value: {})
+        assert_equal "GNIRTS A S'EREH", res["data"]["string2"]["string"]
+      end
+
+      it "can get a super method from a newly-added field" do
+        res = SuperTest::Schema.execute(" { string3 { string } }", root_value: {})
+        assert_equal "GNIRTS A S'EREH", res["data"]["string3"]["string"]
+      end
+    end
+
+    describe "Interface methods" do
+      it "may call super to interface method" do
+        res = SuperTest::Schema.execute(" { float1 { float } }", root_value: { float: 6.0 })
+        assert_equal 3.0, res["data"]["float1"]["float"]
+      end
+
+      it "may call super to superclass method" do
+        res = SuperTest::Schema.execute(" { float2 { float } }", root_value: { float: 6.0 })
+        assert_in_delta 0.001, 0.3, res["data"]["float2"]["float"]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Member::TypeSystemHelpers do
+  let(:object) {
+    Class.new(GraphQL::Schema::Object) do
+      graphql_name "Thing"
+
+      field :int, Integer, null: true
+      field :int2, Integer, null: false
+      field :int_list, [Integer], null: true
+      field :int_list2, [Integer], null: false
+    end
+  }
+
+  let(:int_field) { object.fields["int"] }
+  let(:int2_field) { object.fields["int2"] }
+  let(:int_list_field) { object.fields["intList"] }
+  let(:int_list2_field) { object.fields["intList2"] }
+
+  describe "#list?" do
+    it "is true for lists, including non-null lists, otherwise false" do
+      assert int_list_field.type.list?
+      assert int_list2_field.type.list?
+      refute int_field.type.list?
+      refute int2_field.type.list?
+    end
+  end
+
+  describe "#non_null?" do
+    it "is true for required types" do
+      assert int2_field.type.non_null?
+      assert int_list2_field.type.non_null?
+      refute int_field.type.non_null?
+      refute int_list_field.type.non_null?
+    end
+  end
+
+  describe "#kind" do
+    let(:pairs) {{
+      GraphQL::Schema::Object => "OBJECT",
+      GraphQL::Schema::Union => "UNION",
+      GraphQL::Schema::Interface => "INTERFACE",
+      GraphQL::Schema::Enum => "ENUM",
+      GraphQL::Schema::InputObject => "INPUT_OBJECT",
+      GraphQL::Schema::Scalar => "SCALAR",
+    }}
+    it "returns the TypeKind instance" do
+      pairs.each do |type_class, type_kind_name|
+        type = if type_class.is_a?(Class)
+          Class.new(type_class)
+        else
+          Module.new { include(type_class) }
+        end
+
+        assert_equal type_kind_name, type.kind.name
+      end
+
+      assert_equal "LIST", GraphQL::Schema::Object.to_list_type.kind.name
+      assert_equal "NON_NULL", GraphQL::Schema::Object.to_non_null_type.kind.name
+    end
+  end
+end

data/spec/graphql/schema/mutation_spec.rb

@@ -21,6 +21,14 @@ describe GraphQL::Schema::Mutation do
     end
   end
 
+  describe "argument prepare" do
+    it "calls methods on the mutation, uses `as:`" do
+      query_str = 'mutation { prepareInput(input: 4) }'
+      res = Jazz::Schema.execute(query_str)
+      assert_equal 16, res["data"]["prepareInput"], "It's squared by the prepare method"
+    end
+  end
+
   describe ".field" do
     it "returns a GraphQL::Field instance, for backwards compat" do
       field = mutation.field
@@ -96,4 +104,44 @@ describe GraphQL::Schema::Mutation do
       assert_equal 7, response["data"]["addInstrument"]["entries"].size
     end
   end
+
+  describe ".null" do
+    it "overrides whether or not the field can be null" do
+      non_nullable_mutation_class = Class.new(GraphQL::Schema::Mutation) do
+        graphql_name "Thing1"
+        null(false)
+      end
+
+      nullable_mutation_class = Class.new(GraphQL::Schema::Mutation) do
+        graphql_name "Thing2"
+        null(true)
+      end
+
+      default_mutation_class = Class.new(GraphQL::Schema::Mutation) do
+        graphql_name "Thing3"
+      end
+
+      assert default_mutation_class.graphql_field.instance_variable_get("@return_type_null")
+      assert nullable_mutation_class.graphql_field.instance_variable_get("@return_type_null")
+      refute non_nullable_mutation_class.graphql_field.instance_variable_get("@return_type_null")
+    end
+
+    it "should inherit and override in subclasses" do
+      base_mutation = Class.new(GraphQL::Schema::Mutation) do
+        null(false)
+      end
+
+      inheriting_mutation = Class.new(base_mutation) do
+        graphql_name "Thing"
+      end
+
+      override_mutation = Class.new(base_mutation) do
+        graphql_name "Thing2"
+        null(true)
+      end
+
+      assert_equal false, inheriting_mutation.graphql_field.instance_variable_get("@return_type_null")
+      assert override_mutation.graphql_field.instance_variable_get("@return_type_null")
+    end
+  end
 end

data/spec/graphql/schema/object_spec.rb

@@ -8,7 +8,7 @@ describe GraphQL::Schema::Object do
       assert_equal "Ensemble", object_class.graphql_name
       assert_equal "A group of musicians playing together", object_class.description
       assert_equal 6, object_class.fields.size
-      assert_equal 2, object_class.interfaces.size
+      assert_equal 3, object_class.interfaces.size
       # Compatibility methods are delegated to the underlying BaseType
       assert object_class.respond_to?(:connection_type)
     end
@@ -22,7 +22,7 @@ describe GraphQL::Schema::Object do
       # one more than the parent class
       assert_equal 7, new_object_class.fields.size
       # inherited interfaces are present
-      assert_equal 2, new_object_class.interfaces.size
+      assert_equal 3, new_object_class.interfaces.size
       # The new field is present
       assert new_object_class.fields.key?("newField")
       # The overridden field is present:
@@ -40,6 +40,18 @@ describe GraphQL::Schema::Object do
       assert_equal "NewSubclass", new_subclass_2.graphql_name
       assert_equal object_class.description, new_subclass_2.description
     end
+
+    it "should take Ruby name (without Type suffix) as default graphql name" do
+      TestingClassType = Class.new(GraphQL::Schema::Object)
+      assert_equal "TestingClass", TestingClassType.graphql_name
+    end
+
+    it "raise on anonymous class without declared graphql name" do
+      anonymous_class = Class.new(GraphQL::Schema::Object)
+      assert_raises NotImplementedError do
+        anonymous_class.graphql_name
+      end
+    end
   end
 
   describe "wrapping a Hash" do
@@ -47,7 +59,6 @@ describe GraphQL::Schema::Object do
       query_str = <<-GRAPHQL
       {
         hashyEnsemble {
-          name
           musicians { name }
           formedAt
         }
@@ -55,10 +66,21 @@ describe GraphQL::Schema::Object do
       GRAPHQL
       res = Jazz::Schema.execute(query_str)
       ensemble = res["data"]["hashyEnsemble"]
-      assert_equal "The Grateful Dead", ensemble["name"]
       assert_equal ["Jerry Garcia"], ensemble["musicians"].map { |m| m["name"] }
       assert_equal "May 5, 1965", ensemble["formedAt"]
     end
+
+    it "works with strings and symbols" do
+      query_str = <<-GRAPHQL
+      {
+        hashByString { falsey }
+        hashBySym { falsey }
+      }
+      GRAPHQL
+      res = Jazz::Schema.execute(query_str)
+      assert_equal false, res["data"]["hashByString"]["falsey"]
+      assert_equal false, res["data"]["hashBySym"]["falsey"]
+    end
   end
 
   describe ".to_graphql_type" do
@@ -86,7 +108,7 @@ describe GraphQL::Schema::Object do
       GRAPHQL
 
       res = Jazz::Schema.execute(query_str)
-      assert_equal ["BELA FLECK AND THE FLECKTONES"], res["data"]["ensembles"].map { |e| e["upcaseName"] }
+      assert_equal ["BELA FLECK AND THE FLECKTONES", "ROBERT GLASPER EXPERIMENT"], res["data"]["ensembles"].map { |e| e["upcaseName"] }
     end
   end
 
@@ -104,7 +126,11 @@ describe GraphQL::Schema::Object do
       }
       GRAPHQL
       res = Jazz::Schema.execute(query_str)
-      assert_equal [{"name" => "Bela Fleck and the Flecktones"}], res["data"]["ensembles"]
+      expected_ensembles = [
+        {"name" => "Bela Fleck and the Flecktones"},
+        {"name" => "ROBERT GLASPER Experiment"},
+      ]
+      assert_equal expected_ensembles, res["data"]["ensembles"]
       assert_equal({"name" => "Banjo"}, res["data"]["instruments"].first)
     end
 
@@ -127,10 +153,10 @@ describe GraphQL::Schema::Object do
       }
       GRAPHQL
 
-      res = Jazz::Schema.execute(mutation_str, variables: { "name" => "Miles Davis Quartet" })
+      res = Jazz::Schema.execute(mutation_str, variables: { name: "Miles Davis Quartet" })
       new_id = res["data"]["addEnsemble"]["id"]
 
-      res2 = Jazz::Schema.execute(query_str, variables: { "id" => new_id })
+      res2 = Jazz::Schema.execute(query_str, variables: { id: new_id })
       assert_equal "Miles Davis Quartet", res2["data"]["find"]["name"]
     end
 

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -25,4 +25,14 @@ describe GraphQL::Schema::RelayClassicMutation do
       assert_equal mutation, mutation.input_type.graphql_definition.mutation
     end
   end
+
+  describe ".null" do
+    it "is inherited as true" do
+      mutation = Class.new(GraphQL::Schema::RelayClassicMutation) do
+        graphql_name "Test"
+      end
+
+      assert mutation.null
+    end
+  end
 end