graphql 1.9.0 → 2.1.1

data/spec/graphql/field_spec.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-# Must be top-level so it can be found by string
-FieldSpecReturnType = GraphQL::ObjectType.define do
-  name "FieldReturn"
-  field :id, types.Int
-  field :source, types.String, hash_key: :source
-end
-
-describe GraphQL::Field do
-
-  it "accepts a proc as type" do
-    field = GraphQL::Field.define do
-      type(-> { FieldSpecReturnType })
-    end
-
-    assert_equal(FieldSpecReturnType, field.type)
-  end
-
-  it "accepts a string as a type" do
-    field = GraphQL::Field.define do
-      type("FieldSpecReturnType")
-    end
-
-    assert_equal(FieldSpecReturnType, field.type)
-  end
-
-  it "accepts arguments definition" do
-    number = GraphQL::Argument.define(name: :number, type: -> { GraphQL::INT_TYPE })
-    field = GraphQL::Field.define(type: FieldSpecReturnType, arguments: [number])
-    assert_equal([number], field.arguments)
-  end
-
-  describe ".property " do
-    let(:field) do
-      GraphQL::Field.define do
-        name "field_name"
-        # satisfies 'can define by config' below
-        property :internal_prop
-      end
-    end
-
-    it "can define by config" do
-      assert_equal(field.property, :internal_prop)
-    end
-
-    it "has nil property if not defined" do
-      no_prop_field = GraphQL::Field.define { }
-      assert_equal(no_prop_field.property, nil)
-    end
-
-    describe "default resolver" do
-      def acts_like_default_resolver(field, old_prop, new_prop)
-        object = OpenStruct.new(old_prop => "old value", new_prop => "new value", field.name.to_sym => "unset value")
-
-
-        old_result = field.resolve(object, nil, nil)
-        field.property = new_prop
-        new_result = field.resolve(object, nil, nil)
-        field.property = nil
-        unset_result = field.resolve(object, nil, nil)
-
-        assert_equal(old_result, "old value")
-        assert_equal(new_result, "new value")
-        assert_equal(unset_result, "unset value")
-      end
-
-      it "responds to changes in property" do
-        acts_like_default_resolver(field, :internal_prop, :new_prop)
-      end
-
-      it "is reassigned if resolve is set to nil" do
-        field.resolve = nil
-        acts_like_default_resolver(field, :internal_prop, :new_prop)
-      end
-    end
-  end
-
-  describe "#name" do
-    it "must be a string" do
-      dummy_query = GraphQL::ObjectType.define do
-        name "QueryType"
-      end
-
-      invalid_field = GraphQL::Field.new
-      invalid_field.type = dummy_query
-      invalid_field.name = :symbol_name
-
-      dummy_query.fields["symbol_name"] = invalid_field
-
-      err = assert_raises(GraphQL::Schema::InvalidTypeError) {
-        GraphQL::Schema.define(query: dummy_query, raise_definition_error: true)
-      }
-      assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message
-    end
-  end
-
-  describe "#hash_key" do
-    let(:source_field) { FieldSpecReturnType.get_field("source") }
-    after { source_field.hash_key = :source }
-
-    it "looks up a value with obj[hash_key]" do
-      resolved_source = source_field.resolve({source: "Abc", "source" => "Xyz"}, nil, nil)
-      assert_equal :source, source_field.hash_key
-      assert_equal "Abc", resolved_source
-    end
-
-    it "can be reassigned" do
-      source_field.hash_key = "source"
-      resolved_source = source_field.resolve({source: "Abc", "source" => "Xyz"}, nil, nil)
-      assert_equal "source", source_field.hash_key
-      assert_equal "Xyz", resolved_source
-    end
-  end
-
-  describe "#metadata" do
-    it "accepts user-defined metadata" do
-      similar_cheese_field = Dummy::Cheese.graphql_definition.get_field("similarCheese")
-      assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
-    end
-  end
-
-  describe "reusing a GraphQL::Field" do
-    let(:schema) {
-      int_field = GraphQL::Field.define do
-        type types.Int
-        argument :value, types.Int
-        resolve ->(obj, args, ctx) { args[:value] }
-      end
-
-      query_type = GraphQL::ObjectType.define do
-        name "Query"
-        field :int, int_field
-        field :int2, int_field
-        field :int3, field: int_field
-      end
-
-      GraphQL::Schema.define do
-        query(query_type)
-      end
-    }
-
-    it "can be used in two places" do
-      res = schema.execute %|{ int(value: 1) int2(value: 2) int3(value: 3) }|
-      assert_equal({ "int" => 1, "int2" => 2, "int3" => 3}, res["data"], "It works in queries")
-
-      res = schema.execute %|{ __type(name: "Query") { fields { name } } }|
-      query_field_names = res["data"]["__type"]["fields"].map { |f| f["name"] }
-      assert_equal ["int", "int2", "int3"], query_field_names, "It works in introspection"
-    end
-  end
-
-  describe "#redefine" do
-    it "can add arguments" do
-      int_field = GraphQL::Field.define do
-        argument :value, types.Int
-      end
-
-      int_field_2 = int_field.redefine do
-        argument :value_2, types.Int
-      end
-
-      assert_equal 1, int_field.arguments.size
-      assert_equal 2, int_field_2.arguments.size
-    end
-
-    it "rebuilds when the resolve_proc is default NameResolve" do
-      int_field = GraphQL::Field.define do
-        name "a"
-      end
-
-      int_field_2 = int_field.redefine(name: "b")
-
-      object = Struct.new(:a, :b).new(1, 2)
-
-      assert_equal 1, int_field.resolve_proc.call(object, nil, nil)
-      assert_equal 2, int_field_2.resolve_proc.call(object, nil, nil)
-    end
-
-    it "keeps the same resolve_proc when it is not a NameResolve" do
-      int_field = GraphQL::Field.define do
-        name "a"
-        resolve ->(obj, _, _) { 'GraphQL is Kool' }
-      end
-
-      int_field_2 = int_field.redefine(name: "b")
-
-      assert_equal(
-        int_field.resolve_proc.call(nil, nil, nil),
-        int_field_2.resolve_proc.call(nil, nil, nil)
-      )
-    end
-
-    it "keeps the same resolve_proc when it is a built in property resolve" do
-      int_field = GraphQL::Field.define do
-        name "a"
-        property :c
-      end
-
-      int_field_2 = int_field.redefine(name: "b")
-
-      object = Struct.new(:a, :b, :c).new(1, 2, 3)
-
-      assert_equal 3, int_field.resolve_proc.call(object, nil, nil)
-      assert_equal 3, int_field_2.resolve_proc.call(object, nil, nil)
-    end
-
-    it "copies metadata, even out-of-bounds assignments" do
-      int_field = GraphQL::Field.define do
-        metadata(:a, 1)
-        argument :value, types.Int
-      end
-      int_field.metadata[:b] = 2
-
-      int_field_2 = int_field.redefine do
-        metadata(:c, 3)
-        argument :value_2, types.Int
-      end
-
-      assert_equal({a: 1, b: 2}, int_field.metadata)
-      assert_equal({a: 1, b: 2, c: 3}, int_field_2.metadata)
-    end
-  end
-
-  describe "#resolve_proc" do
-    it "ensures the definition was called" do
-      class SimpleResolver
-        def self.call(*args)
-          :whatever
-        end
-      end
-
-      field_with_proc = GraphQL::Field.define do
-        resolve ->(o, a, c) { :whatever }
-      end
-
-      field_with_class = GraphQL::Field.define do
-        resolve SimpleResolver
-      end
-
-      assert_respond_to field_with_proc.resolve_proc, :call
-      assert_respond_to field_with_class.resolve_proc, :call
-    end
-  end
-end

