graphql 1.9.11 → 1.9.12

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.graphql_name)
-        assert_equal("cantBeNullButIs", err.field.name)
-        assert_equal(nil, err.value)
-      end
-    end
-  end
-end

data/spec/graphql/object_type_spec.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::ObjectType do
-  let(:type) { Dummy::Cheese.graphql_definition }
-
-  it "doesn't allow double non-null constraints" do
-    assert_raises(GraphQL::DoubleNonNullTypeError) {
-      DoubleNullObject = GraphQL::ObjectType.define do
-        name "DoubleNull"
-
-        field :id, !!types.Int, "Fails because double !"
-      end
-
-      # Force evaluation
-      DoubleNullObject.name
-    }
-  end
-
-  it "doesn't allow invalid name" do
-    exception = assert_raises(GraphQL::InvalidNameError) {
-      InvalidNameObject = GraphQL::ObjectType.define do
-        name "Three Word Query"
-
-        field :id, !types.Int, "id field"
-      end
-
-      # Force evaluation
-      InvalidNameObject.name
-    }
-    assert_equal("Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but 'Three Word Query' does not", exception.message)
-  end
-
-  it "has a name" do
-    assert_equal("Cheese", type.name)
-    type.name = "Fromage"
-    assert_equal("Fromage", type.name)
-    type.name = "Cheese"
-  end
-
-  it "has a description" do
-    assert_equal(22, type.description.length)
-  end
-
-  describe "interfaces" do
-    it "may have interfaces" do
-      assert_equal([
-        Dummy::Edible.graphql_definition,
-        Dummy::EdibleAsMilk.graphql_definition,
-        Dummy::AnimalProduct.graphql_definition,
-        Dummy::LocalProduct.graphql_definition
-      ], type.interfaces)
-    end
-
-    it "raises if the interfaces arent an array" do
-      type = GraphQL::ObjectType.define do
-        name "InvalidInterfaces"
-        interfaces(55)
-      end
-
-      assert_raises(ArgumentError) { type.name }
-    end
-
-    it "doesnt convolute field names that differ with underscore" do
-      interface = Module.new do
-        include GraphQL::Schema::Interface
-        graphql_name 'TestInterface'
-        description 'Requires an id'
-
-        field :id, GraphQL::ID_TYPE, null: false
-      end
-
-      object = Class.new(GraphQL::Schema::Object) do
-        graphql_name 'TestObject'
-        implements interface
-        global_id_field :id
-
-        # When the validation for `id` is run for `_id`, it will fail because
-        # GraphQL::STRING_TYPE cannot be transformed into a GraphQL::ID_TYPE
-        field :_id, String, description: 'database id', null: true
-      end
-
-      assert_equal nil, GraphQL::Schema::Validation.validate(object.to_graphql)
-    end
-  end
-
-  it "accepts fields definition" do
-    last_produced_dairy = GraphQL::Field.define(name: :last_produced_dairy, type: Dummy::DairyProduct)
-    cow_type = GraphQL::ObjectType.define(name: "Cow", fields: [last_produced_dairy])
-    assert_equal([last_produced_dairy], cow_type.fields)
-  end
-
-  describe "#implements" do
-    it "adds an interface" do
-      type = GraphQL::ObjectType.define do
-        name 'Hello'
-        implements Dummy::Edible
-        implements Dummy::AnimalProduct
-
-        field :hello, types.String
-      end
-
-      assert_equal([Dummy::Edible.graphql_definition, Dummy::AnimalProduct.graphql_definition], type.interfaces)
-    end
-
-    it "adds many interfaces" do
-      type = GraphQL::ObjectType.define do
-        name 'Hello'
-        implements Dummy::Edible, Dummy::AnimalProduct
-
-        field :hello, types.String
-      end
-
-      assert_equal([Dummy::Edible.graphql_definition, Dummy::AnimalProduct.graphql_definition], type.interfaces)
-    end
-
-    it "preserves existing interfaces and appends a new one" do
-      type = GraphQL::ObjectType.define do
-        name 'Hello'
-        interfaces [Dummy::Edible]
-        implements Dummy::AnimalProduct
-
-        field :hello, types.String
-      end
-
-      assert_equal([Dummy::Edible.graphql_definition, Dummy::AnimalProduct.graphql_definition], type.interfaces)
-    end
-
-    it "can be used to inherit fields from the interface" do
-      type_1 = GraphQL::ObjectType.define do
-        name 'Hello'
-        implements Dummy::Edible
-        implements Dummy::AnimalProduct
-      end
-
-      type_2 = GraphQL::ObjectType.define do
-        name 'Hello'
-        implements Dummy::Edible
-        implements Dummy::AnimalProduct, inherit: true
-      end
-
-      type_3 = GraphQL::ObjectType.define do
-        name 'Hello'
-        implements Dummy::Edible, Dummy::AnimalProduct, inherit: true
-      end
-
-      assert_equal [], type_1.all_fields.map(&:name)
-      assert_equal ["source"], type_2.all_fields.map(&:name)
-      assert_equal ["fatContent", "origin", "selfAsEdible", "source"], type_3.all_fields.map(&:name)
-    end
-  end
-
-  describe '#get_field' do
-    it "exposes fields" do
-      field = type.get_field("id")
-      assert_equal(GraphQL::TypeKinds::NON_NULL, field.type.kind)
-      assert_equal(GraphQL::TypeKinds::SCALAR, field.type.of_type.kind)
-    end
-
-    it "exposes defined field property" do
-      field_without_prop = Dummy::Cheese.graphql_definition.get_field("flavor")
-      field_with_prop = Dummy::Cheese.graphql_definition.get_field("fatContent")
-      assert_equal(field_without_prop.property, nil)
-      # This used to lookup `:fat_content`, but not since migrating to class-based
-      assert_equal(field_with_prop.property, nil)
-    end
-
-    it "looks up from interfaces" do
-      field_from_self = Dummy::Cheese.graphql_definition.get_field("fatContent")
-      field_from_iface = Dummy::Milk.graphql_definition.get_field("fatContent")
-      # This used to lookup `:fat_content`, but not since migrating to class-based
-      assert_equal(field_from_self.property, nil)
-      assert_equal(field_from_iface.property, nil)
-    end
-  end
-
-  describe "#dup" do
-    it "copies fields and interfaces without altering the original" do
-      type.interfaces # load the internal cache
-      assert_equal 4, type.interfaces.size
-      assert_equal 9, type.fields.size
-
-      type_2 = type.dup
-
-      # IRL, use `+=`, not this
-      # (this tests the internal cache)
-      type_2.interfaces << type
-
-      type_2.fields["nonsense"] = GraphQL::Field.define(name: "nonsense", type: type)
-
-      assert_equal 4, type.interfaces.size
-      assert_equal 5, type_2.interfaces.size
-      assert_equal 9, type.fields.size
-      assert_equal 10, type_2.fields.size
-    end
-  end
-end

