mongo 2.6.4 → 2.7.0.rc0

data/spec/mongo/protocol/query_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe Mongo::Protocol::Query do
 
   let(:opcode)   { 2004 }
-  let(:db)       { TEST_DB }
+  let(:db)       { SpecConfig.instance.test_db }
   let(:coll)     { TEST_COLL }
   let(:ns)       { "#{db}.#{coll}" }
   let(:selector) { { :name => 'Tyler' } }

data/spec/mongo/protocol/update_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Mongo::Protocol::Update do
 
   let(:opcode)   { 2001 }
-  let(:db)       { TEST_DB }
+  let(:db)       { SpecConfig.instance.test_db }
   let(:coll)     { TEST_COLL }
   let(:ns)       { "#{db}.#{coll}" }
   let(:selector) { { :name => 'Tyler' } }

data/spec/mongo/retryable_spec.rb

@@ -67,6 +67,12 @@ class ModernRetryableTestConsumer < LegacyRetryableTestConsumer
   end
 end
 
+class RetryableHost
+  include Mongo::Retryable
+
+  public :retry_write_allowed?
+end
+
 describe Mongo::Retryable do
 
   let(:operation) do
@@ -98,6 +104,16 @@ describe Mongo::Retryable do
       end
     end
 
+    context 'when ending_transaction is true' do
+      let(:retryable) { RetryableTestConsumer.new(operation, cluster) }
+
+      it 'raises ArgumentError' do
+        expect do
+          retryable.write_with_retry(nil, nil, true)
+        end.to raise_error(ArgumentError, 'Cannot end a transaction without a session')
+      end
+    end
+
     context 'when a socket error occurs' do
 
       before do
@@ -206,6 +222,74 @@ describe Mongo::Retryable do
     end
   end
 
+  describe '#retry_write_allowed?' do
+    let(:retryable) { RetryableHost.new }
+
+    context 'nil session' do
+      it 'returns false' do
+        expect(retryable.retry_write_allowed?(nil, nil)).to be false
+      end
+    end
+
+    context 'with session' do
+      let(:session) { double('session') }
+
+      context 'retry writes enabled' do
+        context 'nil write concern' do
+          let(:write_concern) { nil }
+
+          it 'returns true' do
+            expect(session).to receive(:retry_writes?).and_return(true)
+            expect(retryable.retry_write_allowed?(session, write_concern)).to be true
+          end
+        end
+
+        context 'hash write concern with w: 0' do
+          let(:write_concern) { {w: 0} }
+
+          it 'returns false' do
+            expect(session).to receive(:retry_writes?).and_return(true)
+            expect(retryable.retry_write_allowed?(session, write_concern)).to be false
+          end
+        end
+
+        context 'hash write concern with w: :majority' do
+          let(:write_concern) { {w: :majority} }
+
+          it 'returns true' do
+            expect(session).to receive(:retry_writes?).and_return(true)
+            expect(retryable.retry_write_allowed?(session, write_concern)).to be true
+          end
+        end
+
+        context 'write concern object with w: 0' do
+          let(:write_concern) { Mongo::WriteConcern.get(w: 0) }
+
+          it 'returns false' do
+            expect(session).to receive(:retry_writes?).and_return(true)
+            expect(retryable.retry_write_allowed?(session, write_concern)).to be false
+          end
+        end
+
+        context 'write concern object with w: :majority' do
+          let(:write_concern) { Mongo::WriteConcern.get(w: :majority) }
+
+          it 'returns true' do
+            expect(session).to receive(:retry_writes?).and_return(true)
+            expect(retryable.retry_write_allowed?(session, write_concern)).to be true
+          end
+        end
+      end
+
+      context 'retry writes not enabled' do
+        it 'returns false' do
+          expect(session).to receive(:retry_writes?).and_return(false)
+          expect(retryable.retry_write_allowed?(session, nil)).to be false
+        end
+      end
+    end
+  end
+
   describe '#write_with_retry - legacy' do
 
     before do

data/spec/mongo/{cluster → server}/app_metadata_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Mongo::Cluster::AppMetadata do
+describe Mongo::Server::AppMetadata do
 
   let(:app_metadata) do
-    described_class.new(cluster)
+    described_class.new(cluster.options)
   end
 
   let(:cluster) do