data/spec/graphql/float_type_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::FLOAT_TYPE do
-  describe "coerce_input" do
-    it "accepts ints and floats" do
-      assert_equal 1.0, GraphQL::FLOAT_TYPE.coerce_isolated_input(1)
-      assert_equal 6.1, GraphQL::FLOAT_TYPE.coerce_isolated_input(6.1)
-    end
-
-    it "rejects other types" do
-      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
-      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
-    end
-  end
-end

data/spec/graphql/function_spec.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Function do
-  class TestFunc < GraphQL::Function
-    argument :name, GraphQL::STRING_TYPE
-    argument :age, types.Int
-    type do
-      name "TestFuncPayload"
-      field :name, types.String, hash_key: :name
-    end
-
-    description "Returns the string you give it"
-    deprecation_reason "It's useless"
-    complexity 9
-    def call(o, a, c)
-      { name: a[:name] }
-    end
-  end
-
-  describe "function API" do
-    it "exposes required info" do
-      f = TestFunc.new
-      assert_equal ["name", "age"], f.arguments.keys
-      assert_equal "TestFuncPayload", f.type.name
-      assert_equal "Returns the string you give it", f.description
-      assert_equal "It's useless", f.deprecation_reason
-      assert_equal({name: "stuff"}, f.call(nil, { name: "stuff" }, nil))
-      assert_equal 9, f.complexity
-
-      assert_equal TestFunc.new.type, TestFunc.new.type
-    end
-  end
-
-  it "has default values" do
-    default_func = GraphQL::Function.new
-    assert_equal 1, default_func.complexity
-    assert_equal({}, default_func.arguments)
-    assert_equal(nil, default_func.type)
-    assert_equal(nil, default_func.description)
-    assert_equal(nil, default_func.deprecation_reason)
-    assert_raises(NotImplementedError) {
-      default_func.call(nil, nil, nil)
-    }
-  end
-
-  describe "use in a schema" do
-    let(:schema) {
-      query_type = GraphQL::ObjectType.define do
-        name "Query"
-        field :test, function: TestFunc.new
-        connection :testConn, function: TestFunc.new
-      end
-
-      relay_mutation = GraphQL::Relay::Mutation.define do
-        name "Test"
-        function TestFunc.new
-      end
-
-      mutation_type = GraphQL::ObjectType.define do
-        name "Mutation"
-        field :test, field: relay_mutation.field
-      end
-
-      GraphQL::Schema.define do
-        query(query_type)
-        mutation(mutation_type)
-      end
-    }
-
-    it "gets attributes from the function" do
-      field = schema.query.fields["test"]
-      assert_equal ["name", "age"], field.arguments.keys
-      assert_equal "TestFuncPayload", field.type.name
-      assert_equal "Returns the string you give it", field.description
-      assert_equal "It's useless", field.deprecation_reason
-      assert_equal({name: "stuff"}, field.resolve(nil, { name: "stuff" }, nil))
-      assert_equal 9, field.complexity
-    end
-
-    it "can be used as a field" do
-      query_str = <<-GRAPHQL
-      { test(name: "graphql") { name }}
-      GRAPHQL
-      res = schema.execute(query_str)
-      assert_equal "graphql", res["data"]["test"]["name"]
-    end
-
-    it "can be used as a mutation" do
-      query_str = <<-GRAPHQL
-      mutation { test(input: {clientMutationId: "123", name: "graphql"}) { name, clientMutationId } }
-      GRAPHQL
-      res = schema.execute(query_str)
-      assert_equal "graphql", res["data"]["test"]["name"]
-    end
-  end
-
-  describe "when overriding" do
-    let(:schema) {
-      query_type = GraphQL::ObjectType.define do
-        name "Query"
-        field :blockOverride, function: TestFunc.new do
-          description "I have altered the description"
-          argument :anArg, types.Int
-          argument :oneMoreArg, types.String
-        end
-
-        field :argOverride, types.String, "New Description", function: TestFunc.new
-      end
-
-      GraphQL::Schema.define do
-        query(query_type)
-      end
-    }
-
-    it "can override description" do
-      field = schema.query.fields["blockOverride"]
-      assert_equal "I have altered the description", field.description
-      assert_equal ["name", "age", "anArg", "oneMoreArg"], field.arguments.keys
-    end
-
-    it "can add to arguments" do
-      field = schema.query.fields["argOverride"]
-      assert_equal "New Description", field.description
-      assert_equal GraphQL::STRING_TYPE, field.type
-      assert_equal ["name", "age"], field.arguments.keys
-    end
-  end
-end

