mongo 2.5.0 → 2.5.1

data/spec/mongo/cluster/topology/replica_set_spec.rb

@@ -532,6 +532,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
             allow(d).to receive(:replica_set_member?).and_return(true)
             allow(d).to receive(:replica_set_name).and_return('testing')
             allow(d).to receive(:lists_server?).and_return(true)
+            allow(d).to receive(:servers).and_return([double('server')])
           end
         end
 
@@ -549,6 +550,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
             allow(d).to receive(:replica_set_name).and_return('testing')
             allow(d).to receive(:is_server?).and_return(false)
             allow(d).to receive(:lists_server?).and_return(false)
+            allow(d).to receive(:servers).and_return([double('server')])
           end
         end
 

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -231,26 +231,20 @@ describe Mongo::Collection::View::Aggregation do
       end
 
       let(:client) do
-        authorized_client.with(heartbeat_frequency: 100).tap do |cl|
-          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-        end
+        subscribed_client
       end
 
       let(:session) do
         client.start_session
       end
 
-      let(:subscriber) do
-        EventSubscriber.new
-      end
-
       let(:view) do
         Mongo::Collection::View.new(client[TEST_COLL], selector, view_options)
       end
 
       let(:command) do
         aggregation.explain
-        subscriber.started_events.find { |c| c.command_name == 'aggregate'}.command
+        EventSubscriber.started_events.find { |c| c.command_name == 'aggregate'}.command
       end
 
       it 'sends the session id' do

data/spec/mongo/collection/view/change_stream_spec.rb

@@ -314,11 +314,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
       context 'when a session from another client is provided' do
 
         let(:session) do
-          client.start_session
-        end
-
-        let(:client) do
-          authorized_client.with(read: { mode: :secondary })
+          authorized_client_with_retry_writes.start_session
         end
 
         let(:operation_result) do

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -240,17 +240,11 @@ describe Mongo::Collection::View::MapReduce do
           end
 
           let(:client) do
-            authorized_client.with(monitoring: true).tap do |cl|
-              cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-            end
-          end
-
-          let(:subscriber) do
-            EventSubscriber.new
+            subscribed_client
           end
 
           let(:find_command) do
-            subscriber.started_events[-1].command
+            EventSubscriber.started_events[-1].command
           end
 
           before do

data/spec/mongo/collection/view/readable_spec.rb

@@ -191,7 +191,7 @@ describe Mongo::Collection::View::Readable do
 
       let(:command) do
         operation
-        subscriber.started_events.find { |cmd| cmd.command_name == 'mapreduce' }.command
+        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'mapreduce' }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'

data/spec/mongo/collection_spec.rb

@@ -900,26 +900,20 @@ describe Mongo::Collection do
         end
 
         let(:client) do
-          authorized_client.with(heartbeat_frequency: 100).tap do |cl|
-            cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-          end
+          subscribed_client
         end
 
         let(:session) do
           client.start_session
         end
 
-        let(:subscriber) do
-          EventSubscriber.new
-        end
-
         let(:view) do
           Mongo::Collection::View.new(client[TEST_COLL], selector, view_options)
         end
 
         let(:command) do
           client[TEST_COLL].find({}, session: session).explain
-          subscriber.started_events.find { |c| c.command_name == :explain }.command
+          EventSubscriber.started_events.find { |c| c.command_name == :explain }.command
         end
 
         it 'sends the session id' do
@@ -935,7 +929,7 @@ describe Mongo::Collection do
 
         let(:command) do
           operation
-          subscriber.started_events.find { |cmd| cmd.command_name == 'find' }.command
+          EventSubscriber.started_events.find { |cmd| cmd.command_name == 'find' }.command
         end
 
         it_behaves_like 'an operation supporting causally consistent reads'
@@ -1205,13 +1199,7 @@ describe Mongo::Collection do
     context 'when the documents are sent with OP_MSG', if: op_msg_enabled? do
 
       let(:client) do
-        authorized_client.with(heartbeat_frequency: 100).tap do |cl|
-          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-        end
-      end
-
-      let(:subscriber) do
-        EventSubscriber.new
+        subscribed_client
       end
 
       let(:documents) do
@@ -1227,7 +1215,7 @@ describe Mongo::Collection do
       end
 
       let(:insert_events) do
-        subscriber.started_events.select { |e| e.command_name == :insert }
+        EventSubscriber.started_events.select { |e| e.command_name == :insert }
       end
 
       it 'sends the documents in one OP_MSG' do
@@ -1574,7 +1562,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        subscriber.started_events.find { |cmd| cmd.command_name == 'aggregate' }.command
+        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'aggregate' }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -1738,7 +1726,7 @@ describe Mongo::Collection do
 
         let(:command) do
           operation
-          subscriber.started_events.find { |cmd| cmd.command_name == :count }.command
+          EventSubscriber.started_events.find { |cmd| cmd.command_name == :count }.command
         end
 
         it_behaves_like 'an operation supporting causally consistent reads'
