mongo 2.12.1 → 2.13.0

data/spec/spec_tests/max_staleness_spec.rb

@@ -1,145 +1,9 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
-describe 'Max Staleness Spec' do
+require 'runners/server_selection'
 
-  include Mongo::ServerSelection::Read
+MAX_STALENESS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/max_staleness/**/*.yml").sort
 
-  MAX_STALENESS_TESTS.each do |file|
-
-    spec = Mongo::ServerSelection::Read::Spec.new(file)
-
-    context(spec.description) do
-      # Cluster needs a topology and topology needs a cluster...
-      # This temporary cluster is used for topology construction.
-      let(:temp_cluster) do
-        double('temp cluster').tap do |cluster|
-          allow(cluster).to receive(:servers_list).and_return([])
-        end
-      end
-
-      let(:topology) do
-        options = if spec.type <= Mongo::Cluster::Topology::ReplicaSetNoPrimary
-          {replica_set_name: 'foo'}
-        else
-          {}
-        end
-        spec.type.new(options, monitoring, temp_cluster)
-      end
-
-      let(:monitoring) do
-        Mongo::Monitoring.new(monitoring: false)
-      end
-
-      let(:listeners) do
-        Mongo::Event::Listeners.new
-      end
-
-      let(:options) do
-        if spec.heartbeat_frequency
-          SpecConfig.instance.test_options.merge(heartbeat_frequency: spec.heartbeat_frequency)
-        else
-          SpecConfig.instance.test_options.dup.tap do |opts|
-            opts.delete(:heartbeat_frequency)
-          end
-        end.merge!(server_selection_timeout: 0.2, connect_timeout: 0.1)
-      end
-
-      let(:cluster) do
-        double('cluster').tap do |c|
-          allow(c).to receive(:connected?).and_return(true)
-          allow(c).to receive(:summary)
-          allow(c).to receive(:topology).and_return(topology)
-          allow(c).to receive(:single?).and_return(topology.single?)
-          allow(c).to receive(:sharded?).and_return(topology.sharded?)
-          allow(c).to receive(:replica_set?).and_return(topology.replica_set?)
-          allow(c).to receive(:unknown?).and_return(topology.unknown?)
-          allow(c).to receive(:options).and_return(options)
-          allow(c).to receive(:scan!).and_return(true)
-          allow(c).to receive(:app_metadata).and_return(app_metadata)
-          allow(c).to receive(:heartbeat_interval).and_return(
-            spec.heartbeat_frequency || Mongo::Server::Monitor::HEARTBEAT_FREQUENCY)
-        end
-      end
-
-      let(:candidate_servers) do
-        spec.candidate_servers.collect do |server|
-          features = double('features').tap do |feat|
-            allow(feat).to receive(:max_staleness_enabled?).and_return(server['maxWireVersion'] && server['maxWireVersion'] >= 5)
-            allow(feat).to receive(:check_driver_support!).and_return(true)
-          end
-          address = Mongo::Address.new(server['address'])
-          Mongo::Server.new(address, cluster, monitoring, listeners,
-            {monitoring_io: false}.update(options)
-          ).tap do |s|
-            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0) if server['avg_rtt_ms']
-            allow(s).to receive(:tags).and_return(server['tags'])
-            allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
-            allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
-            allow(s).to receive(:connectable?).and_return(true)
-            allow(s).to receive(:last_write_date).and_return(
-              Time.at(server['lastWrite']['lastWriteDate']['$numberLong'].to_f / 1000)) if server['lastWrite']
-            allow(s).to receive(:last_scan).and_return(
-              Time.at(server['lastUpdateTime'].to_f / 1000))
-            allow(s).to receive(:features).and_return(features)
-          end
-        end
-      end
-
-      let(:in_latency_window) do
-        spec.in_latency_window.collect do |server|
-          Mongo::Server.new(Mongo::Address.new(server['address']), cluster, monitoring, listeners,
-            options.merge(monitoring_io: false))
-        end
-      end
-
-      let(:server_selector_definition) do
-        { mode: spec.read_preference['mode'] }.tap do |definition|
-          definition[:tag_sets] = spec.read_preference['tag_sets']
-          definition[:max_staleness] = spec.max_staleness if spec.max_staleness
-        end
-      end
-
-      let(:server_selector) do
-        Mongo::ServerSelector.get(server_selector_definition)
-      end
-
-      before do
-        allow(cluster).to receive(:servers).and_return(candidate_servers)
-        allow(cluster).to receive(:addresses).and_return(candidate_servers.map(&:address))
-      end
-
-      context 'when the max staleness is invalid' do
-
-        it 'Raises an InvalidServerPreference exception', if: spec.invalid_max_staleness? do
-
-          expect do
-            server_selector.select_server(cluster)
-          end.to raise_exception(Mongo::Error::InvalidServerPreference)
-        end
-      end
-
-      context 'when the max staleness is valid' do
-
-        context 'when there are available servers' do
-
-          it 'Finds all suitable servers in the latency window', if: (spec.replica_set? && !spec.invalid_max_staleness? && spec.server_available?) do
-            expect(server_selector.send(:select, cluster.servers)).to match_array(in_latency_window)
-          end
-
-          it 'Finds the most suitable server in the latency window', if: (!spec.invalid_max_staleness? && spec.server_available?) do
-            expect(in_latency_window).to include(server_selector.select_server(cluster))
-          end
-        end
-
-        context 'when there are no available servers', if: (!spec.invalid_max_staleness? && !spec.server_available?) do
-
-          it 'Raises a NoServerAvailable Exception' do
-            expect do
-              server_selector.select_server(cluster)
-            end.to raise_exception(Mongo::Error::NoServerAvailable)
-          end
-        end
-      end
-    end
-  end
+describe 'Max staleness spec tests' do
+  define_server_selection_spec_tests(MAX_STALENESS_TESTS)
 end

