graphql 1.3.0 → 1.4.0

data/spec/graphql/relay/page_info_spec.rb

@@ -37,6 +37,10 @@ describe GraphQL::Relay::PageInfo do
     }
   |}
 
+  it "is a default relay type" do
+    assert_equal true, GraphQL::Relay::PageInfo.default_relay?
+  end
+
   describe 'hasNextPage / hasPreviousPage' do
     it "hasNextPage is true if there are more items" do
       result = star_wars_query(query_string, "first" => 2)

data/spec/graphql/relay/relation_connection_spec.rb

@@ -95,6 +95,14 @@ describe GraphQL::Relay::RelationConnection do
       result = star_wars_query(query_string, "before" => last_cursor, "last" => 10)
       assert_equal(["Death Star", "Shield Generator"], get_names(result))
 
+      result = star_wars_query(query_string, "last" => 2)
+      assert_equal(["Shield Generator", "Headquarters"], get_names(result))
+    end
+
+    it 'handles cursors beyond the bounds of the array' do
+      overreaching_cursor = Base64.strict_encode64("100")
+      result = star_wars_query(query_string, "after" => overreaching_cursor, "first" => 2)
+      assert_equal([], get_names(result))
     end
 
     it "applies custom arguments" do

data/spec/graphql/scalar_type_spec.rb

@@ -11,6 +11,10 @@ describe GraphQL::ScalarType do
   }
   let(:bignum) { 2 ** 128 }
 
+  it "is not a default scalar" do
+    assert_equal(false, custom_scalar.default_scalar?)
+  end
+
   it "coerces nil into nil" do
     assert_equal(nil, custom_scalar.coerce_input(nil))
   end

data/spec/graphql/schema/middleware_chain_spec.rb

@@ -2,40 +2,54 @@
 require "spec_helper"
 
 describe GraphQL::Schema::MiddlewareChain do
-  let(:step_1) { ->(step_values, next_step) { step_values << 1; next_step.call } }
-  let(:step_2) { ->(step_values, next_step) { step_values << 2; next_step.call } }
-  let(:step_3) { ->(step_values, next_step) { step_values << 3; :return_value } }
+  let(:step_1) { ->(step_values, &next_step) { step_values << 1; next_step.call } }
+  let(:step_2) { ->(step_values, &next_step) { step_values << 2; next_step.call } }
+  let(:step_3) { ->(step_values, &next_step) { step_values << 3; :return_value } }
   let(:steps) { [step_1, step_2, step_3] }
   let(:step_values) { [] }
   let(:arguments) { [step_values] }
-  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps, arguments: arguments)}
+  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps)}
 
-  describe "#call" do
+  describe "#invoke" do
     it "runs steps in order" do
-      middleware_chain.call
+      middleware_chain.invoke(arguments)
       assert_equal([1,2,3], step_values)
     end
 
     it "returns the value of the last middleware" do
-      assert_equal(:return_value, middleware_chain.call)
+      assert_equal(:return_value, middleware_chain.invoke(arguments))
+    end
+
+    describe "when there is a final step" do
+      let(:final_step) { ->(step_values) { step_values << :final; :final_value } }
+      let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: [step_1, step_2], final_step: final_step) }
+
+      it "calls the final step" do
+        middleware_chain.invoke(arguments)
+        assert_equal([1, 2, :final], step_values)
+      end
+
+      it "returns the value from the final step" do
+        assert_equal(:final_value, middleware_chain.invoke(arguments))
+      end
     end
 
     describe "when a step returns early" do
-      let(:early_return_step) { ->(step_values, next_step) { :early_return } }
+      let(:early_return_step) { ->(step_values, &next_step) { :early_return } }
       it "doesn't continue the chain" do
         steps.insert(2, early_return_step)
-        assert_equal(:early_return, middleware_chain.call)
+        assert_equal(:early_return, middleware_chain.invoke(arguments))
         assert_equal([1,2], step_values)
       end
     end
 
     describe "when a step provides alternate arguments" do
       it "passes the new arguments to the next step" do
