graphql 1.9.11 → 1.9.12

data/spec/graphql/language/equality_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Language::Nodes::AbstractNode do
-  describe ".eql?" do
-    let(:document1) { GraphQL::Language::Parser.parse(query_string1) }
-    let(:document2) { GraphQL::Language::Parser.parse(query_string2) }
-
-    describe "large identical document" do
-      let(:query_string1) {%|
-        query getStuff($someVar: Int = 1, $anotherVar: [String!], $skipNested: Boolean! = false) @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: $skipNested)
-          }
-          ... on OtherType @include(unless: false) {
-            field(arg: [{ key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER }])
-            anotherField
-          }
-          ... {
-            id
-          }
-        }
-
-        fragment moreNestedFields on NestedType @or(something: "ok") {
-          anotherNestedField
-        }
-      |}
-      let(:query_string2) { query_string1 }
-
-      it "should be equal" do
-        assert document1.eql?(document2)
-        assert document2.eql?(document1)
-      end
-    end
-
-    describe "different operations" do
-      let(:query_string1) { "query { field }" }
-      let(:query_string2) { "mutation { setField }" }
-
-      it "should not be equal" do
-        refute document1.eql?(document2)
-        refute document2.eql?(document1)
-      end
-    end
-
-    describe "different query fields" do
-      let(:query_string1) { "query { foo }" }
-      let(:query_string2) { "query { bar }" }
-
-      it "should not be equal" do
-        refute document1.eql?(document2)
-        refute document2.eql?(document1)
-      end
-    end
-
-    describe "different schemas" do
-      let(:query_string1) {%|
-        schema {
-          query: Query
-        }
-
-        type Query {
-          field: String!
-        }
-      |}
-      let(:query_string2) {%|
-        schema {
-          query: Query
-        }
-
-        type Query {
-          field: Int!
-        }
-      |}
-
-      it "should not be equal" do
-        refute document1.eql?(document2)
-        refute document2.eql?(document1)
-      end
-    end
-  end
-end

data/spec/graphql/language/generation_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Language::Generation do
-  describe "#to_query_tring" do
-    let(:document) {
-      GraphQL.parse('type Query { a: String! }')
-    }
-
-    let(:custom_printer_class) {
-      Class.new(GraphQL::Language::Printer) {
-        def print_field_definition(print_field_definition)
-          "<Field Hidden>"
-        end
-      }
-    }
-
-    it "accepts a custom printer" do
-      expected = <<-SCHEMA
-type Query {
-  a: String!
-}
-      SCHEMA
-
-      assert_equal expected.chomp, GraphQL::Language::Generation.generate(document)
-    end
-
-    it "accepts a custom printer" do
-      expected = <<-SCHEMA
-type Query {
-  <Field Hidden>
-}
-      SCHEMA
-
-      assert_equal expected.chomp, GraphQL::Language::Generation.generate(document, printer: custom_printer_class.new)
-    end
-  end
-end

