mongo 2.10.2 → 2.10.3

data/spec/mongo/bulk_write_spec.rb

@@ -1924,11 +1924,11 @@ describe Mongo::BulkWrite do
             end
 
             let(:first_txn_number) do
-              started_events[-2].command['txnNumber'].instance_variable_get(:@integer)
+              started_events[-2].command['txnNumber'].value
             end
 
             let(:second_txn_number) do
-              started_events[-1].command['txnNumber'].instance_variable_get(:@integer)
+              started_events[-1].command['txnNumber'].value
             end
 
             it 'inserts the documents' do

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

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

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

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

data/spec/mongo/cursor_spec.rb

@@ -301,7 +301,7 @@ describe Mongo::Cursor do
         Mongo::Collection::View.new(
             authorized_collection,
             {},
-            :batch_size => 2
+            :batch_size => 2,
         )
       end
 
@@ -312,9 +312,9 @@ describe Mongo::Cursor do
 
       it 'schedules a kill cursors op' do
         cluster.instance_variable_get(:@periodic_executor).flush
-        expect {
+        expect do
           cursor.to_a
-        }.to raise_exception(Mongo::Error::OperationFailure, /[cC]ursor.*not found/)
+        end.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

data/spec/mongo/retryable_spec.rb

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

data/spec/runners/sdam/verifier.rb

@@ -0,0 +1,88 @@
+module Sdam
+  class Verifier
+    include RSpec::Matchers
+
+    def verify_sdam_event(expected_events, actual_events, i)
+      expect(expected_events.length).to be > i
+      expect(actual_events.length).to be > i
+
+      expected_event = expected_events[i]
+      actual_event = actual_events[i]
+
+      actual_event_name = Utils.underscore(actual_event.class.name.sub(/.*::/, ''))
+      actual_event_name = actual_event_name.to_s.sub('topology_changed', 'topology_description_changed') + '_event'
+      expect(actual_event_name).to eq(expected_event.name)
+
+      send("verify_#{expected_event.name}", expected_event, actual_event)
+    end
+
+    def verify_topology_opening_event(expected, actual)
+      expect(actual.topology).not_to be nil
+    end
+
+    def verify_topology_description_changed_event(expected, actual)
+      verify_topology_matches(expected.data['previousDescription'], actual.previous_topology)
+      verify_topology_matches(expected.data['newDescription'], actual.new_topology)
+    end
+
+    def verify_topology_matches(expected, actual)
+      expected_type = ::Mongo::Cluster::Topology.const_get(expected['topologyType'])
+      expect(actual).to be_a(expected_type)
+
+      expect(actual.replica_set_name).to eq(expected['setName'])
+
+      expected['servers'].each do |server|
+        desc = actual.server_descriptions[server['address'].to_s]
+        expect(desc).not_to be nil
+        verify_description_matches(server, desc)
+      end
+
+      actual.server_descriptions.keys.each do |address_str|
+        expect(
+          expected['servers'].any? { |server| server['address'] == address_str }
+        ).to be true
+      end
+    end
+
+    def verify_server_opening_event(expected, actual)
+      expect(actual.address.to_s).to eq(expected.data['address'])
+    end
+
+    def verify_server_description_changed_event(expected, actual)
+      verify_description_matches(expected.data['previousDescription'], actual.previous_description)
+      verify_description_matches(expected.data['newDescription'], actual.new_description)
+    end
+
+    def verify_description_matches(expected, actual)
+      case expected['type']
+      when 'Standalone'
+        expect(actual).to be_standalone
+      when 'RSPrimary'
+        expect(actual).to be_primary
+      when 'RSSecondary'
+        expect(actual).to be_secondary
+      when 'RSArbiter'
+        expect(actual).to be_arbiter
+      when 'Mongos'
+        expect(actual).to be_mongos
+      when 'Unknown', 'PossiblePrimary'
+        expect(actual).to be_unknown
+      when 'RSGhost'
+        expect(actual).to be_ghost
+      when 'RSOther'
+        expect(actual).to be_other
+      end
+
+      expect(actual.address.to_s).to eq(expected['address'])
+      expect(actual.arbiters).to eq(expected['arbiters'])
+      expect(actual.hosts).to eq(expected['hosts'])
+      expect(actual.passives).to eq(expected['passives'])
+      expect(actual.primary_host).to eq(expected['primary'])
+      expect(actual.replica_set_name).to eq(expected['setName'])
+    end
+
+    def verify_server_closed_event(expected, actual)
+      expect(actual.address.to_s).to eq(expected.data['address'])
+    end
+  end
+end

