mongo 2.15.0 → 2.18.1

data/spec/mongo/client_encryption_spec.rb

@@ -68,7 +68,7 @@ describe Mongo::ClientEncryption do
       it 'raises an exception' do
         expect do
           client_encryption
-        end.to raise_error(ArgumentError, /kms_providers option must have one of the following keys/)
+        end.to raise_error(ArgumentError, /KMS providers options must have one of the following keys/)
       end
     end
   end
@@ -144,17 +144,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /options cannot be nil/)
-        end
-      end
-
-      context 'with empty options' do
-        let(:options) { {} }
-
-        it 'raises an exception' do
-          expect do
-            data_key_id
-          end.to raise_error(ArgumentError, /options Hash must contain a key named :master_key/)
+          end.to raise_error(ArgumentError, /Key document options must not be nil/)
         end
       end
 
@@ -164,7 +154,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /The :master_key option cannot be nil/)
+          end.to raise_error(ArgumentError, /Key document options must contain a key named :master_key with a Hash value/)
         end
       end
 
@@ -174,7 +164,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /master-key is an invalid :master_key option/)
+          end.to raise_error(ArgumentError, /Key document options must contain a key named :master_key with a Hash value/)
         end
       end
 
@@ -184,7 +174,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /The value of :region option of the :master_key options hash cannot be nil/)
+          end.to raise_error(ArgumentError, /The specified KMS provider options are invalid: {}. AWS key document  must be in the format: { region: 'REGION', key: 'KEY' }/)
         end
       end
 
@@ -194,7 +184,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /The value of :region option of the :master_key options hash cannot be nil/)
+          end.to raise_error(ArgumentError, /The region option must be a String with at least one character; currently have nil/)
         end
       end
 
@@ -204,7 +194,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /5 is an invalid AWS master_key region. The value of :region option of the :master_key options hash must be a String/)
+          end.to raise_error(ArgumentError, /The region option must be a String with at least one character; currently have 5/)
         end
       end
 
@@ -214,7 +204,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /The value of :key option of the :master_key options hash cannot be nil/)
+          end.to raise_error(ArgumentError, /The key option must be a String with at least one character; currently have nil/)
         end
       end
 
@@ -224,7 +214,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /5 is an invalid AWS master_key key. The value of :key option of the :master_key options hash must be a String/)
+          end.to raise_error(ArgumentError, /The key option must be a String with at least one character; currently have 5/)
         end
       end
 
@@ -234,7 +224,7 @@ describe Mongo::ClientEncryption do
         it 'raises an exception' do
           expect do
             data_key_id
-          end.to raise_error(ArgumentError, /5 is an invalid AWS master_key endpoint. The value of :endpoint option of the :master_key options hash must be a String/)
+          end.to raise_error(ArgumentError, /The endpoint option must be a String with at least one character; currently have 5/)
         end
       end
 
@@ -297,8 +287,6 @@ describe Mongo::ClientEncryption do
         end
 
         it 'raises an exception' do
-          # RUBY-2129: This error message could be more specific and inform the user
-          # that there is a problem with their KMS endpoint
           expect do
             data_key_id
           end.to raise_error(Mongo::Error::KmsError, /SocketError/)

data/spec/mongo/client_spec.rb

@@ -8,6 +8,14 @@ require 'spec_helper'
 
 describe Mongo::Client do
 
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  let(:monitored_client) do
+    root_authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
   describe '#==' do
 
     let(:client) do
@@ -584,6 +592,18 @@ describe Mongo::Client do
         expect(result.first).to eq(filter[:name])
       end
     end
+
+    context 'with comment' do
+      min_server_version '4.4'
+
+      it 'returns a list of database names and send comment' do
+        result = monitored_client.database_names({}, comment: "comment")
+        expect(result).to include('admin')
+        command = subscriber.command_started_events("listDatabases").last&.command
+        expect(command).not_to be_nil
+        expect(command["comment"]).to eq("comment")
+      end
+    end
   end
 
   describe '#list_databases' do
@@ -635,7 +655,7 @@ describe Mongo::Client do
         root_authorized_client.options.merge(heartbeat_frequency: 100, monitoring: true)
       end
 
