mongo 2.14.1 → 2.15.0.alpha

data/spec/mongo/server/app_metadata_spec.rb

@@ -53,6 +53,8 @@ describe Mongo::Server::AppMetadata do
     end
 
     context 'when the client document exceeds the max of 512 bytes' do
+      # Server api parameters change metadata length
+      require_no_required_api_version
 
       context 'when the os.type length is too long' do
 

data/spec/mongo/server/connection_pool/populator_spec.rb

@@ -61,7 +61,9 @@ describe Mongo::Server::Populator do
 
       it 'populates the pool up to min_size' do
         populator.run!
-        sleep 1
+        ::Utils.wait_for_condition(3) do
+          pool.size >= 2
+        end
         expect(pool.size).to eq 2
         expect(populator.running?).to be true
       end

data/spec/mongo/server/connection_pool_spec.rb

@@ -531,7 +531,7 @@ describe Mongo::Server::ConnectionPool do
         authorized_client
       end
 
-       let(:pool) do
+      let(:pool) do
         client.cluster.next_primary.pool
       end
 

data/spec/mongo/server/connection_spec.rb

@@ -589,6 +589,8 @@ describe Mongo::Server::Connection do
 
     let(:server) { monitored_server }
 
+    let(:context) { Mongo::Operation::Context.new }
+
     let!(:connection) do
       described_class.new(
         server,
@@ -620,12 +622,12 @@ describe Mongo::Server::Connection do
     context 'when providing a single message' do
 
       let(:reply) do
-        connection.dispatch([ query ])
+        connection.dispatch([ query ], context)
       end
 
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ])
+        authorized_collection.insert_one(name: 'testing')
       end
 
       it 'it dispatches the message to the socket' do
@@ -644,7 +646,7 @@ describe Mongo::Server::Connection do
       end
 
       let(:reply) do
-        connection.dispatch([ insert, command ])
+        connection.dispatch([ insert, command ], context)
       end
 
       before do
@@ -681,22 +683,22 @@ describe Mongo::Server::Connection do
       end
 
       before do
-        connection.dispatch([ insert ])
+        connection.dispatch([ insert ], context)
         # Fake a query for which we did not read the response. See RUBY-1117
         allow(query_bob).to receive(:replyable?) { false }
-        connection.dispatch([ query_bob ])
+        connection.dispatch([ query_bob ], context)
       end
 
       it 'raises an UnexpectedResponse error' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse,
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
       it 'marks connection perished' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         connection.should be_error
@@ -704,16 +706,17 @@ describe Mongo::Server::Connection do
 
       it 'makes the connection no longer usable' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
 
     context 'when a request is interrupted (Thread.kill)' do
+      require_no_required_api_version
 
       let(:documents) do
         [{ 'name' => 'bob' }, { 'name' => 'alice' }]
@@ -733,18 +736,19 @@ describe Mongo::Server::Connection do
 
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ])
+        connection.dispatch([ insert ], context)
       end
 
       it 'closes the socket and does not use it for subsequent requests' do
         t = Thread.new {
           # Kill the thread just before the reply is read
           allow(Mongo::Protocol::Reply).to receive(:deserialize_header) { t.kill && !t.alive? }
-          connection.dispatch([ query_bob ])
+          connection.dispatch([ query_bob ], context)
         }
         t.join
         allow(Mongo::Protocol::Message).to receive(:deserialize_header).and_call_original
-        expect(connection.dispatch([ query_alice ]).documents.first['name']).to eq('alice')
+        resp = connection.dispatch([ query_alice ], context)
+        expect(resp.documents.first['name']).to eq('alice')
       end
     end
 
@@ -761,7 +765,7 @@ describe Mongo::Server::Connection do
         end
 
         let(:reply) do
-          connection.dispatch([ insert ])
+          connection.dispatch([ insert ], context)
         end
 
         it 'checks the size against the max message size' do
@@ -788,7 +792,7 @@ describe Mongo::Server::Connection do
         end
 
         let(:reply) do
-          connection.dispatch([ command ])
+          connection.dispatch([ command ], context)
         end
 
         it 'checks the size against the max bson size' do
