graphql 0.19.3 → 0.19.4

data/spec/graphql/language/generation_spec.rb

@@ -41,74 +41,158 @@ describe GraphQL::Language::Generation do
     end
 
     describe "schema" do
-      # From: https://github.com/graphql/graphql-js/blob/a725499b155285c2e33647a93393c82689b20b0f/src/language/__tests__/schema-kitchen-sink.graphql
-      let(:query_string) {<<-schema
-        schema {
-          query: QueryType
-          mutation: MutationType
+      describe "schema with convention names for root types" do
+        let(:query_string) {<<-schema
+          schema {
+            query: Query
+            mutation: Mutation
+            subscription: Subscription
+          }
+        schema
         }
 
-        type Foo implements Bar {
-          one: Type
-          two(argument: InputType!): Type
-          three(argument: InputType, other: String): Int
-          four(argument: String = "string"): String
-          five(argument: [String] = ["string", "string"]): String
-          six(argument: InputType = {key: "value"}): Type
-        }
+        it 'omits schema definition' do
+          refute document.to_query_string =~ /schema/
+        end
+      end
 
-        type AnnotatedObject @onObject(arg: "value") {
-          annotatedField(arg: Type = "default" @onArg): Type @onField
+      describe "schema with custom query root name" do
+        let(:query_string) {<<-schema
+          schema {
+            query: MyQuery
+            mutation: Mutation
+            subscription: Subscription
+          }
+        schema
         }
 
-        interface Bar {
-          one: Type
-          four(argument: String = "string"): String
-        }
+        it 'includes schema definition' do
+          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
+        end
+      end
 
-        interface AnnotatedInterface @onInterface {
-          annotatedField(arg: Type @onArg): Type @onField
+      describe "schema with custom mutation root name" do
+        let(:query_string) {<<-schema
+          schema {
+            query: Query
+            mutation: MyMutation
+            subscription: Subscription
+          }
+        schema
         }
 
-        union Feed = Story | Article | Advert
-
-        union AnnotatedUnion @onUnion = A | B
-
-        scalar CustomScalar
-
-        scalar AnnotatedScalar @onScalar
-
-        enum Site {
-          DESKTOP
-          MOBILE
-        }
+        it 'includes schema definition' do
+          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
+        end
+      end
 
-        enum AnnotatedEnum @onEnum {
-          ANNOTATED_VALUE @onEnumValue
-          OTHER_VALUE
+      describe "schema with custom subscription root name" do
+        let(:query_string) {<<-schema
+          schema {
+            query: Query
+            mutation: Mutation
+            subscription: MySubscription
+          }
+        schema
         }
 
-        input InputType {
-          key: String!
-          answer: Int = 42
-        }
+        it 'includes schema definition' do
+          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
+        end
+      end
 
-        input AnnotatedInput @onInputObjectType {
-          annotatedField: Type @onField
+      describe "full featured schema" do
+        # From: https://github.com/graphql/graphql-js/blob/a725499b155285c2e33647a93393c82689b20b0f/src/language/__tests__/schema-kitchen-sink.graphql
+        let(:query_string) {<<-schema
+          schema {
+            query: QueryType
+            mutation: MutationType
+          }
+
+          # Union description
+          union AnnotatedUnion @onUnion = A | B
+
+          type Foo implements Bar {
+            one: Type
+            two(argument: InputType!): Type
+            three(argument: InputType, other: String): Int
+            four(argument: String = "string"): String
+            five(argument: [String] = ["string", "string"]): String
+            six(argument: InputType = {key: "value"}): Type
+          }
+
+          # Scalar description
+          scalar CustomScalar
+
+          type AnnotatedObject @onObject(arg: "value") {
+            annotatedField(arg: Type = "default" @onArg): Type @onField
+          }
+
+          interface Bar {
+            one: Type
+            four(argument: String = "string"): String
+          }
+
+          # Enum description
+          enum Site {
+            # Enum value description
+            DESKTOP
+            MOBILE
+          }
+
+          interface AnnotatedInterface @onInterface {
+            annotatedField(arg: Type @onArg): Type @onField
+          }
+
+          union Feed = Story | Article | Advert
+
+          # Input description
+          input InputType {
+            key: String!
+            answer: Int = 42
+          }
+
+          union AnnotatedUnion @onUnion = A | B
+
+          scalar CustomScalar
+
+          # Directive description
+          directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+          scalar AnnotatedScalar @onScalar
+
+          enum Site {
+            DESKTOP
+            MOBILE
+          }
+
+          enum AnnotatedEnum @onEnum {
+            ANNOTATED_VALUE @onEnumValue
+            OTHER_VALUE
+          }
+
+          input InputType {
+            key: String!
+            answer: Int = 42
+          }
+
+          input AnnotatedInput @onInputObjectType {
+            annotatedField: Type @onField
+          }
+
+          directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+          directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+        schema
         }
 
-        directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-
-        directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-      schema
-      }
-
-      it "generate" do
-        assert_equal query_string.gsub(/^        /, "").strip, document.to_query_string
-      end
+        it "generate" do
+          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
+        end
 
-      it "doesn't mutate the document" do
-        assert_equal document.to_query_string, document.to_query_string
+        it "doesn't mutate the document" do
+          assert_equal document.to_query_string, document.to_query_string
+        end
       end
     end
   end

data/spec/graphql/language/lexer_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe GraphQL::Language::Lexer do
+  subject { GraphQL::Language::Lexer }
+
+  describe ".tokenize" do
+    let(:query_string) {%|
+      {
+        query getCheese {
+          cheese(id: 1) {
+            ... cheeseFields
+          }
+        }
+      }
+    |}
+    let(:tokens) { subject.tokenize(query_string) }
+
+    it "keeps track of previous_token" do
+      assert_equal tokens[0], tokens[1].prev_token
+    end
+  end
+end

data/spec/graphql/language/visitor_spec.rb

@@ -19,13 +19,13 @@ describe GraphQL::Language::Visitor do
 
   let(:visitor) do
     v = GraphQL::Language::Visitor.new(document)
-    v[GraphQL::Language::Nodes::Field] << -> (node, parent) { counts[:fields_entered] += 1 }
+    v[GraphQL::Language::Nodes::Field] << ->(node, parent) { counts[:fields_entered] += 1 }
     # two ways to set up enter hooks:
-    v[GraphQL::Language::Nodes::Argument] <<       -> (node, parent) { counts[:argument_names] << node.name }
-    v[GraphQL::Language::Nodes::Argument].enter << -> (node, parent) { counts[:arguments_entered] += 1}
-    v[GraphQL::Language::Nodes::Argument].leave << -> (node, parent) { counts[:arguments_left] += 1 }
+    v[GraphQL::Language::Nodes::Argument] <<       ->(node, parent) { counts[:argument_names] << node.name }
+    v[GraphQL::Language::Nodes::Argument].enter << ->(node, parent) { counts[:arguments_entered] += 1}
+    v[GraphQL::Language::Nodes::Argument].leave << ->(node, parent) { counts[:arguments_left] += 1 }
 
-    v[GraphQL::Language::Nodes::Document].leave << -> (node, parent) { counts[:finished] = true }
+    v[GraphQL::Language::Nodes::Document].leave << ->(node, parent) { counts[:finished] = true }
     v
   end
 
@@ -41,7 +41,7 @@ describe GraphQL::Language::Visitor do
 
   describe "Visitor::SKIP" do
     it "skips the rest of the node" do
-      visitor[GraphQL::Language::Nodes::Document] << -> (node, parent) { GraphQL::Language::Visitor::SKIP }
+      visitor[GraphQL::Language::Nodes::Document] << ->(node, parent) { GraphQL::Language::Visitor::SKIP }
       visitor.visit
       assert_equal(0, counts[:fields_entered])
     end

data/spec/graphql/query/arguments_spec.rb

@@ -45,6 +45,37 @@ describe GraphQL::Query::Arguments do
     assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
   end
 
+  it "yields key, value, and arg_defnition" do
+    type_info = []
+    arguments.each_value do |arg_value|
+      value = arg_value.value.is_a?(GraphQL::Query::Arguments) ? arg_value.value.to_h : arg_value.value
+      type_info << [arg_value.key, value, arg_value.definition.type.unwrap.name]
+    end
+    expected_type_info =[
+      ["a", 1, "Int"],
+      ["b", 2, "Int"],
+      ["c", { d: 3, e: 4 }, "TestInput1"],
+    ]
+    assert_equal expected_type_info, type_info
+  end
+
+  it "can be copied to a new Arguments instance" do
+    transformed_args = {}
+    types = {}
+    arguments.each_value do |arg_value|
+      transformed_args[arg_value.key.upcase] = arg_value.value
+      types[arg_value.key.upcase] = arg_value.definition
+    end
+
+    new_arguments = GraphQL::Query::Arguments.new(transformed_args, argument_definitions: types)
+    expected_hash = {
+      "A" => 1,
+      "B" => 2,
+      "C" => { d: 3 , e: 4 },
+    }
+    assert_equal expected_hash, new_arguments.to_h
+  end
+
   describe "nested hashes" do
     let(:input_type) {
       test_input_type = GraphQL::InputObjectType.define do
@@ -64,6 +95,19 @@ describe GraphQL::Query::Arguments do
     end
   end
 
+  describe "#[]" do
+    it "returns the value at that key" do
+      assert_equal 1, arguments["a"]
+      assert_equal 1, arguments[:a]
+      assert arguments["c"].is_a?(GraphQL::Query::Arguments)
+    end
+
+    it "returns nil for missing keys" do
+      assert_equal nil, arguments["z"]
+      assert_equal nil, arguments[7]
+    end
+  end
+
   describe "#key?" do
     let(:arg_values) { [] }
     let(:schema) {
@@ -84,7 +128,7 @@ describe GraphQL::Query::Arguments do
           argument :b, types.Int, default_value: 2
           argument :c, types.Int
           argument :d, test_input_type
-          resolve -> (obj, args, ctx) {
+          resolve ->(obj, args, ctx) {
             arg_values_array << args
             1
           }

data/spec/graphql/query/context_spec.rb

@@ -5,16 +5,16 @@ describe GraphQL::Query::Context do
     name "Query"
     field :context, types.String do
       argument :key, !types.String
-      resolve -> (target, args, ctx) { ctx[args[:key]] }
+      resolve ->(target, args, ctx) { ctx[args[:key]] }
     end
     field :contextAstNodeName, types.String do
-      resolve -> (target, args, ctx) { ctx.ast_node.class.name }
+      resolve ->(target, args, ctx) { ctx.ast_node.class.name }
     end
     field :contextIrepNodeName, types.String do
-      resolve -> (target, args, ctx) { ctx.irep_node.class.name }
+      resolve ->(target, args, ctx) { ctx.irep_node.class.name }
     end
     field :queryName, types.String do
-      resolve -> (target, args, ctx) { ctx.query.class.name }
+      resolve ->(target, args, ctx) { ctx.query.class.name }
     end
   }}
   let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}

data/spec/graphql/query/executor_spec.rb

@@ -77,7 +77,7 @@ describe GraphQL::Query::Executor do
         name "Query"
         field :dairy do
           type DairyType
-          resolve -> (t, a, c) {
+          resolve ->(t, a, c) {
             raise if resolved
             resolved = true
             DAIRY

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -46,7 +46,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
     GraphQL::Schema.define do
       query(query_root)
       orphan_types [some_object]
-      resolve_type -> (obj, ctx) do
+      resolve_type ->(obj, ctx) do
         if obj.is_a?(OtherObject)
           other_object
         else

data/spec/graphql/relay/mutation_spec.rb

@@ -22,7 +22,7 @@ describe GraphQL::Relay::Mutation do
 
   after do
     STAR_WARS_DATA["Ship"].delete("9")
-    STAR_WARS_DATA["Faction"]["1"]["ships"].delete("9")
+    STAR_WARS_DATA["Faction"]["1"].ships.delete("9")
   end
 
   it "returns the result & clientMutationId" do
@@ -72,7 +72,7 @@ describe GraphQL::Relay::Mutation do
       GraphQL::Relay::Mutation.define do
         name "CustomReturnTypeTest"
         return_type custom_type
-        resolve -> (input, ctx) {
+        resolve ->(input, ctx) {
           OpenStruct.new(name: "Custom Return Type Test")
         }
       end

data/spec/graphql/relay/node_spec.rb

@@ -11,11 +11,11 @@ describe GraphQL::Relay::Node do
         @previous_id_from_object_proc = StarWarsSchema.id_from_object_proc
         @previous_object_from_id_proc = StarWarsSchema.object_from_id_proc
 
-        StarWarsSchema.id_from_object = -> (obj, type_name, ctx) {
+        StarWarsSchema.id_from_object = ->(obj, type_name, ctx) {
           "#{type_name}/#{obj.id}"
         }
 
-        StarWarsSchema.object_from_id = -> (global_id, ctx) {
+        StarWarsSchema.object_from_id = ->(global_id, ctx) {
           type_name, id = global_id.split("/")
           STAR_WARS_DATA[type_name][id]
         }

data/spec/graphql/relay/relation_connection_spec.rb

@@ -345,4 +345,20 @@ describe GraphQL::Relay::RelationConnection do
       end
     end
   end
+
+  describe "#cursor_from_node" do
+    let(:connection) { GraphQL::Relay::RelationConnection.new(Base.where(faction_id: 1), {}) }
+
+    it "returns the cursor for a node in the connection" do
+      assert_equal "MQ==", connection.cursor_from_node(Base.all[0])
+      assert_equal "Mg==", connection.cursor_from_node(Base.all[1])
+    end
+
+    it "raises when the node isn't found" do
+      err = assert_raises(RuntimeError) {
+        connection.cursor_from_node(:not_found)
+      }
+      assert_includes err.message, "item not found"
+    end
+  end
 end

data/spec/graphql/schema/loader_spec.rb

@@ -22,8 +22,8 @@ describe GraphQL::Schema::Loader do
 
     big_int_type = GraphQL::ScalarType.define do
       name "BigInt"
-      coerce_input -> (value) { value =~ /\d+/ ? Integer(value) : nil }
-      coerce_result -> (value) { value.to_s }
+      coerce_input ->(value) { value =~ /\d+/ ? Integer(value) : nil }
+      coerce_result ->(value) { value.to_s }
     end
 
     variant_input_type = GraphQL::InputObjectType.define do

data/spec/graphql/schema/middleware_chain_spec.rb

@@ -1,9 +1,9 @@
 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] }
@@ -20,7 +20,7 @@ describe GraphQL::Schema::MiddlewareChain do
     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)
@@ -30,8 +30,8 @@ describe GraphQL::Schema::MiddlewareChain do
 
     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