-      let(:subscriber) { EventSubscriber.new }
+      let(:subscriber) { Mrss::EventSubscriber.new }
 
       let(:client) do
         ClientRegistry.instance.new_local_client(
@@ -677,6 +697,20 @@ describe Mongo::Client do
         expect(command[:authorizedDatabases]).to be_nil
       end
     end
+
+    context 'with comment' do
+      min_server_version '4.4'
+
+      it 'returns a list of database names and send comment' do
+        result = monitored_client.list_databases({}, false, comment: "comment").collect do |i|
+          i['name']
+        end
+        expect(result).to include('admin')
+        command = subscriber.command_started_events("listDatabases").last&.command
+        expect(command).not_to be_nil
+        expect(command["comment"]).to eq("comment")
+      end
+    end
   end
 
   describe '#list_mongo_databases' do
@@ -719,6 +753,18 @@ describe Mongo::Client do
         expect(result.first.name).to eq(filter[:name])
       end
     end
+
+    context 'with comment' do
+      min_server_version '4.4'
+
+      it 'returns a list of database names and send comment' do
+        result = monitored_client.list_mongo_databases({}, comment: "comment")
+        expect(result).to all(be_a(Mongo::Database))
+        command = subscriber.command_started_events("listDatabases").last&.command
+        expect(command).not_to be_nil
+        expect(command["comment"]).to eq("comment")
+      end
+    end
   end
 
   describe '#close' do
@@ -790,7 +836,8 @@ describe Mongo::Client do
         expect(session).to be_a(Mongo::Session)
       end
 
-      it 'sets the last use field to the current time', retry: 4 do
+      retry_test tries: 4
+      it 'sets the last use field to the current time' do
         expect(session.instance_variable_get(:@server_session).last_use).to be_within(1).of(Time.now)
       end
 
@@ -873,6 +920,255 @@ describe Mongo::Client do
           expect(before_last_use).to be < (pool.instance_variable_get(:@queue)[0].last_use)
         end
       end
+
+      context 'when an implicit session is used without enough connections' do
+        require_no_multi_mongos
+        require_wired_tiger
+
+        let(:client) do
+          authorized_client.with(options).tap do |cl|
+            cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+          end
+        end
+
+        let(:options) do
+          { :max_pool_size => 1, :retry_writes => true }
+        end
+
+        shared_examples "a single connection" do
+          # JRuby, due to being concurrent, does not like rspec setting mocks
+          # in threads while other threads are calling the methods being mocked.
+          # My theory is that rspec removes & redefines methods as part of
+          # the mocking process, but while a method is undefined JRuby is
+          # running another thread that calls it leading to this exception:
+          # NoMethodError: undefined method `with_connection' for #<Mongo::Server:0x5386 address=localhost:27017 PRIMARY>
+          fails_on_jruby
+
+          before do
+            sessions_checked_out = 0
+
+            allow_any_instance_of(Mongo::Server).to receive(:with_connection).and_wrap_original do |m, *args, &block|
+              m.call(*args) do |connection|
+                sessions_checked_out = 0
+                res = block.call(connection)
+                expect(sessions_checked_out).to be < 2
+                res
+              end
+            end
+
+            allow_any_instance_of(Mongo::Session).to receive(:materialize).and_wrap_original do |m, *args|
+              sessions_checked_out += 1
+              m.call(*args).tap do
+                checked_out_connections = args[0].connection_pool.instance_variable_get("@checked_out_connections")
+                expect(checked_out_connections.length).to eq 1
+              end
+            end
+          end
+
+          it 'doesn\'t have any live sessions' do
+            threads.each do |thread|
+              thread.join
+            end
+          end
+        end
+
+        context "when doing three inserts" do
+          let(:threads) do
+            (1..3).map do |i|
+              Thread.new do
+                client['test'].insert_one({test: "test#{i}"})
+              end
+            end
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert and two updates" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and delete" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].delete_one({test: "test"})
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and find" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].find({test: "test"}).to_a
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and bulk write" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].bulk_write([{ insert_one: { test: "test1" } },
+                                         { update_one: { filter: { test: "test1" }, update: { "$set" => { test: "test2" } } } } ])
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and find_one_and_delete" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_delete({test: "test"})
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and find_one_and_update" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_update({test: "test"}, {test: "test2"})
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and find_one_and_replace" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_replace({test: "test"}, {test: "test2"})
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing an insert, update and a replace" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({test: "test"}, { "$set" => { test: "test2" } })
+            end
+            threads << Thread.new do
+              client['test'].replace_one({test: "test"}, {test: "test2"})
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+
+        context "when doing all of the operations" do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: "test" }, { "$set" => { test: 1 } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_replace({test: "test"}, {test: "test2"})
+            end
+            threads << Thread.new do
+              client['test'].delete_one({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].find({test: "test"}).to_a
+            end
+            threads << Thread.new do
+              client['test'].bulk_write([{ insert_one: { test: "test1" } },
+                                         { update_one: { filter: { test: "test1" }, update: { "$set" => { test: "test2" } } } } ])
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_delete({test: "test"})
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_update({test: "test"}, {test: "test2"})
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_replace({test: "test"}, {test: "test2"})
+            end
+            threads << Thread.new do
+              client['test'].replace_one({test: "test"}, {test: "test2"})
+            end
+            threads
+          end
+
+          include_examples "a single connection"
+        end
+      end
     end
 
     context 'when two clients have the same cluster' do
@@ -939,13 +1235,15 @@ describe Mongo::Client do
     end
 
     context 'monitoring present' do
+      require_topology :single, :replica_set, :sharded
+
       let(:client) do
         authorized_client
       end
 
       it 'does not indicate lack of monitoring' do
-        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS)/
-        client.summary.should_not =~ /servers=.*(STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
+        client.summary.should =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS)/
+        client.summary.should_not =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
       end
     end
 
@@ -957,7 +1255,7 @@ describe Mongo::Client do
       end
 
       it 'does not indicate lack of monitoring' do
-        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
+        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS|\bLB\b).*NO-MONITORING/
       end
     end
   end

