graphql 1.0.0 → 1.1.0

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -0,0 +1,117 @@
+require "graphql/compatibility/query_parser_specification/query_assertions"
+require "graphql/compatibility/query_parser_specification/parse_error_specification"
+
+module GraphQL
+  module Compatibility
+    # This asserts that a given parse function turns a string into
+    # the proper tree of {{GraphQL::Language::Nodes}}.
+    module QueryParserSpecification
+      # @yieldparam query_string [String] A query string to parse
+      # @yieldreturn [GraphQL::Language::Nodes::Document]
+      # @return [Class<Minitest::Test>] A test suite for this parse function
+      def self.build_suite(&block)
+        Class.new(Minitest::Test) do
+          include QueryAssertions
+          include ParseErrorSpecification
+
+          @@parse_fn = block
+
+          def parse(query_string)
+            @@parse_fn.call(query_string)
+          end
+
+          def test_it_parses_queries
+            document = parse(QUERY_STRING)
+            query = document.definitions.first
+            assert_valid_query(query)
+            assert_valid_fragment(document.definitions.last)
+            assert_valid_variable(query.variables.first)
+            field = query.selections.first
+            assert_valid_field(field)
+            assert_valid_variable_argument(field.arguments.first)
+            assert_valid_literal_argument(field.arguments.last)
+            assert_valid_directive(field.directives.first)
+            fragment_spread = query.selections[1].selections.last
+            assert_valid_fragment_spread(fragment_spread)
+            assert_valid_typed_inline_fragment(query.selections[2])
+            assert_valid_typeless_inline_fragment(query.selections[3])
+          end
+
+          def test_it_parses_unnamed_queries
+            document = parse("{ name, age, height }")
+            operation =  document.definitions.first
+            assert_equal 1, document.definitions.length
+            assert_equal "query", operation.operation_type
+            assert_equal nil, operation.name
+            assert_equal 3, operation.selections.length
+          end
+
+          def test_it_parses_the_introspection_query
+            parse(GraphQL::Introspection::INTROSPECTION_QUERY)
+          end
+
+          def test_it_parses_inputs
+            query_string = %|
+              {
+                field(
+                  int: 3,
+                  float: 4.7e-24,
+                  bool: false,
+                  string: "☀︎🏆\\n \\" \u00b6 /",
+                  enum: ENUM_NAME,
+                  array: [7, 8, 9]
+                  object: {a: [1,2,3], b: {c: "4"}}
+                  unicode_bom: "\xef\xbb\xbfquery"
+                  keywordEnum: on
+                )
+              }
+            |
+            document = parse(query_string)
+            inputs = document.definitions.first.selections.first.arguments
+            assert_equal 3, inputs[0].value, "Integers"
+            assert_equal 0.47e-23, inputs[1].value, "Floats"
+            assert_equal false, inputs[2].value, "Booleans"
+            assert_equal %|☀︎🏆\n " ¶ /|, inputs[3].value, "Strings"
+            assert_instance_of GraphQL::Language::Nodes::Enum, inputs[4].value
+            assert_equal "ENUM_NAME", inputs[4].value.name, "Enums"
+            assert_equal [7,8,9], inputs[5].value, "Lists"
+
+            obj = inputs[6].value
+            assert_equal "a", obj.arguments[0].name
+            assert_equal [1,2,3], obj.arguments[0].value
+            assert_equal "b", obj.arguments[1].name
+            assert_equal "c", obj.arguments[1].value.arguments[0].name
+            assert_equal "4", obj.arguments[1].value.arguments[0].value
+
+            assert_equal %|\xef\xbb\xbfquery|, inputs[7].value, "Unicode BOM"
+            assert_equal "on", inputs[8].value.name, "Enum value 'on'"
+          end
+        end
+      end
+
+      QUERY_STRING = %|
+            query getStuff($someVar: Int = 1, $anotherVar: [String!] ) @skip(if: false) {
+              myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
+
+              anotherField(someArg: [1,2,3]) {
+                nestedField
+                ... moreNestedFields @skip(if: true)
+              }
+
+              ... on OtherType @include(unless: false){
+                field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
+                anotherField
+              }
+
+              ... {
+                id
+              }
+            }
+
+            fragment moreNestedFields on NestedType @or(something: "ok") {
+              anotherNestedField @enum(directive: true)
+            }
+      |
+    end
+  end
+end

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -0,0 +1,81 @@
+module GraphQL
+  module Compatibility
+    module QueryParserSpecification
+      module ParseErrorSpecification
+        def assert_raises_parse_error(query_string)
+          assert_raises(GraphQL::ParseError) {
+            parse(query_string)
+          }
+        end
+
+        def test_it_includes_line_and_column
+          err = assert_raises_parse_error("
+            query getCoupons {
+              allCoupons: {data{id}}
+            }
+          ")
+
+          assert_includes(err.message, '{')
+          assert_equal(3, err.line)
+          assert_equal(27, err.col)
+        end
+
+        def test_it_rejects_unterminated_strings
+          assert_raises_parse_error('{ " }')
+          assert_raises_parse_error(%|{ "\n" }|)
+        end
+
+        def test_it_rejects_unexpected_ends
+          assert_raises_parse_error("query { stuff { thing }")
+        end
+
+        def assert_rejects_character(char)
+          err = assert_raises_parse_error("{ field#{char} }")
+          expected_char = char.inspect.gsub('"', '').downcase
+          msg_downcase = err.message.downcase
+          # Case-insensitive for UTF-8 printing
+          assert_includes(msg_downcase, expected_char, "The message includes the invalid character")
+        end
+
+        def test_it_rejects_invalid_characters
+          assert_rejects_character(";")
+          assert_rejects_character("\a")
+          assert_rejects_character("\xef")
+          assert_rejects_character("\v")
+          assert_rejects_character("\f")
+          assert_rejects_character("\xa0")
+        end
+
+        def test_it_rejects_bad_unicode
+          assert_raises_parse_error(%|{ field(arg:"\\x") }|)
+          assert_raises_parse_error(%|{ field(arg:"\\u1") }|)
+          assert_raises_parse_error(%|{ field(arg:"\\u0XX1") }|)
+          assert_raises_parse_error(%|{ field(arg:"\\uXXXX") }|)
+          assert_raises_parse_error(%|{ field(arg:"\\uFXXX") }|)
+          assert_raises_parse_error(%|{ field(arg:"\\uXXXF") }|)
+        end
+
+        def assert_empty_document(query_string)
+          doc = parse(query_string)
+          assert_equal 0, doc.definitions.length
+        end
+
+        def test_it_parses_blank_queries
+          assert_empty_document("")
+          assert_empty_document(" ")
+          assert_empty_document("\t \t")
+        end
+
+        def test_it_restricts_on
+          assert_raises_parse_error("{ ...on }")
+          assert_raises_parse_error("fragment on on Type { field }")
+        end
+
+        def test_it_rejects_null
+          err = assert_raises_parse_error("{ field(input: null) }")
+          assert_includes(err.message, "null")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/query_parser_specification/query_assertions.rb

@@ -0,0 +1,78 @@
+module GraphQL
+  module Compatibility
+    module QueryParserSpecification
+      module QueryAssertions
+        def assert_valid_query(query)
+          assert query.is_a?(GraphQL::Language::Nodes::OperationDefinition)
+          assert_equal "getStuff", query.name
+          assert_equal "query", query.operation_type
+          assert_equal 2, query.variables.length
+          assert_equal 4, query.selections.length
+          assert_equal 1, query.directives.length
+          assert_equal [2, 13], [query.line, query.col]
+        end
+
+        def assert_valid_fragment(fragment_def)
+          assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+          assert_equal "moreNestedFields", fragment_def.name
+          assert_equal 1, fragment_def.selections.length
+          assert_equal "NestedType", fragment_def.type.name
+          assert_equal 1, fragment_def.directives.length
+          assert_equal [20, 13], fragment_def.position
+        end
+
+        def assert_valid_variable(variable)
+          assert_equal "someVar", variable.name
+          assert_equal "Int", variable.type.name
+          assert_equal 1, variable.default_value
+          assert_equal [2, 28], variable.position
+        end
+
+        def assert_valid_field(field)
+          assert_equal "someField", field.name
+          assert_equal "myField", field.alias
+          assert_equal 2, field.directives.length
+          assert_equal 2, field.arguments.length
+          assert_equal 0, field.selections.length
+          assert_equal [3, 15], field.position
+        end
+
+        def assert_valid_literal_argument(argument)
+          assert_equal "ok", argument.name
+          assert_equal 1.4, argument.value
+        end
+
+        def assert_valid_variable_argument(argument)
+          assert_equal "someArg", argument.name
+          assert_equal "someVar", argument.value.name
+        end
+
+        def assert_valid_fragment_spread(fragment_spread)
+          assert_equal "moreNestedFields", fragment_spread.name
+          assert_equal 1, fragment_spread.directives.length
+          assert_equal [7, 17], fragment_spread.position
+        end
+
+        def assert_valid_directive(directive)
+          assert_equal "skip", directive.name
+          assert_equal "if", directive.arguments.first.name
+          assert_equal 1, directive.arguments.length
+          assert_equal [3, 62], directive.position
+        end
+
+        def assert_valid_typed_inline_fragment(inline_fragment)
+          assert_equal "OtherType", inline_fragment.type.name
+          assert_equal 2, inline_fragment.selections.length
+          assert_equal 1, inline_fragment.directives.length
+          assert_equal [10, 15], inline_fragment.position
+        end
+
+        def assert_valid_typeless_inline_fragment(inline_fragment)
+          assert_equal nil, inline_fragment.type
+          assert_equal 1, inline_fragment.selections.length
+          assert_equal 0, inline_fragment.directives.length
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -0,0 +1,239 @@
+module GraphQL
+  module Compatibility
+    # This asserts that a given parse function turns a string into
+    # the proper tree of {{GraphQL::Language::Nodes}}.
+    module SchemaParserSpecification
+      # @yieldparam query_string [String] A query string to parse
+      # @yieldreturn [GraphQL::Language::Nodes::Document]
+      # @return [Class<Minitest::Test>] A test suite for this parse function
+      def self.build_suite(&block)
+        Class.new(Minitest::Test) do
+          @@parse_fn = block
+
+          def parse(query_string)
+            @@parse_fn.call(query_string)
+          end
+
+          def test_it_parses_object_types
+            document = parse('
+              # This is what
+              # somebody said about something
+              type Comment implements Node @deprecated(reason: "No longer supported") {
+                id: ID!
+              }
+            ')
+
+            type = document.definitions.first
+            assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, type.class
+            assert_equal 'Comment', type.name
+            assert_equal "This is what\nsomebody said about something", type.description
+            assert_equal ['Node'], type.interfaces.map(&:name)
+            assert_equal ['id'], type.fields.map(&:name)
+            assert_equal [], type.fields[0].arguments
+            assert_equal 'ID', type.fields[0].type.of_type.name
+            assert_equal 1, type.directives.length
+
+            deprecated_directive = type.directives[0]
+            assert_equal 'deprecated', deprecated_directive.name
+            assert_equal 'reason', deprecated_directive.arguments[0].name
+            assert_equal 'No longer supported', deprecated_directive.arguments[0].value
+          end
+
+          def test_it_parses_scalars
+            document = parse('scalar DateTime')
+
+            type = document.definitions.first
+            assert_equal GraphQL::Language::Nodes::ScalarTypeDefinition, type.class
+            assert_equal 'DateTime', type.name
+          end
+
+          def test_it_parses_enum_types
+            document = parse('
+              enum DogCommand {
+                # Good dog
+                SIT
+                DOWN @deprecated(reason: "No longer supported")
+                HEEL
+              }
+            ')
+
+            type = document.definitions.first
+            assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, type.class
+            assert_equal 'DogCommand', type.name
+            assert_equal 3, type.values.length
+
+            assert_equal 'SIT', type.values[0].name
+            assert_equal [], type.values[0].directives
+            assert_equal "Good dog", type.values[0].description
+
+            assert_equal 'DOWN', type.values[1].name
+            assert_equal 1, type.values[1].directives.length
+            deprecated_directive = type.values[1].directives[0]
+            assert_equal 'deprecated', deprecated_directive.name
+            assert_equal 'reason', deprecated_directive.arguments[0].name
+            assert_equal 'No longer supported', deprecated_directive.arguments[0].value
+
+            assert_equal 'HEEL', type.values[2].name
+            assert_equal [], type.values[2].directives
+          end
+
+          def test_it_parses_input_types
+            document = parse('
+              input EmptyMutationInput {
+                clientMutationId: String
+              }
+            ')
+
+            type = document.definitions.first
+            assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, type.class
+            assert_equal 'EmptyMutationInput', type.name
+            assert_equal ['clientMutationId'], type.fields.map(&:name)
+            assert_equal 'String', type.fields[0].type.name
+            assert_equal nil, type.fields[0].default_value
+          end
+
+          def test_it_parses_directives
+            document = parse('
+              directive @include(if: Boolean!)
+                on FIELD
+                | FRAGMENT_SPREAD
+                | INLINE_FRAGMENT
+            ')
+
+            type = document.definitions.first
+            assert_equal GraphQL::Language::Nodes::DirectiveDefinition, type.class
+            assert_equal 'include', type.name
+
+            assert_equal 1, type.arguments.length
+            assert_equal 'if', type.arguments[0].name
+            assert_equal 'Boolean', type.arguments[0].type.of_type.name
+
+            assert_equal ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'], type.locations
+          end
+
+          def test_it_parses_field_arguments
+            document = parse('
+              type Mutation {
+                post(
+                  id: ID! @deprecated(reason: "Not used"),
+                  # This is what goes in the post
+                  data: String
+                ): Post
+              }
+            ')
+
+            field = document.definitions.first.fields.first
+            assert_equal ['id', 'data'], field.arguments.map(&:name)
+            id_arg = field.arguments[0]
+
+            deprecated_directive = id_arg.directives[0]
+            assert_equal 'deprecated', deprecated_directive.name
+            assert_equal 'reason', deprecated_directive.arguments[0].name
+            assert_equal 'Not used', deprecated_directive.arguments[0].value
+
+            data_arg = field.arguments[1]
+            assert_equal "data", data_arg.name
+            assert_equal "This is what goes in the post", data_arg.description
+          end
+
+          def test_it_parses_schema_definition
+            document = parse('
+              schema {
+                query: QueryRoot
+                mutation: MutationRoot
+                subscription: SubscriptionRoot
+              }
+            ')
+
+            schema = document.definitions.first
+            assert_equal 'QueryRoot', schema.query
+            assert_equal 'MutationRoot', schema.mutation
+            assert_equal 'SubscriptionRoot', schema.subscription
+          end
+
+          def test_it_parses_whole_definition_with_descriptions
+            document = parse(SCHEMA_DEFINITION_STRING)
+
+            assert_equal 6, document.definitions.size
+
+            schema_definition = document.definitions.shift
+            assert_equal GraphQL::Language::Nodes::SchemaDefinition, schema_definition.class
+
+            directive_definition = document.definitions.shift
+            assert_equal GraphQL::Language::Nodes::DirectiveDefinition, directive_definition.class
+            assert_equal 'This is a directive', directive_definition.description
+
+            enum_type_definition = document.definitions.shift
+            assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, enum_type_definition.class
+            assert_equal "Multiline comment\n\nWith an enum", enum_type_definition.description
+
+            assert_nil enum_type_definition.values[0].description
+            assert_equal 'Not a creative color', enum_type_definition.values[1].description
+
+            object_type_definition = document.definitions.shift
+            assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, object_type_definition.class
+            assert_equal 'Comment without preceding space', object_type_definition.description
+            assert_equal 'And a field to boot', object_type_definition.fields[0].description
+
+            input_object_type_definition = document.definitions.shift
+            assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, input_object_type_definition.class
+            assert_equal 'Comment for input object types', input_object_type_definition.description
+            assert_equal 'Color of the car', input_object_type_definition.fields[0].description
+
+            interface_type_definition = document.definitions.shift
+            assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, interface_type_definition.class
+            assert_equal 'Comment for interface definitions', interface_type_definition.description
+            assert_equal 'Amount of wheels', interface_type_definition.fields[0].description
+          end
+        end
+      end
+
+      SCHEMA_DEFINITION_STRING = %|
+        # Schema at beginning of file
+
+        schema {
+          query: Hello
+        }
+
+        # Comment between two definitions are omitted
+
+        # This is a directive
+        directive @foo(
+          # It has an argument
+          arg: Int
+        ) on FIELD
+
+        # Multiline comment
+        #
+        # With an enum
+        enum Color {
+          RED
+
+          # Not a creative color
+          GREEN
+          BLUE
+        }
+
+        #Comment without preceding space
+        type Hello {
+          # And a field to boot
+          str: String
+        }
+
+        # Comment for input object types
+        input Car {
+          # Color of the car
+          color: String!
+        }
+
+        # Comment for interface definitions
+        interface Vehicle {
+          # Amount of wheels
+          wheels: Int!
+        }
+
+        # Comment at the end of schema
+      |
+    end
+  end
+end