graphql 1.9.0.pre1 → 1.9.0.pre2

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

@@ -22,21 +22,24 @@ describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
     query_root_error = {
       "message"=>"Field 'cheese' is missing required arguments: id",
       "locations"=>[{"line"=>4, "column"=>7}],
-      "fields"=>["query getCheese", "cheese"],
+      "path"=>["query getCheese", "cheese"],
+      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Field", "name"=>"cheese", "arguments"=>"id"}
     }
     assert_includes(errors, query_root_error)
 
     fragment_error = {
       "message"=>"Field 'similarCheese' is missing required arguments: source",
       "locations"=>[{"line"=>8, "column"=>7}],
-      "fields"=>["fragment cheeseFields", "similarCheese"],
+      "path"=>["fragment cheeseFields", "similarCheese"],
+      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Field", "name"=>"similarCheese", "arguments"=>"source"}
     }
     assert_includes(errors, fragment_error)
 
     directive_error = {
       "message"=>"Directive 'skip' is missing required arguments: if",
       "locations"=>[{"line"=>10, "column"=>10}],
-      "fields"=>["fragment cheeseFields", "id"],
+      "path"=>["fragment cheeseFields", "id"],
+      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Directive", "name"=>"skip", "arguments"=>"if"}
     }
     assert_includes(errors, directive_error)
   end
@@ -55,7 +58,13 @@ describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
           "locations"=>[
             {"line"=>3, "column"=>9}
           ],
-          "fields"=>["query", "__type"],
+          "path"=>["query", "__type"],
+          "extensions"=>{
+            "code"=>"missingRequiredArguments",
+            "className"=>"Field",
+            "name"=>"__type",
+            "arguments"=>"name"
+          }
         }
       ]
       assert_equal(expected_errors, errors)

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
+  include StaticValidationHelpers
+  include ErrorBubblingHelpers
+
+  let(:query_string) {%|
+    query getCheese {
+      stringCheese: cheese(id: "aasdlkfj") { ...cheeseFields }
+      cheese(id: 1) { source @skip(if: "whatever") }
+      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { __typename }
+      badSource: searchDairy(product: [{source: 1.1}]) { __typename }
+      missingSource: searchDairy(product: [{fatContent: 1.1}]) { __typename }
+      listCoerce: cheese(id: 1) { similarCheese(source: YAK) { __typename } }
+      missingInputField: searchDairy(product: [{source: YAK, wacky: 1}]) { __typename }
+    }
+
+    fragment cheeseFields on Cheese {
+      similarCheese(source: 4.5) { __typename }
+    }
+  |}
+  describe "with error bubbling disabled" do
+    missing_required_field_error = {
+      "message"=>"Argument 'product' on Field 'missingSource' has an invalid value. Expected type '[DairyProductInput]'.",
+      "locations"=>[{"line"=>7, "column"=>7}],
+      "path"=>["query getCheese", "missingSource", "product"],
+      "extensions"=>{
+        "code"=>"argumentLiteralsIncompatible",
+        "typeName"=>"Field",
+        "argumentName"=>"product",
+      },
+    }
+    missing_source_error = {
+      "message"=>"Argument 'source' on InputObject 'DairyProductInput' is required. Expected type DairyAnimal!",
+      "locations"=>[{"line"=>7, "column"=>44}],
+      "path"=>["query getCheese", "missingSource", "product", "source"],
+      "extensions"=>{
+        "code"=>"missingRequiredInputObjectAttribute",
+        "argumentName"=>"source",
+        "argumentType"=>"DairyAnimal!",
+        "inputObjectType"=>"DairyProductInput"
+      }
+    }
+    it "finds undefined or missing-required arguments to fields and directives" do
+      without_error_bubbling(schema) do
+        assert_includes(errors, missing_source_error)
+        refute_includes(errors, missing_required_field_error)
+      end
+    end
+    it 'works with error bubbling enabled' do
+      with_error_bubbling(schema) do
+        assert_includes(errors, missing_required_field_error)
+        assert_includes(errors, missing_source_error)
+      end
+    end
+  end
+end

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

@@ -26,7 +26,8 @@ describe GraphQL::StaticValidation::SubscriptionRootExists do
     missing_subscription_root_error = {
       "message"=>"Schema is not configured for subscriptions",
       "locations"=>[{"line"=>2, "column"=>5}],
-      "fields"=>["subscription"],
+      "path"=>["subscription"],
+      "extensions"=>{"code"=>"missingSubscriptionConfiguration"}
     }
     assert_includes(errors, missing_subscription_root_error)
   end

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

@@ -101,7 +101,8 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
     end
   end
@@ -120,13 +121,15 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
 
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
     end
   end
@@ -144,13 +147,15 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
 
       assert_includes errors, {
         "message" => 'The directive "B" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 20 }, { "line" => 4, "column" => 26 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"B"}
       }
     end
   end
@@ -168,13 +173,15 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 3, "column" => 14 }, { "line" => 3, "column" => 17 }],
-        "fields" => ["query", "type"],
+        "path" => ["query", "type"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
 
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
     end
   end

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,17 +42,20 @@ 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"}
       },
     ]
 

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)
@@ -180,10 +182,10 @@ describe GraphQL::StaticValidation::Validator do
     describe "With a legacy-style rule" do
       # GraphQL-Pro's operation store uses this
       class ValidatorSpecLegacyRule