data/spec/mongo/cluster/cursor_reaper_spec.rb

@@ -5,16 +5,18 @@ require 'spec_helper'
 
 describe Mongo::Cluster::CursorReaper do
 
+  let(:cluster) { double('cluster') }
+
   before do
     authorized_collection.drop
   end
 
   let(:reaper) do
-    described_class.new
+    described_class.new(cluster)
   end
 
-  let(:active_cursors) do
-    reaper.instance_variable_get(:@active_cursors)
+  let(:active_cursor_ids) do
+    reaper.instance_variable_get(:@active_cursor_ids)
   end
 
   describe '#intialize' do
@@ -24,16 +26,42 @@ describe Mongo::Cluster::CursorReaper do
     end
 
     it 'initializes a set for the list of active cursors' do
-      expect(reaper.instance_variable_get(:@active_cursors)).to be_a(Set)
+      expect(reaper.instance_variable_get(:@active_cursor_ids)).to be_a(Set)
     end
   end
 
   describe '#schedule_kill_cursor' do
 
-    let(:server) { double('server') }
+    let(:address) { Mongo::Address.new('localhost') }
+    let(:server) do
+      double('server').tap do |server|
+        allow(server).to receive(:address).and_return(address)
+      end
+    end
+    let(:session) do
+      double(Mongo::Session)
+    end
     let(:cursor_id) { 1 }
-    let(:op_spec_1) { double('op_spec_1') }
-    let(:op_spec_2) { double('op_spec_2') }
+    let(:cursor_kill_spec_1) do
+      Mongo::Cursor::KillSpec.new(
+        cursor_id: cursor_id,
+        coll_name: 'c',
+        db_name: 'd',
+        server_address: address,
+        connection_global_id: 1,
+        session: session,
+      )
+    end
+    let(:cursor_kill_spec_2) do
+      Mongo::Cursor::KillSpec.new(
+        cursor_id: cursor_id,
+        coll_name: 'c',
+        db_name: 'q',
+        server_address: address,
+        connection_global_id: 1,
+        session: session,
+      )
+    end
     let(:to_kill) { reaper.instance_variable_get(:@to_kill)}
 
     context 'when the cursor is on the list of active cursors' do
