mongo 2.15.0 → 2.18.1

data/spec/mongo/server/description_spec.rb

@@ -331,7 +331,7 @@ describe Mongo::Server::Description do
       describe '#average_round_trip_time' do
 
         let(:description) do
-          described_class.new(address, { 'secondary' => false }, 4.5)
+          described_class.new(address, { 'secondary' => false }, average_round_trip_time: 4.5)
         end
 
         it 'defaults to nil' do

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

@@ -136,6 +136,28 @@ describe Mongo::Server::Monitor::Connection do
     end
   end
 
+  describe '#connect!' do
+
+    let(:options) do
+      SpecConfig.instance.test_options.merge(
+        app_metadata: monitor_app_metadata,
+      )
+    end
+
+    context 'when address resolution fails' do
+      let(:connection) { described_class.new(server.address, options) }
+
+      it 'propagates the exception' do
+        connection
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          connection.connect!
+        end.should raise_error(SocketError, 'Test exception')
+      end
+    end
+  end
+
   describe '#check_document' do
     context 'with API version' do
       let(:meta) do

data/spec/mongo/server/monitor_spec.rb

@@ -186,16 +186,17 @@ describe Mongo::Server::Monitor do
     context 'when running after a stop' do
       it 'starts the thread' do
         ClientRegistry.instance.close_all_clients
+        sleep 1
         thread
-        sleep 0.5
+        sleep 1
 
         RSpec::Mocks.with_temporary_scope do
           expect(monitor.connection).to receive(:disconnect!).and_call_original
           monitor.stop!
-          sleep 0.5
+          sleep 1
           expect(thread.alive?).to be false
           new_thread = monitor.run!
-          sleep 0.5
+          sleep 1
           expect(new_thread.alive?).to be(true)
         end
       end

data/spec/mongo/server/push_monitor_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Server::PushMonitor do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  let(:address) do
+    default_address
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:monitor_options) 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)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+    end
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, Mongo::Monitoring.new, listeners,
+      monitoring_io: false)
+  end
+
+  let(:monitor) do
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, listeners, Mongo::Monitoring.new,
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
+    )
+  end
+
+  let(:topology_version) do
+    Mongo::TopologyVersion.new('processId' => BSON::ObjectId.new, 'counter' => 1)
+  end
+
+  let(:check_document) do
+    {hello: 1}
+  end
+
+  let(:push_monitor) do
+    described_class.new(monitor, topology_version, monitor.monitoring,
+      **monitor.options.merge(check_document: check_document))
+  end
+
+  describe '#do_work' do
+    it 'works' do
+      lambda do
+        push_monitor.do_work
+      end.should_not raise_error
+    end
+
+    context 'network error during check' do
+      it 'does not propagate the exception' do
+        push_monitor
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+      end
+
+      it 'stops the monitoring' do
+        push_monitor
+
+        start = Mongo::Utils.monotonic_time
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        push_monitor.running?.should be false
+      end
+    end
+  end
+
+end

data/spec/mongo/server_selector_spec.rb

@@ -202,12 +202,7 @@ describe Mongo::ServerSelector do
   describe "#select_server" do
     require_no_linting
 
-    context 'when #select_in_replica_set returns a list of nils' do
-
-      let(:servers) do
-        [ make_server(:primary) ]
-      end
-
+    context 'replica set topology' do
       let(:cluster) do
         double('cluster').tap do |c|
           allow(c).to receive(:connected?).and_return(true)
@@ -223,19 +218,141 @@ describe Mongo::ServerSelector do
           allow(c).to receive(:scan!).and_return(true)
           allow(c).to receive(:options).and_return(server_selection_timeout: 0.1)
           allow(c).to receive(:server_selection_semaphore).and_return(nil)
+          allow(topology).to receive(:compatible?).and_return(true)
         end
       end
 
-      let(:read_pref) do
-        described_class.get(mode: :primary).tap do |pref|
-          allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+      let(:primary) do
+        make_server(:primary).tap do |server|
+          allow(server).to receive(:features).and_return(double("primary features"))
         end
       end
 
