graphql 1.8.0.pre10 → 1.8.0.pre11

data/spec/graphql/schema/argument_spec.rb

@@ -2,30 +2,86 @@
 require "spec_helper"
 
 describe GraphQL::Schema::Argument do
-  class SchemaArgumentTest < GraphQL::Schema::Object
-    field :field, String, null: false do
-      argument :arg, String, description: "test", required: false
+  module SchemaArgumentTest
+    class Query < GraphQL::Schema::Object
+      field :field, String, null: false do
+        argument :arg, String, description: "test", required: false
 
-      argument :argWithBlock, String, required: false do
-        description "test"
+        argument :arg_with_block, String, required: false do
+          description "test"
+        end
+
+        argument :aliased_arg, String, required: false, as: :renamed
+        argument :prepared_arg, Int, required: false, prepare: :multiply
+      end
+
+      def field(**args)
+        args.inspect
       end
+
+      def multiply(val)
+        context[:multiply_by] * val
+      end
+    end
+
+    class Schema < GraphQL::Schema
+      query(Query)
+    end
+  end
+
+
+
+  describe "#name" do
+    it "reflects camelization" do
+      assert_equal "argWithBlock", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].name
+    end
+  end
+
+  describe "#type" do
+    let(:argument) { SchemaArgumentTest::Query.fields["field"].arguments["arg"] }
+    it "returns the type" do
+      assert_equal GraphQL::STRING_TYPE, argument.type
     end
   end
 
   describe "graphql definition" do
     it "calls block" do
-      assert_equal "test", SchemaArgumentTest.fields["field"].arguments["argWithBlock"].description
+      assert_equal "test", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].description
     end
   end
 
   describe "#description" do
     it "sets description" do
-      SchemaArgumentTest.fields["field"].arguments["arg"].description "new description"
-      assert_equal "new description", SchemaArgumentTest.fields["field"].arguments["arg"].description
+      SchemaArgumentTest::Query.fields["field"].arguments["arg"].description "new description"
+      assert_equal "new description", SchemaArgumentTest::Query.fields["field"].arguments["arg"].description
     end
 
     it "returns description" do
