mongoid 7.1.2 → 7.2.0

data/spec/shared/lib/mrss/spec_organizer.rb

@@ -0,0 +1,149 @@
+autoload :JSON, 'json'
+autoload :FileUtils, 'fileutils'
+autoload :Find, 'find'
+
+module Mrss
+
+  autoload :ChildProcessHelper, 'mrss/child_process_helper'
+
+  # Organizes and runs all of the tests in the test suite in batches.
+  #
+  # Organizing the tests in batches serves two purposes:
+  #
+  # 1. This allows running unit tests before integration tests, therefore
+  #    in theory revealing failures quicker on average.
+  # 2. This allows running some tests that have high intermittent failure rate
+  #    in their own test process.
+  #
+  # This class aggregates RSpec results after the test runs.
+  class SpecOrganizer
+
+    class BucketsNotPrioritized < StandardError
+    end
+
+    def initialize(root: nil, classifiers:, priority_order:,
+      spec_root: nil, rspec_json_path: nil, rspec_all_json_path: nil
+    )
+      @spec_root = spec_root || File.join(root, 'spec')
+      @classifiers = classifiers
+      @priority_order = priority_order
+      @rspec_json_path = rspec_json_path || File.join(root, 'tmp/rspec.json')
+      @rspec_all_json_path = rspec_all_json_path || File.join(root, 'tmp/rspec-all.json')
+    end
+
+    attr_reader :spec_root, :classifiers, :priority_order
+    attr_reader :rspec_json_path, :rspec_all_json_path
+
+    def buckets
+      @buckets ||= {}.tap do |buckets|
+        Find.find(spec_root) do |path|
+          next unless File.file?(path)
+          next unless path =~ /_spec\.rb\z/
+          rel_path = path[(spec_root.length + 1)..path.length]
+
+          found = false
+          classifiers.each do |(regexp, category)|
+            if regexp =~ rel_path
+              buckets[category] ||= []
+              buckets[category] << File.join('spec', rel_path)
+              found = true
+              break
+            end
+          end
+
+          unless found
+            buckets[nil] ||= []
+            buckets[nil] << File.join('spec', rel_path)
+          end
+        end
+      end.freeze
+    end
+
+    def ordered_buckets
+      @ordered_buckets ||= {}.tap do |ordered_buckets|
+        buckets = self.buckets.dup
+        priority_order.each do |category|
+          files = buckets.delete(category)
+          ordered_buckets[category] = files
+        end
+
+        if files = buckets.delete(nil)
+          ordered_buckets[nil] = files
+        end
+
+        unless buckets.empty?
+          raise BucketsNotPrioritized, "Some buckets were not prioritized: #{buckets.keys.map(&:to_s).join(', ')}"
+        end
+      end.freeze
+    end
+
+    def run
+      FileUtils.rm_f(rspec_all_json_path)
+
+      failed = []
+      buckets = self.buckets.dup
+
+      priority_order.each do |category|
+        if files = buckets.delete(category)
+          unless run_files(category, files)
+            failed << category
+          end
+        end
+      end
+      if files = buckets.delete(nil)
+        unless run_files('remaining', files)
+          failed << 'remaining'
+        end
+      end
+
+      unless buckets.empty?
+        raise "Some buckets were not executed: #{buckets.keys.map(&:to_s).join(', ')}"
+      end
+
+      if failed.any?
+        raise "The following buckets failed: #{failed.map(&:to_s).join(', ')}"
+      end
+    end
+
+    def run_files(category, paths)
+      puts "Running #{category.to_s.gsub('_', ' ')} tests"
+      FileUtils.rm_f(rspec_json_path)
+      cmd = %w(rspec) + paths
+
+      begin
+        ChildProcessHelper.check_call(cmd)
+      ensure
+        if File.exist?(rspec_json_path)
+          if File.exist?(rspec_all_json_path)
+            merge_rspec_results
+          else
+            FileUtils.cp(rspec_json_path, rspec_all_json_path)
+          end
+        end
+      end
+
+      true
+    rescue ChildProcessHelper::SpawnError
+      false
+    end
+
+    def merge_rspec_results
+      all = JSON.parse(File.read(rspec_all_json_path))
+      new = JSON.parse(File.read(rspec_json_path))
+      all['examples'] += new.delete('examples')
+      new.delete('summary').each do |k, v|
+        all['summary'][k] += v
+      end
+      new.delete('version')
+      new.delete('summary_line')
+      unless new.empty?
+        raise "Unhandled rspec results keys: #{new.keys.join(', ')}"
+      end
+      # We do not merge summary lines, delete them from aggregated results
+      all.delete('summary_line')
+      File.open(rspec_all_json_path, 'w') do |f|
+        f << JSON.dump(all)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@
 
 require 'lite_spec_helper'
 
