mongo 2.12.1 → 2.13.0

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/lite_constraints.rb

@@ -91,4 +91,51 @@ module LiteConstraints
       end
     end
   end
+
+  def require_aws_auth
+    before(:all) do
+      unless (ENV['AUTH'] || '') =~ /^aws/
+        skip 'This test requires AUTH=aws* and an appropriately configured runtime environment'
+      end
+    end
+  end
+
+  def require_ec2_host
+    before(:all) do
+      if $have_aws.nil?
+        $have_aws = begin
+          require 'open-uri'
+          begin
+            Timeout.timeout(3.81) do
+              URI.parse('http://169.254.169.254/latest/meta-data/profile').open.read
+            end
+            true
+          # When trying to use the EC2 metadata endpoint on ECS:
+          # Errno::EINVAL: Failed to open TCP connection to 169.254.169.254:80 (Invalid argument - connect(2) for "169.254.169.254" port 80)
+          rescue Timeout::Error, Errno::ETIMEDOUT, Errno::EINVAL, OpenURI::HTTPError => $aws_error
+            false
+          end
+        end
+      end
+      unless $have_aws
+        skip "EC2 instance metadata is not available - assuming not running on an EC2 instance: #{$aws_error.class}: #{$aws_error}"
+      end
+    end
+  end
+
+  def require_stress
+    before(:all) do
+      if !SpecConfig.instance.stress?
+        skip 'Set STRESS=1 in environment to run stress tests'
+      end
+    end
+  end
+
+  def require_fork
+    before(:all) do
+      if !SpecConfig.instance.fork?
+        skip 'Set FORK=1 in environment to run fork tests'
+      end
+    end
+  end
 end

data/spec/support/shared/scram_conversation.rb

@@ -0,0 +1,100 @@
+shared_context 'scram conversation context' do
+  let(:connection) do
+    double('connection').tap do |connection|
+      features = double('features')
+      allow(features).to receive(:op_msg_enabled?)
+      allow(connection).to receive(:features).and_return(features)
+      allow(connection).to receive(:server)
+    end
+  end
+end
+
+shared_examples 'scram conversation' do
+
+  describe '#parse_payload' do
+    let(:user) { double('user') }
+    let(:mechanism) { :scram }
+
+    shared_examples_for 'parses as expected' do
+      it 'parses as expected' do
+        conversation.send(:parse_payload, payload).should == expected
+      end
+    end
+
+    context 'regular payload' do
+      let(:payload) { 'foo=bar,hello=world' }
+      let(:expected) do
+        {'foo' => 'bar', 'hello' => 'world'}
+      end
+
+      it_behaves_like 'parses as expected'
+    end
+
+    context 'equal signs in value' do
+      let(:payload) { 'foo=bar==,hello=world=is=great' }
+      let(:expected) do
+        {'foo' => 'bar==', 'hello' => 'world=is=great'}
+      end
+
+      it_behaves_like 'parses as expected'
+    end
+
+    context 'missing value' do
+      let(:payload) { 'foo=,hello=' }
+      let(:expected) do
+        {'foo' => '', 'hello' => ''}
+      end
+
+      it_behaves_like 'parses as expected'
+    end
+
+    context 'missing key/value pair' do
+      let(:payload) { 'foo=,,hello=' }
+      let(:expected) do
+        {'foo' => '', 'hello' => ''}
+      end
+
+      it_behaves_like 'parses as expected'
+    end
+
+    context 'missing key' do
+      let(:payload) { '=bar' }
+
+      it 'raises an exception' do
+        lambda do
+          conversation.send(:parse_payload, payload)
+        end.should raise_error(Mongo::Error::InvalidServerAuthResponse, /Payload malformed: missing key/)
+      end
+    end
+
+    context 'all keys missing' do
+      let(:payload) { ',,,' }
+      let(:expected) do
+        {}
+      end
+
+      it_behaves_like 'parses as expected'
+    end
+  end
+end
+
+shared_context 'scram continue and finalize replies' do
+
+  let(:continue_document) do
+    BSON::Document.new(
+      'conversationId' => 1,
+      'done' => false,
+      'payload' => continue_payload,
+      'ok' => 1.0
+    )
+  end
+
+  let(:finalize_document) do
+    BSON::Document.new(
+      'conversationId' => 1,
+      'done' => false,
+      'payload' => finalize_payload,
+      'ok' => 1.0
+    )
+  end
+end

data/spec/support/shared/server_selector.rb

@@ -2,6 +2,8 @@ shared_context 'server selector' do
 
   let(:max_staleness) { nil }
   let(:tag_sets) { [] }
+  let(:hedge) { nil }
+
   let(:tag_set) do
     { 'test' => 'tag' }
   end
@@ -20,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 } }
+  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)
@@ -120,6 +134,84 @@ shared_examples 'a server selector accepting tag sets' do
   end
 end
 
