graphql 1.8.7 → 1.9.0

data/spec/graphql/static_validation/rules/variable_default_values_are_correctly_typed_spec.rb

@@ -29,17 +29,20 @@ describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
       {
         "message"=>"Default value for $badInt doesn't match type Int",
         "locations"=>[{"line"=>6, "column"=>7}],
-        "fields"=>["query getCheese"],
+        "path"=>["query getCheese"],
+        "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"badInt", "typeName"=>"Int"}
       },
       {
         "message"=>"Default value for $badInput doesn't match type DairyProductInput",
         "locations"=>[{"line"=>8, "column"=>7}],
-        "fields"=>["query getCheese"],
+        "path"=>["query getCheese"],
+        "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"badInput", "typeName"=>"DairyProductInput"}
       },
       {
         "message"=>"Non-null variable $nonNull can't have a default value",
         "locations"=>[{"line"=>9, "column"=>7}],
-        "fields"=>["query getCheese"],
+        "path"=>["query getCheese"],
+        "extensions"=>{"code"=>"defaultValueInvalidOnNonNullVariable", "variableName"=>"nonNull"}
       }
     ]
     assert_equal(expected, errors)
@@ -116,17 +119,20 @@ describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
           {
             "message"=>"Non-null variable $a can't have a default value",
             "locations"=>[{"line"=>3, "column"=>11}],
-            "fields"=>["query getCheese"]
+            "path"=>["query getCheese"],
+            "extensions"=>{"code"=>"defaultValueInvalidOnNonNullVariable", "variableName"=>"a"}
           },
           {
             "message"=>"Non-null variable $b can't have a default value",
             "locations"=>[{"line"=>4, "column"=>11}],
-            "fields"=>["query getCheese"]
+            "path"=>["query getCheese"],
+            "extensions"=>{"code"=>"defaultValueInvalidOnNonNullVariable", "variableName"=>"b"}
           },
           {
             "message"=>"Default value for $c doesn't match type ComplexInput",
             "locations"=>[{"line"=>5, "column"=>11}],
-            "fields"=>["query getCheese"]
+            "path"=>["query getCheese"],
+            "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"c", "typeName"=>"ComplexInput"}
           }
         ]
 
@@ -182,7 +188,8 @@ describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
       assert_includes errors, {
         "message"=> "cannot coerce to Float",
         "locations"=>[{"line"=>3, "column"=>9}],
-        "fields"=>["query"]
+        "path"=>["query"],
+        "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"value", "typeName"=>"Time"}
       }
     end
   end

data/spec/graphql/static_validation/rules/variable_usages_are_allowed_spec.rb

@@ -43,22 +43,26 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
       {
         "message"=>"Nullability mismatch on variable $badInt and argument id (Int / Int!)",
         "locations"=>[{"line"=>14, "column"=>28}],
-        "fields"=>["query getCheese", "badCheese", "id"],
+        "path"=>["query getCheese", "badCheese", "id"],
+        "extensions"=>{"code"=>"variableMismatch", "variableName"=>"badInt", "typeName"=>"Int", "argumentName"=>"id", "errorMessage"=>"Nullability mismatch"}
       },
       {
         "message"=>"Type mismatch on variable $badStr and argument id (String! / Int!)",
         "locations"=>[{"line"=>15, "column"=>28}],
-        "fields"=>["query getCheese", "badStrCheese", "id"],
+        "path"=>["query getCheese", "badStrCheese", "id"],
+        "extensions"=>{"code"=>"variableMismatch", "variableName"=>"badStr", "typeName"=>"String!", "argumentName"=>"id", "errorMessage"=>"Type mismatch"}
       },
       {
         "message"=>"Nullability mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
         "locations"=>[{"line"=>18, "column"=>30}],
-        "fields"=>["query getCheese", "cheese", "other", "source"],
+        "path"=>["query getCheese", "cheese", "other", "source"],
+        "extensions"=>{"code"=>"variableMismatch", "variableName"=>"badAnimals", "typeName"=>"[DairyAnimal]!", "argumentName"=>"source", "errorMessage"=>"Nullability mismatch"}
       },
       {
         "message"=>"List dimension mismatch on variable $deepAnimals and argument source ([[DairyAnimal!]!]! / [DairyAnimal!]!)",
         "locations"=>[{"line"=>19, "column"=>32}],
-        "fields"=>["query getCheese", "cheese", "tooDeep", "source"],
+        "path"=>["query getCheese", "cheese", "tooDeep", "source"],
+        "extensions"=>{"code"=>"variableMismatch", "variableName"=>"deepAnimals", "typeName"=>"[[DairyAnimal!]!]!", "argumentName"=>"source", "errorMessage"=>"List dimension mismatch"}
       }
     ]
     assert_equal(expected, errors)

