mongo 2.13.0.beta1 → 2.13.0.rc1

data/spec/spec_tests/retryable_reads_spec.rb

@@ -8,7 +8,7 @@ describe 'Retryable reads spec tests' do
 
   define_crud_spec_tests(RETRYABLE_READS_TESTS) do |spec, req, test|
     let(:client) do
-      authorized_client.with({max_read_retries: 0}.update(test.client_options)).tap do |client|
+      authorized_client.use(spec.database_name).with({max_read_retries: 0}.update(test.client_options)).tap do |client|
         client.subscribe(Mongo::Monitoring::COMMAND, event_subscriber)
       end
     end
@@ -28,7 +28,7 @@ describe 'Retryable reads spec tests - legacy' do
     end
 
     let(:client) do
-      authorized_client.with(client_options).tap do |client|
+      authorized_client.use(spec.database_name).with(client_options).tap do |client|
         client.subscribe(Mongo::Monitoring::COMMAND, event_subscriber)
       end
     end

data/spec/spec_tests/sdam_integration_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+require 'runners/crud'
+require 'runners/transactions'
+
+SDAM_INTEGRATION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam_integration/*.yml").sort
+
+describe 'SDAM integration tests' do
+  require_no_multi_shard
+  require_wired_tiger
+
+  define_transactions_spec_tests(SDAM_INTEGRATION_TESTS)
+end

data/spec/spec_tests/sdam_monitoring_spec.rb

@@ -2,7 +2,6 @@ require 'lite_spec_helper'
 
 require 'runners/sdam'
 require 'runners/sdam/verifier'
-require 'runners/sdam_monitoring'
 
 describe 'SDAM Monitoring' do
   include Mongo::SDAM
@@ -14,7 +13,7 @@ describe 'SDAM Monitoring' do
     context("#{spec.description} (#{file.sub(%r'.*/data/sdam_monitoring/', '')})") do
 
       before(:all) do
-        @subscriber = Mongo::SDAMMonitoring::PhasedTestSubscriber.new
+        @subscriber = PhasedEventSubscriber.new
         sdam_proc = lambda do |client|
           client.subscribe(Mongo::Monitoring::SERVER_OPENING, @subscriber)
           client.subscribe(Mongo::Monitoring::SERVER_CLOSED, @subscriber)

data/spec/spec_tests/server_selection_spec.rb

@@ -1,121 +1,9 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 require 'runners/server_selection'
 
-describe 'Server Selection' do
+SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection/**/*.yml").sort
 
