mongo 2.10.5 → 2.11.0.rc0

data/spec/mongo/cursor/builder/get_more_command_spec.rb

@@ -5,9 +5,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
   describe '#specification' do
 
     let(:reply) do
-      Mongo::Protocol::Reply.allocate.tap do |reply|
-        allow(reply).to receive(:cursor_id).and_return(8000)
-      end
+      Mongo::Protocol::Reply.allocate
     end
 
     let(:result) do
@@ -56,7 +54,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
       end
 
       it 'includes getMore with cursor id' do
-        expect(selector[:getMore]).to eq(BSON::Int64.new(8000))
+        expect(selector[:getMore]).to eq(cursor.id)
       end
 
       it 'includes the collection name' do

data/spec/mongo/cursor/builder/op_get_more_spec.rb

@@ -5,9 +5,7 @@ describe Mongo::Cursor::Builder::OpGetMore do
   describe '#specification' do
 
     let(:reply) do
-      Mongo::Protocol::Reply.allocate.tap do |reply|
-        allow(reply).to receive(:cursor_id).and_return(8000)
-      end
+      Mongo::Protocol::Reply.allocate
     end
 
     let(:result) do
@@ -40,7 +38,7 @@ describe Mongo::Cursor::Builder::OpGetMore do
     end
 
     it 'includes the cursor id' do
-      expect(specification[:cursor_id]).to eq(BSON::Int64.new(8000))
+      expect(specification[:cursor_id]).to eq(cursor.id)
     end
 
     it 'includes the database name' do

data/spec/mongo/cursor_spec.rb

@@ -27,10 +27,23 @@ describe Mongo::Cursor do
       authorized_collection.insert_many(documents)
     end
 
-    context 'cursor exhausted by initial result' do
+    shared_context 'with initialized pool' do
       before do
         ClientRegistry.instance.close_all_clients
+
+        # These tests really like creating pools (and thus scheduling
+        # the pools' finalizers) when querying collections.
+        # Deal with this by pre-creating pools for all known servers.
+        cluster = authorized_collection.client.cluster
+        cluster.next_primary
+        cluster.servers_list.each do |server|
+          server.pool
+        end
       end
+    end
+
+    context 'cursor exhausted by initial result' do
+      include_context 'with initialized pool'
 
       let(:view) do
         Mongo::Collection::View.new(authorized_collection)
@@ -47,15 +60,19 @@ describe Mongo::Cursor do
     end
 
     context 'cursor not exhausted by initial result' do
-      clean_slate
+      include_context 'with initialized pool'
 
       let(:view) do
         Mongo::Collection::View.new(authorized_collection, {}, batch_size: 2)
       end
 
       it 'schedules the finalizer' do
-        expect(ObjectSpace).to receive(:define_finalizer)
-        cursor
+        # Due to https://jira.mongodb.org/browse/RUBY-1772, restrict
+        # the scope of the assertion
+        RSpec::Mocks.with_temporary_scope do
+          expect(ObjectSpace).to receive(:define_finalizer)
+          cursor
+        end
       end
     end
   end
@@ -301,7 +318,7 @@ describe Mongo::Cursor do
         Mongo::Collection::View.new(
             authorized_collection,
             {},
-            :batch_size => 2,
+            :batch_size => 2
         )
       end
 
@@ -312,12 +329,15 @@ describe Mongo::Cursor do
 
       it 'schedules a kill cursors op' do
         cluster.instance_variable_get(:@periodic_executor).flush
-        expect do
+        expect {
           cursor.to_a
-        end.to raise_exception(Mongo::Error::OperationFailure, /[cC]ursor.*not found/)
+        }.to raise_exception(Mongo::Error::OperationFailure, /[cC]ursor.*not found/)
       end
 
       context 'when the cursor is unregistered before the kill cursors operations are executed' do
+        # Sometimes JRuby yields 4 documents even though we are allowing
+        # repeated cursor iteration below
+        fails_on_jruby
 
         it 'does not send a kill cursors operation for the unregistered cursor' do
           # We need to verify that the cursor was able to retrieve more documents

data/spec/mongo/monitoring/event/cmap/connection_checked_in_spec.rb

@@ -1,4 +1,4 @@
-require 'lite_spec_helper'
+require 'spec_helper'
 
 describe Mongo::Monitoring::Event::Cmap::ConnectionCheckedIn do
 
@@ -12,12 +12,19 @@ describe Mongo::Monitoring::Event::Cmap::ConnectionCheckedIn do
       1
     end
 
+    declare_topology_double
+
+    let(:pool) do
+      server = make_server(:primary)
+      Mongo::Server::ConnectionPool.new(server)
+    end
+
     let(:event) do
-      described_class.new(address, id)
+      described_class.new(address, id, pool)
     end
 
     it 'renders correctly' do