@@ -1852,7 +1840,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        subscriber.started_events.find { |cmd| cmd.command_name == :distinct }.command
+        EventSubscriber.started_events.find { |cmd| cmd.command_name == :distinct }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -2344,7 +2332,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        subscriber.started_events.find { |cmd| cmd.command_name == :parallelCollectionScan }.command
+        EventSubscriber.started_events.find { |cmd| cmd.command_name == :parallelCollectionScan }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -3486,13 +3474,7 @@ describe Mongo::Collection do
     context 'when the documents are sent with OP_MSG', if: op_msg_enabled? do
 
       let(:client) do
-        authorized_client.with(heartbeat_frequency: 100).tap do |cl|
-          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-        end
-      end
-
-      let(:subscriber) do
-        EventSubscriber.new
+        subscribed_client
       end
 
       let(:documents) do
@@ -3509,7 +3491,7 @@ describe Mongo::Collection do
       end
 
       let(:update_events) do
-        subscriber.started_events.select { |e| e.command_name == :update }
+        EventSubscriber.started_events.select { |e| e.command_name == :update }
       end
 
       it 'sends the documents in one OP_MSG' do

data/spec/mongo/crud_spec.rb

@@ -10,6 +10,12 @@ describe 'CRUD' do
 
       spec.tests.each do |test|
 
+        around do |example|
+          if spec.server_version_satisfied?(authorized_client)
+            example.run
+          end
+        end
+
         context(test.description) do
 
           before(:each) do
@@ -25,12 +31,10 @@ describe 'CRUD' do
           end
 
           it 'returns the correct result' do
-            skip 'Test cannot be run on this server version' unless spec.server_version_satisfied?(authorized_client)
             expect(results).to match_operation_result(test)
           end
 
           it 'has the correct data in the collection', if: test.outcome_collection_data do
-            skip 'Test cannot be run on this server version' unless spec.server_version_satisfied?(authorized_client)
             results
             expect(authorized_collection.find.to_a).to match_collection_data(test)
           end

data/spec/mongo/cursor_spec.rb

@@ -301,10 +301,14 @@ describe Mongo::Cursor do
         authorized_collection.find({}, batch_size: 2)
       end
 
+      let(:cursor) do
+        view.instance_variable_get(:@cursor)
+      end
+
       let!(:cursor_id) do
         enum.next
         enum.next
-        view.instance_variable_get(:@cursor).id
+        cursor.id
       end
 
       let(:enum) do
@@ -322,6 +326,85 @@ describe Mongo::Cursor do
     end
   end
 
+  context 'when an implicit session is used', if: sessions_enabled? do
+
+    let(:collection) do
+      subscribed_client[TEST_COLL]
+    end
+
+    before do
+      collection.insert_many(documents)
+    end
+
+    after do
+      collection.delete_many
+    end
+
+    let(:cursor) do
+      view.instance_variable_get(:@cursor)
+    end
+
+    let(:enum) do
+      view.to_enum
+    end
+
+    let(:session_pool_ids) do
+      queue = view.client.cluster.session_pool.instance_variable_get(:@queue)
+      queue.collect { |s| s.session_id }
+    end
+
+    let(:find_events) do
+      EventSubscriber.started_events.select { |e| e.command_name == "find" }
+    end
+
+    context 'when all results are retrieved in the first response' do
+
+      let(:documents) do
+        (1..2).map{ |i| { field: "test#{i}" }}
+      end
+
+      let(:view) do
+        collection.find
+      end
+
+      it 'returns the session to the cluster session pool' do
+        1.times { enum.next }
+        expect(find_events.collect { |event| event.command['lsid'] }.uniq.size).to eq(1)
+        expect(session_pool_ids).to include(find_events.collect { |event| event.command['lsid'] }.uniq.first)
+      end
+    end
+
+    context 'when a getmore is needed to retrieve all results', if: sessions_enabled? && !sharded? do
+
+      let(:documents) do
+        (1..4).map{ |i| { field: "test#{i}" }}
+      end
+
+      let(:view) do
+        collection.find({}, batch_size: 2, limit: 4)
+      end
+
+
+      context 'when not all documents are iterated' do
+
+        it 'returns the session to the cluster session pool' do
+          3.times { enum.next }
+          expect(find_events.collect { |event| event.command['lsid'] }.uniq.size).to eq(1)
+          expect(session_pool_ids).to include(find_events.collect { |event| event.command['lsid'] }.uniq.first)
+        end
+      end
+
+      context 'when all documents are iterated' do
+
+        it 'returns the session to the cluster session pool' do
+          4.times { enum.next }
+          expect(find_events.collect { |event| event.command['lsid'] }.uniq.size).to eq(1)
+          expect(session_pool_ids).to include(find_events.collect { |event| event.command['lsid'] }.uniq.first)
+        end
+      end
+    end
+  end
+
   describe '#inspect' do
 
     let(:view) do

data/spec/mongo/database_spec.rb

@@ -256,13 +256,7 @@ describe Mongo::Database do
       end
 
       let(:client) do
-        authorized_client.with(heartbeat_frequency: 100).tap do |cl|
-          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-        end
-      end
-
-      let(:subscriber) do
-        EventSubscriber.new
+        subscribed_client
       end
 
       it_behaves_like 'an operation using a session'