-  include Mongo::ServerSelection::Read
-
-  SERVER_SELECTION_TESTS.each do |file|
-
-    spec = Mongo::ServerSelection::Read::Spec.new(file)
-
-    context(spec.description) do
-
-      let(:monitoring) do
-        Mongo::Monitoring.new(monitoring: false)
-      end
-
-      # Cluster needs a topology and topology needs a cluster...
-      # This temporary cluster is used for topology construction.
-      let(:temp_cluster) do
-        double('temp cluster').tap do |cluster|
-          allow(cluster).to receive(:servers_list).and_return([])
-        end
-      end
-
-      let(:topology) do
-        options = if spec.type <= Mongo::Cluster::Topology::ReplicaSetNoPrimary
-          {replica_set_name: 'foo'}
-        else
-          {}
-        end
-        spec.type.new(options, monitoring, temp_cluster)
-      end
-
-      let(:listeners) do
-        Mongo::Event::Listeners.new
-      end
-
-      let(:cluster) do
-        double('cluster').tap do |c|
-          allow(c).to receive(:connected?).and_return(true)
-          allow(c).to receive(:summary)
-          allow(c).to receive(:topology).and_return(topology)
-          allow(c).to receive(:single?).and_return(topology.single?)
-          allow(c).to receive(:sharded?).and_return(topology.sharded?)
-          allow(c).to receive(:replica_set?).and_return(topology.replica_set?)
-          allow(c).to receive(:unknown?).and_return(topology.unknown?)
-          allow(c).to receive(:app_metadata).and_return(app_metadata)
-          allow(c).to receive(:options).and_return({})
-          allow(c).to receive(:server_selection_semaphore).and_return(nil)
-        end
-      end
-
-      let(:candidate_servers) do
-        spec.candidate_servers.collect do |server|
-          address = Mongo::Address.new(server['address'])
-          Mongo::Server.new(address, cluster, monitoring, listeners,
-            {monitoring_io: false}.update(SpecConfig.instance.test_options)
-          ).tap do |s|
-            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0)
-            allow(s).to receive(:tags).and_return(server['tags'])
-            allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
-            allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
-            allow(s).to receive(:connectable?).and_return(true)
-            allow(s).to receive(:check_driver_support!).and_return(true)
-          end
-        end
-      end
-
-      let(:in_latency_window) do
-        spec.in_latency_window.collect do |server|
-          address = Mongo::Address.new(server['address'])
-          Mongo::Server.new(address, cluster, monitoring, listeners,
-            {monitoring_io: false}.update(SpecConfig.instance.test_options)
-          ).tap do |s|
-            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0)
-            allow(s).to receive(:tags).and_return(server['tags'])
-            allow(s).to receive(:connectable?).and_return(true)
-            allow(s).to receive(:check_driver_support!).and_return(true)
-          end
-        end
-      end
-
-      let(:server_selector) do
-        Mongo::ServerSelector.get(:mode => spec.read_preference['mode'],
-                                  :tag_sets => spec.read_preference['tag_sets'])
-      end
-
-      before do
-        allow(cluster).to receive(:servers).and_return(candidate_servers)
-        allow(cluster).to receive(:servers_list).and_return(candidate_servers)
-        allow(cluster).to receive(:addresses).and_return(candidate_servers.map(&:address))
-        allow(cluster).to receive(:options).and_return(server_selection_timeout: 0.2)
-        allow(cluster).to receive(:scan!).and_return(true)
-        allow(cluster).to receive(:app_metadata).and_return(app_metadata)
-      end
-
-      context 'Valid read preference and matching server available', if: spec.server_available? do
-
-        it 'Finds all suitable servers in the latency window', if: spec.replica_set? do
-          expect(server_selector.send(:select, cluster.servers)).to match_array(in_latency_window)
-        end
-
-        it 'Finds the most suitable server in the latency window' do
-          expect(in_latency_window).to include(server_selector.select_server(cluster))
-        end
-      end
-
-      context 'No matching server available', if: !spec.server_available? do
-        skip_if_linting
-
-        it 'Raises exception' do
-          expect do
-            server_selector.select_server(cluster)
-          end.to raise_exception(Mongo::Error::NoServerAvailable)
-        end
-      end
-    end
-  end
+describe 'Server selection spec tests' do
+  define_server_selection_spec_tests(SERVER_SELECTION_TESTS)
 end

data/spec/stress/cleanup_spec.rb

@@ -20,17 +20,32 @@ describe 'Cleanup stress test' do
 
     it 'cleans up' do
       client
+      client.cluster.servers_list.map(&:scan!)
+
+      sleep 1
+      GC.start
 
       start_resources = resources
 
-      100.times do
+      500.times do
         client.close
         client.reconnect
       end
 
+      sleep 1
+      GC.start
+
       end_resources = resources
 
-      end_resources.should == start_resources
+      # There seem to be a temporary file descriptor leak in CI,
+      # where we start with 75 fds and end with 77 fds.
+      # Allow a few to be leaked, run more iterations to ensure the leak
+      # is not a real one.
+      # Sometimes we end with fewer fds than we started with also...
+      end_resources[:open_file_count].should >= start_resources[:open_file_count] - 3
+      end_resources[:open_file_count].should <= start_resources[:open_file_count] + 3
+
+      end_resources[:running_thread_count].should == start_resources[:running_thread_count]
     end
   end
 

data/spec/stress/connection_pool_stress_spec.rb

@@ -21,9 +21,9 @@ describe 'Connection pool stress test' do
     [].tap do |threads|
       thread_count.times do |i|
         threads << Thread.new do
-          10.times do |j|
+          100.times do |j|
             collection.find(a: i+j).to_a
-            sleep 0.5
+            sleep 0.1
             collection.find(a: i+j).to_a
           end
         end
@@ -132,7 +132,7 @@ describe 'Connection pool stress test' do
     end
 
     context '25 threads, max pool size 5' do
-      let(:thread_count) { 20 }
+      let(:thread_count) { 25 }
 
       it_behaves_like 'does not raise error'
     end