data/spec/graphql/static_validation/rules/variables_are_input_types_spec.rb

@@ -22,25 +22,29 @@ describe GraphQL::StaticValidation::VariablesAreInputTypes do
     assert_includes(errors, {
       "message"=>"AnimalProduct isn't a valid input type (on $interface)",
       "locations"=>[{"line"=>5, "column"=>7}],
-      "fields"=>["query getCheese"],
+      "path"=>["query getCheese"],
+      "extensions"=> {"code"=>"variableRequiresValidType", "typeName"=>"AnimalProduct", "variableName"=>"interface"}
     })
 
     assert_includes(errors, {
       "message"=>"Milk isn't a valid input type (on $object)",
       "locations"=>[{"line"=>6, "column"=>7}],
-      "fields"=>["query getCheese"],
+      "path"=>["query getCheese"],
+      "extensions"=>{"code"=>"variableRequiresValidType", "typeName"=>"Milk", "variableName"=>"object"}
     })
 
     assert_includes(errors, {
       "message"=>"Cheese isn't a valid input type (on $objects)",
       "locations"=>[{"line"=>7, "column"=>7}],
-      "fields"=>["query getCheese"],
+      "path"=>["query getCheese"],
+      "extensions"=>{"code"=>"variableRequiresValidType", "typeName"=>"Cheese", "variableName"=>"objects"}
     })
 
     assert_includes(errors, {
       "message"=>"Nonsense isn't a defined input type (on $unknownType)",
       "locations"=>[{"line"=>8, "column"=>7}],
-      "fields"=>["query getCheese"],
+      "path"=>["query getCheese"],
+      "extensions"=>{"code"=>"variableRequiresValidType", "typeName"=>"Nonsense", "variableName"=>"unknownType"}
     })
   end
 

data/spec/graphql/static_validation/rules/variables_are_used_and_defined_spec.rb

@@ -42,20 +42,40 @@ describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
       {
         "message"=>"Variable $notUsedVar is declared by getCheese but not used",
         "locations"=>[{"line"=>2, "column"=>5}],
-        "fields"=>["query getCheese"],
+        "path"=>["query getCheese"],
+        "extensions"=>{"code"=>"variableNotUsed", "variableName"=>"notUsedVar"}
       },
       {
         "message"=>"Variable $undefinedVar is used by getCheese but not declared",
         "locations"=>[{"line"=>19, "column"=>22}],
-        "fields"=>["query getCheese", "c3", "id"],
+        "path"=>["query getCheese", "c3", "id"],
+        "extensions"=>{"code"=>"variableNotDefined", "variableName"=>"undefinedVar"}
       },
       {
         "message"=>"Variable $undefinedFragmentVar is used by innerCheeseFields but not declared",
         "locations"=>[{"line"=>29, "column"=>22}],
-        "fields"=>["fragment innerCheeseFields", "c4", "id"],
+        "path"=>["fragment innerCheeseFields", "c4", "id"],
+        "extensions"=>{"code"=>"variableNotDefined", "variableName"=>"undefinedFragmentVar"}
       },
     ]
 
     assert_equal(expected, errors)
   end
+
+  describe "usages in directives on fragment spreads" do
+    let(:query_string) {
+      <<-GRAPHQL
+      query($f: Boolean!){
+        ...F @include(if: $f)
+      }
+      fragment F on Query {
+        __typename
+      }
+      GRAPHQL
+    }
+
+    it "finds usages" do
+      assert_equal([], errors)
+    end
+  end
 end

data/spec/graphql/static_validation/type_stack_spec.rb

@@ -1,19 +1,6 @@
 # frozen_string_literal: true
 require "spec_helper"
 
-class TypeCheckValidator
-  def self.checks
-    @checks ||= []
-  end
-
-  def validate(context)
-    self.class.checks.clear
-    context.visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) {
-      self.class.checks << context.object_types.map {|t| t.name || t.kind.name }
-    }
-  end
-end
-
 describe GraphQL::StaticValidation::TypeStack do
   let(:query_string) {%|
     query getCheese {
@@ -22,17 +9,21 @@ describe GraphQL::StaticValidation::TypeStack do
     fragment edibleFields on Edible { fatContent @skip(if: false)}
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema, rules: [TypeCheckValidator]) }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-
-
   it "stores up types" do
