mongo 2.20.0 → 2.20.2

data/spec/integration/ocsp_verifier_spec.rb

@@ -9,6 +9,21 @@ describe Mongo::Socket::OcspVerifier do
   with_openssl_debug
   retry_test sleep: 5
 
+  def self.with_ocsp_responder(port = 8100, path = '/', &setup)
+    around do |example|
+      server = WEBrick::HTTPServer.new(Port: port)
+      server.mount_proc path, &setup
+      Thread.new { server.start }
+      begin
+        example.run
+      ensure
+        server.shutdown
+      end
+
+      ::Utils.wait_for_port_free(port, 5)
+    end
+  end
+
   shared_examples 'verifies' do
     context 'mri' do
       fails_on_jruby
@@ -173,21 +188,10 @@ describe Mongo::Socket::OcspVerifier do
 
     context 'one time' do
 
-      around do |example|
-        server = WEBrick::HTTPServer.new(Port: 8100)
-        server.mount_proc '/' do |req, res|
-          res.status = 303
-          res['locAtion'] = "http://localhost:8101#{req.path}"
-          res.body = "See http://localhost:8101#{req.path}"
-        end
-        Thread.new { server.start }
-        begin
-          example.run
-        ensure
-          server.shutdown
-        end
-
-        ::Utils.wait_for_port_free(8100, 5)
+      with_ocsp_responder do |req, res|
+        res.status = 303
+        res['locAtion'] = "http://localhost:8101#{req.path}"
+        res.body = "See http://localhost:8101#{req.path}"
       end
 
       include_context 'verifier', algorithm: algorithm
@@ -248,21 +252,10 @@ describe Mongo::Socket::OcspVerifier do
         port: 8101,
       )
 
-      around do |example|
-        server = WEBrick::HTTPServer.new(Port: 8100)
-        server.mount_proc '/' do |req, res|
-          res.status = 303
-          res['locAtion'] = req.path
-          res.body = "See #{req.path} indefinitely"
-        end
-        Thread.new { server.start }
-        begin
-          example.run
-        ensure
-          server.shutdown
-        end
-
-        ::Utils.wait_for_port_free(8100, 5)
+      with_ocsp_responder do |req, res|
+        res.status = 303
+        res['locAtion'] = req.path
+        res.body = "See #{req.path} indefinitely"
       end
 
       include_context 'verifier', algorithm: algorithm
@@ -274,85 +267,23 @@ describe Mongo::Socket::OcspVerifier do
 
     include_context 'verifier', algorithm: 'rsa'
 
-    context '40x / 50x' do
-      around do |example|
-        server = WEBrick::HTTPServer.new(Port: 8100)
-        server.mount_proc '/' do |req, res|
+    [400, 404, 500, 503].each do |code|
+      context "code #{code}" do
+        with_ocsp_responder do |req, res|
           res.status = code
           res.body = "HTTP #{code}"
         end
-        Thread.new { server.start }
-        begin
-          example.run
-        ensure
-          server.shutdown
-        end
-
-        ::Utils.wait_for_port_free(8100, 5)
-      end
-
-      [400, 404, 500, 503].each do |_code|
-        context "code #{_code}" do
-          let(:code) { _code }
-          include_examples 'does not verify'
-        end
-      end
-    end
-
-    context '204' do
-      around do |example|
-        server = WEBrick::HTTPServer.new(Port: 8100)
-        server.mount_proc '/' do |req, res|
-          res.status = 204
-        end
-        Thread.new { server.start }
-        begin
-          example.run
-        ensure
-          server.shutdown
-        end
 
-        ::Utils.wait_for_port_free(8100, 5)
-      end
-
-      context "code 204" do
-        let(:code) { 204 }
         include_examples 'does not verify'
       end
     end
-  end
-
-  context 'responder URI has no path' do
-    require_external_connectivity
-
-    # https://github.com/jruby/jruby-openssl/issues/210
-    fails_on_jruby
 
-    include_context 'basic verifier'
-
-    # The fake certificates all have paths in them for use with the ocsp mock.
-    # Use real certificates retrieved from Atlas for this test as they don't
-    # have a path in the OCSP URI (which the test also asserts).
-    # Note that these certificates expire in 3 months and need to be replaced
-    # with a more permanent solution.
-    # Use the spec/support/certificates/retrieve-atlas-cert script to retrieve
-    # current certificates from Atlas.
-    let(:cert_path) { File.join(File.dirname(__FILE__), '../support/certificates/atlas-ocsp.crt') }
-    let(:ca_cert_path) { File.join(File.dirname(__FILE__), '../support/certificates/atlas-ocsp-ca.crt') }
-    let(:cert_store) do
-      OpenSSL::X509::Store.new.tap do |store|
-        store.set_default_paths
+    context 'code 204' do
+      with_ocsp_responder do |req, res|
+        res.status = 204
       end