@@ -270,7 +264,7 @@ describe Mongo::Database do
 
 
       let(:full_command) do
-        subscriber.started_events.find { |cmd| cmd.command_name == :ismaster }.command
+        EventSubscriber.started_events.find { |cmd| cmd.command_name == :ismaster }.command
       end
 
       it 'does not add a afterClusterTime field' do

data/spec/mongo/dns_seedlist_discovery_spec.rb

@@ -1,92 +1,96 @@
 require 'spec_helper'
 
 describe 'DNS Seedlist Discovery' do
-  include Mongo::ConnectionString
-
-  before(:all) do
-
-    module Mongo
-      class Server
-        # The constructor keeps the same API, but does not instantiate a
-        # monitor and run it.
-        alias :original_initialize :initialize
-
-        def initialize(address, cluster, monitoring, event_listeners, options = {})
-          @address = address
-          @cluster = cluster
-          @monitoring = monitoring
-          @options = options.freeze
-          @monitor = Monitor.new(address, event_listeners, options)
-        end
 
-        # Disconnect simply needs to return true since we have no monitor and
-        # no connection.
-        alias :original_disconnect! :disconnect!
+  if test_connecting_externally?
+
+    include Mongo::ConnectionString
+
+    before(:all) do
+
+      module Mongo
+        class Server
+          # The constructor keeps the same API, but does not instantiate a
+          # monitor and run it.
+          alias :original_initialize :initialize
 
-        def disconnect!;
-          true;
+          def initialize(address, cluster, monitoring, event_listeners, options = {})
+            @address = address
+            @cluster = cluster
+            @monitoring = monitoring
+            @options = options.freeze
+            @monitor = Monitor.new(address, event_listeners, options)
+          end
+
+          # Disconnect simply needs to return true since we have no monitor and
+          # no connection.
+          alias :original_disconnect! :disconnect!
+
+          def disconnect!;
+            true;
+          end
         end
       end
     end
-  end
 
-  after(:all) do
+    after(:all) do
 
-    module Mongo
-      class Server
-        alias :initialize :original_initialize
-        remove_method(:original_initialize)
+      module Mongo
+        class Server
+          alias :initialize :original_initialize
+          remove_method(:original_initialize)
 
-        alias :disconnect! :original_disconnect!
-        remove_method(:original_disconnect!)
+          alias :disconnect! :original_disconnect!
+          remove_method(:original_disconnect!)
+        end
       end
     end
-  end
 
-  DNS_SEEDLIST_DISCOVERY_TESTS.each do |file_name|
+    DNS_SEEDLIST_DISCOVERY_TESTS.each do |file_name|
 
-    file = File.new(file_name)
-    spec = YAML.load(ERB.new(file.read).result)
-    file.close
+      file = File.new(file_name)
+      spec = YAML.load(ERB.new(file.read).result)
+      file.close
 
-    test = Mongo::ConnectionString::Test.new(spec)
+      test = Mongo::ConnectionString::Test.new(spec)
 
-    context(File.basename(file_name)) do
+      context(File.basename(file_name), if: test_connecting_externally?) do
 
-      context 'when the uri is invalid', if: test.raise_error? do
+        context 'when the uri is invalid', if: test.raise_error? do
 
-        let(:valid_errors) do
-          [
-            Mongo::Error::InvalidTXTRecord,
-            Mongo::Error::NoSRVRecords,
-            Mongo::Error::InvalidURI,
-            Mongo::Error::MismatchedDomain,
-          ]
-        end
+          let(:valid_errors) do
+            [
+              Mongo::Error::InvalidTXTRecord,
+              Mongo::Error::NoSRVRecords,
+              Mongo::Error::InvalidURI,
+              Mongo::Error::MismatchedDomain,
+            ]
+          end
 
-        let(:error) do
-          e = nil
-          begin; test.uri; rescue => ex; e = ex; end
-          e
-        end
+          let(:error) do
+            e = nil
+            begin; test.uri; rescue => ex; e = ex; end
+            e
+          end
 
-        it 'raises an error' do
-          expect(valid_errors).to include(error.class)
+          it 'raises an error' do
+            expect(valid_errors).to include(error.class)
+          end
         end
-      end
 
-      context 'when the uri is valid', unless: test.raise_error? do
+        context 'when the uri is valid', unless: test.raise_error? do
 
-        it 'does not raise an exception' do
-          expect(test.uri).to be_a(Mongo::URI::SRVProtocol)
-        end
+          it 'does not raise an exception' do
+            expect(test.uri).to be_a(Mongo::URI::SRVProtocol)
+          end
 
-        it 'creates a client with the correct hosts' do
-          expect(test.client).to have_hosts(test)
-        end
+          it 'creates a client with the correct hosts' do
+            expect(test.client).to have_hosts(test)
+          end
 
-        it 'creates a client with the correct options' do
-          expect(test.client).to match_options(test)
+          it 'creates a client with the correct options' do
+            expect(test.client).to match_options(test)
+          end
         end
       end
     end