mongo 2.13.0.beta1 → 2.14.0

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

data/spec/support/keyword_struct.rb

@@ -0,0 +1,26 @@
+# Intermediate step between a Struct and an OpenStruct. Allows only designated
+# field names to be read or written but allows passing fields to constructor
+# as keyword arguments.
+class KeywordStruct
+  def self.new(*field_names, &block)
+    Class.new.tap do |cls|
+      cls.class_exec do
+        define_method(:initialize) do |**fields|
+          fields.each do |field, value|
+            unless field_names.include?(field)
+              raise ArgumentError, "Unknown field #{field}"
+            end
+
+            instance_variable_set("@#{field}", value)
+          end
+        end
+
+        attr_accessor *field_names
+      end
+
+      if block_given?
+        cls.class_exec(&block)
+      end
+    end
+  end
+end

data/spec/support/matchers.rb

@@ -54,3 +54,19 @@ RSpec::Matchers.define :be_uuid do
     object.is_a?(BSON::Binary) && object.type == :uuid
   end
 end
+
+RSpec::Matchers.define :take_longer_than do |min_expected_time|
+  match do |proc|
+    start_time = Time.now
+    proc.call
+    (Time.now - start_time).should > min_expected_time
+  end
+end
+
+RSpec::Matchers.define :take_shorter_than do |min_expected_time|
+  match do |proc|
+    start_time = Time.now
+    proc.call
+    (Time.now - start_time).should < min_expected_time
+  end
+end

data/spec/support/ocsp

@@ -0,0 +1 @@
+spec/support/../../.mod/drivers-evergreen-tools/.evergreen/ocsp

data/spec/support/session_registry.rb

@@ -0,0 +1,52 @@
+require 'singleton'
+
+module Mongo
+  class Client
+    alias :get_session_without_tracking :get_session
+
+    def get_session(options = {})
+      get_session_without_tracking(options).tap do |session|
+        SessionRegistry.instance.register(session)
+      end
+    end
+  end
+
+  class Session
+    alias :end_session_without_tracking :end_session
+
+    def end_session
+      SessionRegistry.instance.unregister(self)
+      end_session_without_tracking
+    end
+  end
+end
+
+
+class SessionRegistry
+  include Singleton
+
+  def initialize
+    @registry = {}
+  end
+
+  def register(session)
+    @registry[session.session_id] = session if session
+  end
+
+  def unregister(session)
+    @registry.delete(session.session_id) unless session.ended?
+  end
+
+  def verify_sessions_ended!
+    @registry.delete_if { |_, session| session.ended? }
+
+    unless @registry.empty?
+      sessions = @registry.map { |_, session| session }
+      raise "Session registry contains live sessions: #{sessions.join(', ')}"
+    end
+  end
+
+  def clear_registry
+    @registry = {}
+  end
+end

data/spec/support/shared/server_selector.rb

@@ -22,7 +22,19 @@ shared_context 'server selector' do
       expect(server.unknown?).to be true
     end
   end
-  let(:options) { { :mode => name, :tag_sets => tag_sets, max_staleness: max_staleness, hedge: hedge } }
+  let(:server_selection_timeout_options) do
+    {
+      server_selection_timeout: 0.1,
+    }
+  end
+  let(:options) do
+    {
+      mode: name,
+      tag_sets: tag_sets,
+      max_staleness: max_staleness,
+      hedge: hedge,
+    }
+  end
   let(:selector) { described_class.new(options) }
   let(:monitoring) do
     Mongo::Monitoring.new(monitoring: false)

data/spec/support/spec_config.rb

@@ -74,7 +74,7 @@ class SpecConfig
       # TLS options need to be merged for evergreen due to
       # https://github.com/10gen/mongo-orchestration/issues/268
       client = Mongo::Client.new(addresses, Mongo::Options::Redacted.new(
-        server_selection_timeout: 5,
+        server_selection_timeout: 5.03,
       ).merge(ssl_options))
 
       begin
