Merge pull request #1842 from rmosolgo/migrate-dummy-schema

Migrate dummy schema to class-based

Author: Robert Mosolgo

lib/graphql/base_type.rb

@@ -187,7 +187,7 @@ def self.resolve_related_type(type_arg)
         resolve_related_type(type_arg.call)
       when String
         # Get a constant by this name
-        Object.const_get(type_arg)
+        resolve_related_type(Object.const_get(type_arg))
       else
         if type_arg.respond_to?(:graphql_definition)
           type_arg.graphql_definition

lib/graphql/schema/field.rb

@@ -126,7 +126,7 @@ def scoped?
       # @param complexity [Numeric] When provided, set the complexity for this field
       # @param scope [Boolean] If true, the return type's `.scope_items` method will be called on the return value
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, trace: nil, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
 
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
@@ -170,6 +170,7 @@ def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function
         @extras = extras
         @resolver_class = resolver_class
         @scope = scope
+        @trace = trace
 
         # Override the default from HasArguments
         @own_arguments = {}
@@ -258,6 +259,10 @@ def to_graphql
           field_defn.metadata[:resolver] = @resolver_class
         end
 
+        if !@trace.nil?
+          field_defn.trace = @trace
+        end
+
         field_defn.resolve = self.method(:resolve_field)
         field_defn.connection = connection?
         field_defn.connection_max_page_size = @max_page_size

spec/graphql/analysis/analyze_query_spec.rb

@@ -78,7 +78,7 @@ def call(memo, visit_type, irep_node)
 
     it "calls the defined analyzers" do
       collected_types, node_counts = reduce_result
-      expected_visited_types = [Dummy::DairyAppQueryType, Dummy::CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
+      expected_visited_types = [Dummy::DairyAppQuery.graphql_definition, Dummy::Cheese.graphql_definition, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
       assert_equal expected_visited_types, collected_types
       expected_node_counts = {
         GraphQL::Language::Nodes::OperationDefinition => 1,

spec/graphql/base_type_spec.rb

@@ -11,7 +11,7 @@
   end
 
   it "can be compared" do
-    obj_type = Dummy::MilkType
+    obj_type = Dummy::Milk.graphql_definition
     assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
     refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
     assert_equal(
@@ -25,7 +25,7 @@
   end
 
   it "Accepts arbitrary metadata" do
-    assert_equal ["Cheese"], Dummy::CheeseType.metadata[:class_names]
+    assert_equal ["Cheese"], Dummy::Cheese.graphql_definition.metadata[:class_names]
   end
 
   describe "#name" do
@@ -63,7 +63,7 @@ class BaseType < GraphQL::Schema::Object
   end
 
   describe "forwards-compat with new api" do
-    let(:type_defn) { Dummy::CheeseType }
+    let(:type_defn) { Dummy::Cheese.graphql_definition }
     it "responds to new methods" do
       assert_equal "Cheese", type_defn.graphql_name
       assert_equal type_defn, type_defn.graphql_definition

spec/graphql/enum_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::EnumType do
-  let(:enum) { Dummy::DairyAnimalEnum }
+  let(:enum) { Dummy::DairyAnimal.graphql_definition }
 
   it "coerces names to underlying values" do
     assert_equal("YAK", enum.coerce_isolated_input("YAK"))

spec/graphql/execution/typecast_spec.rb

@@ -8,36 +8,36 @@ def 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)
+      assert subtype?(Dummy::Milk.graphql_definition, Dummy::Milk.graphql_definition)
+      assert !subtype?(Dummy::Milk.graphql_definition, Dummy::Cheese.graphql_definition)
+      assert subtype?(Dummy::Milk.graphql_definition.to_list_type.to_non_null_type, Dummy::Milk.graphql_definition.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::Edible.graphql_definition, Dummy::Cheese.graphql_definition)
+      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Milk.graphql_definition)
+      assert subtype?(Dummy::DairyProduct.graphql_definition, Dummy::Milk.graphql_definition)
+      assert subtype?(Dummy::DairyProduct.graphql_definition, Dummy::Cheese.graphql_definition)
 
-      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)
+      assert !subtype?(Dummy::DairyAppQuery.graphql_definition, Dummy::DairyProduct.graphql_definition)
+      assert !subtype?(Dummy::Cheese.graphql_definition, Dummy::DairyProduct.graphql_definition)
+      assert !subtype?(Dummy::Edible.graphql_definition, Dummy::DairyProduct.graphql_definition)
+      assert !subtype?(Dummy::Edible.graphql_definition, GraphQL::STRING_TYPE)
+      assert !subtype?(Dummy::Edible.graphql_definition, Dummy::DairyProductInput.graphql_definition)
     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)