@@ -45,36 +73,40 @@ describe Mongo::Cluster::CursorReaper do
       context 'when there is not a list already for the server' do
 
         before do
-          reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_1)
+          reaper.read_scheduled_kill_specs
         end
 
         it 'initializes the list of op specs to a set' do
-          expect(to_kill.keys).to eq([ server ])
-          expect(to_kill[server]).to eq(Set.new([op_spec_1]))
+          expect(to_kill.keys).to eq([ address ])
+          expect(to_kill[address]).to contain_exactly(cursor_kill_spec_1)
         end
       end
 
       context 'when there is a list of ops already for the server' do
 
         before do
-          reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
-          reaper.schedule_kill_cursor(cursor_id, op_spec_2, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_1)
+          reaper.read_scheduled_kill_specs
+          reaper.schedule_kill_cursor(cursor_kill_spec_2)
+          reaper.read_scheduled_kill_specs
         end
 
         it 'adds the op to the server list' do
-          expect(to_kill.keys).to eq([ server ])
-          expect(to_kill[server]).to contain_exactly(op_spec_1, op_spec_2)
+          expect(to_kill.keys).to eq([ address ])
+          expect(to_kill[address]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
         end
 
         context 'when the same op is added more than once' do
 
           before do
-            reaper.schedule_kill_cursor(cursor_id, op_spec_2, server)
+            reaper.schedule_kill_cursor(cursor_kill_spec_2)
+            reaper.read_scheduled_kill_specs
           end
 
           it 'does not allow duplicates ops for a server' do
-            expect(to_kill.keys).to eq([ server ])
-            expect(to_kill[server]).to contain_exactly(op_spec_1, op_spec_2)
+            expect(to_kill.keys).to eq([ address ])
+            expect(to_kill[address]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
           end
         end
       end
@@ -83,7 +115,7 @@ describe Mongo::Cluster::CursorReaper do
     context 'when the cursor is not on the list of active cursors' do
 
       before do
-        reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
+        reaper.schedule_kill_cursor(cursor_kill_spec_1)
       end
 
       it 'does not add the kill cursors op spec to the list' do
@@ -131,7 +163,7 @@ describe Mongo::Cluster::CursorReaper do
       end
 
       it 'registers the cursor id as active' do
-        expect(active_cursors).to eq(Set.new([2]))
+        expect(active_cursor_ids).to eq(Set.new([2]))
       end
     end
   end
@@ -146,7 +178,7 @@ describe Mongo::Cluster::CursorReaper do
       end
 
       it 'removes the cursor id' do
-        expect(active_cursors.size).to eq(0)
+        expect(active_cursor_ids.size).to eq(0)
       end
     end
   end
@@ -174,8 +206,11 @@ describe Mongo::Cluster::CursorReaper do
     around do |example|
       authorized_collection.insert_many(docs)
       periodic_executor.stop!
-      cluster.schedule_kill_cursor(cursor.id, cursor.send(:kill_cursors_op_spec),
-                                   cursor.instance_variable_get(:@server))
+      cluster.schedule_kill_cursor(
+        cursor.kill_spec(
+          cursor.instance_variable_get(:@server)
+        )
+      )
       periodic_executor.flush
       example.run
       periodic_executor.run!
@@ -184,7 +219,12 @@ describe Mongo::Cluster::CursorReaper do
     it 'schedules the kill cursor op' do
       expect {
         cursor.to_a
-      }.to raise_exception(Mongo::Error::OperationFailure)
+        # Mongo::Error::SessionEnded is raised here because the periodic executor
+        # called in around block kills the cursor and closes the session.
+        # This code is normally scheduled in cursor finalizer, so the cursor object
+        # is garbage collected when the code is executed. So, a user won't get
+        # this exception.
+      }.to raise_exception(Mongo::Error::SessionEnded)
     end
   end
 end

data/spec/mongo/cluster/periodic_executor_spec.rb

@@ -5,8 +5,10 @@ require 'spec_helper'
 
 describe Mongo::Cluster::PeriodicExecutor do
 
+  let(:cluster) { double('cluster') }
+
   let(:executor) do
-    described_class.new
+    described_class.new(cluster)
   end
 
   describe '#log_warn' do