-MODELS = File.join(File.dirname(__FILE__), "app/models")
+MODELS = File.join(File.dirname(__FILE__), "support/models")
 $LOAD_PATH.unshift(MODELS)
 
 require "action_controller"
@@ -35,6 +35,7 @@ require 'support/helpers'
 require 'support/macros'
 require 'support/cluster_config'
 require 'support/constraints'
+require 'mrss/constraints'
 
 # Give MongoDB servers time to start up in CI environments
 if SpecConfig.instance.ci?
@@ -82,7 +83,7 @@ Mongoid.configure do |config|
   config.load_configuration(CONFIG)
 end
 
-# Autoload every model for the test suite that sits in spec/app/models.
+# Autoload every model for the test suite that sits in spec/support/models.
 Dir[ File.join(MODELS, "*.rb") ].sort.each do |file|
   name = File.basename(file, ".rb")
   autoload name.camelize.to_sym, name
@@ -128,6 +129,7 @@ RSpec.configure do |config|
   config.raise_errors_for_deprecations!
   config.include(Helpers)
   config.include(Mongoid::Expectations)
+  config.extend(Mrss::Constraints)
   config.extend(Constraints)
   config.extend(Mongoid::Macros)
 

data/spec/support/constraints.rb

@@ -4,252 +4,50 @@
 module Constraints
   RAILS_VERSION = ActiveSupport.version.to_s.split('.')[0..1].join('.').freeze
 
-  def min_rails_version(version)
-    unless version =~ /\A\d+\.\d+\z/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
+  def min_driver_version(version)
+    required_version = version.split('.').map(&:to_i)
+    actual_version = driver_version(required_version.length)
     before(:all) do
-      if version > RAILS_VERSION
-        skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
+      if (actual_version <=> required_version) < 0
+        skip "Driver version #{version} or higher is required"
       end
     end
   end
 
-  def max_rails_version(version)
-    unless version =~ /\A\d+\.\d+\z/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
+  def max_driver_version(version)
+    required_version = version.split('.').map(&:to_i)
+    actual_version = driver_version(required_version.length)
     before(:all) do
-      if version < RAILS_VERSION
-        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
+      if (actual_version <=> required_version) > 0
+        skip "Driver version #{version} or lower is required"
       end
     end
   end
 
-  def min_server_version(version)
-    unless version =~ /\A\d+\.\d+\z/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
-    before(:all) do
-      if version > ClusterConfig.instance.server_version
-        skip "Server version #{version} or higher required, we have #{ClusterConfig.instance.server_version}"
-      end
-    end
+  def driver_version(precision)
+    Mongo::VERSION.split('.')[0...precision].map(&:to_i)
   end
 
-  def max_server_version(version)
+  def min_rails_version(version)
     unless version =~ /\A\d+\.\d+\z/
       raise ArgumentError, "Version can only be major.minor: #{version}"
     end
 
     before(:all) do
