graphql 1.7.6 → 1.8.0

data/spec/graphql/relay/mutation_spec.rb

@@ -103,14 +103,16 @@ describe GraphQL::Relay::Mutation do
   end
 
   it "applies the description to the derived field" do
-    assert_equal "Add a ship to this faction", StarWars::IntroduceShipMutation.field.description
+    field = GraphQL::Schema::Field.from_options(name: "x", **StarWars::IntroduceShipMutation.field_options)
+    assert_equal "Add a ship to this faction", field.description
   end
 
   it "inserts itself into the derived objects' metadata" do
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.field.mutation
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.return_type.mutation
+    field = GraphQL::Schema::Field.from_options(name: "x", **StarWars::IntroduceShipMutation.field_options)
+    assert_equal StarWars::IntroduceShipMutation, field.mutation
+    assert_equal StarWars::IntroduceShipMutation, field.to_graphql.mutation
+    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.payload_type.mutation
     assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.input_type.mutation
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.result_class.mutation
   end
 
   describe "return_field ... property:" do
@@ -193,17 +195,17 @@ describe GraphQL::Relay::Mutation do
     end
 
     it "doesn't get a mutation in the metadata" do
-      assert_equal nil, custom_return_type.mutation
+      assert_nil custom_return_type.mutation
     end
 
     it "supports input fields with nil default value" do
       assert input.arguments['nullDefault'].default_value?
-      assert_equal nil, input.arguments['nullDefault'].default_value
+      assert_nil input.arguments['nullDefault'].default_value
     end
 
     it "supports input fields with no default value" do
       assert !input.arguments['noDefault'].default_value?
-      assert_equal nil, input.arguments['noDefault'].default_value
+      assert_nil input.arguments['noDefault'].default_value
     end
 
     it "supports input fields with non-nil default value" do

data/spec/graphql/relay/range_add_spec.rb

@@ -70,7 +70,11 @@ describe GraphQL::Relay::RangeAdd do
       field :add_item, add_item.field
     end
 
-    GraphQL::Schema.define(query: query, mutation: mutation, cursor_encoder: PassThroughEncoder)
+    Class.new(GraphQL::Schema) do
+      self.query(query)
+      self.mutation(mutation)
+      self.cursor_encoder(PassThroughEncoder)
+    end
   }
 
 

data/spec/graphql/relay/relation_connection_spec.rb

@@ -74,6 +74,35 @@ describe GraphQL::Relay::RelationConnection do
       )
     end
 