-        include GraphQL::StaticValidation::Message::MessageHelper
+        include GraphQL::StaticValidation::Error::ErrorHelper
         def validate(ctx)
           ctx.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(n, _p) {
-            ctx.errors << message("Busted!", n, context: ctx)
+            ctx.errors << error("Busted!", n, context: ctx)
           }
         end
       end

data/spec/graphql/tracing/new_relic_tracing_spec.rb

@@ -26,6 +26,11 @@ describe GraphQL::Tracing::NewRelicTracing do
         use GraphQL::Execution::Interpreter
       end
     end
+
+    class SchemaWithScalarTrace < GraphQL::Schema
+      query(Query)
+      use(GraphQL::Tracing::NewRelicTracing, trace_scalars: true)
+    end
   end
 
   before do
@@ -50,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/skylight_tracing_spec.rb

@@ -26,6 +26,11 @@ describe GraphQL::Tracing::SkylightTracing do
         use GraphQL::Execution::Interpreter
       end
     end
+
+    class SchemaWithScalarTrace < GraphQL::Schema
+      query(Query)
+      use(GraphQL::Tracing::SkylightTracing, trace_scalars: true)
+    end
   end
 
   before do
@@ -50,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

data/spec/integration/mongoid/star_trek/schema.rb

@@ -169,11 +169,11 @@ module StarTrek
       all_bases.to_a
     end
 
-    field :basesWithMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 2, method: :all_bases
-    field :basesWithMaxLimitArray, BaseType.connection_type, null: true, max_page_size: 2, method: :all_bases_array
-    field :basesWithDefaultMaxLimitRelation, BaseType.connection_type, null: true, method: :all_bases
-    field :basesWithDefaultMaxLimitArray, BaseType.connection_type, null: true, method: :all_bases_array
-    field :basesWithLargeMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 1000, method: :all_bases
+    field :basesWithMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 2, resolver_method: :all_bases
+    field :basesWithMaxLimitArray, BaseType.connection_type, null: true, max_page_size: 2, resolver_method: :all_bases_array
+    field :basesWithDefaultMaxLimitRelation, BaseType.connection_type, null: true, resolver_method: :all_bases
+    field :basesWithDefaultMaxLimitArray, BaseType.connection_type, null: true, resolver_method: :all_bases_array
+    field :basesWithLargeMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 1000, resolver_method: :all_bases
 
     field :basesWithCustomEdge, CustomEdgeBaseConnectionType, null: true, connection: true
     def bases_with_custom_edge

data/spec/integration/rails/graphql/relay/relation_connection_spec.rb

@@ -21,7 +21,7 @@ describe GraphQL::Relay::RelationConnection do
 
   describe "results" do
     let(:query_string) {%|
-      query getShips($first: Int, $after: String, $last: Int, $before: String,  $nameIncludes: String){
+      query getShips($first: Int, $after: String, $last: Int, $before: String, $nameIncludes: String){
         empire {
           bases(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
             ... basesConnection
@@ -66,6 +66,39 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal("Mw", get_last_cursor(result))
     end
 
+    it "uses unscope(:order) count(*) when the relation has some complicated SQL" do
+      query_s = <<-GRAPHQL
+        query getShips($first: Int, $after: String, $complexOrder: Boolean){
+          empire {
+            bases(first: $first, after: $after, complexOrder: $complexOrder) {
+              edges {
+                node {
+                  name
+                }
+              }
+              pageInfo {
+                hasNextPage
+              }
+            }
+          }
+        }
+      GRAPHQL
+      result = nil
+      log = with_active_record_log do
+        result = star_wars_query(query_s, "first" => 1, "after" => "MQ==", "complexOrder" => true)
+      end
+
+      conn = result["data"]["empire"]["bases"]
+      assert_equal(1, conn["edges"].size)
+      assert_equal(true, conn["pageInfo"]["hasNextPage"])
+
+      log_entries = log.split("\n")
+      assert_equal 2, log_entries.size, "It ran 2 sql queries"
+      edges_query, has_next_page_query = log_entries
+      assert_includes edges_query, "ORDER BY bases.name", "The query for edges _is_ ordered"
+      refute_includes has_next_page_query, "ORDER BY bases.name", "The count query **does not** have an order"
+    end
+
     it 'provides custom fields on the connection type' do
       result = star_wars_query(query_string, "first" => 2)
       assert_equal(
@@ -90,15 +123,11 @@ describe GraphQL::Relay::RelationConnection do
         }
       }
       GRAPHQL
-      io = StringIO.new
-      begin
-        prev_logger = ActiveRecord::Base.logger
-        ActiveRecord::Base.logger = Logger.new(io)
+      result = nil
+      log = with_active_record_log do
         result = star_wars_query(query_str, "first" => 2)
-      ensure
-        ActiveRecord::Base.logger = prev_logger
       end
-      assert_equal 2, io.string.scan("\n").count, "Two log entries"
+      assert_equal 2, log.scan("\n").count, "Two log entries"
       assert_equal 3, result["data"]["empire"]["bases"]["totalCount"]
       assert_equal 2, result["data"]["empire"]["bases"]["edges"].size
     end