@@ -828,7 +832,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ])
+            connection.dispatch([ insert ], context)
           end.to raise_error(Mongo::Error::SocketError)
         end
 
@@ -862,7 +866,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ])
+            connection.dispatch([ insert ], context)
           end.to raise_error(Mongo::Error::SocketTimeoutError)
         end
 
@@ -906,6 +910,7 @@ describe Mongo::Server::Connection do
       end
 
       before do
+        authorized_collection.insert_one(test: 1)
         client.cluster.next_primary
       end
 
@@ -919,6 +924,8 @@ describe Mongo::Server::Connection do
           end_time = Time.now
           expect(ex).to be_a(Mongo::Error::SocketTimeoutError)
           expect(ex.message).to match(/Took more than 1.5 seconds to receive data/)
+        else
+          fail 'Expected a timeout'
         end
         # allow 1.5 seconds +- 0.5 seconds
         expect(end_time - start).to be_within(1).of(2)
@@ -938,7 +945,7 @@ describe Mongo::Server::Connection do
 
         before do
           expect(message).to receive(:replyable?) { false }
-          connection.send(:deliver, message, nil)
+          connection.send(:deliver, message, context)
 
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end

data/spec/mongo/server/monitor/connection_spec.rb

@@ -9,13 +9,21 @@ describe Mongo::Server::Monitor::Connection do
 
   declare_topology_double
 
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
   let(:cluster) do
-    double('cluster').tap do |cl|
-      allow(cl).to receive(:topology).and_return(topology)
-      allow(cl).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
-      allow(cl).to receive(:options).and_return({})
-      allow(cl).to receive(:heartbeat_interval).and_return(1000)
-      allow(cl).to receive(:run_sdam_flow)
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:topology).and_return(topology)
+      allow(cluster).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
+      allow(cluster).to receive(:options).and_return({})
+      allow(cluster).to receive(:monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:push_monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+      allow(cluster).to receive(:run_sdam_flow)
     end
   end
 
@@ -27,10 +35,12 @@ describe Mongo::Server::Monitor::Connection do
   end
 
   let(:monitor) do
+    metadata = Mongo::Server::Monitor::AppMetadata.new(options)
     register_background_thread_object(
       Mongo::Server::Monitor.new(server, server.event_listeners, server.monitoring,
         {
-          app_metadata: Mongo::Server::Monitor::AppMetadata.new(options),
+          app_metadata: metadata,
+          push_monitor_app_metadata: metadata,
         }.update(options))
     ).tap do |monitor|
       monitor.scan!

data/spec/mongo/server/monitor_spec.rb

@@ -17,6 +17,12 @@ describe Mongo::Server::Monitor do
     {}
   end
 
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
   let(:cluster) do
     double('cluster').tap do |cluster|
       allow(cluster).to receive(:run_sdam_flow)
@@ -32,7 +38,9 @@ describe Mongo::Server::Monitor do
   let(:monitor) do
     register_background_thread_object(
       described_class.new(server, listeners, Mongo::Monitoring.new,
-        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options))
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
     )
   end
 

data/spec/mongo/server_selector/secondary_preferred_spec.rb

@@ -78,8 +78,8 @@ describe Mongo::ServerSelector::SecondaryPreferred do
 
     context 'tag sets not provided' do
 
-      it 'returns secondaryPreferred' do
-        selector.to_mongos.should == {mode: 'secondaryPreferred'}
+      it 'returns nil' do
+        expect(selector.to_mongos).to be_nil
       end
     end
 
@@ -89,8 +89,8 @@ describe Mongo::ServerSelector::SecondaryPreferred do
         { :mode => 'secondaryPreferred' }
       end
 
-      it 'returns secondaryPreferred' do
-        selector.to_mongos.should == {mode: 'secondaryPreferred'}
+      it 'returns nil' do
+        expect(selector.to_mongos).to be_nil
       end
     end
 
@@ -120,8 +120,8 @@ describe Mongo::ServerSelector::SecondaryPreferred do
     context 'hedge not provided' do
       let(:hedge) { nil }
 
-      it 'returns secondaryPreferred' do
-        selector.to_mongos.should == {mode: 'secondaryPreferred'}
+      it 'returns nil' do
+        expect(selector.to_mongos).to be_nil
       end
     end
 

