graphql 1.7.6 → 1.7.7

data/spec/graphql/execution/multiplex_spec.rb

@@ -126,7 +126,7 @@ describe GraphQL::Execution::Multiplex do
         "before multiplex 1",
         "before multiplex 2",
         "before Q1", "before Q2", "before Q3",
-        "after Q1", "after Q2", "after Q3",
+        "after Q3", "after Q2", "after Q1",
         "after multiplex 2",
         "after multiplex 1",
       ], checks

data/spec/graphql/float_type_spec.rb

@@ -9,8 +9,8 @@ describe GraphQL::FLOAT_TYPE do
     end
 
     it "rejects other types" do
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
+      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
+      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/id_type_spec.rb

@@ -26,7 +26,7 @@ describe GraphQL::ID_TYPE do
     let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
 
     it "doesn't allow other types" do
-      assert_equal nil, result["data"]
+      assert_nil result["data"]
       assert_equal 1, result["errors"].length
     end
   end

data/spec/graphql/input_object_type_spec.rb

@@ -251,7 +251,7 @@ describe GraphQL::InputObjectType do
       assert_equal 'Test', result['a']
 
       assert result.key?('b')
-      assert_equal nil, result['b']
+      assert_nil result['b']
 
       assert_equal "Test", result['c']
     end
@@ -264,7 +264,7 @@ describe GraphQL::InputObjectType do
       assert_equal 1, result['b']
 
       assert result.key?('c')
-      assert_equal nil, result['c']
+      assert_nil result['c']
     end
 
     it "omitted arguments are not returned" do

data/spec/graphql/int_type_spec.rb

@@ -9,8 +9,8 @@ describe GraphQL::INT_TYPE do
     end
 
     it "rejects other types" do
-      assert_equal nil, GraphQL::INT_TYPE.coerce_isolated_input("55")
-      assert_equal nil, GraphQL::INT_TYPE.coerce_isolated_input(true)
+      assert_nil GraphQL::INT_TYPE.coerce_isolated_input("55")
+      assert_nil GraphQL::INT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -110,7 +110,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
 
     it "groups selections by object types which they apply to" do
       doc = rewrite_result.operation_definitions["getPlant"]
-      assert_equal nil, doc.definition
+      assert_nil doc.definition
 
       plant_scoped_selection = doc.scoped_children[schema.types["Query"]]["plant"]
       assert_equal ["Fruit", "Nut", "Plant"], plant_scoped_selection.scoped_children.keys.map(&:name).sort
@@ -132,7 +132,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
 
     it "tracks parent nodes" do
       doc = rewrite_result.operation_definitions["getPlant"]
-      assert_equal nil, doc.parent
+      assert_nil doc.parent
 
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
       assert_equal doc, plant_selection.parent

data/spec/graphql/introspection/schema_type_spec.rb

@@ -37,6 +37,7 @@ describe GraphQL::Introspection::SchemaType do
             {"name"=>"milk"},
             {"name"=>"root"},
             {"name"=>"searchDairy"},
+            {"name"=>"tracingScalar"},
             {"name"=>"valueWithExecutionError"},
           ]
         },

