Give super-method behavior its own tests

Author: rmosolgo

lib/graphql/schema/field.rb

@@ -262,7 +262,7 @@ def resolve_field_method(obj, ruby_kwargs, ctx)
           end
         else
           raise <<-ERR
-        Failed to implement #{ctx.irep_node.owner_type.name}.#{ctx.field.name}, tried:
+        Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
         - `#{obj.class}##{@method_sym}`, which did not exist
         - `#{obj.object.class}##{@method_sym}`, which did not exist

spec/graphql/schema/member/has_fields_spec.rb

@@ -0,0 +1,126 @@
+# 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 Query < BaseObject
+      field :int, Integer, null: false
+      def int
+        # This should call default resolution
+        super * 2
+      end
+
+      field :string1, ObjectWithStringField, null: false
+      alias :string1 :object
+
+      field :string2, SubObjectWithStringField, null: false
+      alias :string2 :object
+
+      field :float1, ObjectWithFloatField, null: false
+      alias :float1 :object
+
+      field :float2, ObjectWithSubFloatField, null: false
+      alias :float2 :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
+    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

spec/graphql/schema/object_spec.rb

@@ -54,8 +54,7 @@
       GRAPHQL
       res = Jazz::Schema.execute(query_str)
       ensemble = res["data"]["hashyEnsemble"]
-      # This also tests `super` in an interface field
-      assert_equal ["Jerry Garcia", "Phil Lesh"], ensemble["musicians"].map { |m| m["name"] }
+      assert_equal ["Jerry Garcia"], ensemble["musicians"].map { |m| m["name"] }
       assert_equal "May 5, 1965", ensemble["formedAt"]
     end
 

spec/support/jazz.rb

@@ -169,11 +169,6 @@ def upcase_name
   module HasMusicians
     include BaseInterface
     field :musicians, "[Jazz::Musician]", null: false
-
-    def musicians
-      # Test that super works
-      super + [Models::Musician.new("Phil Lesh")]
-    end
   end
 
 
@@ -312,11 +307,6 @@ def self.resolve_type(object, context)
 
   class HashKeyTest < BaseObject
     field :falsey, Boolean, null: false
-
-    def falsey
-      # test that super can be used in objects
-      super
-    end
   end
 
   # Another new-style definition, with method overrides