data/spec/spec_tests/read_write_concern_connection_string_spec.rb

@@ -1,5 +1,7 @@
 require 'lite_spec_helper'
 
+require 'runners/connection_string'
+
 READ_WRITE_CONCERN_CONNECTION_STRING_TESTS =
   Dir.glob("#{CURRENT_PATH}/spec_tests/data/read_write_concern/connection-string/*.yml").sort
 

data/spec/spec_tests/read_write_concern_operaton_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+require 'runners/crud'
+require 'runners/transactions'
+
+test_paths = Dir.glob("#{CURRENT_PATH}/spec_tests/data/read_write_concern/operation/**/*.yml").sort
+
+describe 'Read write concern operation spec tests' do
+  define_transactions_spec_tests(test_paths)
+end

data/spec/spec_tests/retryable_reads_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
+require 'runners/crud'
+
 describe 'Retryable reads spec tests' do
   require_wired_tiger
   require_no_multi_shard
 
   define_crud_spec_tests(RETRYABLE_READS_TESTS) do |spec, req, test|
     let(:client) do
-      authorized_client.with({max_read_retries: 0}.update(test.client_options)).tap do |client|
+      authorized_client.use(spec.database_name).with({max_read_retries: 0}.update(test.client_options)).tap do |client|
         client.subscribe(Mongo::Monitoring::COMMAND, event_subscriber)
       end
     end
@@ -26,7 +28,7 @@ describe 'Retryable reads spec tests - legacy' do
     end
 
     let(:client) do
-      authorized_client.with(client_options).tap do |client|
+      authorized_client.use(spec.database_name).with(client_options).tap do |client|
         client.subscribe(Mongo::Monitoring::COMMAND, event_subscriber)
       end
     end

data/spec/spec_tests/retryable_writes_spec.rb

@@ -1,12 +1,19 @@
 require 'spec_helper'
 
+require 'runners/crud'
+
 describe 'Retryable writes spec tests' do
   require_wired_tiger
   require_no_multi_shard
 
   define_crud_spec_tests(RETRYABLE_WRITES_TESTS) do |spec, req, test|
     let(:client) do
-      authorized_client_with_retry_writes
+      # Evergreen allows a RETRY_WRITES environment variable to be specified,
+      # which determines whether authorized_client has retry_writes enabled by default.
+      # The line below ensures that the retryable_write spec tests still work,
+      # even if retryable writes was initially disabled for this client, by
+      # enabling retry_writes by default, which is the standard driver behavior.
+      authorized_client.with({ retry_writes: true }.merge(test.client_options))
     end
   end
 end

data/spec/spec_tests/sdam_integration_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+require 'runners/crud'
+require 'runners/transactions'
+
+SDAM_INTEGRATION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam_integration/*.yml").sort
+
+describe 'SDAM integration tests' do
+  require_no_multi_shard
+  require_wired_tiger
+
+  define_transactions_spec_tests(SDAM_INTEGRATION_TESTS)
+end

data/spec/spec_tests/sdam_monitoring_spec.rb

@@ -1,6 +1,7 @@
 require 'lite_spec_helper'
 
-require_relative '../runners/sdam/verifier'
+require 'runners/sdam'
+require 'runners/sdam/verifier'
 
 describe 'SDAM Monitoring' do
   include Mongo::SDAM
@@ -12,7 +13,7 @@ describe 'SDAM Monitoring' do
     context("#{spec.description} (#{file.sub(%r'.*/data/sdam_monitoring/', '')})") do
 
       before(:all) do
