graphql 1.8.0 → 1.12.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,36 +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! }')
-    }
-
-    class CustomPrinter < GraphQL::Language::Printer
-      def print_field_definition(print_field_definition)
-        "<Field Hidden>"
-      end
-    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: CustomPrinter.new)
-    end
-  end
-end

data/spec/graphql/language/lexer_spec.rb

@@ -1,66 +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
-
-    describe "block strings" do
-      let(:query_string) { %|{ a(b: """\nc\n  d\n""")}|}
-
-      it "tokenizes them" do
-        str_token = tokens[5]
-        assert_equal "c\n  d", str_token.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 "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:10])', rparen_token.inspect
-    end
-  end
-end

data/spec/graphql/language/nodes_spec.rb

@@ -1,45 +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! }')
-    }
-
-    class CustomPrinter < GraphQL::Language::Printer
-      def print_field_definition(print_field_definition)
-        "<Field Hidden>"
-      end
-    end
-
-    it "accepts a custom printer" do
-      expected = <<-SCHEMA
-type Query {
-  <Field Hidden>
-}
-      SCHEMA
-      assert_equal expected.chomp, document.to_query_string(printer: CustomPrinter.new)
-    end
-  end
-end

data/spec/graphql/language/parser_spec.rb

@@ -1,90 +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
-
-  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_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

data/spec/graphql/language/printer_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Language::Printer do
-  let(:document) { GraphQL::Language::Parser.parse(query_string) }
-  let(:query_string) {%|
-    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(:printer) { GraphQL::Language::Printer.new }
-
-  describe "#print" do
-    it "prints the query string" do
-      assert_equal query_string.gsub(/^    /, "").strip, printer.print(document)
-    end
-
-    describe "inputs" do
-      let(:query_string) {%|
-        query {
-          field(null_value: null, null_in_array: [1, null, 3], int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
-        }
-      |}
-
-      it "prints the query string" do
-        assert_equal query_string.gsub(/^        /, "").strip, printer.print(document)
-      end
-    end
-
-    describe "schema" do
-      describe "schema with convention names for root types" do
-        let(:query_string) {<<-schema
-          schema {
-            query: Query
-            mutation: Mutation
-            subscription: Subscription
-          }
-        schema
-        }
-
-        it 'omits schema definition' do
-          refute printer.print(document) =~ /schema/
-        end
-      end
-
-      describe "schema with custom query root name" do
-        let(:query_string) {<<-schema
-          schema {
-            query: MyQuery
-            mutation: Mutation
-            subscription: Subscription
-          }
-        schema
-        }
-
-        it 'includes schema definition' do
-          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
-        end
-      end
-
-      describe "schema with custom mutation root name" do
-        let(:query_string) {<<-schema
-          schema {
-            query: Query
-            mutation: MyMutation
-            subscription: Subscription
-          }
-        schema
-        }
-
-        it 'includes schema definition' do
-          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
-        end
-      end
-
-      describe "schema with custom subscription root name" do
-        let(:query_string) {<<-schema
-          schema {
-            query: Query
-            mutation: Mutation
-            subscription: MySubscription
-          }
-        schema
-        }
-
-        it 'includes schema definition' do
-          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
-        end
-      end
-
-      describe "full featured schema" do
-        # Based on: https://github.com/graphql/graphql-js/blob/bc96406ab44453a120da25a0bd6e2b0237119ddf/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 & AnnotatedInterface {
-            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
-            seven(argument: String = null): Type
-          }
-
-          # Scalar description
-          scalar CustomScalar
-
-          type AnnotatedObject implements Bar @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
-        }
-
-        it "generate" do
-          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
-        end
-
-        it "doesn't mutate the document" do
-          assert_equal printer.print(document), printer.print(document)
-        end
-      end
-    end
-  end
-end