data/spec/graphql/query/arguments_spec.rb

@@ -1,346 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Query::Arguments do
-  let(:arguments) {
-    test_input_1 = GraphQL::InputObjectType.define do
-      name "TestInput1"
-      argument :d, types.Int
-      argument :e, types.Int
-    end
-
-    test_input_2 = GraphQL::InputObjectType.define do
-      name "TestInput2"
-      argument :a, types.Int
-      argument :b, types.Int
-      argument :c, !test_input_1, as: :inputObject
-    end
-
-    GraphQL::Query::Arguments.construct_arguments_class(test_input_1)
-    GraphQL::Query::Arguments.construct_arguments_class(test_input_2)
-    arg_values = {a: 1, b: 2, c: { d: 3, e: 4 }}
-    test_input_2.arguments_class.new(arg_values, context: nil, defaults_used: Set.new)
-  }
-
-  it "returns keys as strings, with aliases" do
-    assert_equal(["a", "b", "inputObject"], arguments.keys)
-  end
-
-  it "delegates values to values hash" do
-    assert_equal([1, 2, {"d" => 3, "e" => 4}], arguments.values)
-  end
-
-  it "delegates each to values hash" do
-    pairs = []
-    arguments.each do |key, value|
-      pairs << [key, value]
-    end
-    assert_equal([["a", 1], ["b", 2], ["inputObject", {"d" => 3, "e" => 4}]], pairs)
-  end
-
-  it "returns a stringified, aliased hash with to_h" do
-    assert_equal({ "a"=> 1, "b" => 2, "inputObject" => { "d" => 3, "e" => 4 } }, arguments.to_h)
-  end
-
-  it "yields key, value, and arg_defnition" do
-    type_info = []
-    arguments.each_value do |arg_value|
-      value = arg_value.value.is_a?(GraphQL::Query::Arguments) ? arg_value.value.to_h : arg_value.value
-      type_info << [arg_value.key, value, arg_value.definition.type.unwrap.name]
-    end
-
-    expected_type_info =[
-      ["a", 1, "Int"],
-      ["b", 2, "Int"],
-      ["inputObject", { "d" => 3, "e" => 4 }, "TestInput1"],
-    ]
-    assert_equal expected_type_info, type_info
-  end
-
-  it "can be copied to a new Arguments instance" do
-    transformed_args = {}
-    types = {}
-    arguments.each_value do |arg_value|
-      transformed_args[arg_value.key.upcase] = arg_value.value
-      defn = arg_value.definition
-      types[arg_value.key.upcase] = defn.redefine(
-        name: defn.name.upcase,
-        as: defn.as ? defn.as.to_s.upcase : nil,
-      )
-    end
-
-    args_class = Class.new(GraphQL::Query::Arguments) do
-      self.argument_definitions = types
-    end
-
-    new_arguments = args_class.new(transformed_args, context: nil, defaults_used: Set.new)
-    expected_hash = {
-      "A" => 1,
-      "B" => 2,
-      "INPUTOBJECT" => { "d"  => 3 , "e" => 4 },
-    }
-    assert_equal expected_hash, new_arguments.to_h
-  end
-
-  describe "nested hashes" do
-    let(:input_type) {
-      test_input_type = GraphQL::InputObjectType.define do
-        name "TestInput"
-        argument :a, types.Int
-        argument :b, test_input_type
-        argument :c, types.Int # will be a hash
-      end
-      GraphQL::Query::Arguments.construct_arguments_class(test_input_type)
-      test_input_type
-    }
-    it "wraps input objects, but not other hashes" do
-      args = input_type.arguments_class.new(
-        {a: 1, b: {a: 2}, c: {a: 3}},
-        defaults_used: Set.new,
-        context: nil,
-      )
-      assert_kind_of GraphQL::Query::Arguments, args["b"]
-      assert_instance_of Hash, args["c"]
-    end
-  end
-
-  describe "#[]" do
-    it "fetches using specified `as` keyword" do
-      assert arguments["inputObject"].is_a?(GraphQL::Query::Arguments)
-    end
-
-    it "returns the value at that key" do
-      assert_equal 1, arguments["a"]
-      assert_equal 1, arguments[:a]
-      assert arguments["inputObject"].is_a?(GraphQL::Query::Arguments)
-    end
-
-    it "returns nil for missing keys" do
-      assert_nil arguments["z"]
-      assert_nil arguments[7]
-    end
-  end
-
-  describe "#dig" do
-    it "returns the value at that key" do
-      assert_equal 1, arguments.dig("a")
-      assert_equal 1, arguments.dig(:a)
-      assert arguments.dig("inputObject").is_a?(GraphQL::Query::Arguments)
-    end
-
-    it "works with nested keys" do
-      assert_equal 3, arguments.dig("inputObject", "d")
-      assert_equal 3, arguments.dig(:inputObject, :d)
-      assert_equal 3, arguments.dig("inputObject", :d)
-      assert_equal 3, arguments.dig(:inputObject, "d")
-    end
-
-    it "returns nil for missing keys" do
-      assert_nil arguments.dig("z")
-      assert_nil arguments.dig(7)
-    end
-  end
-
-
-  describe "#key?" do
-    let(:arg_values) { [] }
-    let(:schema) {
-      arg_values_array = arg_values
-
-      test_input_type = GraphQL::InputObjectType.define do
-        name "TestInput"
-        argument :a, types.Int
-        argument :b, types.Int, default_value: 2
-        argument :c, types.Int
-        argument :d, types.Int
-      end
-
-      query = GraphQL::ObjectType.define do
-        name "Query"
-        field :argTest, types.Int do
-          argument :a, types.Int
-          argument :b, types.Int, default_value: 2
-          argument :c, types.Int, as: :specialKeyName
-          argument :d, test_input_type
-          resolve ->(obj, args, ctx) {
-            arg_values_array << args
-            1
-          }
-        end
-
-        field :noArgTest, types.Int do
-          resolve ->(obj, args, ctx) {
-            arg_values_array << args
-            1
-          }
-        end
-
-        field :noDefaultsTest, types.Int do
-          argument :a, types.Int
-          argument :b, types.Int
-          resolve ->(obj, args, ctx) {
-            arg_values_array << args
-            1
-          }
-          resolve ->(obj, args, ctx) {
-            arg_values_array << args
-            1
-          }
-        end
-      end
-
-      GraphQL::Schema.define(query: query)
-    }
-
-    it "detects missing keys by string or symbol" do
-      assert_equal true, arguments.key?(:a)
-      assert_equal true, arguments.key?("a")
-      assert_equal false, arguments.key?(:f)
-      assert_equal false, arguments.key?("f")
-    end
-
-    it "detects keys using `as` to rename an arg at resolve time" do
-      schema.execute("{ argTest(c: 1) }")
-
-      last_args = arg_values.last
-
-      assert_equal true, last_args.key?(:specialKeyName)
-      assert_equal true, last_args.key?("specialKeyName")
-    end
-
-    it "works from query literals" do
-      schema.execute("{ argTest(a: 1) }")
-
-      last_args = arg_values.last
-
-      assert_equal true, last_args.key?(:a)
-      # This is present from default value:
-      assert_equal true, last_args.key?(:b)
-      assert_equal false, last_args.key?(:c)
-      assert_equal({"a" => 1, "b" => 2}, last_args.to_h)
-    end
-
-    it "indicates when default argument values were applied" do
-      schema.execute("{ argTest(a: 1) }")
-
-      last_args = arg_values.last
-
-      assert_equal false, last_args.default_used?('a')
-      assert_equal true, last_args.default_used?('b')
-    end
-
-    it "works from variables" do
-      variables = { "arg" => { "a" => 1, "d" => nil } }
-      schema.execute("query ArgTest($arg: TestInput){ argTest(d: $arg) }", variables: variables)
-
-      test_inputs = arg_values.last["d"]
-
-      assert_equal true, test_inputs.key?(:a)
-      # This is present from default value:
-      assert_equal true, test_inputs.key?(:b)
-
-      assert_equal false, test_inputs.key?(:c)
-      assert_equal true, test_inputs.key?(:d)
-
-      assert_equal({"a" => 1, "b" => 2, "d" => nil}, test_inputs.to_h)
-    end
-
-    it "works with variable default values" do
-      schema.execute("query ArgTest($arg: TestInput = {a: 1}){ argTest(d: $arg) }")
-
-      test_defaults = arg_values.last["d"]
-
-      assert_equal true, test_defaults.key?(:a)
-      # This is present from default val
-      assert_equal true, test_defaults.key?(:b)
-
-      assert_equal false, test_defaults.key?(:c)
-      assert_equal false, test_defaults.key?(:d)
-      assert_equal({"a" => 1, "b" => 2}, test_defaults.to_h)
-    end
-
-    it "works with variable default values with null" do
-      schema.execute("query ArgTest($arg: TestInput = {d: null}){ argTest(d: $arg) }")
-
-      test_defaults = arg_values.last["d"]
-
-      assert_equal false, test_defaults.key?(:a)
-      # This is present from default val
-      assert_equal true, test_defaults.key?(:b)
-
-      assert_equal false, test_defaults.key?(:c)
-      assert_equal true, test_defaults.key?(:d)
-
-      assert_equal({"d" => nil, "b" => 2}, test_defaults.to_h)
-    end
-  end
-
-  describe "prepare" do
-    let(:arg_values) { [] }
-    let(:schema) {
-      arg_values_array = arg_values
-      test_input_1 = GraphQL::InputObjectType.define do
-        name "TestInput1"
-        argument :a, types.Int, prepare: ->(value, ctx) do
-          value * 10
-        end
-      end
-
-      test_input_2 = GraphQL::InputObjectType.define do
-        name "TestInput2"
-        argument :b, !test_input_1, as: :inputObject
-      end
-
-      query = GraphQL::ObjectType.define do
-        name "Query"
-        field :prepareTest, types.Int do
-          argument :a, test_input_2
-          resolve ->(obj, args, ctx) {
-            arg_values_array << args
-            1
-          }
-        end
-      end
-
-      GraphQL::Schema.define(query: query)
-    }
-
-    it "returns prepared argument value for nested input type" do
-      schema.execute("query prepareTest($arg: TestInput2 = {b: {a: 2}}){ prepareTest(a: $arg) }")
-
-      args = arg_values[0].values[0]
-      assert_equal 2 * 10, args['inputObject']['a']
-    end
-
-    it "returns prepared argument value for nested input type" do
-      query_str = "
-        query($arg: TestInput2){
-          prepareTest(a: $arg)
-      }"
-
-      schema.execute(query_str, variables: { "arg" => { "b" => { "a" => 3 } } } )
-
-      args = arg_values[0].values[0]
-      assert_equal 30, args['inputObject']['a']
-    end
-  end
-
-  describe "construct_arguments_class" do
-    let(:input_object) do
-      GraphQL::InputObjectType.define do
-        argument :foo, types.Int
-        argument :bar, types.Int
-      end
-    end
-
-    it "generates argument classes that responds to keys as functions" do
-      assert_nil input_object.arguments_class
-
-      GraphQL::Query::Arguments.construct_arguments_class(input_object)
-      args = input_object.arguments_class.new({foo: 3, bar: -90}, defaults_used: Set.new, context: nil)
-
-      assert_equal 3, args.foo
-      assert_equal -90, args.bar
-    end
-  end
-end