@@ -183,17 +183,19 @@ describe 'Connection pool stress test' do
       # The populator calls create_and_add_connection, which calls connection.connect!
       # and raises if an error occurs (eg, an auth error), so in this test we
       # randomly raise errors on this method.
-      expect(server.pool).to receive(:create_and_add_connection).at_least(:once).and_wrap_original { |m, *args|
-        if rand < 0.05
+      expect(server.pool).to receive(:create_and_add_connection).at_least(:once).and_wrap_original do |m, *args|
+        if rand < 0.1
           raise Mongo::Error::SocketError
         else
           m.call(*args)
         end
-      }
+      end
 
-      expect {
+      server.pool.clear(stop_populator: false)
+
+      expect do
         threads.collect { |t| t.join }
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 end

data/spec/support/child_process_helper.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+autoload :ChildProcess, 'childprocess'
+autoload :Tempfile, 'tempfile'
+
+module ChildProcessHelper
+  class SpawnError < StandardError; end
+
+  module_function def call(cmd, env: nil, cwd: nil)
+    process = ChildProcess.new(*cmd)
+    process.io.inherit!
+    if cwd
+      process.cwd = cwd
+    end
+    if env
+      env.each do |k, v|
+        process.environment[k.to_s] = v
+      end
+    end
+    process.start
+    process.wait
+    process
+  end
+
+  module_function def check_call(cmd, env: nil, cwd: nil)
+    process = call(cmd, env: env, cwd: cwd)
+    unless process.exit_code == 0
+      raise SpawnError, "Failed to execute: #{cmd}"
+    end
+  end
+
+  module_function def get_output(cmd, env: nil, cwd: nil)
+    process = ChildProcess.new(*cmd)
+    process.io.inherit!
+    if cwd
+      process.cwd = cwd
+    end
+    if env
+      env.each do |k, v|
+        process.environment[k.to_s] = v
+      end
+    end
+
+    output = ''
+    r, w = IO.pipe
+
+    begin
+      process.io.stdout = w
+      process.start
+      w.close
+
+      thread = Thread.new do
+        begin
+          loop do
+            output << r.readpartial(16384)
+          end
+        rescue EOFError
+        end
+      end
+
+      process.wait
+      thread.join
+    ensure
+      r.close
+    end
+
+    [process, output]
+  end
+
+  module_function def check_output(*args)
+    process, output = get_output(*args)
+    unless process.exit_code == 0
+      raise SpawnError,"Failed to execute: #{args}"
+    end
+    output
+  end
+end

data/spec/support/client_registry.rb

@@ -105,6 +105,7 @@ class ClientRegistry
       }.update(SpecConfig.instance.credentials_or_external_user(
         user: SpecConfig.instance.test_user.name,
         password: SpecConfig.instance.test_user.password,
+        auth_source: 'admin',
       ))
 
       Mongo::Client.new(

data/spec/support/cluster_config.rb

@@ -38,6 +38,10 @@ class ClusterConfig
   # less than 3.4. This method returns FCV on 3.4+ servers when in single
   # or RS topologies, and otherwise returns the major.minor server version.
   def fcv_ish
+    if server_version.nil?
+      raise "Deployment server version not known - check that connection to deployment succeeded"
+    end
+
     if server_version >= '3.4' && topology != :sharded
       fcv
     else

data/spec/support/event_subscriber.rb

@@ -3,6 +3,21 @@
 # @since 2.5.0
 class EventSubscriber
 
+  # The mappings of event names to types.
+  #
+  # @since 2.4.0
+  MAPPINGS = {
+    'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening,
+    'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
+    'topology_closed_event' => Mongo::Monitoring::Event::TopologyClosed,
+    'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
+    'server_description_changed_event' => Mongo::Monitoring::Event::ServerDescriptionChanged,
+    'server_closed_event' => Mongo::Monitoring::Event::ServerClosed
+  }.freeze
+
+  # All events.
+  attr_reader :all_events
+
   # The started events.
   #
   # @since 2.5.0
@@ -20,25 +35,40 @@ class EventSubscriber
 
   attr_reader :published_events
 
-  # Cache the succeeded event.
-  #
-  # @param [ Event ] event The event.
-  #
-  # @since 2.5.0
-  def succeeded(event)
-    @mutex.synchronize do
-      succeeded_events.push(event)
+  # @param [ String ] name Optional name for the event subscriber.
+  def initialize(name: nil)
+    @mutex = Mutex.new
+    clear_events!
+    @name = name
+  end
+
+  def to_s
+    %Q`#<EventSubscriber:#{@name ? "\"#{@name}\"" : '%x' % object_id} \
+started=#{started_events.length} \
+succeeded=#{succeeded_events.length} \
+failed=#{failed_events.length} \
+published=#{published_events.length}>`
+  end
+
+  alias :inspect :to_s
+
+  # Event retrieval
+
+  def select_started_events(cls)
+    started_events.select do |event|
+      event.is_a?(cls)
     end
   end
 
-  # Cache the started event.
-  #
-  # @param [ Event ] event The event.
-  #
-  # @since 2.5.0
-  def started(event)
-    @mutex.synchronize do
-      started_events.push(event)
+  def select_succeeded_events(cls)
+    succeeded_events.select do |event|
+      event.is_a?(cls)
+    end
+  end
+
+  def select_published_events(cls)
+    published_events.select do |event|
+      event.is_a?(cls)
     end
   end
 
@@ -59,8 +89,13 @@ class EventSubscriber
 
   # Locates command stated events for the specified command name,
   # asserts that there is exactly one such event, and returns it.
-  def single_command_started_event(command_name)
-    events = started_events.select do |event|
+  def single_command_started_event(command_name, include_auth: false)
+    events = if include_auth
+      started_events
+    else
+      non_auth_command_started_events
+    end
+    events.select! do |event|
       event.command[command_name]
     end
     if events.length != 1
@@ -69,38 +104,65 @@ class EventSubscriber
     events.first
   end
 
-  def select_started_events(cls)
-    @started_events.select do |event|
-      event.is_a?(cls)
+  # Get the first succeeded event published for the name, and then delete it.
+  #
+  # @param [ String ] name The event name.
+  #
+  # @return [ Event ] The matching event.
+  def first_event(name)
+    cls = MAPPINGS[name]
+    if cls.nil?
+      raise ArgumentError, "Bogus event name #{name}"
     end
+    matching = succeeded_events.find do |event|
+      cls === event
+    end
+    succeeded_events.delete(matching)
+    matching
   end
 
-  def select_succeeded_events(cls)
-    @succeeded_events.select do |event|
-      event.is_a?(cls)
+  # Event recording
+
+  # Cache the started event.
+  #
+  # @param [ Event ] event The event.
+  #
+  # @since 2.5.0
+  def started(event)
+    @mutex.synchronize do
+      started_events << event
+      all_events << event
     end
   end
 
-  # Cache the failed event.
+  # Cache the succeeded event.
   #
   # @param [ Event ] event The event.
   #
   # @since 2.5.0
-  def failed(event)
+  def succeeded(event)
     @mutex.synchronize do
-      failed_events.push(event)
+      succeeded_events << event
+      all_events << event
     end
   end
 
-  def select_published_events(cls)
-    @published_events.select do |event|
-      event.is_a?(cls)
+  # Cache the failed event.
+  #
+  # @param [ Event ] event The event.
+  #
+  # @since 2.5.0
+  def failed(event)
+    @mutex.synchronize do
+      failed_events << event
+      all_events << event
     end
   end
 
   def published(event)
     @mutex.synchronize do
-      @published_events << event
+      published_events << event
+      all_events << event
     end
   end
 
@@ -108,15 +170,43 @@ class EventSubscriber
   #
   # @since 2.5.1
   def clear_events!
+    @all_events = []
     @started_events = []
     @succeeded_events = []
     @failed_events = []
     @published_events = []
     self
   end
+end
 
+# Only handles succeeded events correctly.
+class PhasedEventSubscriber < EventSubscriber
   def initialize
-    @mutex = Mutex.new
-    clear_events!
+    super
+    @phase_events = {}
+  end
+
+  def phase_finished(phase_index)
+    @phase_events[phase_index] = succeeded_events
+    @succeeded_events = []
+  end
+
+  def phase_events(phase_index)
+    @phase_events[phase_index]
+  end
+
+  def event_count
+    @phase_events.inject(0) do |sum, event|
+      sum + event.length
+    end
+  end
+end
+
+class VerboseEventSubscriber < EventSubscriber
+  %w(started succeeded failed published).each do |meth|
+    define_method(meth) do |event|
+      puts event.summary
+      super(event)
+    end
   end
 end