graphql 1.9.5 → 1.13.19

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::TimeoutMiddleware do
-  let(:max_seconds) { 1 }
-  let(:timeout_middleware) {  GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) }
-  let(:timeout_schema) {
-
-    sleep_for_seconds_resolve = ->(obj, args, ctx) {
-      sleep(args[:seconds])
-      args[:seconds]
-    }
-
-    nested_sleep_type = GraphQL::ObjectType.define do
-      name "NestedSleep"
-      field :seconds, types.Float do
-        resolve ->(obj, args, ctx) { obj }
-      end
-
-      field :nestedSleep, -> { nested_sleep_type } do
-        argument :seconds, !types.Float
-        resolve(sleep_for_seconds_resolve)
-      end
-    end
-
-    query_type = GraphQL::ObjectType.define do
-      name "Query"
-      field :sleepFor, types.Float do
-        argument :seconds, !types.Float
-        resolve(sleep_for_seconds_resolve)
-      end
-
-      field :nestedSleep, nested_sleep_type do
-        argument :seconds, !types.Float
-        resolve(sleep_for_seconds_resolve)
-      end
-    end
-
-    schema = GraphQL::Schema.define(query: query_type)
-    schema.middleware << timeout_middleware
-    schema
-  }
-
-  let(:result) { timeout_schema.execute(query_string) }
-
-  describe "timeout part-way through" do
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.4)
-        b: sleepFor(seconds: 0.4)
-        c: sleepFor(seconds: 0.4)
-        d: sleepFor(seconds: 0.4)
-        e: sleepFor(seconds: 0.4)
-      }
-    |}
-    it "returns a partial response and error messages" do
-      expected_data = {
-        "a"=>0.4,
-        "b"=>0.4,
-        "c"=>0.4,
-        "d"=>nil,
-        "e"=>nil,
-      }
-
-      expected_errors =  [
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>6, "column"=>9}],
-          "path"=>["d"]
-        },
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>7, "column"=>9}],
-          "path"=>["e"]
-        },
-      ]
-      assert_equal expected_data, result["data"]
-      assert_equal expected_errors, result["errors"]
-    end
-  end
-
-  describe "timeout in nested fields" do
-    let(:query_string) {%|
-    {
-      a: nestedSleep(seconds: 0.3) {
-        seconds
-        b: nestedSleep(seconds: 0.3) {
-          seconds
-          c: nestedSleep(seconds: 0.3) {
-            seconds
-            d: nestedSleep(seconds: 0.4) {
-              seconds
-              e: nestedSleep(seconds: 0.4) {
-                seconds
-              }
-            }
-          }
-        }
-      }
-    }
-    |}
-
-    it "returns a partial response and error messages" do
-      expected_data = {
-        "a" => {
-          "seconds" => 0.3,
-          "b" => {
-            "seconds" => 0.3,
-            "c" => {
-              "seconds"=>0.3,
-              "d" => {
-                "seconds"=>nil,
-                "e"=>nil
-              }
-            }
-          }
-        }
-      }
-      expected_errors = [
-        {
-          "message"=>"Timeout on NestedSleep.seconds",
-          "locations"=>[{"line"=>10, "column"=>15}],
-          "path"=>["a", "b", "c", "d", "seconds"]
-        },
-        {
-          "message"=>"Timeout on NestedSleep.nestedSleep",
-          "locations"=>[{"line"=>11, "column"=>15}],
-          "path"=>["a", "b", "c", "d", "e"]
-        },
-      ]
-
-      assert_equal expected_data, result["data"]
-      assert_equal expected_errors, result["errors"]
-    end
-  end
-
-  describe "long-running fields" do
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.2)
-        b: sleepFor(seconds: 0.2)
-        c: sleepFor(seconds: 0.8)
-        d: sleepFor(seconds: 0.1)
-      }
-    |}
-    it "doesn't terminate long-running field execution" do
-      expected_data = {
-        "a"=>0.2,
-        "b"=>0.2,
-        "c"=>0.8,
-        "d"=>nil,
-      }
-
-      expected_errors = [
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>6, "column"=>9}],
-          "path"=>["d"]
-        },
-      ]
-
-      assert_equal expected_data, result["data"]
-      assert_equal expected_errors, result["errors"]
-    end
-  end
-
-  describe "with a custom block" do
-    let(:timeout_middleware) {
-      GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) do |err, query|
-        raise("Query timed out after 2s: #{query.operations.count} on #{query.context.ast_node.alias}")
-      end
-    }
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.4)
-        b: sleepFor(seconds: 0.4)
-        c: sleepFor(seconds: 0.4)
-        d: sleepFor(seconds: 0.4)
-        e: sleepFor(seconds: 0.4)
-      }
-    |}
-
-    it "calls the block" do
-      err = assert_raises(RuntimeError) { result }
-      assert_equal "Query timed out after 2s: 1 on d", err.message
-    end
-  end
-end

