mongo 2.14.0.rc1 → 2.14.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

@@ -1,8 +1,9 @@
 require 'lite_spec_helper'
 
+require 'mrss/constraints'
+require 'support/constraints'
 require 'support/authorization'
 require 'support/primary_socket'
-require 'support/constraints'
 require 'support/cluster_config'
 require 'support/cluster_tools'
 require 'rspec/retry'
@@ -11,6 +12,7 @@ require 'support/local_resource_registry'
 
 RSpec.configure do |config|
   config.include(Authorization)
+  config.extend(Mrss::Constraints)
   config.extend(Constraints)
 
   config.before(:all) do

data/spec/stress/fork_reconnect_stress_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe 'fork reconnect' do
   require_fork
-  only_mri
+  require_mri
 
   # On multi-shard sharded clusters a succeeding write request does not
   # guarantee that the next operation will succeed (since it could be sent to

data/spec/support/constraints.rb

@@ -1,105 +1,4 @@
 module Constraints
-  def min_server_version(version)
-    unless version =~ /^\d+\.\d+$/
-      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
-  end
-
-  def max_server_version(version)
-    unless version =~ /^\d+\.\d+$/
-      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 min_server_fcv(version)
-    unless version =~ /^\d+\.\d+$/
-      raise ArgumentError, "FCV can only be major.minor: #{version}"
-    end
-
-    before(:all) do
-      unless ClusterConfig.instance.fcv_ish >= version
-        skip "FCV #{version} or higher required, we have #{ClusterConfig.instance.fcv_ish} (server #{ClusterConfig.instance.server_version})"
-      end
-    end
-  end
-
-  def max_server_fcv(version)
-    unless version =~ /^\d+\.\d+$/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
-    before(:all) do
-      if version < ClusterConfig.instance.fcv_ish
-        skip "FCV #{version} or lower required, we have #{ClusterConfig.instance.fcv_ish} (server #{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
-    min_server_fcv '4.0'
-    require_topology :replica_set
-  end
-
-  # Fail command fail point was added to mongod in 4.0 and to mongos in 4.2.
-  def require_fail_command
-    min_server_fcv '4.0'
-
-    before(:all) do
-      if ClusterConfig.instance.topology == :sharded
-        unless ClusterConfig.instance.short_server_version >= '4.2'
-          skip 'Test requires failCommand fail point which was added to mongos in 4.2'
-        end
-      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
 
   # Some tests hardcode the TLS certificates shipped with the driver's
   # test suite, and will fail when using TLS connections that use other
@@ -114,173 +13,4 @@ module Constraints
       end
     end
   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(*values)
-    before(:all) do
-      if values.any?
-        unless values.include?(ENV['AUTH'])
-          msg = values.map { |v| "AUTH=#{v}" }.join(' or ')
-          skip "This test requires #{msg}"
-        end
-      else
-        unless ENV['AUTH'] == 'auth' || SpecConfig.instance.user || ClusterConfig.instance.auth_enabled?
-          skip "Auth required"
-        end
-      end
-    end
-  end
-
-  def require_no_auth
-    before(:all) do
-      if (ENV['AUTH'] && ENV['AUTH'] != 'noauth') || SpecConfig.instance.user || ClusterConfig.instance.auth_enabled?
-        skip "Auth not allowed"
-      end
-    end
-  end
-
-  def require_x509_auth
-    before(:all) do
-      unless SpecConfig.instance.x509_auth?
-        skip "X.509 auth required"
-      end
-    end
-  end
-
-  def require_no_external_user
-    before(:all) do
-      if SpecConfig.instance.external_user?
-        skip "External user configurations are not compatible with this test"
-      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'
-      end
-    end
-  end
-
-  def require_enterprise
-    before(:all) do
-      unless ClusterConfig.instance.enterprise?
-        skip 'Test requires enterprise build of MongoDB'
-      end
-    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'
-      end
-    end
-  end
-
-  # Some tests perform assertions on what the driver is logging.
-  # Some test configurations, for example OCSP with unknown response,
-  # produce warnings due to optional checks failing.
-  # This constraint skips tests that issue logging assertions on configurations
-  # that may produce non-test-originated log entries.
-  def require_warning_clean
-    before(:all) do
-      if ENV['OCSP_STATUS'] == 'unknown'
-        skip 'Unknown OCSP status is not global warning-clean'
-      end
-    end
-  end
 end