data/spec/graphql/language/lexer_spec.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-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 "makes utf-8 comments" do
-      tokens = subject.tokenize("# 不要!\n{")
-      comment_token = tokens.first.prev_token
-      assert_equal "# 不要!", comment_token.to_s
-    end
-
-    it "keeps track of previous_token" do
-      assert_equal tokens[0], tokens[1].prev_token
-    end
-
-    it "allows escaped quotes in strings" do
-      tokens = subject.tokenize('"a\\"b""c"')
-      assert_equal 'a"b', tokens[0].value
-      assert_equal 'c', tokens[1].value
-    end
-
-    describe "block strings" do
-      let(:query_string) { %|{ a(b: """\nc\n \\""" d\n""" """""e""""")}|}
-
-      it "tokenizes them" do
-        assert_equal "c\n \"\"\" d", tokens[5].value
-        assert_equal "\"\"e\"\"", tokens[6].value
-      end
-
-      it "tokenizes 10 quote edge case correctly" do
-        tokens = subject.tokenize('""""""""""')
-        assert_equal '""', tokens[0].value # first 8 quotes are a valid block string """"""""
-        assert_equal '', tokens[1].value # last 2 quotes are a valid string ""
-      end
-
-      it "tokenizes with nested single quote strings correctly" do
-        tokens = subject.tokenize('"""{"x"}"""')
-        assert_equal '{"x"}', tokens[0].value
-
-        tokens = subject.tokenize('"""{"foo":"bar"}"""')
-        assert_equal '{"foo":"bar"}', tokens[0].value
-      end
-
-      it "tokenizes empty block strings correctly" do
-        empty_block_string = '""""""'
-        tokens = subject.tokenize(empty_block_string)
-
-        assert_equal '', tokens[0].value
-      end
-    end
-
-    it "unescapes escaped characters" do
-      assert_equal "\" \\ / \b \f \n \r \t", subject.tokenize('"\\" \\\\ \\/ \\b \\f \\n \\r \\t"').first.to_s
-    end
-
-    it "unescapes escaped unicode characters" do
-      assert_equal "\t", subject.tokenize('"\\u0009"').first.to_s
-    end
-
-    it "rejects bad unicode, even when there's good unicode in the string" do
-      assert_equal :BAD_UNICODE_ESCAPE, subject.tokenize('"\\u0XXF \\u0009"').first.name
-    end
-
-    it "rejects truly invalid UTF-8 bytes" do
-      error_filename = "spec/support/parser/filename_example_invalid_utf8.graphql"
-      assert_equal :BAD_UNICODE_ESCAPE, subject.tokenize(File.read(error_filename)).first.name
-    end
-
-    it "rejects unicode that's well-formed but results in invalidly-encoded strings" do
-      # when the string here gets tokenized into an actual `:STRING`, it results in `valid_encoding?` being false for
-      # the ruby string so application code usually blows up trying to manipulate it
-      assert_equal :BAD_UNICODE_ESCAPE, subject.tokenize('"\\ud83c\\udf2c"').first.name
-    end
-
-    it "clears the previous_token between runs" do
-      tok_2 = subject.tokenize(query_string)
-      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:11])', rparen_token.inspect
-    end
-
-    it "counts block string line properly" do
-      str = <<-GRAPHQL
-      """
-      Here is a
-      multiline description
-      """
-      type Query {
-        a: B
-      }
-
-      "Here's another description"
-
-      type B {
-        a: B
-      }
-
-      """
-      And another
-      multiline description
-      """
-
-
-      type C {
-        a: B
-      }
-      GRAPHQL
-
-      tokens = subject.tokenize(str)
-
-      string_tok, type_keyword_tok, query_name_tok,
-        _curly, _ident, _colon, _ident, _curly,
-        string_tok_2, type_keyword_tok_2, b_name_tok,
-        _curly, _ident, _colon, _ident, _curly,
-        string_tok_3, type_keyword_tok_3, c_name_tok = tokens
-
-      assert_equal 1, string_tok.line
-      assert_equal 5, type_keyword_tok.line
-      assert_equal 5, query_name_tok.line
-
-      # Make sure it handles the empty spaces, too
-      assert_equal 9, string_tok_2.line
-      assert_equal 11, type_keyword_tok_2.line
-      assert_equal 11, b_name_tok.line
-
-      assert_equal 15, string_tok_3.line
-      assert_equal 21, type_keyword_tok_3.line
-      assert_equal 21, c_name_tok.line
-    end
-  end
-end

data/spec/graphql/language/nodes_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Language::Nodes::AbstractNode do
-  describe "#filename" do
-    it "is set after .parse_file" do
-      filename = "spec/support/parser/filename_example.graphql"
-      doc = GraphQL.parse_file(filename)
-      op = doc.definitions.first
-      field = op.selections.first
-      arg = field.arguments.first
-
-      assert_equal filename, doc.filename
-      assert_equal filename, op.filename
-      assert_equal filename, field.filename
-      assert_equal filename, arg.filename
-    end
-
-    it "is null when parse from string" do
-      doc = GraphQL.parse("{ thing }")
-      assert_nil doc.filename
-    end
-  end
-
-  describe "#to_query_tring" do
-    let(:document) {
-      GraphQL.parse('type Query { a: String! }')
-    }
-
-    let(:custom_printer_class) {
-      Class.new(GraphQL::Language::Printer) {
-        def print_field_definition(print_field_definition)
-          "<Field Hidden>"
-        end
-      }
-    }
-
-    it "accepts a custom printer" do
-      expected = <<-SCHEMA
-type Query {
-  <Field Hidden>
-}
-      SCHEMA
-      assert_equal expected.chomp, document.to_query_string(printer: custom_printer_class.new)
-    end
-  end
-
-  describe "#dup" do
-    it "works with adding selections" do
-      f = GraphQL::Language::Nodes::Field.new(name: "f")
-      # Calling `.children` may populate an internal cache
-      assert_equal "f", f.to_query_string, "the original is unchanged"
-      assert_equal 0, f.children.size
-      assert_equal 0, f.selections.size
-
-      f2 = f.merge(selections: [GraphQL::Language::Nodes::Field.new(name: "__typename")])
-
-      assert_equal "f", f.to_query_string, "the original is unchanged"
-      assert_equal 0, f.children.size
-      assert_equal 0, f.selections.size
-
-      assert_equal "f {\n  __typename\n}", f2.to_query_string, "the duplicate is updated"
-      assert_equal 1, f2.children.size
-      assert_equal 1, f2.selections.size
-    end
-  end
-end

data/spec/graphql/language/parser_spec.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Language::Parser do
-  subject { GraphQL::Language::Parser }
-
-  describe "anonymous fragment extension" do
-    let(:document) { GraphQL.parse(query_string) }
-    let(:query_string) {%|
-      fragment on NestedType @or(something: "ok") {
-        anotherNestedField
-      }
-    |}
-
-    let(:fragment) { document.definitions.first }
-
-    it "creates an anonymous fragment definition" do
-      assert fragment.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-      assert_nil fragment.name
-      assert_equal 1, fragment.selections.length
-      assert_equal "NestedType", fragment.type.name
-      assert_equal 1, fragment.directives.length
-      assert_equal [2, 7], fragment.position
-    end
-  end
-
-  describe "string description" do
-    it "is parsed for scalar definitions" do
-      document = subject.parse <<-GRAPHQL
-        "Thing description"
-        scalar Thing
-      GRAPHQL
-
-      thing_defn = document.definitions[0]
-      assert_equal "Thing", thing_defn.name
-      assert_equal "Thing description", thing_defn.description
-    end
-
-    it "is parsed for object definitions, field definitions, and input value definitions" do
-      document = subject.parse <<-GRAPHQL
-      "Thing description"
-      type Thing {
-        "field description"
-        field("arg description" arg: Stuff): Stuff
-      }
-      GRAPHQL
-
-      thing_defn = document.definitions[0]
-      assert_equal "Thing", thing_defn.name
-      assert_equal "Thing description", thing_defn.description
-
-      field_defn = thing_defn.fields[0]
-      assert_equal "field", field_defn.name
-      assert_equal "field description", field_defn.description
-
-      arg_defn = field_defn.arguments[0]
-      assert_equal "arg", arg_defn.name
-      assert_equal "arg description", arg_defn.description
-    end
-
-    it "is parsed for interface definitions" do
-      document = subject.parse <<-GRAPHQL
-        "Thing description"
-        interface Thing {}
-      GRAPHQL
-
-      thing_defn = document.definitions[0]
-      assert_equal "Thing", thing_defn.name
-      assert_equal "Thing description", thing_defn.description
-    end
-
-    it "is parsed for union definitions" do
-      document = subject.parse <<-GRAPHQL
-        "Thing description"
-        union Thing = Int | String
-      GRAPHQL
-
-      thing_defn = document.definitions[0]
-      assert_equal "Thing", thing_defn.name
-      assert_equal "Thing description", thing_defn.description
-    end
-
-    it "is parsed for enum definitions and enum value definitions" do
-      document = subject.parse <<-GRAPHQL
-        "Thing description"
-        enum Thing {
-          "VALUE description"
-          VALUE
-        }
-      GRAPHQL
-
-      thing_defn = document.definitions[0]
-      assert_equal "Thing", thing_defn.name
-      assert_equal "Thing description", thing_defn.description
-
-      value_defn = thing_defn.values[0]
-      assert_equal "VALUE", value_defn.name
-      assert_equal "VALUE description", value_defn.description
-    end
-
-    it "is parsed for directive definitions" do
-      document = subject.parse <<-GRAPHQL
-      "thing description" directive @thing on FIELD
-      GRAPHQL
-
-      thing_defn = document.definitions[0]
-      assert_equal "thing", thing_defn.name
-      assert_equal "thing description", thing_defn.description
-    end
-  end
-
-  it "parses empty arguments" do
-    strings = [
-      "{ field { inner } }",
-      "{ field() { inner }}",
-    ]
-    strings.each do |query_str|
-      doc = subject.parse(query_str)
-      field = doc.definitions.first.selections.first
-      assert_equal 0, field.arguments.length
-      assert_equal 1, field.selections.length
-    end
-  end
-
-  it "parses the test schema" do
-    schema = Dummy::Schema
-    schema_string = GraphQL::Schema::Printer.print_schema(schema)
-    document = subject.parse(schema_string)
-    assert_equal schema_string, document.to_query_string
-  end
-
-  describe "parse errors" do
-    it "raises parse errors for nil" do
-      assert_raises(GraphQL::ParseError) {
-        GraphQL.parse(nil)
-      }
-    end
-  end
-
-  describe ".parse_file" do
-    it "assigns filename to all nodes" do
-      example_filename = "spec/support/parser/filename_example.graphql"
-      doc = GraphQL.parse_file(example_filename)
-      assert_equal example_filename, doc.filename
-      field = doc.definitions[0].selections[0].selections[0]
-      assert_equal example_filename, field.filename
-    end
-
-    it "raises errors with filename" do
-      error_filename = "spec/support/parser/filename_example_error_1.graphql"
-      err = assert_raises(GraphQL::ParseError) {
-        GraphQL.parse_file(error_filename)
-      }
-
-      assert_includes err.message, error_filename
-
-      error_filename_2 = "spec/support/parser/filename_example_error_2.graphql"
-      err_2 = assert_raises(GraphQL::ParseError) {
-        GraphQL.parse_file(error_filename_2)
-      }
-
-      assert_includes err_2.message, error_filename_2
-      assert_includes err_2.message, "3, 11"
-
-    end
-  end
-
-  it "serves traces" do
-    TestTracing.clear
-    GraphQL.parse("{ t: __typename }", tracer: TestTracing)
-    traces = TestTracing.traces
-    assert_equal 2, traces.length
-    lex_trace, parse_trace = traces
-
-    assert_equal "{ t: __typename }", lex_trace[:query_string]
-    assert_equal "lex", lex_trace[:key]
-    assert_instance_of Array, lex_trace[:result]
-
-    assert_equal "{ t: __typename }", parse_trace[:query_string]
-    assert_equal "parse", parse_trace[:key]
-    assert_instance_of GraphQL::Language::Nodes::Document, parse_trace[:result]
-  end
-end