graphql 0.16.0 → 2.0.15

data/spec/graphql/schema/reduce_types_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::ReduceTypes do
-  def reduce_types(types)
-    GraphQL::Schema::ReduceTypes.reduce(types)
-  end
-
-  it "finds types from a single type and its fields" do
-    expected = {
-      "Cheese" => CheeseType,
-      "Float" => GraphQL::FLOAT_TYPE,
-      "String" => GraphQL::STRING_TYPE,
-      "DairyAnimal" => DairyAnimalEnum,
-      "Int" => GraphQL::INT_TYPE,
-      "Edible" => EdibleInterface,
-      "AnimalProduct" => AnimalProductInterface,
-    }
-    result = reduce_types([CheeseType])
-    assert_equal(expected.keys, result.keys)
-    assert_equal(expected, result.to_h)
-  end
-
-  it "finds type from arguments" do
-    result = reduce_types([QueryType])
-    assert_equal(DairyProductInputType, result["DairyProductInput"])
-  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 = reduce_types([type_parent])
-    expected = {
-      "InputTypeParent" => type_parent,
-      "InputTypeChild" => type_child,
-      "String" => GraphQL::STRING_TYPE
-    }
-    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) {  reduce_types([invalid_type]) }
-    end
-
-    it "raises an InvalidTypeError when passed an object that isnt a GraphQL::BaseType" do
-      assert_raises(GraphQL::Schema::InvalidTypeError) {  reduce_types([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) {
-        reduce_types([type_1, type_2])
-      }
-    end
-  end
-
-  describe "when getting a type which doesnt exist" do
-    it "raises an error" do
-      type_map = reduce_types([])
-      assert_raises(RuntimeError) { type_map["SomeType"] }
-    end
-  end
-
-  describe "when a field is only accessible through an interface" do
-    it "is found through Schema.new(types:)" do
-      assert_equal HoneyType, DummySchema.types["Honey"]
-    end
-  end
-end

data/spec/graphql/schema/rescue_middleware_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-class SpecExampleError < StandardError; end
-
-describe GraphQL::Schema::RescueMiddleware do
-  let(:error_middleware) { -> (next_middleware) { raise(error_class) } }
-
-  let(:rescue_middleware) do
-    middleware = GraphQL::Schema::RescueMiddleware.new
-    middleware.rescue_from(SpecExampleError) { |err| "there was an example error: #{err.class.name}" }
-    middleware
-  end
-
-  let(:steps) { [rescue_middleware, error_middleware] }
-
-  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps, arguments: [])}
-
-  describe "known errors" do
-    let(:error_class) { SpecExampleError }
-    it "handles them as execution errors" do
-      result = middleware_chain.call
-      assert_equal("there was an example error: SpecExampleError", result.message)
-      assert_equal(GraphQL::ExecutionError, result.class)
-    end
-  end
-
-  describe "unknown errors" do
-    let(:error_class) { RuntimeError }
-    it "re-raises them" do
-      assert_raises(RuntimeError) { middleware_chain.call }
-    end
-  end
-end

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -1,180 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::TimeoutMiddleware do
-  let(:max_seconds) { 2 }
-  let(:timeout_middleware) {  GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2) }
-  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.new(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.7)
-        b: sleepFor(seconds: 0.7)
-        c: sleepFor(seconds: 0.7)
-        d: sleepFor(seconds: 0.7)
-        e: sleepFor(seconds: 0.7)
-      }
-    |}
-    it "returns a partial response and error messages" do
-      expected_data = {
-        "a"=>0.7,
-        "b"=>0.7,
-        "c"=>0.7,
-        "d"=>nil,
-        "e"=>nil,
-      }
-
-      expected_errors =  [
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>6, "column"=>9}]
-        },
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>7, "column"=>9}]
-        },
-      ]
-      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: 1) {
-        seconds
-        b: nestedSleep(seconds: 0.4) {
-          seconds
-          c: nestedSleep(seconds: 0.4) {
-            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" => 1.0,
-          "b" => {
-            "seconds" => 0.4,
-            "c" => {
-              "seconds"=>0.4,
-              "d" => {
-                "seconds"=>nil,
-                "e"=>nil
-              }
-            }
-          }
-        }
-      }
-      expected_errors = [
-        {
-          "message"=>"Timeout on NestedSleep.seconds",
-          "locations"=>[{"line"=>10, "column"=>15}]
-        },
-        {
-          "message"=>"Timeout on NestedSleep.nestedSleep",
-          "locations"=>[{"line"=>11, "column"=>15}]
-        },
-      ]
-
-      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.7)
-        b: sleepFor(seconds: 0.7)
-        c: sleepFor(seconds: 1.5)
-        d: sleepFor(seconds: 0.1)
-      }
-    |}
-    it "doesn't terminate long-running field execution" do
-      expected_data = {
-        "a"=>0.7,
-        "b"=>0.7,
-        "c"=>1.5,
-        "d"=>nil,
-      }
-
-      expected_errors = [
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>6, "column"=>9}]
-        },
-      ]
-
-      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: 2) do |err, query|
-        raise("Query timed out after 2s: #{query.class.name}")
-      end
-    }
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.7)
-        b: sleepFor(seconds: 0.7)
-        c: sleepFor(seconds: 0.7)
-        d: sleepFor(seconds: 0.7)
-        e: sleepFor(seconds: 0.7)
-      }
-    |}
-
-    it "calls the block" do
-      assert_raises(RuntimeError) { result }
-    end
-  end
-end

