graphql 1.8.8 → 1.8.9

data/spec/graphql/introspection/input_value_type_spec.rb

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

data/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 GraphQL::ObjectType do
   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 @@ describe GraphQL::ObjectType do
   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 @@ describe GraphQL::ObjectType do
     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,16 +158,18 @@ describe GraphQL::ObjectType do
     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
@@ -175,6 +177,9 @@ describe GraphQL::ObjectType do
   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 @@ describe GraphQL::ObjectType do
 
       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

data/spec/graphql/query/executor_spec.rb

@@ -110,7 +110,7 @@ describe GraphQL::Query::Executor do
       DummyQueryType = GraphQL::ObjectType.define do
         name "Query"
         field :dairy do
-          type Dummy::DairyType
+          type Dummy::Dairy.graphql_definition
           resolve ->(t, a, c) {
             raise if resolved
             resolved = true
@@ -119,7 +119,7 @@ describe GraphQL::Query::Executor do
         end
       end
 
-      GraphQL::Schema.define(query: DummyQueryType, mutation: Dummy::DairyAppMutationType, resolve_type: ->(a,b,c) { :pass }, id_from_object: :pass)
+      GraphQL::Schema.define(query: DummyQueryType, mutation: Dummy::DairyAppMutation.graphql_definition, resolve_type: ->(a,b,c) { :pass }, id_from_object: :pass)
     }
     let(:variables) { nil }
     let(:query_string) { %|

data/spec/graphql/schema/argument_spec.rb

@@ -13,6 +13,15 @@ describe GraphQL::Schema::Argument do
 
         argument :aliased_arg, String, required: false, as: :renamed
         argument :prepared_arg, Int, required: false, prepare: :multiply
+        argument :prepared_by_proc_arg, Int, required: false, prepare: ->(val, context) { context[:multiply_by] * val }
+
+        class Multiply
+          def call(val, context)
+            context[:multiply_by] * val
+          end
+        end
+
+        argument :prepared_by_callable_arg, Int, required: false, prepare: Multiply.new
       end
 
       def field(**args)
@@ -93,5 +102,23 @@ describe GraphQL::Schema::Argument do
       # Make sure it's getting the renamed symbol:
       assert_equal '{:prepared_arg=>15}', res["data"]["field"]
     end
+    it "calls the method on the provided Proc" do
+      query_str = <<-GRAPHQL
+      { field(preparedByProcArg: 5) }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
+      # Make sure it's getting the renamed symbol:
+      assert_equal '{:prepared_by_proc_arg=>15}', res["data"]["field"]
+    end
+    it "calls the method on the provided callable object" do
+      query_str = <<-GRAPHQL
+      { field(preparedByCallableArg: 5) }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
+      # Make sure it's getting the renamed symbol:
+      assert_equal '{:prepared_by_callable_arg=>15}', res["data"]["field"]
+    end
   end
 end

data/spec/graphql/schema/field_spec.rb

@@ -107,6 +107,22 @@ describe GraphQL::Schema::Field do
         assert_equal ["find", "addError"], err["path"]
         assert_equal [{"line"=>4, "column"=>15}], err["locations"]
       end
+
+      it "can get methods from the field instance" do
+        query_str = <<-GRAPHQL
+        {
+          upcaseCheck1
+          upcaseCheck2
+          upcaseCheck3
+          upcaseCheck4
+        }
+        GRAPHQL
+        res = Jazz::Schema.execute(query_str)
+        assert_equal "nil", res["data"].fetch("upcaseCheck1")
+        assert_equal "false", res["data"]["upcaseCheck2"]
+        assert_equal "TRUE", res["data"]["upcaseCheck3"]
+        assert_equal "\"WHY NOT?\"", res["data"]["upcaseCheck4"]
+      end
     end
 
     it "is the #owner of its arguments" do

data/spec/graphql/schema/interface_spec.rb

@@ -83,11 +83,11 @@ describe GraphQL::Schema::Interface do
       interface = Module.new do
         include GraphQL::Schema::Interface
         graphql_name "MyInterface"
-        orphan_types Dummy::CheeseType, Dummy::HoneyType
+        orphan_types Dummy::Cheese, Dummy::Honey
       end
 
       interface_type = interface.to_graphql
-      assert_equal [Dummy::CheeseType, Dummy::HoneyType], interface_type.orphan_types
+      assert_equal [Dummy::Cheese, Dummy::Honey], interface_type.orphan_types
     end
   end
 

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -135,6 +135,42 @@ describe GraphQL::Schema::RelayClassicMutation do
       assert_equal "August Greene", res["data"]["renameEnsemble"]["ensemble"]["name"]
     end
 
+    it "loads arguments as objects when provided an interface type" do
+      query = <<-GRAPHQL
+        mutation($id: ID!, $newName: String!) {
+          renameNamedEntity(input: {namedEntityId: $id, newName: $newName}) {
+            namedEntity {
+              __typename
+              name
+            }
+          }
+        }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renameNamedEntity"]["namedEntity"]["name"]
+      assert_equal "Ensemble", res["data"]["renameNamedEntity"]["namedEntity"]["__typename"]
+    end
+
+    it "loads arguments as objects when provided an union type" do
+      query = <<-GRAPHQL
+        mutation($id: ID!, $newName: String!) {
+          renamePerformingAct(input: {performingActId: $id, newName: $newName}) {
+            performingAct {
+              __typename
+              ... on Ensemble {
+                name
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renamePerformingAct"]["performingAct"]["name"]
+      assert_equal "Ensemble", res["data"]["renamePerformingAct"]["performingAct"]["__typename"]
+    end
+
     it "uses the `as:` name when loading" do
       band_query_str = query_str.sub("renameEnsemble", "renameEnsembleAsBand")
       res = Jazz::Schema.execute(band_query_str, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})

data/spec/graphql/schema/traversal_spec.rb

@@ -20,24 +20,24 @@ describe GraphQL::Schema::Traversal do
   it "finds types from a single type and its fields" do
     expected = {
       "Boolean" => GraphQL::BOOLEAN_TYPE,
-      "Cheese" => Dummy::CheeseType,
+      "Cheese" => Dummy::Cheese.graphql_definition,
       "Float" => GraphQL::FLOAT_TYPE,
       "String" => GraphQL::STRING_TYPE,
-      "Edible" => Dummy::EdibleInterface,
-      "EdibleAsMilk" => Dummy::EdibleAsMilkInterface,
-      "DairyAnimal" => Dummy::DairyAnimalEnum,
+      "Edible" => Dummy::Edible.graphql_definition,
+      "EdibleAsMilk" => Dummy::EdibleAsMilk.graphql_definition,
+      "DairyAnimal" => Dummy::DairyAnimal.graphql_definition,
       "Int" => GraphQL::INT_TYPE,
-      "AnimalProduct" => Dummy::AnimalProductInterface,
-      "LocalProduct" => Dummy::LocalProductInterface,
+      "AnimalProduct" => Dummy::AnimalProduct.graphql_definition,
+      "LocalProduct" => Dummy::LocalProduct.graphql_definition,
     }
-    result = traversal([Dummy::CheeseType]).type_map
+    result = traversal([Dummy::Cheese.graphql_definition]).type_map
     assert_equal(expected.keys.sort, result.keys.sort)
     assert_equal(expected, result.to_h)
   end
 
   it "finds type from arguments" do
-    result = traversal([Dummy::DairyAppQueryType]).type_map
-    assert_equal(Dummy::DairyProductInputType, result["DairyProductInput"])
+    result = traversal([Dummy::DairyAppQuery.graphql_definition]).type_map
+    assert_equal(Dummy::DairyProductInput.graphql_definition, result["DairyProductInput"])
   end
 
   it "finds types from field instrumentation" do
@@ -126,7 +126,7 @@ describe GraphQL::Schema::Traversal do
 
   describe "when a field is only accessible through an interface" do
     it "is found through Schema.define(types:)" do
-      assert_equal Dummy::HoneyType, Dummy::Schema.types["Honey"]
+      assert_equal Dummy::Honey.graphql_definition, Dummy::Schema.types["Honey"]
     end
   end
 

data/spec/graphql/schema/type_expression_spec.rb

@@ -13,7 +13,7 @@ describe GraphQL::Schema::TypeExpression do
     describe "simple types" do
       let(:type_name) { "DairyProductInput" }
       it "it gets types from the provided types" do
-        assert_equal(Dummy::DairyProductInputType, type_expression_result)
+        assert_equal(Dummy::DairyProductInput.graphql_definition, type_expression_result)
       end
     end
 
@@ -28,7 +28,7 @@ describe GraphQL::Schema::TypeExpression do
       let(:type_name) { "[DairyAnimal!]!" }
 
       it "makes list types" do
-        expected = Dummy::DairyAnimalEnum
+        expected = Dummy::DairyAnimal.graphql_definition
           .to_non_null_type
           .to_list_type
           .to_non_null_type

data/spec/graphql/schema/validation_spec.rb

@@ -315,7 +315,7 @@ describe GraphQL::Schema::Validation do
     let(:null_default_value) {
       GraphQL::Argument.define do
         name "NullDefault"
-        type Dummy::DairyAnimalEnum
+        type Dummy::DairyAnimal
         default_value nil
       end
     }

data/spec/graphql/types/iso_8601_date_time_spec.rb

@@ -90,6 +90,31 @@ describe GraphQL::Types::ISO8601DateTime do
       full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
       assert_equal date_str, full_res["data"]["parseDate"]["iso8601"]
     end
+
+    describe "with time_precision = 3 (i.e. 'with milliseconds')" do
+      before do
+        @tp = GraphQL::Types::ISO8601DateTime.time_precision
+        GraphQL::Types::ISO8601DateTime.time_precision = 3
+      end
+
+      after do
+        GraphQL::Types::ISO8601DateTime.time_precision = @tp
+      end
+
+      it "returns a string" do
+        query_str = <<-GRAPHQL
+        query($date: ISO8601DateTime!){
+          parseDate(date: $date) {
+            iso8601
+          }
+        }
+        GRAPHQL
+
+        date_str = "2010-02-02T22:30:30.123-06:00"
+        full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
+        assert_equal date_str, full_res["data"]["parseDate"]["iso8601"]
+      end
+    end
   end
 
   describe "structure" do

data/spec/graphql/union_type_spec.rb

@@ -169,7 +169,7 @@ describe GraphQL::UnionType do
     |}
 
     let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-    let(:union) { Dummy::BeverageUnion }
+    let(:union) { Dummy::Beverage.graphql_definition }
 
     it "returns the type definition if the type exists and is a possible type of the union" do
       assert union.get_possible_type("Milk", query.context)
@@ -194,7 +194,7 @@ describe GraphQL::UnionType do
     |}
 
     let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-    let(:union) { Dummy::BeverageUnion }
+    let(:union) { Dummy::Beverage.graphql_definition }
 
     it "returns true if the type exists and is a possible type of the union" do
       assert union.possible_type?("Milk", query.context)

data/spec/integration/rails/graphql/input_object_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::InputObjectType do
-  let(:input_object) { Dummy::DairyProductInputType }
+  let(:input_object) { Dummy::DairyProductInput.graphql_definition }
   it "has a description" do
     assert(input_object.description)
   end
@@ -113,7 +113,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has correct problem explanation" do
-          expected = Dummy::DairyAnimalEnum.validate_isolated_input("KOALA").problems[0]["explanation"]
+          expected = Dummy::DairyAnimal.graphql_definition.validate_isolated_input("KOALA").problems[0]["explanation"]
 
           source_problem = result.problems.detect { |p| p["path"] == ["source"] }
           actual = source_problem["explanation"]
@@ -191,7 +191,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "list with one invalid element" do
-        let(:list_type) { GraphQL::ListType.new(of_type: Dummy::DairyProductInputType) }
+        let(:list_type) { GraphQL::ListType.new(of_type: Dummy::DairyProductInput.graphql_definition) }
         let(:result) do
           list_type.validate_isolated_input([
             { "source" => "COW", "fatContent" => 0.4 },
@@ -213,7 +213,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has problem with correct explanation" do
-          expected = Dummy::DairyAnimalEnum.validate_isolated_input("KOALA").problems[0]["explanation"]
+          expected = Dummy::DairyAnimal.graphql_definition.validate_isolated_input("KOALA").problems[0]["explanation"]
           actual = result.problems[0]["explanation"]
           assert_equal(expected, actual)
         end