-      assert_equal "test", SchemaArgumentTest.fields["field"].arguments["argWithBlock"].description
+      assert_equal "test", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].description
+    end
+  end
+
+  describe "as:" do
+    it "uses that Symbol for Ruby kwargs" do
+      query_str = <<-GRAPHQL
+      { field(aliasedArg: "x") }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str)
+      # Make sure it's getting the renamed symbol:
+      assert_equal '{:renamed=>"x"}', res["data"]["field"]
+    end
+  end
+
+  describe "prepare:" do
+    it "calls the method on the field's owner" do
+      query_str = <<-GRAPHQL
+      { field(preparedArg: 5) }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
+      # Make sure it's getting the renamed symbol:
+      assert_equal '{:prepared_arg=>15}', res["data"]["field"]
     end
   end
 end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -132,11 +132,12 @@ type Hello {
 
     it 'supports adding directives while maintaining built-in directives' do
       schema = <<-SCHEMA
-schema {
+schema @custom(thing: true) {
   query: Hello
 }
 
 directive @foo(arg: Int) on FIELD
+directive @custom(thing: Boolean) on SCHEMA
 
 type Hello {
   str: String
@@ -615,7 +616,7 @@ type Query {
 
     it "tracks original AST node" do
       schema_definition = <<-GRAPHQL
-schema {
+schema @custom(thing: true) {
   query: Query
 }
 
@@ -653,6 +654,7 @@ type Type implements Interface {
       schema = GraphQL::Schema.from_definition(schema_definition)
 
       assert_equal [1, 1], schema.ast_node.position
+      assert_equal [1, 8], schema.ast_node.directives.first.position
       assert_equal [5, 1], schema.types["Enum"].ast_node.position
       assert_equal [6, 3], schema.types["Enum"].values["VALUE"].ast_node.position
       assert_equal [9, 1], schema.types["Query"].ast_node.position

data/spec/graphql/schema/enum_spec.rb

@@ -67,7 +67,7 @@ describe GraphQL::Schema::Enum do
     it "works as input" do
       query_str = "query($family: Family!) { instruments(family: $family) { name } }"
       expected_names = ["Piano", "Organ"]
-      result = Jazz::Schema.execute(query_str, variables: { "family" => "KEYS" })
+      result = Jazz::Schema.execute(query_str, variables: { family: "KEYS" })
       assert_equal expected_names, result["data"]["instruments"].map { |i| i["name"] }
     end
   end

data/spec/graphql/schema/field_spec.rb

@@ -4,15 +4,20 @@ require "spec_helper"
 describe GraphQL::Schema::Field do
   describe "graphql definition" do
     let(:object_class) { Jazz::Query }
-    let(:field) { object_class.fields["inspect_input"] }
+    let(:field) { object_class.fields["inspectInput"] }
 
     it "uses the argument class" do
       arg_defn = field.graphql_definition.arguments.values.first
       assert_equal :ok, arg_defn.metadata[:custom]
     end
 
+    it "attaches itself to its graphql_definition as type_class" do
+      assert_equal field, field.graphql_definition.metadata[:type_class]
+    end
+
     it "camelizes the field name, unless camelize: false" do
       assert_equal 'inspectInput', field.graphql_definition.name
+      assert_equal 'inspectInput', field.name
 
       underscored_field = GraphQL::Schema::Field.new(:underscored_field, String, null: false, camelize: false, owner: nil) do
         argument :underscored_arg, String, required: true, camelize: false
@@ -25,11 +30,11 @@ describe GraphQL::Schema::Field do
     end
 
     it "exposes the method override" do
-      assert_nil field.method
       object = Class.new(Jazz::BaseObject) do
         field :t, String, method: :tt, null: true
       end
-      assert_equal :tt, object.fields["t"].method
+      assert_equal :tt, object.fields["t"].method_sym
+      assert_equal "tt", object.fields["t"].method_str
     end
 
     it "accepts a block for definition" do
@@ -84,6 +89,17 @@ describe GraphQL::Schema::Field do
       assert_equal Jazz::Query, field.owner
     end
 
+    describe "type" do
+      it "tells the return type" do
+        assert_equal "[String!]!", field.type.graphql_definition.to_s
+      end
+
+      it "returns the type class" do
+        field = Jazz::Query.fields["nowPlaying"]
+        assert_equal Jazz::PerformingAct, field.type.of_type
+      end
+    end
+
     describe "complexity" do
       it "accepts a keyword argument" do
         object = Class.new(Jazz::BaseObject) do
@@ -158,10 +174,69 @@ describe GraphQL::Schema::Field do
       end
 
       err = assert_raises ArgumentError do
-        thing.fields["stuff"].to_graphql.type
+        thing.fields["stuff"].type
+      end
+
+      assert_includes err.message, "Thing.stuff"
+      assert_includes err.message, "Unexpected class/module"
+    end
+
+    it "makes a suggestion when the type is false" do
+      thing = Class.new(GraphQL::Schema::Object) do
+        graphql_name "Thing"
+        # False might come from an invalid `!`
+        field :stuff, false, null: false
+      end
+
+      err = assert_raises ArgumentError do
+        thing.fields["stuff"].type
       end
 
       assert_includes err.message, "Thing.stuff"
+      assert_includes err.message, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
+    end
+
+    it "makes a suggestion when the type is a GraphQL::Field" do
+      err = assert_raises ArgumentError do
+        Class.new(GraphQL::Schema::Object) do
+          graphql_name "Thing"
+          # Previously, field was a valid second argument
+          field :stuff, GraphQL::Relay::Node.field, null: false
+        end
+      end
+
+      assert_includes err.message, "use the `field:` keyword for this instead"
+    end
+  end
+
+  describe "mutation" do
+    let(:mutation) do
+      Class.new(GraphQL::Schema::Mutation) do
+        graphql_name "Thing"
+
+        field :stuff, String, null: false
+      end
+    end
+    let(:error_message) { "when keyword `mutation:` is present, all arguments are ignored, please remove them" }
+
+    it "fails when including null option as true" do
+      error = assert_raises(ArgumentError) do
+        GraphQL::Schema::Field.new(:my_field, mutation: mutation, null: true)
+      end
+
+      assert_equal error.message, error_message
+    end
+
+    it "fails when including null option as false" do
+      error = assert_raises(ArgumentError) do
+        GraphQL::Schema::Field.new(:my_field, mutation: mutation, null: false)
+      end
+
+      assert_equal error.message, error_message
+    end
+
+    it "passes when not including extra arguments" do
+      assert_equal GraphQL::Schema::Field.new(:my_field, mutation: mutation).mutation, mutation
     end
   end
 end

data/spec/graphql/schema/input_object_spec.rb

@@ -14,6 +14,22 @@ describe GraphQL::Schema::InputObject do
       argument = input_object.arguments["name"]
       assert_equal input_object, argument.owner
     end
+
+    it "inherits arguments" do
+      base_class = Class.new(GraphQL::Schema::InputObject) do
+        argument :arg1, String, required: true
+        argument :arg2, String, required: true
+      end
+
+      subclass = Class.new(base_class) do
+        argument :arg2, Integer, required: true
+        argument :arg3, Integer, required: true
+      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_s }
+    end
   end
 
   describe ".to_graphql" do
@@ -28,6 +44,46 @@ describe GraphQL::Schema::InputObject do
     end
   end
 
+  describe "prepare: / as:" do
+    module InputObjectPrepareTest
+      class InputObj < GraphQL::Schema::InputObject
+        argument :a, Integer, required: true
+        argument :b, Integer, required: true, as: :b2
+        argument :c, Integer, required: true, prepare: :prep
+        argument :d, Integer, required: true, prepare: :prep, as: :d2
+        argument :e, Integer, required: true, prepare: ->(val, ctx) { val * ctx[:multiply_by] * 2 }, as: :e2
+
+        def prep(val)
+          val * context[:multiply_by]
+        end
+      end
+
+      class Query < GraphQL::Schema::Object
+        field :inputs, String, null: false do
+          argument :input, InputObj, required: true
+        end
+
+        def inputs(input:)
+          input.to_kwargs.inspect
+        end
+      end
+
+      class Schema < GraphQL::Schema
+        query(Query)
+      end
+    end
+
+    it "calls methods on the input object" do
+      query_str = <<-GRAPHQL
+      { inputs(input: { a: 1, b: 2, c: 3, d: 4, e: 5 }) }
+      GRAPHQL
+
+      res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 })
+      expected_obj = { a: 1, b2: 2, c: 9, d2: 12, e2: 30 }.inspect
+      assert_equal expected_obj, res["data"]["inputs"]
+    end
+  end
+
   describe "in queries" do
     it "is passed to the field method" do
       query_str = <<-GRAPHQL

data/spec/graphql/schema/instrumentation_spec.rb

@@ -2,8 +2,9 @@
 require "spec_helper"
 
 module InstrumentationSpec
-  class SomeInterface < GraphQL::Schema::Interface
-    field :neverCalled, String, null: false
+  module SomeInterface
+    include GraphQL::Schema::Interface
+    field :never_called, String, null: false
 
     def never_called
       "should never be called"
@@ -15,7 +16,7 @@ module InstrumentationSpec
   end
 
   class Query < GraphQL::Schema::Object
-    field :someField, [SomeInterface], null: true
+    field :some_field, [SomeInterface], null: true
 
     def some_field
       nil

data/spec/graphql/schema/interface_spec.rb

@@ -10,21 +10,17 @@ describe GraphQL::Schema::Interface do
       assert_equal 2, interface.fields.size
     end
 
-    class NewInterface1 < Jazz::GloballyIdentifiableType
-      # TODO not great
-      module Implementation
-        include Jazz::GloballyIdentifiableType::Implementation
-      end
+    module NewInterface1
+      include Jazz::GloballyIdentifiableType
     end
 
-    class NewInterface2 < Jazz::GloballyIdentifiableType
-      module Implementation
-        def new_method
-        end
+    module NewInterface2
+      include Jazz::GloballyIdentifiableType
+      def new_method
       end
     end
 
-    it "can override Implementation" do
+    it "can override methods" do
       new_object_1 = Class.new(GraphQL::Schema::Object) do
         implements NewInterface1
       end
@@ -33,14 +29,19 @@ describe GraphQL::Schema::Interface do
       assert new_object_1.method_defined?(:id)
 
       new_object_2 = Class.new(GraphQL::Schema::Object) do
+        graphql_name "XYZ"
         implements NewInterface2
+        field :id, "ID", null: false, description: "The ID !!!!!"
       end
 
       assert_equal 2, new_object_2.fields.size
       # It got the new method
       assert new_object_2.method_defined?(:new_method)
-      # But not the old method
-      refute new_object_2.method_defined?(:id)
+      # And the inherited method
+      assert new_object_2.method_defined?(:id)
+
+      # It gets an overridden description:
+      assert_equal "The ID !!!!!", new_object_2.graphql_definition.fields["id"].description
     end
   end
 
@@ -57,25 +58,25 @@ describe GraphQL::Schema::Interface do
     end
 
     it "can specify a resolve_type method" do
-      interface = Class.new(GraphQL::Schema::Interface) do
-        def self.resolve_type(_object, _context)
-          "MyType"
-        end
-
-        def self.name
-          "MyInterface"
+      interface = Module.new do
+        include GraphQL::Schema::Interface
+        graphql_name "MyInterface"
+
+        module self::DefinitionMethods # rubocop:disable Style/ClassAndModuleChildren
+          def resolve_type(_object, _context)
+            "MyType"
+          end
         end
       end
+
       interface_type = interface.to_graphql
       assert_equal "MyType", interface_type.resolve_type_proc.call(nil, nil)
     end
 
     it "can specify orphan types" do
-      interface = Class.new(GraphQL::Schema::Interface) do
-        def self.name
-          "MyInterface"
-        end
-
+      interface = Module.new do
+        include GraphQL::Schema::Interface
+        graphql_name "MyInterface"
         orphan_types Dummy::CheeseType, Dummy::HoneyType
       end
 
@@ -85,10 +86,12 @@ describe GraphQL::Schema::Interface do
   end
 
   it 'supports global_id_field' do
-    object = Class.new(GraphQL::Schema::Interface) do
+    object = Module.new do
+      include GraphQL::Schema::Interface
       graphql_name 'GlobalIdFieldTest'
       global_id_field :uuid
     end.to_graphql
+
     uuid_field = object.fields["uuid"]
 
     assert_equal GraphQL::NonNullType, uuid_field.type.class
@@ -99,6 +102,18 @@ describe GraphQL::Schema::Interface do
     )
   end
 
+  describe "using `include`" do
+    it "raises" do
+      err = assert_raises RuntimeError do
+        Class.new(GraphQL::Schema::Object) do
+          include(Jazz::GloballyIdentifiableType)
+        end
+      end
+
+      assert_includes err.message, "implements(Jazz::GloballyIdentifiableType)"
+    end
+  end
+
   describe "in queries" do
     it "works" do
       query_str = <<-GRAPHQL