-      if version < ClusterConfig.instance.short_server_version
-        skip "Server version #{version} or lower required, we have #{ClusterConfig.instance.server_version}"
-      end
-    end
-  end
-
-  def require_topology(*topologies)
-    invalid_topologies = topologies - [:single, :replica_set, :sharded]
-
-    unless invalid_topologies.empty?
-      raise ArgumentError, "Invalid topologies requested: #{invalid_topologies.join(', ')}"
-    end
-
-    before(:all) do
-      unless topologies.include?(topology = ClusterConfig.instance.topology)
-        skip "Topology #{topologies.join(' or ')} required, we have #{topology}"
-      end
-    end
-  end
-
-  def max_example_run_time(timeout)
-    around do |example|
-      TimeoutInterrupt.timeout(timeout, TimeoutInterrupt::Error.new("Test execution terminated after #{timeout} seconds")) do
-        example.run
-      end
-    end
-  end
-
-  def require_transaction_support
-    before(:all) do
-      case ClusterConfig.instance.topology
-      when :single
-        skip 'Transactions tests require a replica set (4.0+) or a sharded cluster (4.2+)'
-      when :replica_set
-        unless ClusterConfig.instance.server_version >= '4.0'
-          skip 'Transactions tests in a replica set topology require server 4.0+'
-        end
-      when :sharded
-        unless ClusterConfig.instance.server_version >= '4.2'
-          skip 'Transactions tests in a sharded cluster topology require server 4.2+'
-        end
-      else
-        raise NotImplementedError
-      end
-    end
-  end
-
-  def require_tls
-    before(:all) do
-      unless SpecConfig.instance.ssl?
-        skip "SSL not enabled"
-      end
-    end
-  end
-
-  def require_no_tls
-    before(:all) do
-      if SpecConfig.instance.ssl?
-        skip "SSL enabled"
-      end
-    end
-  end
-
-  def require_local_tls
-    require_tls
-  end
-
-  def require_no_retry_writes
-    before(:all) do
-      if SpecConfig.instance.retry_writes?
-        skip "Retry writes is enabled"
-      end
-    end
-  end
-
-  def require_compression
-    before(:all) do
-      if SpecConfig.instance.compressors.nil?
-        skip "Compression is not enabled"
-      end
-    end
-  end
-
-  def require_no_compression
-    before(:all) do
-      if SpecConfig.instance.compressors
-        skip "Compression is enabled"
-      end
-    end
-  end
-
-  def ruby_version_gte(version)
-    before(:all) do
-      if RUBY_VERSION < version
-        skip "Ruby version #{version} or higher required"
-      end
-    end
-  end
-
-  def ruby_version_lt(version)
-    before(:all) do
-      if RUBY_VERSION >= version
-        skip "Ruby version less than #{version} required"
-      end
-    end
-  end
-
-  def require_auth
-    before(:all) do
-      unless ENV['AUTH'] == 'auth' || SpecConfig.instance.user || ClusterConfig.instance.auth_enabled?
-        skip "Auth required"
-      end
-    end
-  end
-
-  def require_no_auth
-    before(:all) do
-      if ENV['AUTH'] == 'auth' || SpecConfig.instance.user || ClusterConfig.instance.auth_enabled?
-        skip "Auth not allowed"
-      end
-    end
-  end
-
-  def require_no_x509_auth
-    before(:all) do
-      if SpecConfig.instance.x509_auth?
-        skip "X.509 auth not allowed"
-      end
-    end
-  end
-
-  # Can the driver specify a write concern that won't be overridden?
-  # (mongos 4.0+ overrides the write concern)
-  def require_set_write_concern
-    before(:all) do
-      if ClusterConfig.instance.topology == :sharded && ClusterConfig.instance.short_server_version >= '4.0'
-        skip "mongos 4.0+ overrides write concern"
-      end
-    end
-  end
-
-  def require_multi_shard
-    before(:all) do
-      if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length == 1
-        skip 'Test requires a minimum of two shards if run in sharded topology'
-      end
-    end
-  end
-
-  def require_no_multi_shard
-    before(:all) do
-      if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length > 1
-        skip 'Test requires a single shard if run in sharded topology'
-      end
-    end
-  end
-
-  def require_wired_tiger
-    before(:all) do
-      if ClusterConfig.instance.storage_engine != :wired_tiger
-        skip 'Test requires WiredTiger storage engine'
-      end
-    end
-  end
-
-  def require_wired_tiger_on_36
-    before(:all) do
-      if ClusterConfig.instance.short_server_version >= '3.6'
-        if ClusterConfig.instance.storage_engine != :wired_tiger
-          skip 'Test requires WiredTiger storage engine on 3.6+ servers'
-        end
-      end
-    end
-  end
-
-  def require_mmapv1
-    before(:all) do
-      if ClusterConfig.instance.storage_engine != :mmapv1
-        skip 'Test requires MMAPv1 storage engine'
+      if version > RAILS_VERSION
+        skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
       end
     end
   end
 
-  def require_enterprise
-    before(:all) do
-      unless ClusterConfig.instance.enterprise?
-        skip 'Test requires enterprise build of MongoDB'
-      end
+  def max_rails_version(version)
+    unless version =~ /\A\d+\.\d+\z/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
     end
-  end
 
-  # Integration tests for SRV polling require internet connectivity to
-  # look up SRV records and a sharded cluster configured on default port on
-  # localhost (localhost:27017, localhost:27018).
-  def require_default_port_deployment
-    # Because the DNS records at test1.test.build.10gen.cc point to
-    # localhost:27017 & localhost:27018, the test suite must have been
-    # configured to use these addresses
     before(:all) do
-      have_default_port = SpecConfig.instance.addresses.any? do |address|
-        %w(127.0.0.1 127.0.0.1:27017 localhost localhost:27017).include?(address)
-      end
-      unless have_default_port
-        skip 'This test requires the test suite to be configured for localhost:27017'
+      if version < RAILS_VERSION
+        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
       end
     end
   end