data/spec/graphql/schema/type_expression_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::TypeExpression do
-  let(:schema) { DummySchema }
-  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(schema, ast_node) }
-
-  describe "#type" do
-    describe "simple types" do
-      let(:type_name) { "DairyProductInput" }
-      it "it gets types from the schema" do
-        assert_equal(DairyProductInputType, 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 = DairyAnimalEnum
-          .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/validation_spec.rb

@@ -1,219 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::Validation do
-  def assert_error_includes(object, error_substring)
-    validation_error = GraphQL::Schema::Validation.validate(object)
-    assert_includes validation_error, error_substring
-  end
-
-  describe "validating Fields" do
-    let(:unnamed_field) {
-      GraphQL::Field.define do
-        type GraphQL::STRING_TYPE
-      end
-    }
-
-    let(:untyped_field) {
-      GraphQL::Field.define do
-        name "Untyped"
-        type :something_invalid
-      end
-    }
-
-    let(:bad_arguments_field) {
-      field = GraphQL::Field.define do
-        name "BadArgs"
-        type !GraphQL::BOOLEAN_TYPE
-      end
-      field.arguments[:bad_key] = :bad_value
-      field
-    }
-
-    let(:invalid_argument_member_field) {
-      GraphQL::Field.define do
-        name "InvalidArgument"
-        type !types[!GraphQL::INT_TYPE]
-        argument :invalid do
-          type GraphQL::STRING_TYPE
-          default_value [1,2,3]
-        end
-      end
-    }
-
-    it "requires a String for name" do
-      assert_error_includes unnamed_field, "must return String, not NilClass"
-    end
-
-    it "requires a BaseType for type" do
-      assert_error_includes untyped_field, "must return GraphQL::BaseType, not Symbol"
-    end
-
-    it "requires String => Argument arguments" do
-      assert_error_includes bad_arguments_field, "must map String => GraphQL::Argument, not Symbol => Symbol"
-    end
-
-    it "applies validation to its member Arguments" do
-      assert_error_includes invalid_argument_member_field, "default value [1, 2, 3] is not valid for type String"
-    end
-  end
-
-  describe "validating BaseType" do
-    let(:unnamed_type) {
-      GraphQL::BaseType.define do
-        name :invalid_name
-      end
-    }
-
-    let(:wrongly_described_type) {
-      GraphQL::BaseType.define do
-        name "WronglyDescribed"
-        description 12345
-      end
-    }
-    it "requires a String name" do
-      assert_error_includes unnamed_type, "must return String, not Symbol"
-    end
-
-    it "requires String-or-nil description" do
-      assert_error_includes wrongly_described_type, "must return String or NilClass, not Fixnum"
-    end
-  end
-
-  describe "validating ObjectTypes" do
-    let(:invalid_interfaces_object) {
-      GraphQL::ObjectType.define do
-        name "InvalidInterfaces"
-        interfaces(55)
-      end
-    }
-    let(:invalid_interface_member_object) {
-      GraphQL::ObjectType.define do
-        name "InvalidInterfaceMember"
-        interfaces [:not_an_interface]
-      end
-    }
-
-    let(:invalid_field_object) {
-      GraphQL::ObjectType.define do
-        name "InvalidField"
-        field :invalid, :nonsense
-      end
-    }
-
-    it "requires an Array for interfaces" do
-      assert_error_includes invalid_interfaces_object, "must be an Array of GraphQL::InterfaceType, not a Fixnum"
-      assert_error_includes invalid_interface_member_object, "must contain GraphQL::InterfaceType, not Symbol"
-    end
-
-    it "validates the fields" do
-      assert_error_includes invalid_field_object, "must return GraphQL::BaseType, not Symbol"
-    end
-  end
-
-  describe "validating UnionTypes" do
-    let(:non_array_union) {
-      GraphQL::UnionType.define do
-        name "NonArray"
-        possible_types 55
-      end
-    }
-
-    let(:non_object_type_union) {
-      GraphQL::UnionType.define do
-        name "NonObjectTypes"
-        possible_types [
-          GraphQL::InterfaceType.new
-        ]
-      end
-    }
-
-    let(:no_possible_types_union) {
-      GraphQL::UnionType.define do
-        name "NoPossibleTypes"
-        possible_types []
-      end
-    }
-
-    it "requires an array of ObjectTypes for possible_types" do
-      assert_error_includes non_array_union, "must be an Array of GraphQL::ObjectType, not a Fixnum"
-
-      assert_error_includes non_object_type_union, "must contain GraphQL::ObjectType, not GraphQL::InterfaceType"
-    end
-
-    it "requires at least one possible_types" do
-      assert_error_includes no_possible_types_union, "must have at least one possible type"
-    end
-  end
-
-  describe "validating InputObjectTypes" do
-    let(:invalid_arguments_input) {
-      input = GraphQL::InputObjectType.define do
-        name "InvalidArgumentsHash"
-      end
-      input.arguments[123] = :nonsense
-      input
-    }
-
-    let(:invalid_argument_member_input) {
-      GraphQL::InputObjectType.define do
-        name "InvalidArgumentMember"
-        argument :nonsense do
-          type GraphQL::FLOAT_TYPE
-          default_value "xyz"
-        end
-      end
-    }
-
-    it "requires {String => Argument} arguments" do
-      assert_error_includes invalid_arguments_input, "map String => GraphQL::Argument, not Fixnum => Symbol"
-    end
-
-    it "applies validation to its member Arguments" do
-      assert_error_includes invalid_argument_member_input, "default value \"xyz\" is not valid for type Float"
-    end
-  end
-
-  describe "validating InterfaceTypes" do
-    let(:invalid_field_interface) {
-      GraphQL::InterfaceType.define do
-        name "InvalidField"
-        field :invalid do
-          type GraphQL::BOOLEAN_TYPE
-          argument :invalid do
-            type GraphQL::STRING_TYPE
-            default_value 4.56
-          end
-        end
-      end
-    }
-
-    it "validates fields" do
-      assert_error_includes invalid_field_interface, "default value 4.56 is not valid for type String"
-    end
-  end
-
-  describe "validating Arguments" do
-    let(:untyped_argument) {
-      GraphQL::Argument.define do
-        name "Untyped"
-        type :Bogus
-      end
-    }
-
-    let(:invalid_default_argument) {
-      GraphQL::Argument.define do
-        name "InvalidDefault"
-        type GraphQL::INT_TYPE
-        default_value "abc"
-      end
-    }
-
-    it "requires the type is a Base type" do
-      assert_error_includes untyped_argument, "must be a valid input type (Scalar or InputObject), not Symbol"
-    end
-
-    it "requires the default value is compatible" do
-      assert_error_includes invalid_default_argument, 'default value "abc" is not valid for type Int'
-    end
-  end
-end

data/spec/graphql/schema_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema do
-  let(:schema) { DummySchema }
-
-  describe "#rescue_from" do
-    let(:rescue_middleware) { schema.middleware.first }
-
-    it "adds handlers to the rescue middleware" do
-      assert_equal(1, rescue_middleware.rescue_table.length)
-      # normally, you'd use a real class, not a symbol:
-      schema.rescue_from(:error_class) { "my custom message" }
-      assert_equal(2, rescue_middleware.rescue_table.length)
-    end
-  end
-
-  describe "#subscription" do
-    it "calls fields on the subscription type" do
-      res = schema.execute("subscription { test }")
-      assert_equal("Test", res["data"]["test"])
-    end
-  end
-end

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: "aasdlkfj") { source }
-      cheese(id: 1) { source @skip(if: {id: 1})}
-      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { source }
-      badSource: searchDairy(product: [{source: 1.1}]) { source }
-      missingSource: searchDairy(product: [{fatContent: 1.1}]) { source }
-      listCoerce: cheese(id: 1) { similarCheese(source: YAK) }
-      missingInputField: searchDairy(product: [{source: YAK, wacky: 1}])
-    }
-
-    fragment cheeseFields on Cheese {
-      similarCheese(source: 4.5)
-    }
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentLiteralsAreCompatible]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds undefined or missing-required arguments to fields and directives" do
-    assert_equal(6, errors.length)
-
-    query_root_error = {
-      "message"=>"Argument 'id' on Field 'cheese' has an invalid value",
-      "locations"=>[{"line"=>3, "column"=>7}]
-    }
-    assert_includes(errors, query_root_error)
-
-    directive_error = {
-      "message"=>"Argument 'if' on Directive 'skip' has an invalid value",
-      "locations"=>[{"line"=>4, "column"=>30}]
-    }
-    assert_includes(errors, directive_error)
-
-    input_object_error = {
-      "message"=>"Argument 'product' on Field 'badSource' has an invalid value",
-      "locations"=>[{"line"=>6, "column"=>7}]
-    }
-    assert_includes(errors, input_object_error)
-
-    input_object_field_error = {
-      "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value",
-      "locations"=>[{"line"=>6, "column"=>40}]
-    }
-    assert_includes(errors, input_object_field_error)
-
-    missing_required_field_error = {
-      "message"=>"Argument 'product' on Field 'missingSource' has an invalid value",
-      "locations"=>[{"line"=>7, "column"=>7}]
-    }
-    assert_includes(errors, missing_required_field_error)
-
-    fragment_error = {
-      "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value",
-      "locations"=>[{"line"=>13, "column"=>7}]
-    }
-    assert_includes(errors, fragment_error)
-  end
-end