data/spec/graphql/language/visitor_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Language::Visitor do
-  let(:document) { GraphQL.parse("
-    query cheese {
-      cheese(id: 1) {
-        flavor,
-        source,
-        producers(first: 3) {
-          name
-        }
-        ... cheeseFields
-      }
-    }
-
-    fragment cheeseFields on Cheese { flavor }
-    ")}
-  let(:counts) { {fields_entered: 0, arguments_entered: 0, arguments_left: 0, argument_names: []} }
-
-  let(:visitor) do
-    v = GraphQL::Language::Visitor.new(document)
-    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::Document].leave << ->(node, parent) { counts[:finished] = true }
-    v
-  end
-
-  it "calls hooks during a depth-first tree traversal" do
-    assert_equal(2, visitor[GraphQL::Language::Nodes::Argument].enter.length)
-    visitor.visit
-    assert_equal(6, counts[:fields_entered])
-    assert_equal(2, counts[:arguments_entered])
-    assert_equal(2, counts[:arguments_left])
-    assert_equal(["id", "first"], counts[:argument_names])
-    assert(counts[:finished])
-  end
-
-  describe "Visitor::SKIP" do
-    it "skips the rest of the node" do
-      visitor[GraphQL::Language::Nodes::Document] << ->(node, parent) { GraphQL::Language::Visitor::SKIP }
-      visitor.visit
-      assert_equal(0, counts[:fields_entered])
-    end
-  end
-end

data/spec/graphql/list_type_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::ListType do
-  let(:float_list) { GraphQL::ListType.new(of_type: GraphQL::FLOAT_TYPE) }
-
-  it "coerces elements in the list" do
-    assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_isolated_input([1, 2, 3]).inspect)
-  end
-
-  it "converts items that are not lists into lists" do
-    assert_equal([1.0].inspect, float_list.coerce_isolated_input(1.0).inspect)
-  end
-
-  describe "validate_input with bad input" do
-    let(:bad_num) { "bad_num" }
-    let(:result) { float_list.validate_isolated_input([bad_num, 2.0, 3.0]) }
-
-    it "returns an invalid result" do
-      assert(!result.valid?)
-    end
-
-    it "has one problem" do
-      assert_equal(result.problems.length, 1)
-    end
-
-    it "has path [0]" do
-      assert_equal(result.problems[0]["path"], [0])
-    end
-
-    it "has the correct explanation" do
-      expected = GraphQL::FLOAT_TYPE.validate_isolated_input(bad_num).problems[0]["explanation"]
-      actual = result.problems[0]["explanation"]
-      assert_equal(actual, expected)
-    end
-  end
-
-  describe "list of input objects" do
-    let(:input_object) do
-      input_object = GraphQL::InputObjectType.define do
-        name "SomeInputObjectType"
-        argument :float, !types.Float
-      end
-
-      GraphQL::Query::Arguments.construct_arguments_class(input_object)
-
-      input_object
-    end
-
-    let(:input_object_list) { input_object.to_list_type }
-
-    it "converts hashes into lists of hashes" do
-      hash = { 'float' => 1.0 }
-      assert_equal([hash].inspect, input_object_list.coerce_isolated_input(hash).map(&:to_h).inspect)
-    end
-  end
-end

data/spec/graphql/non_null_type_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::NonNullType do
-  describe "when a non-null field returns null" do
-    it "nulls out the parent selection" do
-      query_string = %|{ cow { name cantBeNullButIs } }|
-      result = Dummy::Schema.execute(query_string)
-      assert_equal({"cow" => nil }, result["data"])
-      assert_equal([{"message"=>"Cannot return null for non-nullable field Cow.cantBeNullButIs"}], result["errors"])
-    end
-
-    it "propagates the null up to the next nullable field" do
-      query_string = %|
-      {
-        nn1: deepNonNull {
-          nni1: nonNullInt(returning: 1)
-          nn2: deepNonNull {
-            nni2: nonNullInt(returning: 2)
-            nn3: deepNonNull {
-              nni3: nonNullInt
-            }
-          }
-        }
-      }
-      |
-      result = Dummy::Schema.execute(query_string)
-      assert_equal(nil, result["data"])
-      assert_equal([{"message"=>"Cannot return null for non-nullable field DeepNonNull.nonNullInt"}], result["errors"])
-    end
-
-    describe "when type_error is configured to raise an error" do
-      it "crashes query execution" do
-        raise_schema = Dummy::Schema.redefine {
-          type_error ->(type_err, ctx) {
-            raise type_err
-          }
-        }
-        query_string = %|{ cow { name cantBeNullButIs } }|
-        err = assert_raises(GraphQL::InvalidNullError) { raise_schema.execute(query_string) }
-        assert_equal("Cannot return null for non-nullable field Cow.cantBeNullButIs", err.message)
-        assert_equal("Cow", err.parent_type.name)
-        assert_equal("cantBeNullButIs", err.field.name)
-        assert_equal(nil, err.value)
-      end
-    end
-  end
-end