-      expect(event.summary).to eq('#<ConnectionCheckedIn address=127.0.0.1:27017 connection_id=1>')
+      expect(event.summary).to eq("#<ConnectionCheckedIn address=127.0.0.1:27017 connection_id=1 pool=0x#{pool.object_id}>")
     end
   end
 end

data/spec/mongo/monitoring/event/cmap/connection_checked_out_spec.rb

@@ -1,4 +1,4 @@
-require 'lite_spec_helper'
+require 'spec_helper'
 
 describe Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut do
 
@@ -12,12 +12,19 @@ describe Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut do
       1
     end
 
+    declare_topology_double
+
+    let(:pool) do
+      server = make_server(:primary)
+      Mongo::Server::ConnectionPool.new(server)
+    end
+
     let(:event) do
-      described_class.new(address, id)
+      described_class.new(address, id, pool)
     end
 
     it 'renders correctly' do
-      expect(event.summary).to eq('#<ConnectionCheckedOut address=127.0.0.1:27017 connection_id=1>')
+      expect(event.summary).to eq("#<ConnectionCheckedOut address=127.0.0.1:27017 connection_id=1 pool=0x#{pool.object_id}>")
     end
   end
 end

data/spec/mongo/monitoring/event/cmap/pool_closed_spec.rb

@@ -1,4 +1,4 @@
-require 'lite_spec_helper'
+require 'spec_helper'
 
 describe Mongo::Monitoring::Event::Cmap::PoolClosed do
 
@@ -8,12 +8,19 @@ describe Mongo::Monitoring::Event::Cmap::PoolClosed do
       Mongo::Address.new('127.0.0.1:27017')
     end
 
+    declare_topology_double
+
+    let(:pool) do
+      server = make_server(:primary)
+      Mongo::Server::ConnectionPool.new(server)
+    end
+
     let(:event) do
-      described_class.new(address)
+      described_class.new(address, pool)
     end
 
     it 'renders correctly' do
-      expect(event.summary).to eq('#<PoolClosed address=127.0.0.1:27017>')
+      expect(event.summary).to eq("#<PoolClosed address=127.0.0.1:27017 pool=0x#{pool.object_id}>")
     end
   end
 end

data/spec/mongo/monitoring/event/cmap/pool_created_spec.rb

@@ -1,4 +1,4 @@
-require 'lite_spec_helper'
+require 'spec_helper'
 
 describe Mongo::Monitoring::Event::Cmap::PoolCreated do
 
@@ -15,12 +15,19 @@ describe Mongo::Monitoring::Event::Cmap::PoolCreated do
       }
     end
 
+    declare_topology_double
+
+    let(:pool) do
+      server = make_server(:primary)
+      Mongo::Server::ConnectionPool.new(server)
+    end
+
     let(:event) do
-      described_class.new(address, options)
+      described_class.new(address, options, pool)
     end
 
     it 'renders correctly' do
-      expect(event.summary).to eq('#<PoolCreated address=127.0.0.1:27017 options={:wait_queue_timeout=>3, :min_pool_size=>5}>')
+      expect(event.summary).to eq("#<PoolCreated address=127.0.0.1:27017 options={:wait_queue_timeout=>3, :min_pool_size=>5} pool=0x#{pool.object_id}>")
     end
   end
 end

data/spec/mongo/operation/delete/op_msg_spec.rb

@@ -143,6 +143,8 @@ describe Mongo::Operation::Delete::OpMsg do
         end
 
         context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
+          # Mocks on features are incompatible with linting
+          skip_if_linting
 
           let(:expected_global_args) do
             global_args.dup.tap do |args|
@@ -153,15 +155,20 @@ describe Mongo::Operation::Delete::OpMsg do
           before do
             session.instance_variable_set(:@options, { implicit: true })
             # Topology is standalone, hence there is exactly one server
-            authorized_client.cluster.servers.first.monitor.stop!(true)
-            allow(authorized_primary.features).to receive(:sessions_enabled?).and_return(false)
+            authorized_primary.monitor.stop!
           end
 
           it 'creates the correct OP_MSG message' do
-            authorized_client.command(ping:1)
-            expect(expected_global_args[:session]).to be nil
-            expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
-            op.send(:message, authorized_primary)
+            RSpec::Mocks.with_temporary_scope do
+              # Override description as it gets replaced on every connection
+              description = authorized_primary.description
+              allow(authorized_primary).to receive(:description).and_return(description)
+              allow(description.features).to receive(:sessions_enabled?).and_return(false)
+
+              expect(expected_global_args[:session]).to be nil
+              expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
+              op.send(:message, authorized_primary)
+            end
           end
         end
       end
@@ -232,8 +239,10 @@ describe Mongo::Operation::Delete::OpMsg do
 
           it 'does not send a session id in the command' do
             authorized_client.command(ping:1)