@@ -130,4 +130,16 @@ describe Mongo::Cluster::AppMetadata do
       end
     end
   end
-end
+
+  describe '#document' do
+    context 'when user is given and auth_mech is not given' do
+      let(:app_metadata) do
+        described_class.new(user: 'foo')
+      end
+
+      it 'includes saslSupportedMechs' do
+        expect(app_metadata.send(:document)[:saslSupportedMechs]).to eq('admin.foo')
+      end
+    end
+  end
+end

data/spec/mongo/server/connection_auth_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+# these tests fail intermittently in evergreen
+describe Mongo::Server::Connection, retry: 3 do
+  let(:address) do
+    Mongo::Address.new(SpecConfig.instance.addresses.first)
+  end
+
+  let(:monitoring) do
+    Mongo::Monitoring.new(monitoring: false)
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:app_metadata) do
+    Mongo::Server::AppMetadata.new(SpecConfig.instance.test_options)
+  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(app_metadata)
+      allow(cl).to receive(:options).and_return({})
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:update_cluster_time)
+      pool = double('pool')
+      allow(pool).to receive(:disconnect!)
+      allow(cl).to receive(:pool).and_return(pool)
+    end
+  end
+
+  declare_topology_double
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options.merge(monitoring_io: false))
+  end
+
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  describe '#auth_mechanism' do
+
+    let(:connection) do
+      described_class.new(server, server.options)
+    end
+
+    let(:reply) do
+      double('reply').tap do |r|
+        allow(r).to receive(:documents).and_return([ ismaster ])
+      end
+    end
+
+    context 'when the ismaster response includes saslSupportedMechs' do
+      min_server_version '4.0'
+
+      let(:server_options) do
+        SpecConfig.instance.test_options.merge(
+          user: SpecConfig.instance.test_user.name,
+          password: SpecConfig.instance.test_user.password,
+          auth_source: SpecConfig.instance.test_db,
+        )
+      end
+
+      let(:app_metadata) do
+        Mongo::Server::AppMetadata.new(server_options)
+      end
+
+      before do
+        client = authorized_client.with(database: SpecConfig.instance.test_db)
+        info = client.database.users.info(SpecConfig.instance.test_user.name)
+        expect(info.length).to eq(1)
+        # this before block may have made 2 or 3 clients
+        ClientRegistry.instance.close_all_clients
+      end
+
+      it 'uses scram256' do
+        connection.connect!
+        expect(connection.send(:default_mechanism)).to eq(:scram256)
+      end
+    end
+
+    context 'when the ismaster response indicates the auth mechanism is :scram' do
+      let(:features) do
+        Mongo::Server::Description::Features.new(0..7)
+      end
+
+      it 'uses scram' do
+        connection
+        # the second Features instantiation is for SDAM event publication
+        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
+        connection.connect!
+        expect(connection.send(:default_mechanism)).to eq(:scram)
+      end
+    end
+
+    context 'when the ismaster response indicates the auth mechanism is :mongodb_cr' do
+      let(:features) do
+        Mongo::Server::Description::Features.new(0..2)
+      end
+
+      it 'uses mongodb_cr' do
+        connection
+        # the second Features instantiation is for SDAM event publication
+        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
+        connection.connect!
+        expect(connection.send(:default_mechanism)).to eq(:mongodb_cr)
+      end
+    end
+  end
+end

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

@@ -2,11 +2,18 @@ require 'spec_helper'
 
 describe Mongo::Server::ConnectionPool::Queue do
 
-  describe '#dequeue' do
-
-    let(:connection) do
-      double('connection')
+  def create_connection(generation=-1)
+    double('connection').tap do |connection|
+      allow(connection).to receive(:generation).and_return(generation)
+      allow(connection).to receive(:disconnect!)
     end
+  end
+
+  let(:connection) do
+    create_connection
+  end
+
+  describe '#dequeue' do
 
     let(:queue) do
       described_class.new(:max_pool_size => 1) { connection }
@@ -26,7 +33,7 @@ describe Mongo::Server::ConnectionPool::Queue do
 
       context 'when the max size is not reached' do
 
-        it 'creates a new connecection' do
+        it 'creates a new connection' do
           expect(queue.dequeue).to eq(connection)
         end
       end
@@ -50,38 +57,130 @@ describe Mongo::Server::ConnectionPool::Queue do
 
   describe '#disconnect!' do
 