+      assert subtype?(Dummy::Edible.graphql_definition.to_list_type, Dummy::Milk.graphql_definition.to_list_type)
+      assert subtype?(Dummy::DairyProduct.graphql_definition.to_list_type, Dummy::Milk.graphql_definition.to_list_type)
+      assert !subtype?(Dummy::Cheese.graphql_definition.to_list_type, Dummy::DairyProduct.graphql_definition.to_list_type)
+      assert !subtype?(Dummy::Edible.graphql_definition.to_list_type, Dummy::DairyProduct.graphql_definition.to_list_type)
+      assert !subtype?(Dummy::Edible.graphql_definition.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?(Dummy::Milk.graphql_definition, Dummy::Milk.graphql_definition.to_non_null_type)
+      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Milk.graphql_definition.to_non_null_type)
+      assert subtype?(Dummy::Edible.graphql_definition.to_non_null_type, Dummy::Milk.graphql_definition.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,

spec/graphql/field_spec.rb

@@ -116,7 +116,7 @@ def acts_like_default_resolver(field, old_prop, new_prop)
 
   describe "#metadata" do
     it "accepts user-defined metadata" do
-      similar_cheese_field = Dummy::CheeseType.get_field("similarCheese")
+      similar_cheese_field = Dummy::Cheese.graphql_definition.get_field("similarCheese")
       assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
     end
   end

spec/graphql/interface_type_spec.rb

@@ -2,11 +2,11 @@
 require "spec_helper"
 
 describe GraphQL::InterfaceType do
-  let(:interface) { Dummy::EdibleInterface }
+  let(:interface) { Dummy::Edible.graphql_definition }
   let(:dummy_query_context) { OpenStruct.new(schema: Dummy::Schema) }
 
   it "has possible types" do
-    assert_equal([Dummy::CheeseType, Dummy::HoneyType, Dummy::MilkType], Dummy::Schema.possible_types(interface))
+    assert_equal([Dummy::Cheese.graphql_definition, Dummy::Honey.graphql_definition, Dummy::Milk.graphql_definition], Dummy::Schema.possible_types(interface))
   end
 
   describe "query evaluation" do
@@ -96,11 +96,11 @@
     it "copies orphan types without affecting the original" do
       interface = GraphQL::InterfaceType.define do
         name "AInterface"
-        orphan_types [Dummy::HoneyType]
+        orphan_types [Dummy::Honey]
       end
 
       interface_2 = interface.dup
-      interface_2.orphan_types << Dummy::CheeseType
+      interface_2.orphan_types << Dummy::Cheese
       assert_equal 1, interface.orphan_types.size
       assert_equal 2, interface_2.orphan_types.size
     end

spec/graphql/introspection/input_value_type_spec.rb

@@ -40,7 +40,7 @@
           ]
         }
       }}
-    assert_equal(expected, result)
+    assert_equal(expected, result.to_h)
   end
 
   let(:cheese_type) {

spec/graphql/object_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::ObjectType do
-  let(:type) { Dummy::CheeseType }
+  let(:type) { Dummy::Cheese.graphql_definition }
 
   it "doesn't allow double non-null constraints" do
     assert_raises(GraphQL::DoubleNonNullTypeError) {
@@ -45,10 +45,10 @@
   describe "interfaces" do
     it "may have interfaces" do
       assert_equal([
-        Dummy::EdibleInterface,
-        Dummy::EdibleAsMilkInterface,
-        Dummy::AnimalProductInterface,
-        Dummy::LocalProductInterface
+        Dummy::Edible.graphql_definition,
+        Dummy::EdibleAsMilk.graphql_definition,
+        Dummy::AnimalProduct.graphql_definition,
+        Dummy::LocalProduct.graphql_definition
       ], type.interfaces)
     end
 
@@ -85,7 +85,7 @@
   end
 
   it "accepts fields definition" do
-    last_produced_dairy = GraphQL::Field.define(name: :last_produced_dairy, type: Dummy::DairyProductUnion)
+    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
@@ -94,54 +94,54 @@
     it "adds an interface" do
       type = GraphQL::ObjectType.define do
         name 'Hello'
-        implements Dummy::EdibleInterface
-        implements Dummy::AnimalProductInterface
+        implements Dummy::Edible
+        implements Dummy::AnimalProduct
 
         field :hello, types.String
       end
 
-      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface], type.interfaces)
+      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::EdibleInterface, Dummy::AnimalProductInterface
+        implements Dummy::Edible, Dummy::AnimalProduct
 
         field :hello, types.String
       end
 
-      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface], type.interfaces)
+      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::EdibleInterface]
-        implements Dummy::AnimalProductInterface
+        interfaces [Dummy::Edible]
+        implements Dummy::AnimalProduct
 
         field :hello, types.String
       end
 
-      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface], type.interfaces)
+      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::EdibleInterface
-        implements Dummy::AnimalProductInterface
+        implements Dummy::Edible
+        implements Dummy::AnimalProduct
       end
 
       type_2 = GraphQL::ObjectType.define do
         name 'Hello'
-        implements Dummy::EdibleInterface
-        implements Dummy::AnimalProductInterface, inherit: true
+        implements Dummy::Edible
+        implements Dummy::AnimalProduct, inherit: true
       end
 
       type_3 = GraphQL::ObjectType.define do
         name 'Hello'
-        implements Dummy::EdibleInterface, Dummy::AnimalProductInterface, inherit: true
+        implements Dummy::Edible, Dummy::AnimalProduct, inherit: true
       end
 
       assert_equal [], type_1.all_fields.map(&:name)
@@ -158,23 +158,28 @@
     end
 
     it "exposes defined field property" do
-      field_without_prop = Dummy::CheeseType.get_field("flavor")
-      field_with_prop = Dummy::CheeseType.get_field("fatContent")
+      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)
-      assert_equal(field_with_prop.property, :fat_content)
+      # 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::CheeseType.get_field("fatContent")
-      field_from_iface = Dummy::MilkType.get_field("fatContent")
-      assert_equal(field_from_self.property, :fat_content)
+      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
@@ -185,8 +190,8 @@
 
       assert_equal 4, type.interfaces.size
       assert_equal 5, type_2.interfaces.size
-      assert_equal 8, type.fields.size
-      assert_equal 9, type_2.fields.size
+      assert_equal 9, type.fields.size
+      assert_equal 10, type_2.fields.size
     end
   end
 end