-    validator.validate(query)
+    document = GraphQL.parse(query_string)
+    visitor = GraphQL::Language::Visitor.new(document)
+    type_stack = GraphQL::StaticValidation::TypeStack.new(Dummy::Schema, visitor)
+    checks = []
+    visitor[GraphQL::Language::Nodes::Field].enter << ->(node, parent) {
+      checks << type_stack.object_types.map {|t| t.name || t.kind.name }
+    }
+    visitor.visit
+
     expected = [
       ["Query", "Cheese"],
       ["Query", "Cheese", "NON_NULL"],
       ["Edible", "NON_NULL"]
     ]
-    assert_equal(expected, TypeCheckValidator.checks)
+    assert_equal(expected, checks)
   end
 end

data/spec/graphql/static_validation/validator_spec.rb

@@ -34,7 +34,8 @@ describe GraphQL::StaticValidation::Validator do
       expected_errors = [{
         "message" => "Variable $undefinedVar is used by  but not declared",
         "locations" => [{"line" => 1, "column" => 14, "filename" => "not_a_real.graphql"}],
-        "fields" => ["query", "cheese", "id"]
+        "path" => ["query", "cheese", "id"],
+        "extensions"=>{"code"=>"variableNotDefined", "variableName"=>"undefinedVar"}
       }]
       assert_equal expected_errors, errors
     end
@@ -115,7 +116,8 @@ describe GraphQL::StaticValidation::Validator do
             {
               "message"=>"Fragment cheeseFields contains an infinite loop",
               "locations"=>[{"line"=>10, "column"=>9}],
-              "fields"=>["fragment cheeseFields"]
+              "path"=>["fragment cheeseFields"],
+              "extensions"=>{"code"=>"infiniteLoop", "fragmentName"=>"cheeseFields"}
             }
           ]
           assert_equal(expected, errors)
@@ -153,4 +155,50 @@ describe GraphQL::StaticValidation::Validator do
       end
     end
   end
+
+  describe "Custom ruleset" do
+    let(:query_string) { "
+        fragment Thing on Cheese {
+          __typename
+          similarCheese(source: COW)
+        }
+      "
+    }
+
+    let(:rules) {
+      # This is from graphql-client, eg
+      # https://github.com/github/graphql-client/blob/c86fc05d7eba2370452592bb93572caced4123af/lib/graphql/client.rb#L168
+      GraphQL::StaticValidation::ALL_RULES - [
+        GraphQL::StaticValidation::FragmentsAreUsed,
+        GraphQL::StaticValidation::FieldsHaveAppropriateSelections
+      ]
+    }
+    let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema, rules: rules) }
+
+    it "runs the specified rules" do
+      assert_equal 0, errors.size
+    end
+
+    describe "With a legacy-style rule" do
+      # GraphQL-Pro's operation store uses this
+      class ValidatorSpecLegacyRule
+        include GraphQL::StaticValidation::Error::ErrorHelper
+        def validate(ctx)
+          ctx.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(n, _p) {
+            ctx.errors << error("Busted!", n, context: ctx)
+          }
+        end
+      end
+
+      let(:rules) {
+        GraphQL::StaticValidation::ALL_RULES + [ValidatorSpecLegacyRule]
+      }
+
+      let(:query_string) { "{ __typename }"}
+
+      it "runs the rule" do
+        assert_equal ["Busted!"], errors.map { |e| e["message"] }
+      end
+    end
+  end
 end

data/spec/graphql/subscriptions_spec.rb

@@ -109,32 +109,32 @@ class ClassBasedInMemoryBackend < InMemoryBackend
   end
 
   class Subscription < GraphQL::Schema::Object
+    if TESTING_INTERPRETER
+      extend GraphQL::Subscriptions::SubscriptionRoot
+    else
+      # Stub methods are required
+      [:payload, :event, :my_event].each do |m|
+        define_method(m) { |*a| nil }
+      end
+    end
     field :payload, Payload, null: false do
       argument :id, ID, required: true
     end
 
-    def payload(id:)
-      object
-    end
-
     field :event, Payload, null: true do
       argument :stream, StreamInput, required: false
     end
 
-    def event(stream: nil)
-      object
-    end
-
     field :my_event, Payload, null: true, subscription_scope: :me do
       argument :type, PayloadType, required: false
     end
 
-    def my_event(type: nil)
-      object
+    field :failed_event, Payload, null: false  do
+      argument :id, ID, required: true
     end
 
-    field :failed_event, Payload, null: false, resolve: ->(o, a, c) { raise GraphQL::ExecutionError.new("unauthorized") }  do
-      argument :id, ID, required: true
+    def failed_event(id:)
+      raise GraphQL::ExecutionError.new("unauthorized")
     end
   end
 