-        step_1 = ->(test_arg, next_step) { assert_equal(test_arg, 'HELLO'); next_step.call(['WORLD']) }
-        step_2 = ->(test_arg, next_step) { assert_equal(test_arg, 'WORLD'); test_arg }
+        step_1 = ->(test_arg, &next_step) { assert_equal(test_arg, 'HELLO'); next_step.call(['WORLD']) }
+        step_2 = ->(test_arg, &next_step) { assert_equal(test_arg, 'WORLD'); test_arg }
 
-        chain = GraphQL::Schema::MiddlewareChain.new(steps: [step_1, step_2], arguments: ['HELLO'])
-        result = chain.call
+        chain = GraphQL::Schema::MiddlewareChain.new(steps: [step_1, step_2])
+        result = chain.invoke(['HELLO'])
         assert_equal(result, 'WORLD')
       end
     end

data/spec/graphql/schema/printer_spec.rb

@@ -336,7 +336,8 @@ SCHEMA
 
   describe ".print_schema" do
     it "includes schema definition when query root name doesn't match convention" do
-      schema.query.name = 'MyQueryRoot'
+      custom_query = schema.query.redefine(name: "MyQueryRoot")
+      custom_schema = schema.redefine(query: custom_query)
 
       expected = <<SCHEMA
 schema {
@@ -346,11 +347,13 @@ schema {
 }
 SCHEMA
 
-      assert_match expected, GraphQL::Schema::Printer.print_schema(schema)
+      assert_match expected, GraphQL::Schema::Printer.print_schema(custom_schema)
     end
 
     it "includes schema definition when mutation root name doesn't match convention" do
-      schema.mutation.name = 'MyMutationRoot'
+      custom_mutation = schema.mutation.redefine(name: "MyMutationRoot")
+      custom_schema = schema.redefine(mutation: custom_mutation)
+
 
       expected = <<SCHEMA
 schema {
@@ -360,11 +363,12 @@ schema {
 }
 SCHEMA
 
-      assert_match expected, GraphQL::Schema::Printer.print_schema(schema)
+      assert_match expected, GraphQL::Schema::Printer.print_schema(custom_schema)
     end
 
     it "includes schema definition when subscription root name doesn't match convention" do
-      schema.subscription.name = 'MySubscriptionRoot'
+      custom_subscription = schema.subscription.redefine(name: "MySubscriptionRoot")
+      custom_schema = schema.redefine(subscription: custom_subscription)
 
       expected = <<SCHEMA
 schema {
@@ -374,7 +378,7 @@ schema {
 }
 SCHEMA
 
-      assert_match expected, GraphQL::Schema::Printer.print_schema(schema)
+      assert_match expected, GraphQL::Schema::Printer.print_schema(custom_schema)
     end
 
     it "returns the schema as a string for the defined types" do
@@ -475,4 +479,115 @@ SCHEMA
       assert_equal expected.chomp, GraphQL::Schema::Printer.print_schema(schema)
     end
   end
+
+  it "applies an `only` filter" do
+    expected = <<SCHEMA
+enum Choice {
+  FOO
+  BAR
+}
+
+type Subscription {
+
+}
+
+input Varied {
+  int: Int
+  float: Float
+  bool: Boolean
+  enum: Choice = FOO
+}
+SCHEMA
+
+    only_filter = -> (member, ctx) {
+      case member
+      when GraphQL::ScalarType
+        true
+      when GraphQL::BaseType
+        ctx[:names].include?(member.name)
+      when GraphQL::Argument
+        member.name != "id"
+      else
+        member.deprecation_reason.nil?
+      end
+    }
+
+    context = { names: ["Varied", "Choice", "Subscription"] }
+    assert_equal expected.chomp, schema.to_definition(context: context, only: only_filter)
+  end
+
+
+  it "applies an `except` filter" do
+    expected = <<SCHEMA
+type Audio {
+  id: ID!
+  name: String!
+  duration: Int!
+}
+
+enum Choice {
+  FOO
+  BAR
+}
+
+# A blog comment
+type Comment implements Node {
+  id: ID!
+}
+
+# Autogenerated input type of CreatePost
+input CreatePostInput {
+  # A unique identifier for the client performing the mutation.
+  clientMutationId: String
+  title: String!
+  body: String!
+}
+
+# Autogenerated return type of CreatePost
+type CreatePostPayload {
+  # A unique identifier for the client performing the mutation.
+  clientMutationId: String
+  post: Post
+}
+
+# Media objects
+union Media = Audio
+
+type Mutation {
+  # Create a blog post
+  createPost(input: CreatePostInput!): CreatePostPayload
+}
+
+interface Node {
+  id: ID!
+}
+
+# A blog post
+type Post {
+  id: ID!
+  title: String!
+  body: String!
+  comments: [Comment!]
+}
+
+# The query root of this schema
+type Query {
+  post(
+    # Post ID
+    id: ID!
+  ): Post
+}
+
+type Subscription {
+  post(id: ID!): Post
+}
+SCHEMA
+
+    except_filter = -> (member, ctx) {
+      ctx[:names].include?(member.name) || (member.respond_to?(:deprecation_reason) && member.deprecation_reason)
+    }
+
+    context = { names: ["Varied", "Image", "Sub"] }
+    assert_equal expected.chomp, schema.to_definition(context: context, except: except_filter)
+  end
 end

data/spec/graphql/schema/rescue_middleware_spec.rb

@@ -4,7 +4,7 @@ require "spec_helper"
 class SpecExampleError < StandardError; end
 
 describe GraphQL::Schema::RescueMiddleware do
-  let(:error_middleware) { ->(next_middleware) { raise(error_class) } }
+  let(:error_middleware) { ->{ raise(error_class) } }
 
   let(:rescue_middleware) do
     middleware = GraphQL::Schema::RescueMiddleware.new
@@ -14,12 +14,12 @@ describe GraphQL::Schema::RescueMiddleware do
 
   let(:steps) { [rescue_middleware, error_middleware] }
 
-  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps, arguments: [])}
+  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps) }
 
   describe "known errors" do
     let(:error_class) { SpecExampleError }
     it "handles them as execution errors" do