+shared_examples 'a server selector accepting hedge' do
+  describe '#initialize' do
+    context 'when hedge is not provided' do
+      it 'initializes successfully' do
+        expect do
+          selector
+        end.not_to raise_error
+      end
+    end
+
+    context 'when hedge is not a Hash' do
+      let(:hedge) { true }
+
+      it 'raises an exception' do
+        expect do
+          selector
+        end.to raise_error(Mongo::Error::InvalidServerPreference, /`hedge` value \(true\) is invalid/)
+      end
+    end
+
+    context 'when hedge is an empty Hash' do
+      let(:hedge) { {} }
+
+      it 'raises an exception' do
+        expect do
+          selector
+        end.to raise_error(Mongo::Error::InvalidServerPreference, /`hedge` value \({}\) is invalid/)
+      end
+    end
+
+    context 'when hedge is a Hash with data' do
+      let(:hedge) { { enabled: false } }
+
+      it 'initializes successfully' do
+        expect do
+          selector
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe '#hedge' do
+    context 'when hedge is not provided' do
+      it 'returns nil' do
+        expect(selector.hedge).to be_nil
+      end
+    end
+
+    context 'when hedge is a Hash with data' do
+      let(:hedge) { { enabled: false } }
+
+      it 'returns the same Hash' do
+        expect(selector.hedge).to eq({ enabled: false })
+      end
+    end
+  end
+
+  describe '#==' do
+    let(:other_selector) { described_class.new(hedge: { enabled: false }) }
+
+    context 'when hedges are the same' do
+      let(:hedge) { { enabled: false } }
+
+      it 'returns true' do
+        expect(selector).to eq(other_selector)
+      end
+    end
+
+    context 'when hedges are different' do
+      let(:hedge) { { enabled: true } }
+
+      it 'returns false' do
+        expect(selector).not_to eq(other_selector)
+      end
+    end
+  end
+end
+
 shared_examples 'a server selector with sensitive data in its options' do
 
   describe '#inspect' do

data/spec/support/shared/session.rb

@@ -123,10 +123,6 @@ end
 
 shared_examples 'an explicit session with an unacknowledged write' do
 
-  before do
-    EventSubscriber.clear_events!
-  end
-
   context 'when sessions are supported' do
     min_server_fcv '3.6'
 
@@ -135,8 +131,10 @@ shared_examples 'an explicit session with an unacknowledged write' do
     end
 
     it 'does not add a session id to the operation' do
+      subscriber.clear_events!
       operation
