feat(Compatibility) introduce QueryParserSpec

Author: rmosolgo

Rakefile

@@ -20,7 +20,7 @@ task(default: [:test, :rubocop])
 
 desc "Use Racc & Ragel to regenerate parser.rb & lexer.rb from configuration files"
 task :build_parser do
-  `rm lib/graphql/language/parser.rb lib/graphql/language/lexer.rb `
+  `rm -f lib/graphql/language/parser.rb lib/graphql/language/lexer.rb `
   `racc lib/graphql/language/parser.y -o lib/graphql/language/parser.rb`
   `ragel -R lib/graphql/language/lexer.rl`
 end

lib/graphql.rb

@@ -82,3 +82,4 @@ def self.scan_with_ragel(query_string)
 require "graphql/version"
 require "graphql/relay"
 require "graphql/execution"
+require "graphql/compatibility"

lib/graphql/compatibility.rb

@@ -1,15 +1,3 @@
 require "graphql/compatibility/execution_spec"
-
-
-module GraphQL
-  # This module contains specifications for third-party GraphQL extensions.
-  # It's not loaded by default. To use any members of this module, add:
-  #
-  # ```
-  # require "graphql/compatibility"
-  # ```
-  #
-  # to your project.
-  module Compatibility
-  end
-end
+require "graphql/compatibility/query_parser_spec"
+require "graphql/compatibility/schema_parser_spec"

lib/graphql/compatibility/query_parser_spec.rb

@@ -0,0 +1,126 @@
+require "graphql/compatibility/query_parser_spec/query_assertions"
+require "graphql/compatibility/query_parser_spec/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 QueryParserSpec
+      # @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_empty_arguments
+            strings = [
+              "{ field { } }",
+              "{ field() }",
+            ]
+            strings.each do |query_str|
+              doc = parse(query_str)
+              field = doc.definitions.first.selections.first
+              assert_equal 0, field.arguments.length
+              assert_equal 0, field.selections.length
+            end
+          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_inputs
+            query_string = %|
+              {
+                field(
+                  int: 3,
+                  float: 4.7e-24,
+                  bool: false,
+                  string: "☀︎🏆\\n escaped \\" unicode \\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 escaped " unicode ¶ /|, 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

lib/graphql/compatibility/query_parser_spec/parse_error_specification.rb

@@ -0,0 +1,78 @@
+module GraphQL
+  module Compatibility
+    # Include me into a minitest class
+    # to add assertions about parse errors
+    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(25, 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} }")
+        assert_includes(err.message, char.inspect, "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

lib/graphql/compatibility/query_parser_spec/query_assertions.rb

@@ -0,0 +1,78 @@
+module GraphQL
+  module Compatibility
+    module QueryParserSpec
+      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