-      result = middleware_chain.call
+      result = middleware_chain.invoke([])
       assert_equal("there was an example error: SpecExampleError", result.message)
       assert_equal(GraphQL::ExecutionError, result.class)
     end
@@ -28,7 +28,7 @@ describe GraphQL::Schema::RescueMiddleware do
   describe "unknown errors" do
     let(:error_class) { RuntimeError }
     it "re-raises them" do
-      assert_raises(RuntimeError) { middleware_chain.call }
+      assert_raises(RuntimeError) { middleware_chain.invoke([]) }
     end
   end
 end

data/spec/graphql/schema/warden_spec.rb

@@ -109,7 +109,11 @@ module MaskHelpers
   end
 
   def self.query_with_mask(str, mask, variables: {})
-    Schema.execute(str, except: mask, root_value: Data, variables: variables)
+    run_query(str, except: mask, root_value: Data, variables: variables)
+  end
+
+  def self.run_query(str, options = {})
+    Schema.execute(str, options.merge(root_value: Data))
   end
 end
 
@@ -149,7 +153,7 @@ describe GraphQL::Schema::Warden do
 
   describe "hiding fields" do
     let(:mask) {
-      -> (member) { member.metadata[:hidden_field] || member.metadata[:hidden_type] }
+      -> (member, ctx) { member.metadata[:hidden_field] || member.metadata[:hidden_type] }
     }
 
     it "causes validation errors" do
@@ -194,8 +198,8 @@ describe GraphQL::Schema::Warden do
   end
 
   describe "hiding types" do
-    let(:mask) {
-      -> (member) { member.metadata[:hidden_type] }
+    let(:whitelist) {
+      -> (member, ctx) { !member.metadata[:hidden_type] }
     }
 
     it "hides types from introspection" do
@@ -227,7 +231,7 @@ describe GraphQL::Schema::Warden do
       }
       |
 
-      res = MaskHelpers.query_with_mask(query_string, mask)
+      res = MaskHelpers.run_query(query_string, only: whitelist)
 
       # It's not visible by name
       assert_equal nil, res["data"]["Phoneme"]
