graphql 1.8.7 → 1.9.0

data/spec/{graphql → integration/rails/graphql}/relay/page_info_spec.rb

@@ -46,63 +46,63 @@ describe GraphQL::Relay::PageInfo do
       result = star_wars_query(query_string, "first" => 2)
       assert_equal(true, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false if 'last' is missing")
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
 
       last_cursor = get_last_cursor(result)
       result = star_wars_query(query_string, "first" => 100, "after" => last_cursor)
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mw==", get_page_info(result)["startCursor"])
-      assert_equal("Mw==", get_page_info(result)["endCursor"])
+      assert_equal("Mw", get_page_info(result)["startCursor"])
+      assert_equal("Mw", get_page_info(result)["endCursor"])
     end
 
     it "hasPreviousPage if there are more items" do
       result = star_wars_query(query_string, "last" => 100, "before" => cursor_of_last_base)
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
 
       result = star_wars_query(query_string, "last" => 1, "before" => cursor_of_last_base)
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mg==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
+      assert_equal("Mg", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
     end
 
     it "has both if first and last are present" do
       result = star_wars_query(query_string, "last" => 1, "first" => 1, "before" => cursor_of_last_base)
       assert_equal(true, get_page_info(result)["hasNextPage"])
       assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("MQ==", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("MQ", get_page_info(result)["endCursor"])
     end
 
     it "startCursor and endCursor are the cursors of the first and last edge" do
       result = star_wars_query(query_string, "first" => 2)
       assert_equal(true, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
-      assert_equal("MQ==", get_first_cursor(result))
-      assert_equal("Mg==", get_last_cursor(result))
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_first_cursor(result))
+      assert_equal("Mg", get_last_cursor(result))
 
       result = star_wars_query(query_string, "first" => 1, "after" => get_page_info(result)["endCursor"])
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mw==", get_page_info(result)["startCursor"])
-      assert_equal("Mw==", get_page_info(result)["endCursor"])
-      assert_equal("Mw==", get_first_cursor(result))
-      assert_equal("Mw==", get_last_cursor(result))
+      assert_equal("Mw", get_page_info(result)["startCursor"])
+      assert_equal("Mw", get_page_info(result)["endCursor"])
+      assert_equal("Mw", get_first_cursor(result))
+      assert_equal("Mw", get_last_cursor(result))
 
       result = star_wars_query(query_string, "last" => 1, "before" => get_page_info(result)["endCursor"])
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mg==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
-      assert_equal("Mg==", get_first_cursor(result))
-      assert_equal("Mg==", get_last_cursor(result))
+      assert_equal("Mg", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
+      assert_equal("Mg", get_first_cursor(result))
+      assert_equal("Mg", get_last_cursor(result))
     end
   end
 

data/spec/{graphql → integration/rails/graphql}/relay/range_add_spec.rb

@@ -4,12 +4,12 @@ require "spec_helper"
 describe GraphQL::Relay::RangeAdd do
   # Make sure that the encoder is found through `ctx.schema`:
   module PassThroughEncoder
-    def self.encode(plaintext, nonce: false)
-      "__#{plaintext}"
+    def self.encode(unencoded_text, nonce: false)
+      "__#{unencoded_text}"
     end
 
-    def self.decode(ciphertext, nonce: false)
-      ciphertext[2..-1]
+    def self.decode(encoded_text, nonce: false)
+      encoded_text[2..-1]
     end
   end
 

data/spec/{graphql → 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
@@ -51,19 +51,52 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal(2, get_names(result).length)
       assert_equal(true, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
-      assert_equal("MQ==", get_first_cursor(result))
-      assert_equal("Mg==", get_last_cursor(result))
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_first_cursor(result))
+      assert_equal("Mg", get_last_cursor(result))
 
       result = star_wars_query(query_string, "first" => 3)
       assert_equal(3, get_names(result).length)
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mw==", get_page_info(result)["endCursor"])
-      assert_equal("MQ==", get_first_cursor(result))
-      assert_equal("Mw==", get_last_cursor(result))
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mw", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_first_cursor(result))
+      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
@@ -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
@@ -288,7 +317,7 @@ describe GraphQL::Relay::RelationConnection do
         assert_equal(first_and_second_names, get_names(result))
         assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
 
-        third_cursor = "Mw=="
+        third_cursor = "Mw"
         result = star_wars_query(query_string, "last" => 100, "before" => third_cursor)
         assert_equal(first_and_second_names, get_names(result))
 
@@ -528,19 +557,19 @@ describe GraphQL::Relay::RelationConnection do
         assert_equal(2, get_names(result).length)
         assert_equal(true, get_page_info(result)["hasNextPage"])
         assert_equal(false, get_page_info(result)["hasPreviousPage"])
-        assert_equal("MQ==", get_page_info(result)["startCursor"])
-        assert_equal("Mg==", get_page_info(result)["endCursor"])
-        assert_equal("MQ==", get_first_cursor(result))
-        assert_equal("Mg==", get_last_cursor(result))
+        assert_equal("MQ", get_page_info(result)["startCursor"])
+        assert_equal("Mg", get_page_info(result)["endCursor"])
+        assert_equal("MQ", get_first_cursor(result))
+        assert_equal("Mg", get_last_cursor(result))
 
         result = star_wars_query(query_string, "first" => 3)
         assert_equal(3, get_names(result).length)
         assert_equal(false, get_page_info(result)["hasNextPage"])
         assert_equal(false, get_page_info(result)["hasPreviousPage"])
-        assert_equal("MQ==", get_page_info(result)["startCursor"])
-        assert_equal("Mw==", get_page_info(result)["endCursor"])
-        assert_equal("MQ==", get_first_cursor(result))
-        assert_equal("Mw==", get_last_cursor(result))
+        assert_equal("MQ", get_page_info(result)["startCursor"])
+        assert_equal("Mw", get_page_info(result)["endCursor"])
+        assert_equal("MQ", get_first_cursor(result))
+        assert_equal("Mw", get_last_cursor(result))
       end
 
       it 'provides custom fields on the connection type' do
@@ -635,8 +664,8 @@ describe GraphQL::Relay::RelationConnection do
     let(:connection) { GraphQL::Relay::RelationConnection.new(StarWars::Base.where(faction_id: 1), {}) }
 
     it "returns the cursor for a node in the connection" do
-      assert_equal "MQ==", connection.cursor_from_node(StarWars::Base.all[0])
-      assert_equal "Mg==", connection.cursor_from_node(StarWars::Base.all[1])
+      assert_equal "MQ", connection.cursor_from_node(StarWars::Base.all[0])
+      assert_equal "Mg", connection.cursor_from_node(StarWars::Base.all[1])
     end
 
     it "raises when the node isn't found" do

data/spec/{graphql → integration/rails/graphql}/schema_spec.rb

@@ -18,8 +18,8 @@ describe GraphQL::Schema do
       rescue_middleware = schema_defn.middleware.first
       assert_equal(1, rescue_middleware.rescue_table.length)
       # normally, you'd use a real class, not a symbol:
-      schema_defn.rescue_from(:error_class) { "my custom message" }
-      assert_equal(2, rescue_middleware.rescue_table.length)
+      schema_defn.rescue_from(:error_class, :another_err_class) { "my custom message" }
+      assert_equal(3, rescue_middleware.rescue_table.length)
     end
   end
 
@@ -47,9 +47,9 @@ describe GraphQL::Schema do
     it "returns a list of the schema's root types" do
       assert_equal(
         [
-          Dummy::DairyAppQueryType,
-          Dummy::DairyAppMutationType.graphql_definition,
-          Dummy::SubscriptionType
+          Dummy::DairyAppQuery.graphql_definition,
+          Dummy::DairyAppMutation.graphql_definition.graphql_definition,
+          Dummy::Subscription.graphql_definition
         ],
         schema.root_types
       )
@@ -58,7 +58,8 @@ describe GraphQL::Schema do
 
   describe "#references_to" do
     it "returns a list of Field and Arguments of that type" do
-      assert_equal [schema.types["Query"].fields["cow"]], schema.references_to("Cow")
+      cow_field = schema.get_field("Query", "cow")
+      assert_equal [cow_field], schema.references_to("Cow")
     end
 
     it "returns an empty list when type is not referenced by any field or argument" do
@@ -72,10 +73,13 @@ describe GraphQL::Schema do
     end
   end
 
-  describe "#subscription" do
-    it "calls fields on the subscription type" do
-      res = schema.execute("subscription { test }")
-      assert_equal("Test", res["data"]["test"])
+  # Interpreter has subscription support hardcoded, it doesn't just call through.
+  if !TESTING_INTERPRETER
+    describe "#subscription" do
+      it "calls fields on the subscription type" do
+        res = schema.execute("subscription { test }")
+        assert_equal("Test", res["data"]["test"])
+      end
     end
   end
 
@@ -450,7 +454,7 @@ type Query {
     it "returns fields by type or type name" do
       field = schema.get_field("Cheese", "id")
       assert_instance_of GraphQL::Field, field
-      field_2 = schema.get_field(Dummy::CheeseType, "id")
+      field_2 = schema.get_field(Dummy::Cheese.graphql_definition, "id")
       assert_equal field, field_2
     end
   end

data/spec/{graphql → integration/rails/graphql}/tracing/active_support_notifications_tracing_spec.rb

@@ -12,7 +12,14 @@ describe GraphQL::Tracing::ActiveSupportNotificationsTracing do
     traces = []
 
     callback = ->(name, started, finished, id, data) {
-      traces << name
+      path_str = if data.key?(:field)
+        " (#{data[:field].path})"
+      elsif data.key?(:context)
+        " (#{data[:context].irep_node.owner_type}.#{data[:context].field.name})"
+      else
+        ""
+      end
+      traces << "#{name}#{path_str}"
     }
 
     query_string = <<-GRAPHQL
@@ -37,16 +44,16 @@ describe GraphQL::Tracing::ActiveSupportNotificationsTracing do
       "graphql.validate",
       "graphql.analyze_query",
       "graphql.analyze_multiplex",
-      "graphql.execute_field",
-      "graphql.execute_field",
+      "graphql.execute_field (Query.batchedBase)",
+      "graphql.execute_field (Query.batchedBase)",
       "graphql.execute_query",
       "graphql.lazy_loader",
-      "graphql.execute_field_lazy",
-      "graphql.execute_field",
-      "graphql.execute_field_lazy",
-      "graphql.execute_field",
-      "graphql.execute_field_lazy",
-      "graphql.execute_field_lazy",
+      "graphql.execute_field_lazy (Query.batchedBase)",
+      "graphql.execute_field (Base.name)",
+      "graphql.execute_field_lazy (Query.batchedBase)",
+      "graphql.execute_field (Base.name)",
+      "graphql.execute_field_lazy (Base.name)",
+      "graphql.execute_field_lazy (Base.name)",
       "graphql.execute_query_lazy",
       "graphql.execute_multiplex",
     ]

data/spec/integration/rails/spec_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require "rake"
+require "rails/all"
+require "rails/generators"
+require "sequel"
+
+if ENV['DATABASE'] == 'POSTGRESQL'
+  require 'pg'
+else
+  require "jdbc/sqlite3" if RUBY_ENGINE == 'jruby'
+  require "sqlite3" if RUBY_ENGINE == 'ruby'
+end
+
+require_relative "generators/base_generator_test"
+require_relative "data"
+
+def with_active_record_log
+  io = StringIO.new
+  prev_logger = ActiveRecord::Base.logger
+  ActiveRecord::Base.logger = Logger.new(io)
+  yield
+  io.string
+ensure
+  ActiveRecord::Base.logger = prev_logger
+end

data/spec/integration/tmp/app/graphql/types/family_type.rb

@@ -0,0 +1,9 @@
+module Types
+  class FamilyType < Types::BaseEnum
+    value "NIGHTSHADE"
+    value "BRASSICA", value: Family::COLE
+    value "UMBELLIFER", value: :umbellifer
+    value "LEGUME", value: "bean & friends"
+    value "CURCURBITS", value: 5
+  end
+end

data/spec/spec_helper.rb

@@ -1,26 +1,21 @@
 # frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+Bundler.require
+
 # Print full backtrace for failiures:
 ENV["BACKTRACE"] = "1"
+# Set this env var to use Interpreter for fixture schemas.
+# Eventually, interpreter will be the default.
+TESTING_INTERPRETER = ENV["TESTING_INTERPRETER"]
+TESTING_RESCUE_FROM = !TESTING_INTERPRETER
 
-def rails_should_be_installed?
-  ENV['WITHOUT_RAILS'] != 'yes'
-end
 require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
 
-if rails_should_be_installed?
-  require "rake"
-  require "rails/all"
-  require "rails/generators"
-
-  require "jdbc/sqlite3" if RUBY_ENGINE == 'jruby'
-  require "sqlite3" if RUBY_ENGINE == 'ruby'
-  require "pg" if RUBY_ENGINE == 'ruby'
-  require "mongoid" if RUBY_ENGINE == 'ruby'
-  require "sequel"
-end
-
 require "graphql"
+require "rake"
 require "graphql/rake_task"
 require "benchmark"
 require "pry"
@@ -28,21 +23,6 @@ require "minitest/autorun"
 require "minitest/focus"
 require "minitest/reporters"
 
-MONGO_DETECTED = begin
-  require "mongo"
-  Mongo::Client.new('mongodb://127.0.0.1:27017/graphql_ruby_test',
-      connect_timeout: 1,
-      socket_timeout: 1,
-      server_selection_timeout: 1,
-      logger: Logger.new(nil)
-    )
-    .database
-    .collections
-rescue StandardError, LoadError => err # rubocop:disable Lint/UselessAssignment
-  # puts err.message, err.backtrace
-  false
-end
-
 Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new(color: true)
 
 Minitest::Spec.make_my_diffs_pretty!
@@ -51,7 +31,6 @@ Minitest::Spec.make_my_diffs_pretty!
 # to be shown.
 Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
-
 # This is for convenient access to metadata in test definitions
 assign_metadata_key = ->(target, key, value) { target.metadata[key] = value }
 assign_metadata_flag = ->(target, flag) { target.metadata[flag] = true }
@@ -76,16 +55,20 @@ NO_OP_RESOLVE_TYPE = ->(type, obj, ctx) {
   raise "this should never be called"
 }
 
+# Load dependencies
+['Mongoid', 'Rails'].each do |integration|
+  begin
+    Object.const_get(integration)
+    Dir["#{File.dirname(__FILE__)}/integration/#{integration.downcase}/**/*.rb"].each do |f|
+      require f
+    end
+  rescue NameError
+    # ignore
+  end
+end
+
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
-  # These require mongodb in order to run,
-  # so only load them in the specific tests that require them.
-  next if f.include?("star_trek")
-
-  unless rails_should_be_installed?
-    next if f.end_with?('star_wars/data.rb')
-    next if f.end_with?('base_generator_test.rb')
-  end
   require f
 end
 
@@ -123,6 +106,7 @@ module TestTracing
 
     def trace(key, data)
       data[:key] = key
+      data[:path] ||= data.key?(:context) ? data[:context].path : nil
       result = yield
       data[:result] = result
       traces << data

data/spec/support/dummy/data.rb

@@ -1,27 +1,32 @@
 # frozen_string_literal: true
 require 'ostruct'
 module Dummy
-  Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source) do
-    def ==(other)
-      # This is buggy on purpose -- it shouldn't be called during execution.
-      other.id == id
-    end
+  module Data
+    Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source) do
+      def ==(other)
+        # This is buggy on purpose -- it shouldn't be called during execution.
+        other.id == id
+      end
 
-    # Alias for when this is treated as milk in EdibleAsMilkInterface
-    def fatContent # rubocop:disable Naming/MethodName
-      fat_content
+      # Alias for when this is treated as milk in EdibleAsMilkInterface
+      def fatContent # rubocop:disable Naming/MethodName
+        fat_content
+      end
     end
+
+    Milk = Struct.new(:id, :fat_content, :origin, :source, :flavors)
+    Cow = Struct.new(:id, :name, :last_produced_dairy)
+    Goat = Struct.new(:id, :name, :last_produced_dairy)
   end
 
   CHEESES = {
-    1 => Cheese.new(1, "Brie", "France", 0.19, 1),
-    2 => Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),
-    3 => Cheese.new(3, "Manchego", "Spain", 0.065, "SHEEP")
+    1 => Data::Cheese.new(1, "Brie", "France", 0.19, 1),
+    2 => Data::Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),
+    3 => Data::Cheese.new(3, "Manchego", "Spain", 0.065, "SHEEP")
   }
 
-  Milk = Struct.new(:id, :fatContent, :origin, :source, :flavors)
   MILKS = {
-    1 => Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
+    1 => Data::Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
   }
 
   DAIRY = OpenStruct.new(
@@ -30,13 +35,11 @@ module Dummy
     milks: [MILKS[1]]
   )
 
-  Cow = Struct.new(:id, :name, :last_produced_dairy)
   COWS = {
-    1 => Cow.new(1, "Billy", MILKS[1])
+    1 => Data::Cow.new(1, "Billy", MILKS[1])
   }
 
-  Goat = Struct.new(:id, :name, :last_produced_dairy)
   GOATS = {
-    1 => Goat.new(1, "Gilly", MILKS[1]),
+    1 => Data::Goat.new(1, "Gilly", MILKS[1]),
   }
 end