-    let(:connection) do
-      double('connection')
+    def create_queue(min_pool_size)
+      described_class.new(max_pool_size: 3, min_pool_size: min_pool_size) do |generation|
+        create_connection(generation)
+      end.tap do |queue|
+        # make queue be of size 2 so that it has enqueued connections
+        # when told to disconnect
+        c1 = queue.dequeue
+        c2 = queue.dequeue
+        allow(c1).to receive(:record_checkin!).and_return(c1)
+        allow(c2).to receive(:record_checkin!).and_return(c2)
+        queue.enqueue(c1)
+        queue.enqueue(c2)
+        expect(queue.queue_size).to eq(2)
+        expect(queue.pool_size).to eq(2)
+      end
     end
 
-    let(:queue) do
-      described_class.new(:max_pool_size => 1) { connection }
+    context 'min size is 0' do
+      let(:queue) do
+        create_queue(0)
+      end
+
+      it 'disconnects and removes all connections in the queue' do
+        queue.queue.each do |connection|
+          expect(connection).to receive(:disconnect!)
+        end
+        expect(queue.queue_size).to eq(2)
+        expect(queue.pool_size).to eq(2)
+        queue.disconnect!
+        expect(queue.queue_size).to eq(0)
+        expect(queue.pool_size).to eq(0)
+      end
     end
 
-    it 'disconnects all connections in the queue' do
-      expect(connection).to receive(:disconnect!)
-      queue.disconnect!
+    context 'min size is not 0' do
+      let(:queue) do
+        create_queue(1)
+      end
+
+      it 'disconnects all connections in the queue and recreates up to min size with new generation' do
+        expect(queue.queue_size).to eq(2)
+        expect(queue.pool_size).to eq(2)
+
+        queue.disconnect!
+
+        expect(queue.queue_size).to eq(1)
+        expect(queue.pool_size).to eq(1)
+
+        new_connection = queue.dequeue
+        expect(new_connection).not_to eq(connection)
+        expect(new_connection.generation).to eq(2)
+      end
     end
   end
 
   describe '#enqueue' do
 
     let(:connection) do
-      double('connection').tap do |con|
-        allow(con).to receive(:record_checkin!).and_return(con)
+      queue.dequeue.tap do |connection|
+        allow(connection).to receive(:generation).and_return(1)
+        allow(connection).to receive(:record_checkin!).and_return(connection)
       end
     end
 
     let(:queue) do
-      described_class.new { connection }
+      # max pool size set to 2 to allow enqueueing a connection
+      # without lint violations
+      described_class.new(:max_pool_size => 2) { create_connection }
     end
 
-    before do
-      queue.enqueue(connection)
+    context 'connection of the same generation as queue' do
+      before do
+        expect(queue.generation).to eq(connection.generation)
+      end
+
+      it 'adds the connection to the queue' do
+        # connection is checked out
+        expect(queue.queue_size).to eq(0)
+        expect(queue.pool_size).to eq(1)
+        queue.enqueue(connection)
+        # now connection is in the queue
+        expect(queue.queue_size).to eq(1)
+        expect(queue.pool_size).to eq(1)
+        expect(queue.dequeue).to eq(connection)
+      end
+    end
+
+    shared_examples 'does not add connection to queue' do
+      before do
+        expect(queue.generation).not_to eq(connection.generation)
+      end
+
+      it 'disconnects connection and does not add connection to queue' do
+        # connection was checked out
+        expect(queue.queue_size).to eq(0)
+        expect(queue.pool_size).to eq(1)
+        expect(connection).to receive(:disconnect!)
+        queue.enqueue(connection)
+        expect(queue.queue_size).to eq(1)
+        expect(queue.pool_size).to eq(1)
+        expect(queue.dequeue).not_to eq(connection)
+      end
     end
 
-    it 'adds the connection to the queue' do
-      expect(queue.dequeue).to eq(connection)
+    context 'connection of earlier generation than queue' do
+      let(:connection) do
+        queue.dequeue.tap do |connection|
+          allow(connection).to receive(:generation).and_return(0)
+          allow(connection).to receive(:record_checkin!).and_return(connection)
+        end
+      end
+
+      it_behaves_like 'does not add connection to queue'
+    end
+
+    context 'connection of later generation than queue' do
+      let(:connection) do
+        queue.dequeue.tap do |connection|
+          allow(connection).to receive(:generation).and_return(7)
+          allow(connection).to receive(:record_checkin!).and_return(connection)
+        end
+      end
+
+      it_behaves_like 'does not add connection to queue'
     end
   end
 