@@ -258,7 +262,7 @@ describe GraphQL::Schema::Warden do
       }
       |
 
-      res = MaskHelpers.query_with_mask(query_string, mask)
+      res = MaskHelpers.run_query(query_string, only: whitelist)
 
       expected_errors = [
         "No such type Phoneme, so it can't be a fragment condition",
@@ -275,13 +279,13 @@ describe GraphQL::Schema::Warden do
       |
 
       assert_raises(GraphQL::UnresolvedTypeError) {
-        MaskHelpers.query_with_mask(query_string, mask)
+        MaskHelpers.run_query(query_string, only: whitelist)
       }
     end
 
     describe "hiding an abstract type" do
       let(:mask) {
-        -> (member) { member.metadata[:hidden_abstract_type] }
+        -> (member, ctx) { member.metadata[:hidden_abstract_type] }
       }
 
       it "isn't present in a type's interfaces" do
@@ -303,7 +307,7 @@ describe GraphQL::Schema::Warden do
 
   describe "hiding arguments" do
     let(:mask) {
-      -> (member) { member.metadata[:hidden_argument] || member.metadata[:hidden_input_type] }
+      -> (member, ctx) { member.metadata[:hidden_argument] || member.metadata[:hidden_input_type] }
     }
 
     it "isn't present in introspection" do
@@ -339,7 +343,7 @@ describe GraphQL::Schema::Warden do
 
   describe "hidding input type arguments" do
     let(:mask) {
-      -> (member) { member.metadata[:hidden_input_field] }
+      -> (member, ctx) { member.metadata[:hidden_input_field] }
     }
 
     it "isn't present in introspection" do
@@ -388,7 +392,7 @@ describe GraphQL::Schema::Warden do
 
   describe "hidding input types" do
     let(:mask) {
-      -> (member) { member.metadata[:hidden_input_object_type] }
+      -> (member, ctx) { member.metadata[:hidden_input_object_type] }
     }
 
     it "isn't present in introspection" do
@@ -433,7 +437,7 @@ describe GraphQL::Schema::Warden do
 
   describe "hiding enum values" do
     let(:mask) {
-      -> (member) { member.metadata[:hidden_enum_value] }
+      -> (member, ctx) { member.metadata[:hidden_enum_value] }
     }
 
     it "isn't present in introspection" do

data/spec/graphql/schema_spec.rb

@@ -17,6 +17,12 @@ describe GraphQL::Schema do
     end
   end
 
+  describe "#to_definition" do
+    it "prints out the schema definition" do
+      assert_equal schema.to_definition, GraphQL::Schema::Printer.print_schema(schema)
+    end
+  end
+
   describe "#subscription" do
     it "calls fields on the subscription type" do
       res = schema.execute("subscription { test }")
@@ -308,6 +314,9 @@ type Query {
 
       refute schema_2.middleware.equal?(schema.middleware)
       assert_equal schema_2.middleware, schema.middleware
+
+      schema_2.middleware << ->(*args) { :noop }
+      refute_equal schema_2.middleware, schema.middleware
     end
   end
 end

data/spec/graphql/string_type_spec.rb

@@ -2,15 +2,21 @@
 require "spec_helper"
 
 describe GraphQL::STRING_TYPE do
+  let(:string_type) { GraphQL::STRING_TYPE }
+
+  it "is a default scalar" do
+    assert_equal(true, string_type.default_scalar?)
+  end
+
   describe "coerce_input" do
     it "accepts strings" do
-      assert_equal "str", GraphQL::STRING_TYPE.coerce_input("str")
+      assert_equal "str", string_type.coerce_input("str")
     end
 
     it "doesn't accept other types" do
-      assert_equal nil, GraphQL::STRING_TYPE.coerce_input(100)
-      assert_equal nil, GraphQL::STRING_TYPE.coerce_input(true)
-      assert_equal nil, GraphQL::STRING_TYPE.coerce_input(0.999)
+      assert_equal nil, string_type.coerce_input(100)
+      assert_equal nil, string_type.coerce_input(true)
+      assert_equal nil, string_type.coerce_input(0.999)
     end
   end
 end