graphql 1.7.6 → 1.8.0

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+# Make sure that `!` has no effect
+using GraphQL::DeprecatedDSL
+
+describe GraphQL::Schema::Mutation do
+  let(:mutation) { Jazz::AddInstrument }
+  after do
+    Jazz::Models.reset
+  end
+
+  it "Doesn't override !" do
+    assert_equal false, !mutation
+  end
+
+  describe "definition" do
+    it "passes along description" do
+      assert_equal "Register a new musical instrument in the database", mutation.field_options[:description]
+      assert_equal "Autogenerated return type of AddInstrument", mutation.payload_type.description
+    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 "a derived field" do
+    it "has a reference to the mutation" do
+      f = GraphQL::Schema::Field.from_options(name: "x", **mutation.field_options)
+      assert_equal mutation, f.mutation
+
+      # Make sure it's also present in the schema
+      f2 = Jazz::Schema.find("Mutation.addInstrument")
+      assert_equal mutation, f2.mutation
+    end
+  end
+
+  describe ".payload_type" do
+    it "has a reference to the mutation" do
+      assert_equal mutation, mutation.payload_type.mutation
+    end
+  end
+
+  describe ".field" do
+    it "raises a nice error when called without args" do
+      err = assert_raises(ArgumentError) { mutation.field }
+      assert_includes err.message, "Use `mutation: Jazz::AddInstrument` to attach this mutation instead."
+    end
+  end
+
+  describe ".object_class" do
+    it "can override & inherit the parent class" do
+      obj_class = Class.new(GraphQL::Schema::Object)
+      mutation_class = Class.new(GraphQL::Schema::Mutation) do
+        object_class(obj_class)
+      end
+      mutation_subclass = Class.new(mutation_class)
+
+      assert_equal(GraphQL::Schema::Object, GraphQL::Schema::Mutation.object_class)
+      assert_equal(obj_class, mutation_class.object_class)
+      assert_equal(obj_class, mutation_subclass.object_class)    end
+  end
+
+  describe ".argument_class" do
+    it "can override & inherit the parent class" do
+      arg_class = Class.new(GraphQL::Schema::Argument)
+      mutation_class = Class.new(GraphQL::Schema::Mutation) do
+        argument_class(arg_class)
+      end
+
+      mutation_subclass = Class.new(mutation_class)
+
+      assert_equal(GraphQL::Schema::Argument, GraphQL::Schema::Mutation.argument_class)
+      assert_equal(arg_class, mutation_class.argument_class)
+      assert_equal(arg_class, mutation_subclass.argument_class)
+    end
+  end
+
+  describe "evaluation" do
+    it "runs mutations" do
+      query_str = <<-GRAPHQL
+      mutation {
+        addInstrument(name: "Trombone", family: BRASS) {
+          instrument {
+            name
+            family
+          }
+          entries {
+            name
+          }
+          ee
+        }
+      }
+      GRAPHQL
+
+      response = Jazz::Schema.execute(query_str)
+      assert_equal "Trombone", response["data"]["addInstrument"]["instrument"]["name"]
+      assert_equal "BRASS", response["data"]["addInstrument"]["instrument"]["family"]
+      assert_equal "GraphQL::Query::Context::ExecutionErrors", response["data"]["addInstrument"]["ee"]
+      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.field_options[:null]
+      assert nullable_mutation_class.field_options[:null]
+      refute non_nullable_mutation_class.field_options[: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.field_options[:null]
+      assert override_mutation.field_options[:null]
+    end
+  end
+end

data/spec/graphql/schema/object_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+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
+      assert_equal 6, object_class.fields.size
+      assert_equal 3, object_class.interfaces.size
+      # Compatibility methods are delegated to the underlying BaseType
+      assert object_class.respond_to?(:connection_type)
+    end
+
+    it "inherits fields and interfaces" do
+      new_object_class = Class.new(object_class) do
+        field :newField, String, null: true
+        field :name, String, description: "The new description", null: true
+      end
+
+      # one more than the parent class
+      assert_equal 7, new_object_class.fields.size
+      # inherited interfaces are present
+      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:
+      name_field = new_object_class.fields["name"]
+      assert_equal "The new description", name_field.description
+    end
+
+    it "inherits name and description" do
+      # Manually assign a name since `.name` isn't populated for dynamic classes
+      new_subclass_1 = Class.new(object_class) do
+        graphql_name "NewSubclass"
+      end
+      new_subclass_2 = Class.new(new_subclass_1)
+      assert_equal "NewSubclass", new_subclass_1.graphql_name
+      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
+    it "automatically looks up symbol and string keys" do
+      query_str = <<-GRAPHQL
+      {
+        hashyEnsemble {
+          musicians { name }
+          formedAt
+        }
+      }
+      GRAPHQL
+      res = Jazz::Schema.execute(query_str)
+      ensemble = res["data"]["hashyEnsemble"]
+      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
+    let(:obj_type) { Jazz::Ensemble.to_graphql }
+    it "returns a matching GraphQL::ObjectType" do
+      assert_equal "Ensemble", obj_type.name
+      assert_equal "A group of musicians playing together", obj_type.description
+      assert_equal 6, obj_type.all_fields.size
+
+      name_field = obj_type.all_fields[2]
+      assert_equal "name", name_field.name
+      assert_equal GraphQL::STRING_TYPE.to_non_null_type, name_field.type
+      assert_equal nil, name_field.description
+    end
+
+    it "has a custom implementation" do
+      assert_equal obj_type.metadata[:config], :configged
+    end
+
+    it "uses the custom field class" do
+      query_str = <<-GRAPHQL
+      {
+        ensembles { upcaseName }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal ["BELA FLECK AND THE FLECKTONES", "ROBERT GLASPER EXPERIMENT"], res["data"]["ensembles"].map { |e| e["upcaseName"] }
+    end
+  end
+
+
+  describe "in queries" do
+    after {
+      Jazz::Models.reset
+    }
+
+    it "returns data" do
+      query_str = <<-GRAPHQL
+      {
+        ensembles { name }
+        instruments { name }
+      }
+      GRAPHQL
+      res = Jazz::Schema.execute(query_str)
+      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
+
+    it "does mutations" do
+      mutation_str = <<-GRAPHQL
+      mutation AddEnsemble($name: String!) {
+        addEnsemble(input: { name: $name }) {
+          id
+        }
+      }
+      GRAPHQL
+
+      query_str = <<-GRAPHQL
+      query($id: ID!) {
+        find(id: $id) {
+          ... on Ensemble {
+            name
+          }
+        }
+      }
+      GRAPHQL
+
+      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 })
+      assert_equal "Miles Davis Quartet", res2["data"]["find"]["name"]
+    end
+
+    it "initializes root wrappers once" do
+      query_str = " { oid1: objectId oid2: objectId }"
+      res = Jazz::Schema.execute(query_str)
+      assert_equal res["data"]["oid1"], res["data"]["oid2"]
+    end
+
+    it "skips fields properly" do
+      query_str = "{ find(id: \"MagicalSkipId\") { __typename } }"
+      res = Jazz::Schema.execute(query_str)
+      assert_equal({"data" => nil }, res.to_h)
+    end
+  end
+end