data/spec/graphql/id_type_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::ID_TYPE do
-  let(:result) { Dummy::Schema.execute(query_string)}
-
-  describe "coercion for int inputs" do
-    let(:query_string) { %|query getMilk { cow: milk(id: 1) { id } }| }
-
-    it "coerces IDs from ints and serializes as strings" do
-      expected = {"data" => {"cow" => {"id" => "1"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "coercion for string inputs" do
-    let(:query_string) { %|query getMilk { cow: milk(id: "1") { id } }| }
-
-    it "coerces IDs from strings and serializes as strings" do
-      expected = {"data" => {"cow" => {"id" => "1"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "coercion for other types" do
-    let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
-
-    it "doesn't allow other types" do
-      assert_nil result["data"]
-      assert_equal 1, result["errors"].length
-    end
-  end
-end

data/spec/graphql/input_object_type_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe GraphQL::InputObjectType do
-  describe 'default values' do
-    describe 'when the type is an enum with underlying ruby values' do
-      it 'provides the default value' do
-        TestEnum = GraphQL::EnumType.define do
-          name 'Test'
-
-          value 'A', 'Represents an authorized agent in our system.', value: 'a'
-          value 'B', 'Agent is disabled, web app access is denied.', value: 'b'
-        end
-
-        class TestInput < GraphQL::Schema::InputObject
-          argument :foo, TestEnum, 'TestEnum', required: false, default_value: 'a'
-        end
-
-        test_input_type = TestInput.to_graphql
-        default_test_input_value = test_input_type.coerce_isolated_input({})
-        assert_equal default_test_input_value[:foo], 'a'
-      end
-    end
-  end
-end

data/spec/graphql/int_type_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::INT_TYPE do
-  describe "coerce_input" do
-    it "accepts ints and floats" do
-      assert_equal 1, GraphQL::INT_TYPE.coerce_isolated_input(1)
-      assert_equal 6, GraphQL::INT_TYPE.coerce_isolated_input(6.1)
-    end
-
-    it "rejects other types" do
-      assert_nil GraphQL::INT_TYPE.coerce_isolated_input("55")
-      assert_nil GraphQL::INT_TYPE.coerce_isolated_input(true)
-    end
-
-    describe "handling boundaries" do
-      let(:context) { GraphQL::Query.new(Dummy::Schema, "{ __typename }").context }
-
-      it "accepts result values in bounds" do
-        assert_equal 0, GraphQL::INT_TYPE.coerce_result(0, context)
-        assert_equal (2**31) - 1, GraphQL::INT_TYPE.coerce_result((2**31) - 1, context)
-        assert_equal -(2**31), GraphQL::INT_TYPE.coerce_result(-(2**31), context)
-      end
-
-      it "replaces values, if configured to do so" do
-        assert_equal Dummy::Schema::MAGIC_INT_COERCE_VALUE, GraphQL::INT_TYPE.coerce_result(99**99, context)
-      end
-
-      it "raises on values out of bounds" do
-        assert_raises(GraphQL::IntegerEncodingError) { GraphQL::INT_TYPE.coerce_result(2**31, context) }
-        assert_raises(GraphQL::IntegerEncodingError) { GraphQL::INT_TYPE.coerce_result(-(2**31 + 1), context) }
-      end
-    end
-  end
-end

data/spec/graphql/interface_type_spec.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::InterfaceType do
-  let(:interface) { Dummy::Edible.graphql_definition }
-  let(:dummy_query_context) { OpenStruct.new(schema: Dummy::Schema) }
-
-  it "has possible types" do
-    assert_equal([Dummy::Cheese.graphql_definition, Dummy::Honey.graphql_definition, Dummy::Milk.graphql_definition], Dummy::Schema.possible_types(interface))
-  end
-
-  describe "query evaluation" do
-    let(:result) { Dummy::Schema.execute(query_string, variables: {"cheeseId" => 2})}
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-    it "gets fields from the type for the given object" do
-      expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "mergable query evaluation" do
-    let(:result) { Dummy::Schema.execute(query_string, variables: {"cheeseId" => 2})}
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-        favoriteEdible { origin }
-      }
-    |}
-    it "gets fields from the type for the given object" do
-      expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04, "origin"=>"Antiquity"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "fragments" do
-    let(:query_string) {%|
-    {
-      favoriteEdible {
-        fatContent
-        ... on LocalProduct {
-          origin
-        }
-      }
-    }
-    |}
-    let(:result) { Dummy::Schema.execute(query_string) }
-
-    it "can apply interface fragments to an interface" do
-      expected_result = { "data" => {
-        "favoriteEdible" => {
-          "fatContent" => 0.04,
-          "origin" => "Antiquity",
-        }
-      } }
-
-      assert_equal(expected_result, result)
-    end
-
-    describe "filtering members by type" do
-      let(:query_string) {%|
-      {
-        allEdible {
-          __typename
-          ... on LocalProduct {
-            origin
-          }
-        }
-      }
-      |}
-
-      it "only applies fields to the right object" do
-        expected_data = [
-          {"__typename"=>"Cheese", "origin"=>"France"},
-          {"__typename"=>"Cheese", "origin"=>"Netherlands"},
-          {"__typename"=>"Cheese", "origin"=>"Spain"},
-          {"__typename"=>"Milk", "origin"=>"Antiquity"},
-        ]
-
-        assert_equal expected_data, result["data"]["allEdible"]
-      end
-    end
-  end
-
-  describe "#dup" do
-    it "copies the fields without altering the original" do
-      interface_2 = interface.dup
-      interface_2.fields["extra"] = GraphQL::Field.define(name: "extra", type: GraphQL::BOOLEAN_TYPE)
-      assert_equal 3, interface.fields.size
-      assert_equal 4, interface_2.fields.size
-    end
-
-    it "copies orphan types without affecting the original" do
-      interface = GraphQL::InterfaceType.define do
-        name "AInterface"
-        orphan_types [Dummy::Honey]
-      end
-
-      interface_2 = interface.dup
-      interface_2.orphan_types << Dummy::Cheese
-      assert_equal 1, interface.orphan_types.size
-      assert_equal 2, interface_2.orphan_types.size
-    end
-  end
-
-  describe "#resolve_type" do
-    let(:result) { Dummy::Schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        allEdible {
-          __typename
-          ... on Milk {
-            milkFatContent: fatContent
-          }
-          ... on Cheese {
-            cheeseFatContent: fatContent
-          }
-        }
-
-        allEdibleAsMilk {
-          __typename
-          ... on Milk {
-            fatContent
-          }
-        }
-      }
-    |}
-
-    it 'returns correct types for general schema and specific interface' do
-      expected_result = {
-        # Uses schema-level resolve_type
-        "allEdible"=>[
-          {"__typename"=>"Cheese", "cheeseFatContent"=>0.19},
-          {"__typename"=>"Cheese", "cheeseFatContent"=>0.3},
-          {"__typename"=>"Cheese", "cheeseFatContent"=>0.065},
-          {"__typename"=>"Milk", "milkFatContent"=>0.04}
-        ],
-        # Uses type-level resolve_type
-        "allEdibleAsMilk"=>[
-          {"__typename"=>"Milk", "fatContent"=>0.19},
-          {"__typename"=>"Milk", "fatContent"=>0.3},
-          {"__typename"=>"Milk", "fatContent"=>0.065},
-          {"__typename"=>"Milk", "fatContent"=>0.04}
-        ]
-      }
-      assert_equal expected_result, result["data"]
-    end
-  end
-
-  describe "#get_possible_type" do
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-
-    it "returns the type definition if the type exists and is a possible type of the interface" do
-      assert interface.get_possible_type("Cheese", query.context)
-    end
-
-    it "returns nil if the type is not found in the schema" do
-      assert_nil interface.get_possible_type("Foo", query.context)
-    end
-
-    it "returns nil if the type is not a possible type of the interface" do
-      assert_nil interface.get_possible_type("Beverage", query.context)
-    end
-  end
-
-  describe "#possible_type?" do
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-
-    it "returns true if the type exists and is a possible type of the interface" do
-      assert interface.possible_type?("Cheese", query.context)
-    end
-
-    it "returns false if the type is not found in the schema" do
-      refute interface.possible_type?("Foo", query.context)
-    end
-
-    it "returns false if the type is not a possible type of the interface" do
-      refute interface.possible_type?("Beverage", query.context)
-    end
-  end
-end