-      it 'raises a NoServerAvailable error' do
-        expect do
-          read_pref.select_server(cluster)
-        end.to raise_exception(Mongo::Error::NoServerAvailable)
+      let(:secondary) do
+        make_server(:secondary).tap do |server|
+          allow(server).to receive(:features).and_return(double("secondary features"))
+        end
+      end
+
+      context "when #select_in_replica_set returns a list of nils" do
+        let(:servers) do
+          [ primary ]
+        end
+
+        let(:read_pref) do
+          described_class.get(mode: :primary).tap do |pref|
+            allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+          end
+        end
+
+        it 'raises a NoServerAvailable error' do
+          expect do
+            read_pref.select_server(cluster)
+          end.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+
+      context "write_aggregation is true" do
+
+        before do
+          # It does not matter for this context whether primary supports secondary wites or not,
+          # but we need to mock out this call.
+          allow(primary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+        end
+
+        context "read preference is primary" do
+          let(:selector) { Mongo::ServerSelector::Primary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is primary preferred" do
+          let(:selector) { Mongo::ServerSelector::PrimaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is secondary preferred" do
+          let(:selector) { Mongo::ServerSelector::SecondaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
+
+        context "read preference is secondary" do
+          let(:selector) { Mongo::ServerSelector::Secondary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+
+          context "no secondaries in cluster" do
+            let(:servers) do
+              [ primary ]
+            end
+
+            it "selects a primary" do
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
       end
     end
 
@@ -381,8 +498,12 @@ describe Mongo::ServerSelector do
         let(:servers) { [unknown, mongos] }
         let(:selector) { described_class.primary }
 
-        it 'returns the mongos' do
-          expect(selector.select_server(cluster)).to eq(mongos)
+        [true, false].each do |write_aggregation|
+          context "write_aggregation is #{write_aggregation}" do
+            it 'returns the mongos' do
+              expect(selector.select_server(cluster, write_aggregation: write_aggregation)).to eq(mongos)
+            end
+          end
         end
       end
     end

data/spec/mongo/session/session_pool_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe Mongo::Session::SessionPool do
   min_server_fcv '3.6'
-  require_topology :replica_set, :sharded
+  require_topology :replica_set, :sharded, :load_balanced
   clean_slate_for_all
 
   let(:cluster) do
@@ -113,10 +113,26 @@ describe Mongo::Session::SessionPool do
           pool.checkout
         end
 
-        it 'disposes of the old session and returns a new one' do
-          expect(checked_out_session).not_to be(old_session_a)
-          expect(checked_out_session).not_to be(old_session_b)
-          expect(pool.instance_variable_get(:@queue)).to be_empty
+        context "in non load-balanced topology" do
+          require_topology :replica_set, :sharded
+
+          it 'disposes of the old session and returns a new one' do
+            old_sessions = [old_session_a, old_session_b]
+            expect(old_sessions).not_to include(pool.checkout)
+            expect(old_sessions).not_to include(pool.checkout)
+            expect(pool.instance_variable_get(:@queue)).to be_empty
+          end
+        end
+
+        context "in load-balanced topology" do
+          require_topology :load_balanced
+
+          it 'doed not dispose of the old session' do
+            old_sessions = [old_session_a, old_session_b]
+            expect(old_sessions).to include(checked_out_session)
+            expect(old_sessions).to include(checked_out_session)
+            expect(pool.instance_variable_get(:@queue)).to be_empty
+          end
         end
       end
     end
@@ -138,10 +154,26 @@ describe Mongo::Session::SessionPool do
         pool.checkin(old_session_b)
       end
 
-      it 'disposes of the old sessions instead of adding them to the pool' do
-        expect(pool.checkout).not_to be(old_session_a)
-        expect(pool.checkout).not_to be(old_session_b)
-        expect(pool.instance_variable_get(:@queue)).to be_empty
+      context "in non load-balanced topology" do
+        require_topology :replica_set, :sharded
+
+        it 'disposes of the old sessions instead of adding them to the pool' do
+          old_sessions = [old_session_a, old_session_b]
+          expect(old_sessions).not_to include(pool.checkout)
+          expect(old_sessions).not_to include(pool.checkout)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
+      end
+
+      context "in load-balanced topology" do
+        require_topology :load_balanced
+
+        it 'does not dispose of the old sessions' do
+          old_sessions = [old_session_a, old_session_b]
+          expect(old_sessions).to include(pool.checkout)
+          expect(old_sessions).to include(pool.checkout)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
       end
     end
   end
@@ -160,7 +192,7 @@ describe Mongo::Session::SessionPool do
       pool.checkout
     end
 
-    let(:subscriber) { EventSubscriber.new }
+    let(:subscriber) { Mrss::EventSubscriber.new }
 
     let(:client) do
       authorized_client.tap do |client|

data/spec/mongo/session_spec.rb

@@ -268,6 +268,21 @@ describe Mongo::Session do
         end.to raise_error(Mongo::Error::SessionEnded)
       end
     end
+
+    context "when the sesion is not materialized" do
+      let(:session) { authorized_client.get_session(implicit: true) }
+
+      before do
+        expect(session.materialized?).to be false
+      end
+
+      it "raises SessionNotMaterialized" do
+
+        expect do
+          session.session_id
+        end.to raise_error(Mongo::Error::SessionNotMaterialized)
+      end
+    end
   end
 
   describe '#txn_num' do
@@ -312,12 +327,12 @@ describe Mongo::Session do
   end
 
   describe '#start_session' do
-    context 'when block doesn\'t raise an error' do 
-      it 'closes the session after the block' do 
+    context 'when block doesn\'t raise an error' do
+      it 'closes the session after the block' do
         block_session = nil
-        authorized_client.start_session do |session| 
+        authorized_client.start_session do |session|
           expect(session.ended?).to be false
-          block_session = session 
+          block_session = session
         end
         expect(block_session.ended?).to be true
       end
@@ -326,7 +341,7 @@ describe Mongo::Session do
     context 'when block raises an error' do
       it 'closes the session after the block' do
         block_session = nil
-        expect do 
+        expect do
           authorized_client.start_session do |session|
             block_session = session
             raise 'This is an error!'
@@ -338,11 +353,16 @@ describe Mongo::Session do
 
     context 'when block returns value' do
       it 'is returned by the function' do
-        res = authorized_client.start_session do |session| 
+        res = authorized_client.start_session do |session|
           4
         end
         expect(res).to be 4
       end
     end
+
+    it 'returns a session with session id' do
+      session = authorized_client.start_session
+      session.session_id.should be_a(BSON::Document)
+    end
   end
 end

data/spec/mongo/session_transaction_spec.rb

@@ -117,25 +117,15 @@ describe Mongo::Session do
       max_example_run_time 7
 
       it 'times out' do
-        warp = Mongo::Utils.monotonic_time + 200
-        entered = false
+        start = Mongo::Utils.monotonic_time
 
-        Thread.new do
-          until entered
-            sleep 0.1
-          end
-          allow(Mongo::Utils).to receive(:monotonic_time).and_return(warp)
-        end
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 1)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 2)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
 
         expect do
           session.with_transaction do
-            entered = true
-
-            # This sleep is to give the interrupting thread a chance to run,
-            # it significantly affects how much time is burned in this
-            # looping thread
-            sleep 0.1
-
             exc = Mongo::Error::OperationFailure.new('timeout test')
             exc.add_label('TransientTransactionError')
             raise exc
@@ -148,21 +138,24 @@ describe Mongo::Session do
       context "timeout with commit raising with #{label}" do
         max_example_run_time 7
 
+        # JRuby seems to burn through the monotonic time expectations
+        # very quickly and the retries of the transaction get the original
+        # time which causes the transaction to be stuck there.
+        fails_on_jruby
+
         before do
           # create collection if it does not exist
           collection.insert_one(a: 1)
         end
 
+        retry_test
         it 'times out' do
-          warp = Mongo::Utils.monotonic_time + 200
-          entered = false
+          start = Mongo::Utils.monotonic_time
 
-          Thread.new do
-            until entered
-              sleep 0.1
-            end
-            allow(Mongo::Utils).to receive(:monotonic_time).and_return(warp)
+          10.times do |i|
+            expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + i)
           end
+          expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
 
           exc = Mongo::Error::OperationFailure.new('timeout test')
           exc.add_label(label)
@@ -171,13 +164,6 @@ describe Mongo::Session do
 
           expect do
             session.with_transaction do
-              entered = true
-
-              # This sleep is to give the interrupting thread a chance to run,
-              # it significantly affects how much time is burned in this
-              # looping thread
-              sleep 0.1
-
               collection.insert_one(a: 2)
             end
           end.to raise_error(Mongo::Error::OperationFailure, 'timeout test')