-    end
-
-    before do
-      verifier.ocsp_uris.length.should > 0
-      URI.parse(verifier.ocsp_uris.first).path.should == ''
-    end
 
-    it 'verifies' do
-      # TODO This test will fail if the certificate expires
-      expect(verifier.verify).to be(true), "If atlas-ocsp certificates have expired, run spec/support/certificates/retrieve-atlas-cert to get a new ones"
+      include_examples 'does not verify'
     end
   end
 end

data/spec/integration/reconnect_spec.rb

@@ -111,6 +111,10 @@ describe 'Client after reconnect' do
       # thread.kill should've similarly failed, but it doesn't.
       fails_on_jruby
 
+      # odd failures related to async on ruby <= 3.1, I suspect something
+      # with how fibers worked in those versions.
+      minimum_mri_version '3.2.0'
+
       it 'recreates SRV monitor' do
         wait_for_discovery
 
@@ -151,6 +155,10 @@ describe 'Client after reconnect' do
       # NotImplementedError: recvmsg_nonblock is not implemented
       fails_on_jruby
 
+      # odd failures related to async on ruby <= 3.1, I suspect something
+      # with how fibers worked in those versions.
+      minimum_mri_version '3.2.0'
+
       let(:uri) do
         "mongodb+srv://test-fake.test.build.10gen.cc/"
       end
@@ -181,8 +189,6 @@ describe 'Client after reconnect' do
       end
 
       around do |example|