data/spec/spec_tests/retryable_reads_spec.rb

@@ -12,3 +12,34 @@ describe 'Retryable reads spec tests' do
     end
   end
 end
+
+describe 'Retryable reads spec tests - legacy' do
+  require_no_multi_shard
+
+  define_crud_spec_tests(RETRYABLE_READS_TESTS) do |spec, req, test|
+    let(:client_options) do
+      {
+        max_read_retries: 1,
+        read_retry_interval: 0,
+        retry_reads: false,
+      }.update(test.client_options)
+    end
+
+    let(:client) do
+      authorized_client.with(client_options).tap do |client|
+        client.subscribe(Mongo::Monitoring::COMMAND, event_subscriber)
+      end
+    end
+
+    around do |example|
+      desc = example.full_description
+      # Skip tests that disable modern retryable reads because they expect
+      # no retries - and since legacy retryable reads are used, the tests
+      # will fail.
+      if desc =~/retryReads is false|fails on first attempt/
+        skip 'Test not applicable to legacy read retries'
+      end
+      example.run
+    end
+  end
+end

data/spec/spec_tests/sdam_monitoring_spec.rb

@@ -1,5 +1,7 @@
 require 'lite_spec_helper'
 
+require_relative '../runners/sdam/verifier'
+
 describe 'SDAM Monitoring' do
   include Mongo::SDAM
 
@@ -67,12 +69,15 @@ describe 'SDAM Monitoring' do
             expect(@subscriber.phase_events(phase_index).length).to eq(phase.outcome.events.length)
           end
 
+          let(:verifier) do
+            Sdam::Verifier.new
+          end
+
           phase.outcome.events.each_with_index do |expectation, index|
 
-            it "expects a #{expectation.name} to be published" do
-              published_event = @subscriber.phase_events(phase_index)[index]
-              expect(published_event).not_to be_nil
-              expect(published_event).to match_sdam_monitoring_event(expectation)
+            it "expects event #{index+1} to be #{expectation.name}" do
+              verifier.verify_sdam_event(
+                phase.outcome.events, @subscriber.phase_events(phase_index), index)
             end
           end
         end

data/spec/support/cluster_tools.rb

@@ -142,6 +142,7 @@ class ClusterTools
   # - call step down on the existing primary
   # - call step up on the target in a loop until it becomes the primary
   def change_primary
+    start = Time.now
     existing_primary = admin_client.cluster.next_primary
     existing_primary_address = existing_primary.address
 
@@ -171,7 +172,7 @@ class ClusterTools
     persistently_step_up(target.address)
 
     new_primary = admin_client.cluster.next_primary
-    puts "#{Time.now} [CT] Primary changed to #{new_primary.address}"
+    puts "#{Time.now} [CT] Primary changed to #{new_primary.address}. Time to change primaries: #{Time.now - start}"
   end
 
   def persistently_step_up(address)
@@ -348,8 +349,6 @@ class ClusterTools
     end
   end
 
-  private
-
   def each_server(&block)
     admin_client.cluster.servers_list.each(&block)
   end
@@ -360,6 +359,8 @@ class ClusterTools
     end
   end
 
+  private
+
   def reset_server_states
     each_server do |server|
       server.unknown!

data/spec/support/command_monitoring.rb

@@ -134,6 +134,11 @@ module Mongo
         end
         if expected.keys.first == '$numberLong'
           converted = expected.values.first.to_i
+          if actual.is_a?(BSON::Int64)
+            actual = actual.value
+          elsif actual.is_a?(BSON::Int32)
+            return false
+          end
           (actual == converted) || actual >= 0
         else
           expected.each do |key, value|

data/spec/support/event_subscriber.rb

@@ -44,6 +44,13 @@ class EventSubscriber
       end
     end
 
+    # Filters command started events for the specified command name.
+    def command_started_events(command_name)
+      started_events.select do |event|
+        event.command[command_name]
+      end
+    end
+
     # Locates command stated events for the specified command name,
     # asserts that there is exactly one such event, and returns it.
     def single_command_started_event(command_name)