@@ -146,6 +146,9 @@ class ClassBasedInMemoryBackend < InMemoryBackend
     query(Query)
     subscription(Subscription)
     use InMemoryBackend::Subscriptions, extra: 123
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+    end
   end
 end
 
@@ -236,9 +239,17 @@ describe GraphQL::Subscriptions do
           res_1 = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
           res_2 = schema.execute(query_str, context: { socket: "2" }, variables: { "id" => "200" }, root_value: root_object)
 
+          # This difference is because of how `SKIP` is handled.
+          # Honestly the new way is probably better, since it puts a value there.
+          empty_response = if TESTING_INTERPRETER && schema == ClassBasedInMemoryBackend::Schema
+            {}
+          else
+            nil
+          end
+
           # Initial response is nil, no broadcasts yet
-          assert_equal(nil, res_1["data"])
-          assert_equal(nil, res_2["data"])
+          assert_equal(empty_response, res_1["data"])
+          assert_equal(empty_response, res_2["data"])
           assert_equal [], deliveries["1"]
           assert_equal [], deliveries["2"]
 
@@ -410,12 +421,12 @@ describe GraphQL::Subscriptions do
             failedEvent(id: $id) { str, int }
           }
             GRAPHQL
-
             assert_equal nil, res["data"]
             assert_equal "unauthorized", res["errors"][0]["message"]
 
             # this is to make sure nothing actually got subscribed.. but I don't have any idea better than checking its instance variable
-            assert_equal 0, schema.subscriptions.instance_variable_get(:@subscriptions).size
+            subscriptions = schema.subscriptions.instance_variable_get(:@subscriptions)
+            assert_equal 0, subscriptions.size
           end
 
           it "lets unhandled errors crash" do

data/spec/graphql/tracing/new_relic_tracing_spec.rb

@@ -14,11 +14,22 @@ describe GraphQL::Tracing::NewRelicTracing do
     class SchemaWithoutTransactionName < GraphQL::Schema
       query(Query)
       use(GraphQL::Tracing::NewRelicTracing)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
     end
 
     class SchemaWithTransactionName < GraphQL::Schema
       query(Query)
       use(GraphQL::Tracing::NewRelicTracing, set_transaction_name: true)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
+    end
+
+    class SchemaWithScalarTrace < GraphQL::Schema
+      query(Query)
+      use(GraphQL::Tracing::NewRelicTracing, trace_scalars: true)
     end
   end
 
@@ -44,4 +55,9 @@ describe GraphQL::Tracing::NewRelicTracing do
     NewRelicTest::SchemaWithoutTransactionName.execute "{ int }", context: { set_new_relic_transaction_name: true }
     assert_equal ["GraphQL/query.anonymous"], NewRelic::TRANSACTION_NAMES
   end
+
+  it "traces scalars when trace_scalars is true" do
+    NewRelicTest::SchemaWithScalarTrace.execute "query X { int }"
+    assert_includes NewRelic::EXECUTION_SCOPES, "GraphQL/Query/int"
+  end
 end

data/spec/graphql/tracing/platform_tracing_spec.rb

@@ -17,7 +17,7 @@ describe GraphQL::Tracing::PlatformTracing do
     }
 
     def platform_field_key(type, field)
-      "#{type.name[0]}.#{field.name[0]}"
+      "#{type.graphql_name[0]}.#{field.graphql_name[0]}"
     end
 
     def platform_trace(platform_key, key, data)
@@ -39,17 +39,25 @@ describe GraphQL::Tracing::PlatformTracing do
 
     it "calls the platform's own method with its own keys" do
       schema.execute(" { cheese(id: 1) { flavor } }")
-      expected_trace = [
-        "em",
-        "l",
-        "p",
-        "v",
-        "am",
-        "aq",
-        "eq",
-        "Q.c", # notice that the flavor is skipped
-        "eql",
-      ]
+      # This is different because schema/member/instrumentation
+      # calls `irep_selection` which causes the query to be parsed.
+      # But interpreter doesn't require parsing until later.
+      expected_trace = if TESTING_INTERPRETER
+        [
+          "em",
+          "am",
+          "l",
+          "p",
+          "v",
+          "aq",
+          "eq",
+          "Q.c", # notice that the flavor is skipped
+          "eql",
+        ]
+      else
+        ["em", "l", "p", "v", "am", "aq", "eq", "Q.c", "eql"]
+      end
+
       assert_equal expected_trace, CustomPlatformTracer::TRACE
     end
   end