data/spec/mongo/server_spec.rb

@@ -40,12 +40,20 @@ describe Mongo::Server do
     )
   end
 
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
   shared_context 'with monitoring io' do
     let(:server_options) do
       {monitoring_io: true}
     end
 
     before do
+      allow(cluster).to receive(:monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:push_monitor_app_metadata).and_return(monitor_app_metadata)
       allow(cluster).to receive(:heartbeat_interval).and_return(1000)
     end
   end
@@ -144,8 +152,13 @@ describe Mongo::Server do
       expect(server.options[:monitoring_io]).to be true
     end
 
-    it 'creates monitor with monitoring app metadata' do
-      expect(server.monitor.options[:app_metadata]).to be_a(Mongo::Server::Monitor::AppMetadata)
+    context 'with monitoring app metadata option' do
+      require_no_required_api_version
+
+      it 'creates monitor with monitoring app metadata' do
+        server.monitor.scan!
+        expect(server.monitor.connection.options[:app_metadata]).to be monitor_app_metadata
+      end
     end
 
     context 'monitoring_io: false' do

data/spec/mongo/socket/ssl_spec.rb

@@ -50,6 +50,46 @@ describe Mongo::Socket::SSL, retry: 3 do
   end
 
   describe '#connect!' do
+    context 'when TLS context hooks are provided' do
+      # https://github.com/jruby/jruby-openssl/issues/221
+      fails_on_jruby
+
+      let(:proc) do
+        Proc.new do |context|
+          if BSON::Environment.jruby?
+            context.ciphers = ["AES256-SHA256"]
+          else
+            context.ciphers = ["AES256-SHA"]
+          end
+        end
+      end
+
+      before do
+        Mongo.tls_context_hooks = [ proc ]
+      end
+
+      after do
+        Mongo.tls_context_hooks.clear
+      end
+
+      it 'runs the TLS context hook before connecting' do
+        if ENV['OCSP_ALGORITHM']
+          skip "OCSP configurations use different certificates which this test does not handle"
+        end
+
+        expect(proc).to receive(:call).and_call_original
+        socket
+        # Even though we are requesting a single cipher in the hook,
+        # there may be multiple ciphers available in the context.
+        # All of the ciphers should match the requested one (using
+        # OpenSSL's idea of what "match" means).
+        socket.context.ciphers.each do |cipher|
+          unless cipher.first =~ /SHA256/ || cipher.last == 256
+            raise "Unexpected cipher #{cipher} after requesting SHA-256"
+          end
+        end
+      end
+    end
 
     context 'when a certificate is provided' do
 

data/spec/mongo/socket_spec.rb

@@ -48,7 +48,7 @@ describe Mongo::Socket do
         socket.send(:map_exceptions) do
           raise OpenSSL::SSL::SSLError.new('Test error')
         end
-      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with TLS support)')
+      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address)')
     end
   end
 
@@ -86,7 +86,7 @@ describe Mongo::Socket do
 
           expect do
             socket.read(10)