@@ -99,7 +99,7 @@ class SpecConfig
   # Environment
 
   def ci?
-    !!ENV['CI']
+    %w(1 true yes).include?(ENV['CI']&.downcase)
   end
 
   def mri?
@@ -122,6 +122,24 @@ class SpecConfig
     %w(1 true yes).include?(ENV['FORK']&.downcase)
   end
 
+  # OCSP tests require python and various dependencies.
+  # Assumes an OCSP responder is running on port 8100 (configured externally
+  # to the test suite).
+  def ocsp?
+    %w(1 true yes).include?(ENV['OCSP']&.downcase)
+  end
+
+  # OCSP tests require python and various dependencies.
+  # When testing OCSP verifier, there cannot be a responder running on
+  # port 8100 or the tests will fail.
+  def ocsp_verifier?
+    %w(1 true yes).include?(ENV['OCSP_VERIFIER']&.downcase)
+  end
+
+  def ocsp_connectivity?
+    ENV.key?('OCSP_CONNECTIVITY') && ENV['OCSP_CONNECTIVITY'] != ''
+  end
+
   # Test suite configuration
 
   def client_debug?
@@ -221,6 +239,10 @@ EOT
     Pathname.new("#{spec_root}/support/certificates")
   end
 
+  def ocsp_files_dir
+    Pathname.new("#{spec_root}/../.mod/drivers-evergreen-tools/.evergreen/ocsp")
+  end
+
   # TLS certificates & keys
 
   def local_client_key_path
@@ -414,15 +436,19 @@ EOT
       # means the test suite hangs for about 4 seconds before
       # failing.
       # Server selection timeout of 1 is insufficient for evergreen.
-      server_selection_timeout: uri_options[:server_selection_timeout] || (ssl? ? 4.01 : 2.01),
+      server_selection_timeout: uri_options[:server_selection_timeout] || (ssl? ? 8.01 : 7.01),
 
       # Since connections are established under the wait queue timeout,
       # the wait queue timeout should be at least as long as the
       # connect timeout.
-      wait_queue_timeout: 4,
-      connect_timeout: 3,
-      socket_timeout: 3,
-      max_idle_time: 5
+      wait_queue_timeout: 6.04,
+      connect_timeout: 2.91,
+      socket_timeout: 5.09,
+      max_idle_time: 100.02,
+
+      # Uncomment to have exceptions in background threads log complete
+      # backtraces.
+      #bg_error_backtrace: true,
    }
   end
 
@@ -437,6 +463,14 @@ EOT
     test_options.merge(auth_options)
   end
 
+  def authorized_test_options
+    test_options.merge(credentials_or_external_user(
+      user: test_user.name,
+      password: test_user.password,
+      auth_source: auth_options[:auth_source],
+    ))
+  end
+
   # User objects
 
   # Gets the root system administrator user.
@@ -457,8 +491,8 @@ EOT
   # Get the default test user for the suite on versions 2.6 and higher.
   def test_user
     Mongo::Auth::User.new(
-      database: test_db,
-      user: 'test-user',
+      database: 'admin',
+      user: 'ruby-test-user',
       password: 'password',
       roles: [
         { role: Mongo::Auth::Roles::READ_WRITE, db: test_db },
@@ -472,10 +506,23 @@ EOT
         { role: Mongo::Auth::Roles::READ_WRITE, db: 'reporting' },
         { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'reporting' },
 
-        # For transaction api spec tests
-        #{ role: Mongo::Auth::Roles::READ_WRITE, db: 'withTransaction-tests' },
-        #{ role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'withTransaction-tests' },
-
+        # For spec tests
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'crud-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'crud-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'crud-default' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'crud-default' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'default_write_concern_db' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'default_write_concern_db' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'retryable-reads-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'retryable-reads-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'sdam-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'sdam-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'transaction-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'transaction-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'withTransaction-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'withTransaction-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'admin' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'admin' },
       ]
     )
   end