data/spec/support/sdam_monitoring.rb

@@ -13,123 +13,8 @@
 # limitations under the License.
 #
 
-RSpec::Matchers.define :match_topology_opening_event do |expectation|
-
-  match do |event|
-    event.is_a?(Mongo::Monitoring::Event::TopologyOpening) &&
-      event.topology != nil
-  end
-end
-
-RSpec::Matchers.define :match_topology_description_changed_event do |expectation|
-  include Mongo::SDAMMonitoring::Matchable
-
-  match do |event|
-    event.is_a?(Mongo::Monitoring::Event::TopologyChanged) &&
-      topologies_match?(event, expectation)
-  end
-end
-
-RSpec::Matchers.define :match_server_opening_event do |expectation|
-
-  match do |event|
-    event.is_a?(Mongo::Monitoring::Event::ServerOpening) &&
-      event.address.to_s == expectation.data['address']
-  end
-end
-
-RSpec::Matchers.define :match_server_description_changed_event do |expectation|
-  include Mongo::SDAMMonitoring::Matchable
-
-  match do |event|
-    event.is_a?(Mongo::Monitoring::Event::ServerDescriptionChanged) &&
-      descriptions_match?(event, expectation)
-  end
-end
-
-RSpec::Matchers.define :match_server_closed_event do |expectation|
-
-  match do |event|
-    event.is_a?(Mongo::Monitoring::Event::ServerClosed) &&
-      event.address.to_s == expectation.data['address']
-  end
-end
-
-RSpec::Matchers.define :match_sdam_monitoring_event do |expectation|
-
-  match do |event|
-    expect(event).to send("match_#{expectation.name}", expectation)
-  end
-end
-
 module Mongo
   module SDAMMonitoring
-    module Matchable
-
-      def descriptions_match?(event, expectation)
-        description_matches?(event.previous_description, expectation.data['previousDescription']) &&
-          description_matches?(event.new_description, expectation.data['newDescription'])
-      end
-
-      def topologies_match?(event, expectation)
-        unless topology_matches?(event.previous_topology, expectation.data['previousDescription'])
-          if ENV['VERBOSE_MATCHERS']
-            $stderr.puts "Previous topology mismatch"
-          end
-          return false
-        end
-        unless topology_matches?(event.new_topology, expectation.data['newDescription'])
-          if ENV['VERBOSE_MATCHERS']
-            $stderr.puts "New topology mismatch:\nHave: #{event.new_topology}\nWant: #{expectation.data['newDescription']}"
-          end
-          return false
-        end
-        true
-      end
-
-      def description_matches?(actual, expected)
-        type_ok = case expected['type']
-          when 'Standalone' then actual.standalone?
-          when 'RSPrimary' then actual.primary?
-          when 'RSSecondary' then actual.secondary?
-          when 'RSArbiter' then actual.arbiter?
-          when 'Mongos' then actual.mongos?
-          when 'Unknown' then actual.unknown?
-          when 'PossiblePrimary' then actual.unknown?
-          when 'RSGhost' then actual.ghost?
-          when 'RSOther' then actual.other?
-        end
-        return false unless type_ok
-
-        return false if actual.address.to_s != expected['address']
-        return false if actual.arbiters != expected['arbiters']
-        return false if actual.hosts != expected['hosts']
-        return false if actual.passives != expected['passives']
-        return false if actual.primary_host != expected['primary']
-        return false if actual.replica_set_name != expected['setName']
-        true
-      end
-
-      def topology_matches?(actual, expected)
-        expected_type = ::Mongo::Cluster::Topology.const_get(expected['topologyType'])
-        return false unless actual.is_a?(expected_type)
-
-        return false unless actual.replica_set_name == expected['setName']
-
-        expected['servers'].each do |server|
-          desc = actual.server_descriptions[server['address'].to_s]
-          return false unless description_matches?(desc, server)
-        end
-
-        actual.server_descriptions.keys.each do |address_str|
-          unless expected['servers'].any? { |server| server['address'] == address_str }
-            return false
-          end
-        end
-
-        true
-      end
-    end
 
     # Test subscriber for SDAM monitoring.
     #