@@ -90,11 +189,12 @@ describe Mongo::Server::ConnectionPool::Queue do
     context 'when a min size is provided' do
 
       let(:queue) do
-        described_class.new(:min_pool_size => 2) { double('connection') }
+        described_class.new(:min_pool_size => 2) { create_connection }
       end
 
       it 'creates the queue with the minimum connections' do
-        expect(queue.size).to eq(2)
+        expect(queue.pool_size).to eq(2)
+        expect(queue.queue_size).to eq(2)
       end
 
       it 'does not use the same objects in the queue' do
@@ -102,14 +202,26 @@ describe Mongo::Server::ConnectionPool::Queue do
       end
     end
 
+    context 'when min size exceeds default max size' do
+
+      let(:queue) do
+        described_class.new(:min_pool_size => 10) { create_connection }
+      end
+
+      it 'sets max size to equal provided min size' do
+        expect(queue.max_size).to eq(10)
+      end
+    end
+
     context 'when no min size is provided' do
 
       let(:queue) do
-        described_class.new { double('connection') }
+        described_class.new { create_connection }
       end
 
       it 'creates the queue with the number of default connections' do
-        expect(queue.size).to eq(1)
+        expect(queue.pool_size).to eq(1)
+        expect(queue.queue_size).to eq(1)
       end
     end
   end
@@ -117,7 +229,7 @@ describe Mongo::Server::ConnectionPool::Queue do
   describe '#inspect' do
 
     let(:queue) do
-      described_class.new(:min_pool_size => 2) { double('connection') }
+      described_class.new(:min_pool_size => 2) { create_connection }
     end
 
     it 'includes the object id' do
@@ -146,7 +258,7 @@ describe Mongo::Server::ConnectionPool::Queue do
     context 'when a max pool size option is provided' do
 
       let(:queue) do
-        described_class.new(:max_pool_size => 3) { double('connection') }
+        described_class.new(:max_pool_size => 3) { create_connection }
       end
 
       it 'returns the max size' do
@@ -157,7 +269,7 @@ describe Mongo::Server::ConnectionPool::Queue do
     context 'when no pool size option is provided' do
 
       let(:queue) do
-        described_class.new { double('connection') }
+        described_class.new { create_connection }
       end
 
       it 'returns the default size' do
@@ -171,7 +283,7 @@ describe Mongo::Server::ConnectionPool::Queue do
     context 'when the wait timeout option is provided' do
 
       let(:queue) do
-        described_class.new(:wait_queue_timeout => 3) { double('connection') }
+        described_class.new(:wait_queue_timeout => 3) { create_connection }
       end
 
       it 'returns the wait timeout' do
@@ -182,7 +294,7 @@ describe Mongo::Server::ConnectionPool::Queue do
     context 'when the wait timeout option is not provided' do
 
       let(:queue) do
-        described_class.new { double('connection') }
+        described_class.new { create_connection }
       end
 
       it 'returns the default wait timeout' do
@@ -196,6 +308,7 @@ describe Mongo::Server::ConnectionPool::Queue do
     let(:queue) do
       described_class.new(max_pool_size: 2, max_idle_time: 0.5) do
         double('connection').tap do |con|
+          expect(con).to receive(:generation).and_return(1)
           expect(con).to receive(:disconnect!).and_return(true)
           allow(con).to receive(:record_checkin!) do
             allow(con).to receive(:last_checkin).and_return(Time.now)
@@ -206,7 +319,9 @@ describe Mongo::Server::ConnectionPool::Queue do
     end
 
     let(:connection) do
-      queue.dequeue
+      queue.dequeue.tap do |con|
+        allow(con).to receive(:disconnect!)
+      end
     end
 
     before do
@@ -217,7 +332,8 @@ describe Mongo::Server::ConnectionPool::Queue do
     end
 
     it 'disconnects and reconnects up to min_size the expired connections' do
-      expect(queue.size).to eq(1)
+      expect(queue.queue_size).to eq(1)
+      expect(queue.pool_size).to eq(1)
     end
   end
 end