@@ -67,18 +75,25 @@ describe GraphQL::Tracing::PlatformTracing do
 
     it "only traces traceTrue, not traceFalse or traceNil" do
       schema.execute(" { tracingScalar { traceNil traceFalse traceTrue } }")
-      expected_trace = [
-        "em",
-        "l",
-        "p",
-        "v",
-        "am",
-        "aq",
-        "eq",
-        "Q.t",
-        "T.t",
-        "eql",
-      ]
+      # This is different because schema/member/instrumentation
+      # calls `irep_selection` which causes the query to be parsed.
+      # But interpreter doesn't require parsing until later.
+      expected_trace = if TESTING_INTERPRETER
+        [
+          "em",
+          "am",
+          "l",
+          "p",
+          "v",
+          "aq",
+          "eq",
+          "Q.t",
+          "T.t",
+          "eql",
+        ]
+      else
+        ["em", "l", "p", "v", "am", "aq", "eq", "Q.t", "T.t", "eql"]
+      end
       assert_equal expected_trace, CustomPlatformTracer::TRACE
     end
   end
@@ -96,19 +111,26 @@ describe GraphQL::Tracing::PlatformTracing do
 
     it "traces traceTrue and traceNil but not traceFalse" do
       schema.execute(" { tracingScalar { traceNil traceFalse traceTrue } }")
-      expected_trace = [
-        "em",
-        "l",
-        "p",
-        "v",
-        "am",
-        "aq",
-        "eq",
-        "Q.t",
-        "T.t",
-        "T.t",
-        "eql",
-      ]
+      # This is different because schema/member/instrumentation
+      # calls `irep_selection` which causes the query to be parsed.
+      # But interpreter doesn't require parsing until later.
+      expected_trace = if TESTING_INTERPRETER
+        [
+          "em",
+          "am",
+          "l",
+          "p",
+          "v",
+          "aq",
+          "eq",
+          "Q.t",
+          "T.t",
+          "T.t",
+          "eql",
+        ]
+      else
+        ["em", "l", "p", "v", "am", "aq", "eq", "Q.t", "T.t", "T.t", "eql"]
+      end
       assert_equal expected_trace, CustomPlatformTracer::TRACE
     end
   end

data/spec/graphql/tracing/prometheus_tracing_spec.rb

@@ -14,6 +14,9 @@ describe GraphQL::Tracing::PrometheusTracing do
 
     class Schema < GraphQL::Schema
       query Query
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
     end
   end
 

data/spec/graphql/tracing/skylight_tracing_spec.rb

@@ -14,11 +14,22 @@ describe GraphQL::Tracing::SkylightTracing do
     class SchemaWithoutTransactionName < GraphQL::Schema
       query(Query)
       use(GraphQL::Tracing::SkylightTracing)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
     end
 
     class SchemaWithTransactionName < GraphQL::Schema
       query(Query)
       use(GraphQL::Tracing::SkylightTracing, set_endpoint_name: true)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
+    end
+
+    class SchemaWithScalarTrace < GraphQL::Schema
+      query(Query)
+      use(GraphQL::Tracing::SkylightTracing, trace_scalars: true)
     end
   end
 
@@ -44,4 +55,9 @@ describe GraphQL::Tracing::SkylightTracing do
     SkylightTest::SchemaWithoutTransactionName.execute "{ int }", context: { set_skylight_endpoint_name: true }
     assert_equal ["GraphQL/query.<anonymous>"], Skylight::ENDPOINT_NAMES
   end
+
+  it "traces scalars when trace_scalars is true" do
+    SkylightTest::SchemaWithScalarTrace.execute "query X { int }"
+    assert_includes Skylight::TITLE_NAMES, "graphql.Query.int"
+  end
 end

data/spec/graphql/types/iso_8601_date_time_spec.rb

@@ -11,8 +11,7 @@ describe GraphQL::Types::ISO8601DateTime do
       field :minute, Integer, null: false
       field :second, Integer, null: false
       field :zone, String, null: false
-      # Use method: :object so that the DateTime instance is passed to the scalar
-      field :iso8601, GraphQL::Types::ISO8601DateTime, null: false, method: :object
+      field :iso8601, GraphQL::Types::ISO8601DateTime, null: false, method: :itself
     end
 
     class Query < GraphQL::Schema::Object
@@ -29,6 +28,9 @@ describe GraphQL::Types::ISO8601DateTime do
 
     class Schema < GraphQL::Schema
       query(Query)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
     end
   end
 
@@ -90,6 +92,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)