-            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
-            op.send(:message, authorized_primary)
+            RSpec::Mocks.with_temporary_scope do
+              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
+              op.send(:message, authorized_primary)
+            end
           end
         end
       end

data/spec/mongo/operation/insert/op_msg_spec.rb

@@ -128,11 +128,13 @@ describe Mongo::Operation::Insert::OpMsg do
 
         it 'creates the correct OP_MSG message' do
           authorized_client.command(ping:1)
-          expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                             { validating_keys: true },
-                                                             expected_global_args,
-                                                             expected_payload_1)
-          op.send(:message, authorized_primary)
+          RSpec::Mocks.with_temporary_scope do
+            expect(Mongo::Protocol::Msg).to receive(:new).with([],
+                                                               { validating_keys: true },
+                                                               expected_global_args,
+                                                               expected_payload_1)
+            op.send(:message, authorized_primary)
+          end
         end
       end
 
@@ -145,12 +147,14 @@ describe Mongo::Operation::Insert::OpMsg do
         end
 
         it 'creates the correct OP_MSG message' do
-          authorized_client.command(ping:1)
-          expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                             { validating_keys: true },
-                                                             expected_global_args,
-                                                             expected_payload_1)
-          op.send(:message, authorized_primary)
+          RSpec::Mocks.with_temporary_scope do
+            authorized_client.command(ping:1)
+            expect(Mongo::Protocol::Msg).to receive(:new).with([],
+                                                               { validating_keys: true },
+                                                               expected_global_args,
+                                                               expected_payload_1)
+            op.send(:message, authorized_primary)
+          end
         end
 
         context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
@@ -164,18 +168,23 @@ describe Mongo::Operation::Insert::OpMsg do
           before do
             session.instance_variable_set(:@options, { implicit: true })
             # Topology is standalone, hence there is exactly one server
-            authorized_client.cluster.servers.first.monitor.stop!(true)
-            expect(authorized_primary.features).to receive(:sessions_enabled?).at_least(:once).and_return(false)
+            authorized_primary.monitor.stop!
           end
 
           it 'creates the correct OP_MSG message' do
-            authorized_client.command(ping:1)
-            expect(expected_global_args).not_to have_key(:lsid)
-            expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                               { validating_keys: true },
-                                                               expected_global_args,
-                                                               expected_payload_1)
-            op.send(:message, authorized_primary)
+            RSpec::Mocks.with_temporary_scope do
+              # Override description as it gets replaced on every connection
+              description = authorized_primary.description
+              allow(authorized_primary).to receive(:description).and_return(description)
+              allow(description.features).to receive(:sessions_enabled?).and_return(false)
+
+              expect(expected_global_args).not_to have_key(:lsid)
+              expect(Mongo::Protocol::Msg).to receive(:new).with([],
+                                                                 { validating_keys: true },
+                                                                 expected_global_args,
+                                                                 expected_payload_1)
+              op.send(:message, authorized_primary)
+            end
           end
         end
       end
@@ -206,11 +215,13 @@ describe Mongo::Operation::Insert::OpMsg do
 
             it 'does not send a session id in the command' do
               authorized_client.command(ping:1)
-              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
-                                                                 { validating_keys: true },
-                                                                 expected_global_args,
-                                                                 expected_payload_1)
-              op.send(:message, authorized_primary)
+              RSpec::Mocks.with_temporary_scope do
+                expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
+                                                                   { validating_keys: true },
+                                                                   expected_global_args,
+                                                                   expected_payload_1)
+                op.send(:message, authorized_primary)
+              end
             end
           end
 
@@ -226,11 +237,13 @@ describe Mongo::Operation::Insert::OpMsg do
 
             it 'creates the correct OP_MSG message' do
               authorized_client.command(ping:1)
-              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
-                                                                 { validating_keys: true },
-                                                                 expected_global_args,
-                                                                 expected_payload_1)
-              op.send(:message, authorized_primary)
+              RSpec::Mocks.with_temporary_scope do
+                expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
+                                                                   { validating_keys: true },
+                                                                   expected_global_args,
+                                                                   expected_payload_1)
+                op.send(:message, authorized_primary)
+              end
             end
           end
         end
@@ -252,11 +265,13 @@ describe Mongo::Operation::Insert::OpMsg do
 
           it 'does not send a session id in the command' do
             authorized_client.command(ping:1)
-            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
-                                                               { validating_keys: true },
-                                                               expected_global_args,
-                                                               expected_payload_1)
-            op.send(:message, authorized_primary)
+            RSpec::Mocks.with_temporary_scope do
+              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
+                                                                 { validating_keys: true },
+                                                                 expected_global_args,
+                                                                 expected_payload_1)
+              op.send(:message, authorized_primary)
+            end
           end
         end
       end

data/spec/mongo/operation/update/op_msg_spec.rb