+    it "makes one sql query for items and another for count" do
+      query_str = <<-GRAPHQL
+      {
+        empire {
+          bases(first: 2) {
+            totalCount
+            edges {
+              cursor
+              node {
+                name
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+      io = StringIO.new
+      begin
+        prev_logger = ActiveRecord::Base.logger
+        ActiveRecord::Base.logger = Logger.new(io)
+        result = star_wars_query(query_str, "first" => 2)
+      ensure
+        ActiveRecord::Base.logger = prev_logger
+      end
+      assert_equal 2, io.string.scan("\n").count, "Two log entries"
+      assert_equal 3, result["data"]["empire"]["bases"]["totalCount"]
+      assert_equal 2, result["data"]["empire"]["bases"]["edges"].size
+    end
+
     it "provides bidirectional_pagination" do
       result = star_wars_query(query_string, "first" => 1)
       last_cursor = get_last_cursor(result)
@@ -88,6 +117,13 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal true, get_page_info(result)["hasNextPage"]
       assert_equal true, get_page_info(result)["hasPreviousPage"]
 
+      last_cursor = get_last_cursor(result)
+      result = with_bidirectional_pagination {
+        star_wars_query(query_string, "last" => 1, "before" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal false, get_page_info(result)["hasPreviousPage"]
+
       result = star_wars_query(query_string, "first" => 100)
       last_cursor = get_last_cursor(result)
 
@@ -100,7 +136,6 @@ describe GraphQL::Relay::RelationConnection do
       }
       assert_equal true, get_page_info(result)["hasNextPage"]
       assert_equal true, get_page_info(result)["hasPreviousPage"]
-
     end
 
     it 'slices the result' do
@@ -564,6 +599,35 @@ describe GraphQL::Relay::RelationConnection do
         result = star_wars_query(query_string, "last" => 1, "nameIncludes" => "ea", "before" => before)
         assert_equal(["Death Star"], get_names(result))
       end
+
+      it "makes one sql query for items and another for count" do
+        query_str = <<-GRAPHQL
+        {
+          empire {
+            basesAsSequelDataset(first: 2) {
+              totalCount
+              edges {
+                cursor
+                node {
+                  name
+                }
+              }
+            }
+          }
+        }
+        GRAPHQL
+        result = nil
+        io = StringIO.new
+        begin
+          StarWars::DB.loggers << Logger.new(io)
+          result = star_wars_query(query_str, "first" => 2)
+        ensure
+          StarWars::DB.loggers.pop
+        end
+        assert_equal 2, io.string.scan("SELECT").count
+        assert_equal 3, result["data"]["empire"]["basesAsSequelDataset"]["totalCount"]
+        assert_equal 2, result["data"]["empire"]["basesAsSequelDataset"]["edges"].size
+      end
     end
   end
 

data/spec/graphql/schema/argument_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Argument do
+  module SchemaArgumentTest
+    class Query < GraphQL::Schema::Object
+      field :field, String, null: false do
+        argument :arg, String, description: "test", required: false
+
+        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::Query.fields["field"].arguments["argWithBlock"].description
+    end
+  end
+
+  describe "#description" do
+    it "sets description" do
+      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::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

@@ -30,6 +30,20 @@ type HelloScalars {
       build_schema_and_compare_output(schema.chop)
     end
 
+    it 'can build a schema with default input object values' do
+      schema = <<-SCHEMA
+input InputObject {
+  a: Int
+}
+
+type Query {
+  a(input: InputObject = {a: 1}): String
+}
+      SCHEMA
+
+      build_schema_and_compare_output(schema.chop)
+    end
+
     it 'can build a schema with directives' do
       schema = <<-SCHEMA
 schema {
@@ -118,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
@@ -294,7 +309,7 @@ schema {
 }
 
 type Hello {
-  str(int: Int, bool: Boolean): String
+  str(bool: Boolean, int: Int): String
 }
       SCHEMA
 
@@ -491,7 +506,7 @@ type HelloScalars {
 }
 
 type Mutation {
-  addHelloScalars(str: String, int: Int, bool: Boolean): HelloScalars
+  addHelloScalars(bool: Boolean, int: Int, str: String): HelloScalars
 }
       SCHEMA
 
@@ -506,7 +521,7 @@ enum Color {
 }
 
 type Mutation {
-  hello(str: String, int: Int, color: Color = RED, nullDefault: Int = null): String
+  hello(color: Color = RED, int: Int, nullDefault: Int = null, str: String): String
 }
 
 type Query {
@@ -531,7 +546,7 @@ type HelloScalars {
 }
 
 type Subscription {
-  subscribeHelloScalars(str: String, int: Int, bool: Boolean): HelloScalars
+  subscribeHelloScalars(bool: Boolean, int: Int, str: String): HelloScalars
 }
       SCHEMA
 
@@ -589,6 +604,75 @@ type Query {
 
       build_schema_and_compare_output(schema.chop)
     end
+
+    it 'supports empty types' do
+      schema = <<-SCHEMA
+type Query {
+}
+      SCHEMA
+
+      build_schema_and_compare_output(schema.chop)
+    end
+
+    it "tracks original AST node" do
+      schema_definition = <<-GRAPHQL
+schema @custom(thing: true) {
+  query: Query
+}
+
+enum Enum {
+  VALUE
+}
+
+type Query {
+  field(argument: String): String
+  deprecatedField(argument: String): String @deprecated(reason: "Test")
+}
+
+interface Interface {
+  field(argument: String): String
+}
+
+union Union = Query
+
+scalar Scalar
+
+input Input {
+  argument: String
+}
+
+directive @Directive (
+  # Argument
+  argument: String
+) on SCHEMA
+
+type Type implements Interface {
+  field(argument: String): String
+}
+      GRAPHQL
+
+      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
+      assert_equal [10, 3], schema.types["Query"].fields["field"].ast_node.position
+      assert_equal [10, 9], schema.types["Query"].fields["field"].arguments["argument"].ast_node.position
+      assert_equal [11, 45], schema.types["Query"].fields["deprecatedField"].ast_node.directives[0].position
+      assert_equal [11, 57], schema.types["Query"].fields["deprecatedField"].ast_node.directives[0].arguments[0].position
+      assert_equal [14, 1], schema.types["Interface"].ast_node.position
+      assert_equal [15, 3], schema.types["Interface"].fields["field"].ast_node.position
+      assert_equal [15, 9], schema.types["Interface"].fields["field"].arguments["argument"].ast_node.position
+      assert_equal [18, 1], schema.types["Union"].ast_node.position
+      assert_equal [20, 1], schema.types["Scalar"].ast_node.position
+      assert_equal [22, 1], schema.types["Input"].ast_node.position
+      assert_equal [23, 3], schema.types["Input"].arguments["argument"].ast_node.position
+      assert_equal [26, 1], schema.directives["Directive"].ast_node.position
+      assert_equal [28, 3], schema.directives["Directive"].arguments["argument"].ast_node.position
+      assert_equal [31, 22], schema.types["Type"].ast_node.interfaces[0].position
+    end
   end
 
   describe 'Failures' do

data/spec/graphql/schema/enum_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Enum do
+  let(:enum) { Jazz::Family }
+  describe "type info" do
+    it "tells about the definition" do
+      assert_equal "Family", enum.graphql_name
+      assert_equal 29, enum.description.length
+      assert_equal 6, enum.values.size
+    end
+
+    it "inherits values and description" do
+      new_enum = Class.new(enum) do
+        value :Nonsense
+        value :PERCUSSION, "new description"
+      end
+
+      # Description was inherited
+      assert_equal 29, new_enum.description.length
+      # values were inherited without modifying the parent
+      assert_equal 6, enum.values.size
+      assert_equal 7, new_enum.values.size
+      perc_value = new_enum.values["PERCUSSION"]
+      assert_equal "new description", perc_value.description
+    end
+
+    it "accepts a block" do
+      assert_equal "Neither here nor there, really", enum.values["KEYS"].description
+    end
+
+    it "is the #owner of its values" do
+      value = enum.values["STRING"]
+      assert_equal enum, value.owner
+    end
+  end
+
+  it "uses a custom enum value class" do
+    enum_type = enum.to_graphql
+    value = enum_type.values["STRING"]
+    assert_equal 1, value.metadata[:custom_setting]
+  end
+
+  describe ".to_graphql" do
+    it "creates an EnumType" do
+      enum_type = enum.to_graphql
+      assert_equal "Family", enum_type.name
+      assert_equal "Groups of musical instruments", enum_type.description
+
+      string_val = enum_type.values["STRING"]
+      didg_val = enum_type.values["DIDGERIDOO"]
+      assert_equal "STRING", string_val.name
+      assert_equal :str, string_val.value
+      assert_equal "DIDGERIDOO", didg_val.name
+      assert_equal "Merged into BRASS", didg_val.deprecation_reason
+    end
+  end
+
+  describe "in queries" do
+    it "works as return values" do
+      query_str = "{ instruments { family } }"
+      expected_families = ["STRING", "WOODWIND", "BRASS", "KEYS", "KEYS", "PERCUSSION"]
+      result = Jazz::Schema.execute(query_str)
+      assert_equal expected_families, result["data"]["instruments"].map { |i| i["family"] }
+    end
+
+    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" })
+      assert_equal expected_names, result["data"]["instruments"].map { |i| i["name"] }
+    end
+  end
+end

data/spec/graphql/schema/field_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Field do
+  describe "graphql definition" do
+    let(:object_class) { Jazz::Query }
+    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.from_options(:underscored_field, String, null: false, camelize: false, owner: nil) do
+        argument :underscored_arg, String, required: true, camelize: false
+      end
+
+      assert_equal 'underscored_field', underscored_field.to_graphql.name
+      arg_name, arg_defn = underscored_field.to_graphql.arguments.first
+      assert_equal 'underscored_arg', arg_name
+      assert_equal 'underscored_arg', arg_defn.name
+    end
+
+    it "exposes the method override" do
+      object = Class.new(Jazz::BaseObject) do
+        field :t, String, method: :tt, null: true
+      end
+      assert_equal :tt, object.fields["t"].method_sym
+      assert_equal "tt", object.fields["t"].method_str
+    end
+
+    it "accepts a block for definition" do
+      object = Class.new(Jazz::BaseObject) do
+        graphql_name "JustAName"
+
+        field :test, String, null: true do
+          argument :test, String, required: true
+          description "A Description."
+        end
+      end.to_graphql
+
+      assert_equal "test", object.fields["test"].arguments["test"].name
+      assert_equal "A Description.", object.fields["test"].description
+    end
+
+    it "accepts anonymous classes as type" do
+      type = Class.new(GraphQL::Schema::Object) do
+        graphql_name 'MyType'
+      end
+      field = GraphQL::Schema::Field.from_options(:my_field, type, owner: nil, null: true)
+      assert_equal type.to_graphql, field.to_graphql.type
+    end
+
+    describe "extras" do
+      it "can get errors, which adds path" do
+        query_str = <<-GRAPHQL
+        query {
+          find(id: "Musician/Herbie Hancock") {
+            ... on Musician {
+              addError
+            }
+          }
+        }
+        GRAPHQL
+
+        res = Jazz::Schema.execute(query_str)
+        err = res["errors"].first
+        assert_equal "this has a path", err["message"]
+        assert_equal ["find", "addError"], err["path"]
+        assert_equal [{"line"=>4, "column"=>15}], err["locations"]
+      end
+    end
+
+    it "is the #owner of its arguments" do
+      field = Jazz::Query.fields["find"]
+      argument = field.arguments["id"]
+      assert_equal field, argument.owner
+    end
+
+    it "has a reference to the object that owns it with #owner" 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
+          graphql_name "complexityKeyword"
+
+          field :complexityTest, String, null: true, complexity: 25
+        end.to_graphql
+
+        assert_equal 25, object.fields["complexityTest"].complexity
+      end
+
+      it "accepts a proc in the definition block" do
+        object = Class.new(Jazz::BaseObject) do
+          graphql_name "complexityKeyword"
+
+          field :complexityTest, String, null: true do
+            complexity ->(_ctx, _args, _child_complexity) { 52 }
+          end
+        end.to_graphql
+
+        assert_equal 52, object.fields["complexityTest"].complexity.call(nil, nil, nil)
+      end
+
+      it "accepts an integer in the definition block" do
+        object = Class.new(Jazz::BaseObject) do
+          graphql_name "complexityKeyword"
+
+          field :complexityTest, String, null: true do
+            complexity 38
+          end
+        end.to_graphql
+
+        assert_equal 38, object.fields["complexityTest"].complexity
+      end
+
+      it 'fails if the complexity is not numeric and not a proc' do
+        err = assert_raises(RuntimeError) do
+          Class.new(Jazz::BaseObject) do
+            graphql_name "complexityKeyword"
+
+            field :complexityTest, String, null: true do
+              complexity 'One hundred and eighty'
+            end
+          end.to_graphql
+        end
+
+        assert_match /^Invalid complexity:/, err.message
+      end
+
+      it 'fails if the proc does not accept 3 parameters' do
+        err = assert_raises(RuntimeError) do
+          Class.new(Jazz::BaseObject) do
+            graphql_name "complexityKeyword"
+
+            field :complexityTest, String, null: true do
+              complexity ->(one, two) { 52 }
+            end
+          end.to_graphql
+        end
+
+        assert_match /^A complexity proc should always accept 3 parameters/, err.message
+      end
+    end
+  end
+
+  describe "build type errors" do
+    it "includes the full name" do
+      thing = Class.new(GraphQL::Schema::Object) do
+        graphql_name "Thing"
+        # `Set` is a class but not a GraphQL type
+        field :stuff, Set, null: false
+      end
+
+      err = assert_raises ArgumentError do
+        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
+    it "passes when not including extra arguments" do
+      mutation_class = Class.new(GraphQL::Schema::Mutation) do
+        graphql_name "Thing"
+        field :stuff, String, null: false
+      end
+
+      obj = Class.new(GraphQL::Schema::Object) do
+        field(:my_field, mutation: mutation_class, null: true)
+      end
+      assert_equal obj.fields["myField"].mutation, mutation_class
+    end
+  end
+end