-        @subscriber = Mongo::SDAMMonitoring::PhasedTestSubscriber.new
+        @subscriber = PhasedEventSubscriber.new
         sdam_proc = lambda do |client|
           client.subscribe(Mongo::Monitoring::SERVER_OPENING, @subscriber)
           client.subscribe(Mongo::Monitoring::SERVER_CLOSED, @subscriber)

data/spec/spec_tests/sdam_spec.rb

@@ -1,8 +1,19 @@
 require 'lite_spec_helper'
 
+require 'runners/sdam'
+require 'runners/sdam/verifier'
+
 describe 'Server Discovery and Monitoring' do
   include Mongo::SDAM
 
+  class Executor
+    include Mongo::Operation::Executable
+
+    def session
+      nil
+    end
+  end
+
   SERVER_DISCOVERY_TESTS.each do |file|
 
     spec = Mongo::SDAM::Spec.new(file)
@@ -37,6 +48,27 @@ describe 'Server Discovery and Monitoring' do
         @client && @client.close
       end
 
+      def raise_application_error(error, connection = nil)
+        case error.type
+        when :network
+          exc = Mongo::Error::SocketError.new
+          exc.generation = error.generation
+          raise exc
+        when :timeout
+          exc = Mongo::Error::SocketTimeoutError.new
+          exc.generation = error.generation
+          raise exc
+        when :command
+          result = error.result
+          if error.generation
+            allow(connection).to receive(:generation).and_return(error.generation)
+          end
+          Executor.new.send(:process_result_for_sdam, result, connection)
+        else
+          raise NotImplementedError, "Error type #{error.type} is not implemented"
+        end
+      end
+
       spec.phases.each_with_index do |phase, index|
 
         context("Phase: #{index + 1}") do
@@ -44,7 +76,7 @@ describe 'Server Discovery and Monitoring' do
           before do
             allow(@client.cluster).to receive(:connected?).and_return(true)
 
-            phase.responses.each do |response|
+            phase.responses&.each do |response|
               server = find_server(@client, response.address)
               unless server
                 server = Mongo::Server.new(
@@ -66,6 +98,35 @@ describe 'Server Discovery and Monitoring' do
                 server.description.address, result, 0.5)
               @client.cluster.run_sdam_flow(server.description, new_description)
             end
+
+            phase.application_errors&.each do |error|
+              server = find_server(@client, error.address_str)
+              unless server
+                raise NotImplementedError, 'Errors can only be produced on known servers'
+              end
+
+              begin
+                case error.when
+                when :before_handshake_completes
+                  connection = Mongo::Server::Connection.new(server,
+                    generation: server.pool.generation)
+                  server.handle_handshake_failure! do
+                    raise_application_error(error, connection)
+                  end
+                when :after_handshake_completes
+                  connection = Mongo::Server::Connection.new(server,
+                    generation: server.pool.generation)
+                  allow(connection).to receive(:description).and_return(server.description)
+                  connection.send(:handle_errors) do
+                    raise_application_error(error, connection)
+                  end
+                else
+                  raise NotImplementedError, "Error position #{error.when} is not implemented"
+                end
+              rescue Mongo::Error
+                # This was the exception we raised
+              end
+            end
           end
 
           if phase.outcome.compatible?
@@ -131,6 +192,14 @@ describe 'Server Discovery and Monitoring' do
                   end
                 end
               end
+
+              let(:verifier) { Sdam::Verifier.new }
+
+              it "#{address_str} server description has expected values" do
+                actual = @client.cluster.topology.server_descriptions[address_str]
+
+                verifier.verify_description_matches(server_spec, actual)
+              end
             end
 
             if %w(ReplicaSetWithPrimary ReplicaSetNoPrimary).include?(phase.outcome.topology_type)

data/spec/spec_tests/server_selection_rtt_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+require 'runners/server_selection_rtt'
+
 describe 'Server Selection moving average round trip time calculation' do
 
   include Mongo::ServerSelection::RTT

data/spec/spec_tests/server_selection_spec.rb