@@ -160,14 +160,19 @@ describe Mongo::Operation::Update::OpMsg do
           before do
             session.instance_variable_set(:@options, { implicit: true })
             # Topology is standalone, hence there is exactly one server
-            authorized_client.cluster.servers.first.monitor.stop!(true)
-            allow(authorized_primary.features).to receive(:sessions_enabled?).and_return(false)
+            authorized_primary.monitor.stop!
           end
 
           it 'creates the correct OP_MSG message' do
-            authorized_client.command(ping:1)
-            expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
-            op.send(:message, authorized_primary)
+            RSpec::Mocks.with_temporary_scope do
+              # Override description as it gets replaced on every connection
+              description = authorized_primary.description
+              allow(authorized_primary).to receive(:description).and_return(description)
+              allow(description.features).to receive(:sessions_enabled?).and_return(false)
+
+              expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
+              op.send(:message, authorized_primary)
+            end
           end
         end
       end
@@ -238,8 +243,10 @@ describe Mongo::Operation::Update::OpMsg do
 
           it 'does not send a session id in the command' do
             authorized_client.command(ping:1)
-            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
-            op.send(:message, authorized_primary)
+            RSpec::Mocks.with_temporary_scope do
+              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
+              op.send(:message, authorized_primary)
+            end
           end
         end
       end

data/spec/mongo/retryable_spec.rb

@@ -175,62 +175,83 @@ describe Mongo::Retryable do
 
     context 'when an operation failure occurs' do
 
-      context 'when the operation failure is not retryable' do
-
-        let(:error) do
-          Mongo::Error::OperationFailure.new('not authorized')
-        end
+      context 'when the cluster is not a mongos' do
 
         before do
-          expect(operation).to receive(:execute).and_raise(error).ordered
+          expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
+          expect(cluster).to receive(:sharded?).and_return(false)
         end
 
-        it 'raises the exception' do
+        it 'raises an exception' do
           expect {
             read_operation
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
 
-      context 'when the operation failure is retryable' do
+      context 'when the cluster is a mongos' do
 
-        let(:error) do
-          Mongo::Error::OperationFailure.new('not master')
-        end
+        context 'when the operation failure is not retryable' do
 
-        context 'when the retry succeeds' do
+          let(:error) do
+            Mongo::Error::OperationFailure.new('not authorized')
+          end
 
           before do
-            expect(retryable).to receive(:select_server).ordered
             expect(operation).to receive(:execute).and_raise(error).ordered
-            expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
-            expect(retryable).to receive(:select_server).ordered
-            expect(operation).to receive(:execute).and_return(true).ordered
+            expect(cluster).to receive(:sharded?).and_return(true)
           end
 
-          it 'returns the result' do
-            expect(read_operation).to be true
+          it 'raises the exception' do
+            expect {
+              read_operation
+            }.to raise_error(Mongo::Error::OperationFailure)
           end
         end
 
-        context 'when the retry fails once and then succeeds' do
-          let(:max_read_retries) { 2 }
+        context 'when the operation failure is retryable' do
 
-          before do
-            expect(retryable).to receive(:select_server).ordered
-            expect(operation).to receive(:execute).and_raise(error).ordered
+          let(:error) do
+            Mongo::Error::OperationFailure.new('not master')
+          end
 
-            expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
-            expect(retryable).to receive(:select_server).ordered
-            expect(operation).to receive(:execute).and_raise(error).ordered
+          context 'when the retry succeeds' do
+
+            before do
+              expect(retryable).to receive(:select_server).ordered
+              expect(operation).to receive(:execute).and_raise(error).ordered
+              expect(cluster).to receive(:sharded?).and_return(true)
+              expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
+              expect(retryable).to receive(:select_server).ordered
+              expect(operation).to receive(:execute).and_return(true).ordered
+            end
 
-            expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
-            expect(retryable).to receive(:select_server).ordered
-            expect(operation).to receive(:execute).and_return(true).ordered
+            it 'returns the result' do
+              expect(read_operation).to be true
+            end
           end
 
-          it 'returns the result' do
-            expect(read_operation).to be true
+          context 'when the retry fails once and then succeeds' do
+            let(:max_read_retries) { 2 }
+
+            before do
+              expect(retryable).to receive(:select_server).ordered
+              expect(operation).to receive(:execute).and_raise(error).ordered
+
+              expect(cluster).to receive(:sharded?).and_return(true)
+              expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
+              expect(retryable).to receive(:select_server).ordered
+              expect(operation).to receive(:execute).and_raise(error).ordered
+
+              expect(cluster).to receive(:sharded?).and_return(true)
+              expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
+              expect(retryable).to receive(:select_server).ordered
+              expect(operation).to receive(:execute).and_return(true).ordered
+            end
+
+            it 'returns the result' do
+              expect(read_operation).to be true
+            end
           end
         end
       end