graphql 1.4.5 → 1.5.3

data/spec/generators/graphql/interface_generator_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/interface_generator"
+
+class GraphQLGeneratorsInterfaceGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::InterfaceGenerator
+
+  test "it generates fields with types" do
+    commands = [
+      # GraphQL-style:
+      ["Bird", "wingspan:Int!", "foliage:[Color]"],
+      # Ruby-style:
+      ["BirdType", "wingspan:!types.Int", "foliage:types[Types::ColorType]"],
+      # Mixed
+      ["BirdType", "wingspan:!Int", "foliage:types[Color]"],
+    ]
+
+    expected_content = <<-RUBY
+Types::BirdType = GraphQL::InterfaceType.define do
+  name "Bird"
+  field :wingspan, !types.Int
+  field :foliage, types[Types::ColorType]
+end
+RUBY
+
+    commands.each do |c|
+      prepare_destination
+      run_generator(c)
+      assert_file "app/graphql/types/bird_type.rb", expected_content
+    end
+  end
+end

data/spec/generators/graphql/loader_generator_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/loader_generator"
+
+class GraphQLGeneratorsLoaderGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::LoaderGenerator
+
+  test "it generates an empty loader by name" do
+    run_generator(["RecordLoader"])
+
+    expected_content = <<-RUBY
+class Loaders::RecordLoader < GraphQL::Batch::Loader
+  # Define `initialize` to store grouping arguments, eg
+  #
+  #     Loaders::RecordLoader.for(group).load(value)
+  #
+  # def initialize()
+  # end
+
+  # `keys` contains each key from `.load(key)`.
+  # Find the corresponding values, then
+  # call `fulfill(key, value)` or `fulfill(key, nil)`
+  # for each key.
+  def perform(keys)
+  end
+end
+RUBY
+
+    assert_file "app/graphql/loaders/record_loader.rb", expected_content
+  end
+end

data/spec/generators/graphql/mutation_generator_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/mutation_generator"
+
+class GraphQLGeneratorsMutationGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::MutationGenerator
+
+  test "it generates an empty resolver by name" do
+    run_generator(["UpdateName"])
+
+    expected_content = <<-RUBY
+Mutations::UpdateName = GraphQL::Relay::Mutation.define do
+  name "UpdateName"
+  # TODO: define return fields
+  # return_field :post, Types::PostType
+
+  # TODO: define arguments
+  # input_field :name, !types.String
+
+  resolve ->(obj, args, ctx) {
+    # TODO: define resolve function
+  }
+end
+RUBY
+
+    assert_file "app/graphql/mutations/update_name.rb", expected_content
+  end
+end

data/spec/generators/graphql/object_generator_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/object_generator"
+
+class GraphQLGeneratorsObjectGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::ObjectGenerator
+
+  test "it generates fields with types" do
+    commands = [
+      # GraphQL-style:
+      ["Bird", "wingspan:Int!", "foliage:[Color]"],
+      # Ruby-style:
+      ["BirdType", "wingspan:!types.Int", "foliage:types[Types::ColorType]"],
+      # Mixed
+      ["BirdType", "wingspan:!Int", "foliage:types[Color]"],
+    ]
+
+    expected_content = <<-RUBY
+Types::BirdType = GraphQL::ObjectType.define do
+  name "Bird"
+  field :wingspan, !types.Int
+  field :foliage, types[Types::ColorType]
+end
+RUBY
+
+    commands.each do |c|
+      prepare_destination
+      run_generator(c)
+      assert_file "app/graphql/types/bird_type.rb", expected_content
+    end
+  end
+
+  test "it makes Relay nodes" do
+    run_generator(["Page", "--node"])
+    assert_file "app/graphql/types/page_type.rb", <<-RUBY
+Types::PageType = GraphQL::ObjectType.define do
+  name "Page"
+  implements GraphQL::Relay::Node.interface
+end
+RUBY
+  end
+end