@@ -1,119 +1,9 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
-describe 'Server Selection' do
+require 'runners/server_selection'
 
-  include Mongo::ServerSelection::Read
+SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection/**/*.yml").sort
 
-  SERVER_SELECTION_TESTS.each do |file|
-
-    spec = Mongo::ServerSelection::Read::Spec.new(file)
-
-    context(spec.description) do
-
-      let(:monitoring) do
-        Mongo::Monitoring.new(monitoring: false)
-      end
-
-      # Cluster needs a topology and topology needs a cluster...
-      # This temporary cluster is used for topology construction.
-      let(:temp_cluster) do
-        double('temp cluster').tap do |cluster|
-          allow(cluster).to receive(:servers_list).and_return([])
-        end
-      end
-
-      let(:topology) do
-        options = if spec.type <= Mongo::Cluster::Topology::ReplicaSetNoPrimary
-          {replica_set_name: 'foo'}
-        else
-          {}
-        end
-        spec.type.new(options, monitoring, temp_cluster)
-      end
-
-      let(:listeners) do
-        Mongo::Event::Listeners.new
-      end
-
-      let(:cluster) do
-        double('cluster').tap do |c|
-          allow(c).to receive(:connected?).and_return(true)
-          allow(c).to receive(:summary)
-          allow(c).to receive(:topology).and_return(topology)
-          allow(c).to receive(:single?).and_return(topology.single?)
-          allow(c).to receive(:sharded?).and_return(topology.sharded?)
-          allow(c).to receive(:replica_set?).and_return(topology.replica_set?)
-          allow(c).to receive(:unknown?).and_return(topology.unknown?)
-          allow(c).to receive(:app_metadata).and_return(app_metadata)
-          allow(c).to receive(:options).and_return({})
-          allow(c).to receive(:server_selection_semaphore).and_return(nil)
-        end
-      end
-
-      let(:candidate_servers) do
-        spec.candidate_servers.collect do |server|
-          address = Mongo::Address.new(server['address'])
-          Mongo::Server.new(address, cluster, monitoring, listeners,
-            {monitoring_io: false}.update(SpecConfig.instance.test_options)
-          ).tap do |s|
-            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0)
-            allow(s).to receive(:tags).and_return(server['tags'])
-            allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
-            allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
-            allow(s).to receive(:connectable?).and_return(true)
-            allow(s).to receive(:check_driver_support!).and_return(true)
-          end
-        end
-      end
-
-      let(:in_latency_window) do
-        spec.in_latency_window.collect do |server|
-          address = Mongo::Address.new(server['address'])
-          Mongo::Server.new(address, cluster, monitoring, listeners,
-            {monitoring_io: false}.update(SpecConfig.instance.test_options)
-          ).tap do |s|
-            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0)
-            allow(s).to receive(:tags).and_return(server['tags'])
-            allow(s).to receive(:connectable?).and_return(true)
-            allow(s).to receive(:check_driver_support!).and_return(true)
-          end
-        end
-      end
-
-      let(:server_selector) do
-        Mongo::ServerSelector.get(:mode => spec.read_preference['mode'],
-                                  :tag_sets => spec.read_preference['tag_sets'])
-      end
-
-      before do
-        allow(cluster).to receive(:servers).and_return(candidate_servers)
-        allow(cluster).to receive(:servers_list).and_return(candidate_servers)
-        allow(cluster).to receive(:addresses).and_return(candidate_servers.map(&:address))
-        allow(cluster).to receive(:options).and_return(server_selection_timeout: 0.2)
-        allow(cluster).to receive(:scan!).and_return(true)
-        allow(cluster).to receive(:app_metadata).and_return(app_metadata)
-      end
-
-      context 'Valid read preference and matching server available', if: spec.server_available? do
-
-        it 'Finds all suitable servers in the latency window', if: spec.replica_set? do
-          expect(server_selector.send(:select, cluster.servers)).to match_array(in_latency_window)
-        end
-
-        it 'Finds the most suitable server in the latency window' do
-          expect(in_latency_window).to include(server_selector.select_server(cluster))
-        end
-      end
-
-      context 'No matching server available', if: !spec.server_available? do
-        skip_if_linting
-
-        it 'Raises exception' do
-          expect do
-            server_selector.select_server(cluster)
-          end.to raise_exception(Mongo::Error::NoServerAvailable)
-        end
-      end
-    end
-  end
+describe 'Server selection spec tests' do
+  define_server_selection_spec_tests(SERVER_SELECTION_TESTS)
 end