data/spec/graphql/schema/traversal_spec.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Traversal do
-  def traversal(types)
-    schema = GraphQL::Schema.define(orphan_types: types, resolve_type: :dummy)
-    GraphQL::Schema::Traversal.new(schema, introspection: false)
-  end
-
-  it "finds types from directives" do
-    expected = {
-      "Boolean" => GraphQL::BOOLEAN_TYPE, # `skip` argument
-      "String" => GraphQL::STRING_TYPE # `deprecated` argument
-    }
-    result = traversal([]).type_map
-    assert_equal(expected.keys.sort, result.keys.sort)
-    assert_equal(expected, result.to_h)
-  end
-
-  it "finds types from a single type and its fields" do
-    expected = {
-      "Boolean" => GraphQL::BOOLEAN_TYPE,
-      "Cheese" => Dummy::Cheese.graphql_definition,
-      "Float" => GraphQL::FLOAT_TYPE,
-      "String" => GraphQL::STRING_TYPE,
-      "Edible" => Dummy::Edible.graphql_definition,
-      "EdibleAsMilk" => Dummy::EdibleAsMilk.graphql_definition,
-      "DairyAnimal" => Dummy::DairyAnimal.graphql_definition,
-      "Int" => GraphQL::INT_TYPE,
-      "AnimalProduct" => Dummy::AnimalProduct.graphql_definition,
-      "LocalProduct" => Dummy::LocalProduct.graphql_definition,
-    }
-    result = traversal([Dummy::Cheese.graphql_definition]).type_map
-    assert_equal(expected.keys.sort, result.keys.sort)
-    assert_equal(expected, result.to_h)
-  end
-
-  it "finds type from arguments" do
-    result = traversal([Dummy::DairyAppQuery.graphql_definition]).type_map
-    assert_equal(Dummy::DairyProductInput.graphql_definition, result["DairyProductInput"])
-  end
-
-  it "finds types from field instrumentation" do
-    type = GraphQL::ObjectType.define do
-      name "ArgTypeTest"
-      connection :t, type.connection_type
-    end
-
-    result = traversal([type]).type_map
-    expected_types = [
-      "ArgTypeTest", "ArgTypeTestConnection", "ArgTypeTestEdge",
-      "Boolean", "Int", "PageInfo", "String"
-    ]
-    assert_equal expected_types, result.keys.sort
-  end
-
-  it "finds types from nested InputObjectTypes" do
-    type_child = GraphQL::InputObjectType.define do
-      name "InputTypeChild"
-      input_field :someField, GraphQL::STRING_TYPE
-    end
-
-    type_parent = GraphQL::InputObjectType.define do
-      name "InputTypeParent"
-      input_field :child, type_child
-    end
-
-    result = traversal([type_parent]).type_map
-    expected = {
-      "Boolean" => GraphQL::BOOLEAN_TYPE,
-      "String" => GraphQL::STRING_TYPE,
-      "InputTypeParent" => type_parent,
-      "InputTypeChild" => type_child,
-    }
-    assert_equal(expected, result.to_h)
-  end
-
-  describe "when a type is invalid" do
-    let(:invalid_type) {
-      GraphQL::ObjectType.define do
-        name "InvalidType"
-        field :someField
-      end
-    }
-
-    let(:another_invalid_type) {
-      GraphQL::ObjectType.define do
-        name "AnotherInvalidType"
-        field :someField, String
-      end
-    }
-
-    it "raises an InvalidTypeError when passed nil" do
-      assert_raises(GraphQL::Schema::InvalidTypeError) {  traversal([invalid_type]) }
-    end
-
-    it "raises an InvalidTypeError when passed an object that isnt a GraphQL::BaseType" do
-      assert_raises(GraphQL::Schema::InvalidTypeError) {  traversal([another_invalid_type]) }
-    end
-  end
-
-  describe "when a schema has multiple types with the same name" do
-    let(:type_1) {
-      GraphQL::ObjectType.define do
-        name "MyType"
-      end
-    }
-    let(:type_2) {
-      GraphQL::ObjectType.define do
-        name "MyType"
-      end
-    }
-    it "raises an error" do
-      assert_raises(RuntimeError) {
-        traversal([type_1, type_2])
-      }
-    end
-  end
-
-  describe "when getting a type which doesnt exist" do
-    it "raises an error" do
-      type_map = traversal([]).type_map
-      assert_raises(KeyError) { type_map.fetch("SomeType") }
-    end
-  end
-
-  describe "when a field is only accessible through an interface" do
-    it "is found through Schema.define(types:)" do
-      assert_equal Dummy::Honey.graphql_definition, Dummy::Schema.types["Honey"]
-    end
-  end
-
-  it "finds all references to types from fields and arguments" do
-    c_type = GraphQL::InputObjectType.define do
-      name "C"
-      input_field :someField, GraphQL::STRING_TYPE
-    end
-
-    b_type = GraphQL::ObjectType.define do
-      name "B"
-      field :anotherField, !GraphQL::STRING_TYPE do |field|
-        field.argument :anArgument, c_type
-      end
-    end
-
-    a_type = GraphQL::ObjectType.define do
-      name "A"
-      field :someField, b_type
-    end
-
-    include_if_argument = GraphQL::Directive::IncludeDirective.arguments["if"]
-    skip_if_argument = GraphQL::Directive::SkipDirective.arguments["if"]
-    deprecated_reason_argument = GraphQL::Directive::DeprecatedDirective.arguments["reason"]
-
-    expected = {
-      "Boolean" => [include_if_argument, skip_if_argument],
-      "B" => [a_type.fields["someField"]],
-      "String" => [deprecated_reason_argument, b_type.fields["anotherField"], c_type.input_fields["someField"]],
-      "C" => [b_type.fields["anotherField"].arguments["anArgument"]]
-    }
-
-    assert_equal expected, traversal([a_type, b_type, c_type]).type_reference_map
-  end
-
-  it "finds unions from which types are members" do
-    b_type = GraphQL::ObjectType.define do
-      name "B"
-    end
-
-    c_type = GraphQL::ObjectType.define do
-      name "C"
-    end
-
-    union = GraphQL::UnionType.define do
-      name "AUnion"
-      possible_types [b_type]
-    end
-
-    another_union = GraphQL::UnionType.define do
-      name "AnotherUnion"
-      possible_types [b_type, c_type]
-    end
-
-    result = traversal([union, another_union, b_type, c_type]).union_memberships
-    expected = {
-      "B" => [union, another_union],
-      "C" => [another_union]
-    }
-    assert_equal expected, result
-  end
-
-  it "finds orphan types from interfaces" do
-    b_type = GraphQL::ObjectType.define do
-      name "B"
-    end
-
-    c_type = GraphQL::ObjectType.define do
-      name "C"
-    end
-
-    interface = GraphQL::InterfaceType.define do
-      name "AInterface"
-      orphan_types [b_type]
-    end
-
-    another_interface = GraphQL::InterfaceType.define do
-      name "AnotherIterface"
-      orphan_types [b_type, c_type]
-    end
-
-    result = traversal([interface, another_interface]).type_map
-    expected = {
-      "Boolean" => GraphQL::BOOLEAN_TYPE,
-      "String" => GraphQL::STRING_TYPE,
-      "AInterface" => interface,
-      "AnotherIterface" => another_interface,
-      "B" => b_type,
-      "C" => c_type
-    }
-    assert_equal expected, result
-  end
-end