-        require 'support/dns'
-
         rules = [
           ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
             [0, 0, 2799, 'localhost.test.build.10gen.cc'],

data/spec/integration/retryable_reads_errors_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe 'Retryable reads errors tests' do
+  retry_test
 
   let(:client) { authorized_client.with(options.merge(retry_reads: true)) }
 
@@ -73,31 +74,42 @@ describe 'Retryable reads errors tests' do
       client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
     end
 
-    it "retries on PoolClearedError" do
-      # After the first find fails, the pool is paused and retry is triggered.
-      # Now, a race is started between the second find acquiring a connection,
-      # and the first retrying the read. Now, retry reads cause the cluster to
-      # be rescanned and the pool to be unpaused, allowing the second checkout
-      # to succeed (when it should fail). Therefore we want the second find's
-      # check out to win the race. This gives the check out a little head start.
-      allow_any_instance_of(Mongo::Server::ConnectionPool).to receive(:ready).and_wrap_original do |m, *args, &block|
-        ::Utils.wait_for_condition(5) do
-          # check_out_results should contain:
-          # - find1 connection check out successful
-          # - pool cleared
-          # - find2 connection check out failed
-          # We wait here for the third event to happen before we ready the pool.
-          cmap_events.select do |e|
-            event_types.include?(e.class)
-          end.length >= 3
+    shared_examples_for 'retries on PoolClearedError' do
+      it "retries on PoolClearedError" do
+        # After the first find fails, the pool is paused and retry is triggered.
+        # Now, a race is started between the second find acquiring a connection,
+        # and the first retrying the read. Now, retry reads cause the cluster to
+        # be rescanned and the pool to be unpaused, allowing the second checkout
+        # to succeed (when it should fail). Therefore we want the second find's
+        # check out to win the race. This gives the check out a little head start.
+        allow_any_instance_of(Mongo::Server::ConnectionPool).to receive(:ready).and_wrap_original do |m, *args, &block|
+          ::Utils.wait_for_condition(5) do
+            # check_out_results should contain:
+            # - find1 connection check out successful
+            # - pool cleared
+            # - find2 connection check out failed
+            # We wait here for the third event to happen before we ready the pool.
+            cmap_events.select do |e|
+              event_types.include?(e.class)
+            end.length >= 3
+          end
+          m.call(*args, &block)
         end
-        m.call(*args, &block)
+        threads.map(&:join)
+        expect(check_out_results[0]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut)
+        expect(check_out_results[1]).to be_a(Mongo::Monitoring::Event::Cmap::PoolCleared)
+        expect(check_out_results[2]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
+        expect(find_events.length).to eq(3)
       end
-      threads.map(&:join)
-      expect(check_out_results[0]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut)
-      expect(check_out_results[1]).to be_a(Mongo::Monitoring::Event::Cmap::PoolCleared)
-      expect(check_out_results[2]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
-      expect(find_events.length).to eq(3)
+    end
+
+    it_behaves_like 'retries on PoolClearedError'
+
+    context 'legacy read retries' do
+
+      let(:client) { authorized_client.with(options.merge(retry_reads: false, max_read_retries: 1)) }
+
+      it_behaves_like 'retries on PoolClearedError'
     end
 
     after do

data/spec/integration/sdam_error_handling_spec.rb

@@ -8,6 +8,8 @@ describe 'SDAM error handling' do
 
   clean_slate
 
+  retry_test
+
   after do
     # Close all clients after every test to avoid leaking expectations into
     # subsequent tests because we set global assertions on sockets.

data/spec/integration/srv_monitoring_spec.rb

@@ -76,9 +76,8 @@ describe 'SRV Monitoring' do
     # NotImplementedError: recvmsg_nonblock is not implemented
     fails_on_jruby
 
-    before(:all) do
-      require 'support/dns'
-    end
+    # mock dns implementation doesn't play nice with 2.7, etc.
+    minimum_mri_version '3.0.0'
 
     around do |example|
       # Speed up the tests by listening on the fake ports we are using.

data/spec/integration/srv_spec.rb

@@ -12,10 +12,6 @@ describe 'SRV lookup' do
     # NotImplementedError: recvmsg_nonblock is not implemented
     fails_on_jruby
 
-    before(:all) do
-      require 'support/dns'
-    end
-
     let(:uri) do
       "mongodb+srv://test-fake.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true"
     end

data/spec/lite_spec_helper.rb

@@ -168,16 +168,6 @@ RSpec.configure do |config|
     end
   end
 
-  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
-    # Tests should take under 10 seconds ideally but it seems
-    # we have some that run for more than 10 seconds in CI.
-    config.around(:each) do |example|
-      TimeoutInterrupt.timeout(example_timeout_seconds, ExampleTimeout) do
-        example.run
-      end
-    end
-  end
-
   if SpecConfig.instance.ci?
     if defined?(Rfc::Rif)
       unless BSON::Environment.jruby?

data/spec/mongo/collection_crud_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe Mongo::Collection do
+  retry_test
 
   let(:subscriber) { Mrss::EventSubscriber.new }
 

data/spec/mongo/server/connection_spec.rb

@@ -583,6 +583,28 @@ describe Mongo::Server::Connection do
       end
     end
 
+    context 'when the server returns unknown saslSupportedMechs' do
+      min_server_version '4.0'
+
+      let(:connection) do
+        described_class.new(server, server.options.merge(connection_pool: pool))
+      end
+
+      before do
+        expect_any_instance_of(Mongo::Server::PendingConnection).to receive(:get_handshake_response).and_wrap_original do |original_method, *args|
+          original_method.call(*args).tap do |result|
+            if result.documents.first.fetch('saslSupportedMechs', nil).is_a?(Array)
+              result.documents.first['saslSupportedMechs'].append('unknownMechanism')
+            end
+          end
+        end
+      end
+
+      it 'does not raise an error' do
+        expect { connection.connect! }.not_to raise_error
+      end
+    end
+
   end
 
   describe '#disconnect!' do

data/spec/shared/CANDIDATE.md

@@ -0,0 +1,28 @@
+# Candidate Tasks
+
+When using the `candidate` rake tasks, you must make sure:
+
+1. You are using at least `git` version 2.49.0.
+2. You have the `gh` CLI tool installed.
+3. You are logged into `gh` with an account that has collaborator access to the repository.
+4. You have run `gh repo set-default` from the root of your local checkout to set the default repository to the canonical MongoDB repo.
+5. The `origin` remote for your local checkout is set to your own fork.
+6. The `upstream` remote for your local checkout is set to the canonical
+   MongoDB repo.
+
+Once configured, you can use the following commands:
+
+1. `rake candidate:prs` - This will list all pull requests that will be included in the next release. Any with `[?]` are unlabelled (or are not labelled with a recognized label). Otherwise, `[b]` means `bug`, `[f]` means `feature`, and `[x]` means `bcbreak`.
+2. `rake candidate:preview` - This will generate and display the release notes for the next release, based on the associated pull requests.
+3. `rake candidate:create` - This will create a new PR against the default repository, using the generated release notes as the description. The new PR will be given the `release-candidate` label.
+
+Then, after the release candidate PR is approved and merged, the release process will automatically bundle, sign, and release the new version.
+
+Once you've merged the PR, you can switch to the "Actions" tab for the repository on GitHub and look for the "Release" workflow (might be named differently), which should have triggered automatically. You can monitor the progress of the release there. If there are any problems, the workflow is generally safe to re-run after you've addressed them.
+
+Things to do after the release succeeds:
+
+1. Copy the release notes from the PR and create a new release announcement on the forums (https://www.mongodb.com/community/forums/c/announcements/driver-releases/110).
+2. If the release was not automatically announced in #ruby, copy a link to the GitHub release or MongoDB forum post there.
+3. Close the release in Jira.
+

data/spec/shared/lib/mrss/docker_runner.rb

@@ -282,7 +282,7 @@ module Mrss
 
     def num_exposed_ports
       case @env['TOPOLOGY'] || 'standalone'
-      when 'standalone'
+      when 'standalone', 'replica-set-single-node'
         1
       when 'replica-set'
         3