data/spec/generators/graphql/union_generator_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/union_generator"
+
+class GraphQLGeneratorsUnionGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::UnionGenerator
+
+  test "it generates a union with possible types" do
+    commands = [
+      # GraphQL-style:
+      ["WingedCreature", "Insect", "Bird"],
+      # Ruby-style:
+      ["Types::WingedCreatureType", "Types::InsectType", "Types::BirdType"],
+    ]
+
+    expected_content = <<-RUBY
+Types::WingedCreatureType = GraphQL::UnionType.define do
+  name "WingedCreature"
+  possible_types [Types::InsectType, Types::BirdType]
+end
+RUBY
+
+    commands.each do |c|
+      prepare_destination
+      run_generator(c)
+      assert_file "app/graphql/types/winged_creature_type.rb", expected_content
+    end
+  end
+
+  test "it works with no possible types" do
+    commands = [
+      # GraphQL-style:
+      ["WingedCreature"],
+      # Ruby-style:
+      ["Types::WingedCreatureType"],
+    ]
+
+    expected_content = <<-RUBY
+Types::WingedCreatureType = GraphQL::UnionType.define do
+  name "WingedCreature"
+end
+RUBY
+
+    commands.each do |c|
+      prepare_destination
+      run_generator(c)
+      assert_file "app/graphql/types/winged_creature_type.rb", expected_content
+    end
+  end
+end

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -141,6 +141,7 @@ describe GraphQL::Analysis::QueryComplexity do
     describe "when there are no selections on any object types" do
       let(:query_string) {%|
         {
+          # 1 for everybody
           favoriteEdible {
             # 1 for everybody
             fatContent
@@ -156,7 +157,7 @@ describe GraphQL::Analysis::QueryComplexity do
 
       it "gets the max among interface types" do
         reduce_result
-        assert_equal 3, complexities.last
+        assert_equal 4, complexities.last
       end
     end
 

data/spec/graphql/define/instance_definable_spec.rb

@@ -116,6 +116,44 @@ describe GraphQL::Define::InstanceDefinable do
     end
   end
 
+  describe "#use" do
+    class TestPlugin
+      attr_reader :target
+
+      def use(defn)
+        @target = defn.target
+        defn.name('Arugula')
+      end
+    end
+
+    module TestPluginWithKwargs
+      extend self
+
+      def use(defn, name:)
+        defn.name(name)
+      end
+    end
+
+    it "sends a message to the specified plugin's :use method with access to the proxy object and target object" do
+      plugin = TestPlugin.new
+
+      arugula = Garden::Vegetable.define do
+        use plugin
+      end
+
+      assert_equal 'Arugula', arugula.name
+      assert_equal arugula, plugin.target
+    end
+
+    it "passes kwargs to plugin's `use` method" do
+      arugula = Garden::Vegetable.define do
+        use TestPluginWithKwargs, name: 'Arugula'
+      end
+
+      assert_equal 'Arugula', arugula.name
+    end
+  end
+
   describe "typos" do
     it "provides the right class name, method name and line number" do
       err = assert_raises(NoMethodError) {

data/spec/graphql/directive/skip_directive_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Directive::SkipDirective do

data/spec/graphql/directive_spec.rb

@@ -28,6 +28,24 @@ describe GraphQL::Directive do
     |
     }
 
+    describe "child fields" do
+      let(:query_string) { <<-GRAPHQL
+      {
+        __type(name: "Cheese") {
+          fields { name }
+          fields @skip(if: true) { isDeprecated }
+        }
+      }
+      GRAPHQL
+      }
+
+      it "skips child fields too" do
+        first_field = result["data"]["__type"]["fields"].first
+        assert first_field.key?("name")
+        assert !first_field.key?("isDeprecated")
+      end
+    end
+
     it "intercepts fields" do
       expected = { "data" =>{
         "cheese" => {

data/spec/graphql/execution/typecast_spec.rb

@@ -2,51 +2,46 @@
 require "spec_helper"
 
 describe GraphQL::Execution::Typecast do
-  let(:milk_value) { MILKS[1] }
-  let(:cheese_value) { CHEESES[1] }
-
-  let(:schema) { Dummy::Schema }
-  let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
-
-  def compatible?(*args)
-    GraphQL::Execution::Typecast.compatible?(*args)
-  end
-
-  it "resolves correctly when both types are the same" do
-    assert compatible?(Dummy::MilkType, Dummy::MilkType, context)
-
-    assert !compatible?(Dummy::MilkType, Dummy::CheeseType, context)
-  end
-
-  it "resolves a union type to a matching member" do
-    assert compatible?(Dummy::DairyProductUnion, Dummy::MilkType, context)
-    assert compatible?(Dummy::DairyProductUnion, Dummy::CheeseType, context)
-
-    assert !compatible?(Dummy::DairyProductUnion, GraphQL::INT_TYPE, context)
-    assert !compatible?(Dummy::DairyProductUnion, Dummy::HoneyType, context)
-  end
-
-  it "resolves correcty when potential type is UnionType and current type is a member of that union" do
-    assert compatible?(Dummy::MilkType, Dummy::DairyProductUnion, context)
-    assert compatible?(Dummy::CheeseType, Dummy::DairyProductUnion, context)
-
-    assert !compatible?(Dummy::DairyAppQueryType, Dummy::DairyProductUnion, context)
-    assert !compatible?(Dummy::EdibleInterface, Dummy::DairyProductUnion, context)
-  end
-
-  it "resolves an object type to one of its interfaces" do
-    assert compatible?(Dummy::CheeseType, Dummy::EdibleInterface, context)
-    assert compatible?(Dummy::MilkType, Dummy::EdibleInterface, context)
-
-    assert !compatible?(Dummy::DairyAppQueryType, Dummy::EdibleInterface, context)
-    assert !compatible?(Dummy::LocalProductInterface, Dummy::EdibleInterface, context)
-  end
-
-  it "resolves an interface to a matching member" do
-    assert compatible?(Dummy::EdibleInterface, Dummy::CheeseType, context)
-    assert compatible?(Dummy::EdibleInterface, Dummy::MilkType, context)
-
-    assert !compatible?(Dummy::EdibleInterface, GraphQL::STRING_TYPE, context)
-    assert !compatible?(Dummy::EdibleInterface, Dummy::DairyProductInputType, context)
+  describe ".subtype?" do
+    def subtype?(*args)
+      GraphQL::Execution::Typecast.subtype?(*args)
+    end
+
+    it "counts the same type as a subtype" do
+      assert subtype?(Dummy::MilkType, Dummy::MilkType)
+      assert !subtype?(Dummy::MilkType, Dummy::CheeseType)
+      assert subtype?(Dummy::MilkType.to_list_type.to_non_null_type, Dummy::MilkType.to_list_type.to_non_null_type)
+    end
+
+    it "counts member types as subtypes" do
+      assert subtype?(Dummy::EdibleInterface, Dummy::CheeseType)
+      assert subtype?(Dummy::EdibleInterface, Dummy::MilkType)
+      assert subtype?(Dummy::DairyProductUnion, Dummy::MilkType)
+      assert subtype?(Dummy::DairyProductUnion, Dummy::CheeseType)
+
+      assert !subtype?(Dummy::DairyAppQueryType, Dummy::DairyProductUnion)
+      assert !subtype?(Dummy::CheeseType, Dummy::DairyProductUnion)
+      assert !subtype?(Dummy::EdibleInterface, Dummy::DairyProductUnion)
+      assert !subtype?(Dummy::EdibleInterface, GraphQL::STRING_TYPE)
+      assert !subtype?(Dummy::EdibleInterface, Dummy::DairyProductInputType)
+    end
+
+    it "counts lists as subtypes if their inner types are subtypes" do
+      assert subtype?(Dummy::EdibleInterface.to_list_type, Dummy::MilkType.to_list_type)
+      assert subtype?(Dummy::DairyProductUnion.to_list_type, Dummy::MilkType.to_list_type)
+      assert !subtype?(Dummy::CheeseType.to_list_type, Dummy::DairyProductUnion.to_list_type)
+      assert !subtype?(Dummy::EdibleInterface.to_list_type, Dummy::DairyProductUnion.to_list_type)
+      assert !subtype?(Dummy::EdibleInterface.to_list_type, GraphQL::STRING_TYPE.to_list_type)
+    end
+
+    it "counts non-null types as subtypes of nullable parent types" do
+      assert subtype?(Dummy::MilkType, Dummy::MilkType.to_non_null_type)
+      assert subtype?(Dummy::EdibleInterface, Dummy::MilkType.to_non_null_type)
+      assert subtype?(Dummy::EdibleInterface.to_non_null_type, Dummy::MilkType.to_non_null_type)
+      assert subtype?(
+        GraphQL::STRING_TYPE.to_non_null_type.to_list_type,
+        GraphQL::STRING_TYPE.to_non_null_type.to_list_type.to_non_null_type,
+      )
+    end
   end
 end

data/spec/graphql/field_spec.rb

@@ -126,7 +126,7 @@ describe GraphQL::Field do
       int_field = GraphQL::Field.define do
         type types.Int
         argument :value, types.Int
-        resolve -> (obj, args, ctx) { args[:value] }
+        resolve ->(obj, args, ctx) { args[:value] }
       end
 
       query_type = GraphQL::ObjectType.define do

data/spec/graphql/function_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Function do
+  class TestFunc < GraphQL::Function
+    argument :name, GraphQL::STRING_TYPE
+    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"], 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"], 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", "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"], field.arguments.keys
+    end
+  end
+end