data/spec/graphql/language/document_from_schema_definition_spec.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Language::DocumentFromSchemaDefinition do
+  let(:schema_idl) { <<-GRAPHQL
+    type QueryType {
+      foo: Foo
+    }
+
+    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: String): Type
+    }
+
+    interface Bar {
+      one: Type
+      four(argument: String = "string"): String
+    }
+
+    type Type {
+      a: String
+    }
+
+    input InputType {
+      key: String!
+      answer: Int = 42
+    }
+
+    type MutationType {
+      a(input: InputType): String
+    }
+
+    # Scalar description
+    scalar CustomScalar
+
+    enum Site {
+      DESKTOP
+      MOBILE
+    }
+
+    union Union = Type | QueryType
+
+    schema {
+      query: QueryType
+      mutation: MutationType
+    }
+  GRAPHQL
+  }
+
+  let(:expected_complete_idl) { <<-GRAPHQL
+    # Represents `true` or `false` values.
+    scalar Boolean
+
+    # Represents textual data as UTF-8 character sequences. This type is most often
+    # used by GraphQL to represent free-form human-readable text.
+    scalar String
+
+    # The fundamental unit of any GraphQL Schema is the type. There are many kinds of
+    # types in GraphQL as represented by the `__TypeKind` enum.
+    #
+    # Depending on the kind of a type, certain fields describe information about that
+    # type. Scalar types provide no information beyond a name and description, while
+    # Enum types provide their values. Object and Interface types provide the fields
+    # they describe. Abstract types, Union and Interface, provide the Object types
+    # possible at runtime. List and NonNull types compose other types.
+    type __Type {
+      kind: __TypeKind!
+      name: String
+      description: String
+      fields(includeDeprecated: Boolean = false): [__Field!]
+      interfaces: [__Type!]
+      possibleTypes: [__Type!]
+      enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+      inputFields: [__InputValue!]
+      ofType: __Type
+    }
+
+    # An enum describing what kind of type a given `__Type` is.
+    enum __TypeKind {
+      # Indicates this type is a scalar.
+      SCALAR
+
+      # Indicates this type is an object. `fields` and `interfaces` are valid fields.
+      OBJECT
+
+      # Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.
+      INTERFACE
+
+      # Indicates this type is a union. `possibleTypes` is a valid field.
+      UNION
+
+      # Indicates this type is an enum. `enumValues` is a valid field.
+      ENUM
+
+      # Indicates this type is an input object. `inputFields` is a valid field.
+      INPUT_OBJECT
+
+      # Indicates this type is a list. `ofType` is a valid field.
+      LIST
+
+      # Indicates this type is a non-null. `ofType` is a valid field.
+      NON_NULL
+    }
+
+    # Object and Interface types are described by a list of Fields, each of which has
+    # a name, potentially a list of arguments, and a return type.
+    type __Field {
+      name: String!
+      description: String
+      args: [__InputValue!]!
+      type: __Type!
+      isDeprecated: Boolean!
+      deprecationReason: String
+    }
+
+    # Arguments provided to Fields or Directives and the input fields of an
+    # InputObject are represented as Input Values which describe their type and
+    # optionally a default value.
+    type __InputValue {
+      name: String!
+      description: String
+      type: __Type!
+
+      # A GraphQL-formatted string representing the default value for this input value.
+      defaultValue: String
+    }
+
+    # One possible value for a given Enum. Enum values are unique values, not a
+    # placeholder for a string or numeric value. However an Enum value is returned in
+    # a JSON response as a string.
+    type __EnumValue {
+      name: String!
+      description: String
+      isDeprecated: Boolean!
+      deprecationReason: String
+    }
+
+    type QueryType {
+      foo: Foo
+    }
+
+    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: String): Type
+    }
+
+    interface Bar {
+      one: Type
+      four(argument: String = "string"): String
+    }
+
+    type Type {
+      a: String
+    }
+
+    input InputType {
+      key: String!
+      answer: Int = 42
+    }
+
+    # Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+    scalar Int
+
+    type MutationType {
+      a(input: InputType): String
+    }
+
+    # A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all
+    # available types and directives on the server, as well as the entry points for
+    # query, mutation, and subscription operations.
+    type __Schema {
+      # A list of all types supported by this server.
+      types: [__Type!]!
+
+      # The type that query operations will be rooted at.
+      queryType: __Type!
+
+      # If this server supports mutation, the type that mutation operations will be rooted at.
+      mutationType: __Type
+
+      # If this server support subscription, the type that subscription operations will be rooted at.
+      subscriptionType: __Type
+
+      # A list of all directives supported by this server.
+      directives: [__Directive!]!
+    }
+
+    # A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
+    #
+    # In some cases, you need to provide options to alter GraphQL's execution behavior
+    # in ways field arguments will not suffice, such as conditionally including or
+    # skipping a field. Directives provide this by describing additional information
+    # to the executor.
+    type __Directive {
+      name: String!
+      description: String
+      locations: [__DirectiveLocation!]!
+      args: [__InputValue!]!
+      onOperation: Boolean!
+      onFragment: Boolean!
+      onField: Boolean!
+    }
+
+    # A Directive can be adjacent to many parts of the GraphQL language, a
+    # __DirectiveLocation describes one such possible adjacencies.
+    enum __DirectiveLocation {
+      # Location adjacent to a query operation.
+      QUERY
+
+      # Location adjacent to a mutation operation.
+      MUTATION
+
+      # Location adjacent to a subscription operation.
+      SUBSCRIPTION
+
+      # Location adjacent to a field.
+      FIELD
+
+      # Location adjacent to a fragment definition.
+      FRAGMENT_DEFINITION
+
+      # Location adjacent to a fragment spread.
+      FRAGMENT_SPREAD
+
+      # Location adjacent to an inline fragment.
+      INLINE_FRAGMENT
+
+      # Location adjacent to a schema definition.
+      SCHEMA
+
+      # Location adjacent to a scalar definition.
+      SCALAR
+
+      # Location adjacent to an object type definition.
+      OBJECT
+
+      # Location adjacent to a field definition.
+      FIELD_DEFINITION
+
+      # Location adjacent to an argument definition.
+      ARGUMENT_DEFINITION
+
+      # Location adjacent to an interface definition.
+      INTERFACE
+
+      # Location adjacent to a union definition.
+      UNION
+
+      # Location adjacent to an enum definition.
+      ENUM
+
+      # Location adjacent to an enum value definition.
+      ENUM_VALUE
+
+      # Location adjacent to an input object type definition.
+      INPUT_OBJECT
+
+      # Location adjacent to an input object field definition.
+      INPUT_FIELD_DEFINITION
+    }
+
+    # Represents signed double-precision fractional values as specified by [IEEE
+    # 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
+    scalar Float
+
+    # Represents a unique identifier that is Base64 obfuscated. It is often used to
+    # refetch an object or as key for a cache. The ID type appears in a JSON response
+    # as a String; however, it is not intended to be human-readable. When expected as
+    # an input type, any string (such as `"VXNlci0xMA=="`) or integer (such as `4`)
+    # input value will be accepted as an ID.
+    scalar ID
+
+    # Scalar description
+    scalar CustomScalar
+
+    enum Site {
+      DESKTOP
+      MOBILE
+    }
+
+    union Union = Type | QueryType
+
+    directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+    directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+    # Marks an element of a GraphQL schema as no longer supported.
+    directive @deprecated(reason: String = "No longer supported") on FIELD_DEFINITION | ENUM_VALUE
+
+    schema {
+      query: QueryType
+      mutation: MutationType
+    }
+  GRAPHQL
+  }
+
+  let(:subject) { GraphQL::Language::DocumentFromSchemaDefinition }
+
+  describe "#document" do
+    it "returns the document AST from the given schema" do
+      schema = GraphQL::Schema.from_definition(schema_idl)
+      document = subject.new(schema).document
+
+      expected_document = GraphQL.parse(expected_complete_idl)
+
+      assert equivalent_node?(expected_document, document)
+    end
+  end
+
+  private
+
+  def equivalent_node?(expected, node)
+    return false unless expected.is_a?(node.class)
+
+    if expected.respond_to?(:children) && expected.respond_to?(:scalars)
+      children_equal = node.children.all? do |child|
+        expected.children.find { |expected_child| equivalent_node?(expected_child, child) }
+      end
+
+      scalars_equal = node.children.all? do |child|
+        expected.children.find { |expected_child| equivalent_node?(expected_child, child) }
+      end
+
+      children_equal && scalars_equal
+    else
+      expected == node
+    end
+  end
+end

data/spec/graphql/language/lexer_spec.rb

@@ -40,7 +40,18 @@ describe GraphQL::Language::Lexer do
 
     it "clears the previous_token between runs" do
       tok_2 = subject.tokenize(query_string)
-      assert_equal nil, tok_2[0].prev_token
+      assert_nil tok_2[0].prev_token
+    end
+
+    it "counts string position properly" do
+      tokens = subject.tokenize('{ a(b: "c")}')
+      str_token = tokens[5]
+      assert_equal :STRING, str_token.name
+      assert_equal "c", str_token.value
+      assert_equal 8, str_token.col
+      assert_equal '(STRING "c" [1:8])', str_token.inspect
+      rparen_token = tokens[6]
+      assert_equal '(RPAREN ")" [1:10])', rparen_token.inspect
     end
   end
 end

data/spec/graphql/language/parser_spec.rb

@@ -16,7 +16,7 @@ describe GraphQL::Language::Parser do
 
     it "creates an anonymous fragment definition" do
       assert fragment.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-      assert_equal nil, fragment.name
+      assert_nil fragment.name
       assert_equal 1, fragment.selections.length
       assert_equal "NestedType", fragment.type.name
       assert_equal 1, fragment.directives.length