-          end.to raise_error(Mongo::Error::SocketTimeoutError, /Took more than .* seconds to receive data \(for /)
+          end.to raise_error(Mongo::Error::SocketTimeoutError, /Took more than .* seconds to receive data.*\(for /)
         end
       end
 

data/spec/mongo/tls_context_hooks_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Mongo do
+  before do
+    Mongo.tls_context_hooks.clear
+  end
+
+  describe '#tls_context_hooks' do
+    it 'returns an array' do
+      expect(Mongo.tls_context_hooks).to eq([])
+    end
+  end
+
+  describe '#tls_context_hooks=' do
+    context 'when argument is not an array' do
+      it 'raises an ArgumentError' do
+        expect do
+          Mongo.tls_context_hooks = "Hello"
+        end.to raise_error(ArgumentError, /TLS context hooks must be an array of Procs/)
+      end
+    end
+
+    context 'when argument is an array not containing procs' do
+      it 'raises an ArgumentError' do
+        expect do
+          Mongo.tls_context_hooks = [1, 2, 3]
+        end.to raise_error(ArgumentError, /TLS context hooks must be an array of Procs/)
+      end
+    end
+
+    it 'saves the provided hooks' do
+      Mongo.tls_context_hooks = [ Proc.new { |x| x ** 2 } ]
+      expect(Mongo.tls_context_hooks.length).to eq(1)
+      expect(Mongo.tls_context_hooks.first).to be_a(Proc)
+    end
+  end
+end

data/spec/runners/connection_string.rb

@@ -235,10 +235,6 @@ module Mongo
           if k.downcase == 'authmechanismproperties'
             expected[k] = ::Utils.downcase_keys(v)
           end
-          # Ruby driver does not support snappy.
-          if k == 'compressors'
-            expected[k] = v.reject { |sub_v| sub_v == 'snappy' }
-          end
         end
         # We omit retryReads/retryWrites=true because some tests do not
         # provide those.

data/spec/runners/crud/requirement.rb

@@ -1,18 +1,39 @@
 module Mongo
   module CRUD
     class Requirement
-      YAML_KEYS = %w(minServerVersion maxServerVersion topology).freeze
+      YAML_KEYS = %w(minServerVersion maxServerVersion topology topologies serverParameters).freeze
 
       def initialize(spec)
+        spec = spec.dup
+        # Legacy tests have the requirements mixed with other test fields
+        spec.delete('data')
+        spec.delete('tests')
+
+        unless (unhandled_keys = spec.keys - YAML_KEYS).empty?
+          raise "Unhandled requirement specification keys: #{unhandled_keys}"
+        end
+
         @min_server_version = spec['minServerVersion']
         @max_server_version = spec['maxServerVersion']
-        @topologies = if topologies = spec['topology']
+        # topologies is for unified test format.
+        # topology is for legacy tests.
+        @topologies = if topologies = spec['topology'] || spec['topologies']
           topologies.map do |topology|
-            {'replicaset' => :replica_set, 'single' => :single, 'sharded' => :sharded}[topology]
+            {
+              'replicaset' => :replica_set,
+              'single' => :single,
+              'sharded' => :sharded,
+              'sharded-replicaset' => :sharded,
+            }[topology].tap do |v|
+              unless v
+                raise "Unknown topology #{topology}"
+              end
+            end
           end
         else
           nil
         end
+        @server_parameters = spec['serverParameters']
       end
 
       attr_reader :min_server_version
@@ -47,6 +68,22 @@ module Mongo
         if topologies
           ok &&= topologies.include?(cc.topology)
         end
+        if @server_parameters
+          @server_parameters.each do |k, required_v|
+            actual_v = cc.server_parameters[k]
+            if actual_v.nil? && !required_v.nil?
+              ok = false
+            elsif actual_v != required_v
+              if Numeric === actual_v && Numeric === required_v
+                if actual_v.to_f != required_v.to_f
+                  ok = false
+                end
+              else
+                ok = false
+              end
+            end
+          end
+        end
         ok
       end
 

data/spec/runners/crud/verifier.rb

@@ -193,6 +193,14 @@ EOT
           return
         end
 
+        if k == 'updateDescription'
+          # Change stream result - verify subset, not exact match
+          expected.fetch(k).each do |sub_k, sub_v|
+            {sub_k => sub_v}.should == {sub_k => actual.fetch(k).fetch(sub_k)}
+          end
+          return
+        end
+
         if expected[k].is_a?(Time)
           expect(k => actual[k].utc.to_s).to eq(k => expected[k].utc.to_s)
         else

data/spec/runners/transactions/operation.rb

@@ -191,7 +191,7 @@ module Mongo
 
       def assert_event_count(client, context)
         events = _select_events(context)
-        if arguments['event'] == 'ServerMarkedUnknownEvent'
+        if %w(ServerMarkedUnknownEvent PoolClearedEvent).include?(arguments['event'])
           # We publish SDAM events from both regular and push monitors.
           # This means sometimes there are two ServerMarkedUnknownEvent
           # events published for the same server transition.

data/spec/runners/transactions/test.rb

@@ -289,6 +289,7 @@ module Mongo
             client.command(configureFailPoint: fail_point_command['configureFailPoint'],
               mode: 'off')
           end
+          $disable_fail_points = nil
         end
 
         if @test_client