-      expect(EventSubscriber.started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
+      subscriber.non_auth_command_started_events.length.should == 1
+      expect(subscriber.non_auth_command_started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
     end
   end
 
@@ -149,24 +147,24 @@ shared_examples 'an explicit session with an unacknowledged write' do
 
     it 'does not add a session id to the operation' do
       expect(Mongo::Session).not_to receive(:new)
+      subscriber.clear_events!
       operation
-      expect(EventSubscriber.started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
+      subscriber.non_auth_command_started_events.length.should == 1
+      expect(subscriber.non_auth_command_started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
     end
   end
 end
 
 shared_examples 'an implicit session with an unacknowledged write' do
 
-  before do
-    EventSubscriber.clear_events!
-  end
-
   context 'when sessions are supported' do
     min_server_fcv '3.6'
 
     it 'does not add a session id to the operation' do
+      subscriber.clear_events!
       operation
-      expect(EventSubscriber.started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
+      subscriber.non_auth_command_started_events.length.should == 1
+      expect(subscriber.non_auth_command_started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
     end
   end
 
@@ -174,16 +172,22 @@ shared_examples 'an implicit session with an unacknowledged write' do
     max_server_version '3.4'
 
     it 'does not add a session id to the operation' do
+      subscriber.clear_events!
       operation
-      expect(EventSubscriber.started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
+      subscriber.non_auth_command_started_events.length.should == 1
+      expect(subscriber.non_auth_command_started_events.collect(&:command).collect { |cmd| cmd['lsid'] }.compact).to be_empty
     end
   end
 end
 
 shared_examples 'an operation supporting causally consistent reads' do
 
+  let(:subscriber) { EventSubscriber.new }
+
   let(:client) do
-    subscribed_client
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
   end
 
   context 'when connected to a standalone' do
@@ -615,8 +619,12 @@ shared_examples 'an operation updating cluster time' do
     client.start_session
   end
 
+  let(:subscriber) { EventSubscriber.new }
+
   let(:client) do
-    subscribed_client
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
   end
 
   shared_examples_for 'does not update the cluster time of the cluster' do
@@ -637,7 +645,7 @@ shared_examples 'an operation updating cluster time' do
 
         let(:reply_cluster_time) do
           operation_with_session
-          EventSubscriber.succeeded_events[-1].reply['$clusterTime']
+          subscriber.succeeded_events[-1].reply['$clusterTime']
         end
 
         it 'updates the cluster time of the cluster', retry: 3 do
@@ -660,7 +668,7 @@ shared_examples 'an operation updating cluster time' do
 
         let!(:reply_cluster_time) do
           operation_with_session
-          EventSubscriber.succeeded_events[-1].reply['$clusterTime']
+          subscriber.succeeded_events[-1].reply['$clusterTime']
         end
 
         it_behaves_like 'does not update the cluster time of the cluster'
@@ -681,7 +689,7 @@ shared_examples 'an operation updating cluster time' do
 
       let(:reply_cluster_time) do
         operation
-        EventSubscriber.succeeded_events[-1].reply['$clusterTime']
+        subscriber.succeeded_events[-1].reply['$clusterTime']
       end
 
       it_behaves_like 'does not update the cluster time of the cluster'
@@ -692,7 +700,7 @@ shared_examples 'an operation updating cluster time' do
 
     let(:reply_cluster_time) do
       operation_with_session
-      EventSubscriber.succeeded_events[-1].reply['$clusterTime']
+      subscriber.succeeded_events[-1].reply['$clusterTime']
     end
 
     context 'when the cluster is sharded or a replica set' do
@@ -707,7 +715,7 @@ shared_examples 'an operation updating cluster time' do
 
         let(:second_command_cluster_time) do
           second_operation
-          EventSubscriber.started_events[-1].command['$clusterTime']
+          subscriber.non_auth_command_started_events[-1].command['$clusterTime']
         end
 
         context 'when the advanced cluster time is greater than the existing cluster time' do
@@ -745,7 +753,7 @@ shared_examples 'an operation updating cluster time' do
 
         let(:second_command_cluster_time) do
           second_operation
-          EventSubscriber.started_events[-1].command['$clusterTime']
+          subscriber.non_auth_command_started_events[-1].command['$clusterTime']
         end
 
         it 'includes the received cluster time in the second command', retry: 3 do
@@ -765,7 +773,7 @@ shared_examples 'an operation updating cluster time' do
 
       let(:second_command_cluster_time) do
         second_operation
-        EventSubscriber.started_events[-1].command['$clusterTime']
+        subscriber.non_auth_command_started_events[-1].command['$clusterTime']
       end
 
       it 'does not update the cluster time of the cluster' do

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?
@@ -114,14 +114,18 @@ class SpecConfig
     RUBY_PLATFORM
   end
 
-  def stress_spec?
-    !!ENV['STRESS_SPEC']
+  def stress?
+    %w(1 true yes).include?(ENV['STRESS']&.downcase)
+  end
+
+  def fork?
+    %w(1 true yes).include?(ENV['FORK']&.downcase)
   end
 
   # Test suite configuration
 
   def client_debug?
-    %w(1 true yes).include?((ENV['CLIENT_DEBUG'] || '').downcase)
+    %w(1 true yes).include?(ENV['MONGO_RUBY_DRIVER_CLIENT_DEBUG']&.downcase)
   end
 
   def drivers_tools?
@@ -354,6 +358,11 @@ EOT
         if auth_source
           options[:auth_source] = auth_source
         end
+        %i(auth_mech auth_mech_properties).each do |key|
+          if uri_options[key]
+            options[key] = uri_options[key]
+          end
+        end
       end
     end
   end
@@ -405,11 +414,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),
-
-      wait_queue_timeout: 2,
-      connect_timeout: 3,
-      max_idle_time: 5
+      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: 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
 
@@ -424,6 +441,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.
@@ -444,8 +469,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 },
@@ -459,10 +484,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
@@ -471,11 +509,28 @@ EOT
     uri_options[:auth_mech] == :mongodb_x509
   end
 
-  # When we use x.509 authentication, omit all of the users we normally create
-  # and authenticate with x.509.
-  def credentials_or_x509(creds)
-    if x509_auth?
-      {auth_mech: :mongodb_x509}
+  # When we authenticate with a username & password mechanism (scram, cr)
+  # we create a variety of users in the test suite for different purposes.
+  # When we authenticate with passwordless mechanisms (x509, aws) we use
+  # the globally specified user for all operations.
+  def external_user?
+    case uri_options[:auth_mech]
+    when :mongodb_x509, :aws
+      true
+    when nil, :scram, :scram256
+      false
+    else
+      raise "Unknown auth mechanism value: #{uri_options[:auth_mech]}"
+    end
+  end
+
+  # When we use external authentication, omit all of the users we normally
+  # create and authenticate with the external mechanism. This also ensures
+  # our various helpers work correctly when the only users available are
+  # the external ones.
+  def credentials_or_external_user(creds)
+    if external_user?
+      auth_options
     else
       creds
     end