data/spec/graphql/schema/type_expression_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::TypeExpression do
-  let(:types) { Dummy::Schema.types }
-  let(:ast_node) {
-    document = GraphQL.parse("query dostuff($var: #{type_name}) { id } ")
-    document.definitions.first.variables.first.type
-  }
-  let(:type_expression_result) { GraphQL::Schema::TypeExpression.build_type(types, ast_node) }
-
-  describe "#type" do
-    describe "simple types" do
-      let(:type_name) { "DairyProductInput" }
-      it "it gets types from the provided types" do
-        assert_equal(Dummy::DairyProductInput.graphql_definition, type_expression_result)
-      end
-    end
-
-    describe "non-null types" do
-      let(:type_name) { "String!"}
-      it "makes non-null types" do
-        assert_equal(GraphQL::STRING_TYPE.to_non_null_type,type_expression_result)
-      end
-    end
-
-    describe "list types" do
-      let(:type_name) { "[DairyAnimal!]!" }
-
-      it "makes list types" do
-        expected = Dummy::DairyAnimal.graphql_definition
-          .to_non_null_type
-          .to_list_type
-          .to_non_null_type
-        assert_equal(expected, type_expression_result)
-      end
-    end
-  end
-end

data/spec/graphql/schema/union_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Union do
-  let(:union) { Jazz::PerformingAct }
-
-  describe ".path" do
-    it "is the name" do
-      assert_equal "PerformingAct", union.path
-    end
-  end
-
-  describe "type info" do
-    it "has some" do
-      assert_equal 2, union.possible_types.size
-    end
-  end
-
-  describe ".to_graphql" do
-    it "creates a UnionType" do
-      union = Class.new(GraphQL::Schema::Union) do
-        possible_types Jazz::Musician, Jazz::Ensemble
-
-        def self.name
-          "MyUnion"
-        end
-      end
-      union_type = union.to_graphql
-      assert_equal "MyUnion", union_type.name
-      assert_equal [Jazz::Musician.to_graphql, Jazz::Ensemble.to_graphql], union_type.possible_types
-      assert_nil union_type.resolve_type_proc
-    end
-
-    it "can specify a resolve_type method" do
-      union = Class.new(GraphQL::Schema::Union) do
-        def self.resolve_type(_object, _context)
-          "MyType"
-        end
-
-        def self.name
-          "MyUnion"
-        end
-      end
-      union_type = union.to_graphql
-      assert_equal "MyType", union_type.resolve_type_proc.call(nil, nil)
-    end
-  end
-
-  describe "in queries" do
-    it "works" do
-      query_str = <<-GRAPHQL
-      {
-        nowPlaying {
-          ... on Musician {
-            name
-            instrument {
-              family
-            }
-          }
-          ... on Ensemble {
-            name
-          }
-        }
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      expected_data = { "name" => "Bela Fleck and the Flecktones" }
-      assert_equal expected_data, res["data"]["nowPlaying"]
-    end
-  end
-end

data/spec/graphql/schema/unique_within_type_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::UniqueWithinType do
-  describe 'encode / decode' do
-    it 'Converts typename and ID to and from ID' do
-      global_id = GraphQL::Schema::UniqueWithinType.encode("SomeType", 123)
-      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id)
-      assert_equal("SomeType", type_name)
-      assert_equal("123", id)
-    end
-
-    it "allows you specify default separator" do
-      GraphQL::Schema::UniqueWithinType.default_id_separator = '|'
-      global_id = GraphQL::Schema::UniqueWithinType.encode("Type-With-UUID", "250cda0e-a89d-41cf-99e1-2872d89f1100")
-      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id)
-      assert_equal("Type-With-UUID", type_name)
-      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
-      GraphQL::Schema::UniqueWithinType.default_id_separator = '-'
-    end
-
-    it "allows you to specify the separator" do
-      custom_separator = "---"
-      global_id = GraphQL::Schema::UniqueWithinType.encode("Type-With-UUID", "250cda0e-a89d-41cf-99e1-2872d89f1100", separator: custom_separator)
-      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id, separator: custom_separator)
-      assert_equal("Type-With-UUID", type_name)
-      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
-    end
-
-    it "allows using the separator in the ID" do
-      global_id = GraphQL::Schema::UniqueWithinType.encode("SomeUUIDType", "250cda0e-a89d-41cf-99e1-2872d89f1100")
-      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id)
-      assert_equal("SomeUUIDType", type_name)
-      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
-    end
-
-    it "raises an error if you try and use a reserved character in the typename" do
-      err = assert_raises(RuntimeError) {
-        GraphQL::Schema::UniqueWithinType.encode("Best-Thing", "234-567")
-      }
-      assert_includes err.message, "encode(Best-Thing, 234-567) contains reserved characters `-` in the type name"
-    end
-  end
-end