mongo 2.13.0.beta1 → 2.13.0.rc1

data/spec/integration/server_monitor_spec.rb

@@ -5,7 +5,11 @@ describe 'Server::Monitor' do
   let(:client) do
     new_local_client([ClusterConfig.instance.primary_address_str],
       SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options.merge(
-        heartbeat_frequency: 1)))
+        monitor_options)))
+  end
+
+  let(:monitor_options) do
+    {heartbeat_frequency: 1}
   end
 
   it 'refreshes server descriptions in background', retry: 3 do
@@ -25,4 +29,24 @@ describe 'Server::Monitor' do
 
     expect(server.description).not_to be_unknown
   end
+
+  context 'server-pushed ismaster' do
+    min_server_fcv '4.4'
+    require_topology :replica_set
+
+    let(:monitor_options) do
+      {heartbeat_frequency: 20}
+    end
+
+    it 'updates server description' do
+      starting_primary_address = client.cluster.next_primary.address
+
+      ClusterTools.instance.step_down
+
+      sleep 2
+
+      new_primary_address = client.cluster.next_primary.address
+      new_primary_address.should_not == starting_primary_address
+    end
+  end
 end

data/spec/integration/size_limit_spec.rb

@@ -36,7 +36,7 @@ describe 'BSON & command size limits' do
     end
 
     authorized_collection.insert_many(documents)
-    authorized_collection.count_documents({}).should == 8
+    authorized_collection.count_documents.should == 8
   end
 
   # This test ensures that document which are too big definitely fail insertion.
@@ -49,7 +49,7 @@ describe 'BSON & command size limits' do
     lambda do
       authorized_collection.insert_many(documents)
     end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-    authorized_collection.count_documents({}).should == 0
+    authorized_collection.count_documents.should == 0
   end
 
   it 'allows user-provided documents to be exactly 16MiB' do
@@ -81,6 +81,10 @@ describe 'BSON & command size limits' do
   end
 
   it 'allows bulk writes of multiple documents of exactly 16 MiB each' do
+    if SpecConfig.instance.compressors
+      pending "RUBY-2234"
+    end
+
     documents = []
     1.upto(3) do |index|
       document = { key: 'a' * (max_document_size - 28), _id: "in#{index}" }
@@ -89,6 +93,6 @@ describe 'BSON & command size limits' do
     end
 
     authorized_collection.insert_many(documents)
-    authorized_collection.count_documents({}).should == 3
+    authorized_collection.count_documents.should == 3
   end
 end

data/spec/integration/size_limit_spec.rb~12e1e9c4f... RUBY-2242 Fix zlib compression (#2021)

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'BSON & command size limits' do
+  let(:max_document_size) { 16*1024*1024 }
+
+  before do
+    authorized_collection.delete_many
+  end
+
+  # This test uses a large document that is significantly smaller than the
+  # size limit. It is a basic sanity check.
+  it 'allows user-provided documents to be 15MiB' do
+    document = { key: 'a' * 15*1024*1024, _id: 'foo' }
+
+    authorized_collection.insert_one(document)
+  end
+
+  # This test uses a large document that is significantly larger than the
+  # size limit. It is a basic sanity check.
+  it 'fails single write of oversized documents' do
+    document = { key: 'a' * 17*1024*1024, _id: 'foo' }
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  # This test checks our bulk write splitting when documents are not close
+  # to the limit, but where splitting is definitely required.
+  it 'allows split bulk write of medium sized documents' do
+    # 8 documents of 4 MiB each = 32 MiB total data, should be split over
+    # either 2 or 3 bulk writes depending on how well the driver splits
+    documents = []
+    1.upto(8) do |index|
+      documents << { key: 'a' * 4*1024*1024, _id: "in#{index}" }
+    end
+
+    authorized_collection.insert_many(documents)
+    authorized_collection.count_documents({}).should == 8
+  end
+
+  # This test ensures that document which are too big definitely fail insertion.
+  it 'fails bulk write of oversized documents' do
+    documents = []
+    1.upto(3) do |index|
+      documents << { key: 'a' * 17*1024*1024, _id: "in#{index}" }
+    end
+
+    lambda do
+      authorized_collection.insert_many(documents)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+    authorized_collection.count_documents({}).should == 0
+  end
+
+  it 'allows user-provided documents to be exactly 16MiB' do
+    # The document must contain the _id field, otherwise the server will
+    # add it which will increase the size of the document as persisted by
+    # the server.
+    document = { key: 'a' * (max_document_size - 28), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size)
+
+    authorized_collection.insert_one(document)
+  end
+
+  it 'fails on the server when a document larger than 16MiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
+  end
+
+  it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27 + 16*1024), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+16*1024+1)
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'allows bulk writes of multiple documents of exactly 16 MiB each' do
+    if SpecConfig.instance.compressors
+      pending "RUBY-2234"
+    end
+
+    documents = []
+    1.upto(3) do |index|
+      document = { key: 'a' * (max_document_size - 28), _id: "in#{index}" }
+      expect(document.to_bson.length).to eq(max_document_size)
+      documents << document
+    end
+
+    authorized_collection.insert_many(documents)
+    authorized_collection.count_documents({}).should == 3
+  end
+end

data/spec/integration/ssl_uri_options_spec.rb

@@ -20,6 +20,6 @@ describe 'SSL connections with URI options' do
 
   it 'successfully connects and runs an operation' do
     client = new_local_client(uri)
-    expect { client[:foo].count_documents({}) }.not_to raise_error
+    expect { client[:foo].count_documents }.not_to raise_error
   end
-end
+end

data/spec/integration/zlib_compression_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Zlib compression' do
+  require_compression
+
+  before do
+    authorized_client['test'].drop
+  end
+
+  context 'when client has zlib compressor option enabled' do
+    it 'compresses the message to the server' do
+      # Double check that the client has zlib compression enabled
+      expect(authorized_client.options[:compressors]).to include('zlib')
+
+      expect(Mongo::Protocol::Compressed).to receive(:new).twice.and_call_original
+      expect(Zlib::Deflate).to receive(:deflate).twice.and_call_original
+      expect(Zlib::Inflate).to receive(:inflate).twice.and_call_original
+
+      authorized_client['test'].insert_one(_id: 1, text: 'hello world')
+      document = authorized_client['test'].find(_id: 1).first
+
+      expect(document['text']).to eq('hello world')
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -4,8 +4,6 @@ CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
 SERVER_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam/**/*.yml").sort
 SDAM_MONITORING_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam_monitoring/*.yml").sort
 SERVER_SELECTION_RTT_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection_rtt/*.yml").sort
-SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection/**/*.yml").sort
-MAX_STALENESS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/max_staleness/**/*.yml").sort
 CRUD_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/crud/**/*.yml").sort
 CRUD2_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/crud_v2/**/*.yml").sort
 RETRYABLE_WRITES_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/retryable_writes/**/*.yml").sort
@@ -22,7 +20,11 @@ CMAP_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/cmap/*.yml").sort
 AUTH_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/auth/*.yml").sort
 CLIENT_SIDE_ENCRYPTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/client_side_encryption/*.yml").sort
 
-if ENV['CI']
+# Disable output buffering: https://www.rubyguides.com/2019/02/ruby-io/
+STDOUT.sync = true
+STDERR.sync = true
+
+if %w(1 true yes).include?(ENV['CI']&.downcase)
   autoload :Byebug, 'byebug'
 else
   # Load debuggers before loading the driver code, so that breakpoints
@@ -107,14 +109,19 @@ RSpec.configure do |config|
     # 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(45) do
+      timeout = if %w(1 true yes).include?(ENV['STRESS']&.downcase)
+        210
+      else
+        45
+      end
+      TimeoutInterrupt.timeout(timeout) do
         example.run
       end
     end
   end
 
   if SpecConfig.instance.ci?
-    if defined?(Rfc)
+    if defined?(Rfc::Rif)
       unless BSON::Environment.jruby?
         Rfc::Rif.output_object_space_stats = true
       end

data/spec/mongo/auth/aws/request_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Mongo::Auth::Aws::Request do 
+
+  describe "#formatted_time" do 
+    context "when time is provided and frozen" do 
+      let(:original_time) { Time.at(1592399523).freeze }
+      let(:request) do 
+        described_class.new(access_key_id: 'access_key_id', 
+          secret_access_key: 'secret_access_key', 
+          session_token: 'session_token', 
+          host: 'host', 
+          server_nonce: 'server_nonce',
+          time: original_time
+        )
+      end
+
+      it 'doesn\'t modify the time instance variable' do
+        expect { request.formatted_time }.to_not raise_error
+      end
+
+      it 'returns the correct formatted time' do
+        expect(request.formatted_time).to eq('20200617T131203Z')
+      end
+    end
+
+    context "when time is not provided" do 
+      let(:request) do 
+        described_class.new(access_key_id: 'access_key_id', 
+          secret_access_key: 'secret_access_key', 
+          session_token: 'session_token', 
+          host: 'host', 
+          server_nonce: 'server_nonce'
+        )
+      end
+
+      it 'doesn\'t raise an error on formatted_time' do
+        expect { request.formatted_time }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#signature" do 
+    context "when time is provided and frozen" do 
+      let(:original_time) { Time.at(1592399523).freeze }
+      let(:request) do 
+        described_class.new(access_key_id: 'access_key_id', 
+          secret_access_key: 'secret_access_key', 
+          session_token: 'session_token', 
+          host: 'host', 
+          server_nonce: 'server_nonce',
+          time: original_time
+        )
+      end
+  
+      it 'doesn\'t raise error on signature' do 
+        expect { request.signature }.to_not raise_error
+      end
+    end
+
+    context "when time is not provided" do 
+      let(:request) do 
+        described_class.new(access_key_id: 'access_key_id', 
+          secret_access_key: 'secret_access_key', 
+          session_token: 'session_token', 
+          host: 'host', 
+          server_nonce: 'server_nonce'
+        )
+      end
+  
+      it 'doesn\'t raise error on signature' do 
+        expect { request.signature }.to_not raise_error
+      end
+    end    
+  end
+end

data/spec/mongo/auth/scram_spec.rb

@@ -65,7 +65,7 @@ describe Mongo::Auth::Scram do
           it 'does not compress the message' do
             expect(Mongo::Protocol::Compressed).not_to receive(:new)
             expect {
-              authenticator.login(connection)
+              authenticator.login
             }.to raise_error(Mongo::Auth::Unauthorized)
           end
         end

data/spec/mongo/client_construction_spec.rb

@@ -319,6 +319,104 @@ describe Mongo::Client do
         end
       end
 
+      context 'timeout options' do
+        let(:client) do
+          new_local_client(SpecConfig.instance.addresses,
+            SpecConfig.instance.authorized_test_options.merge(options))
+        end
+
+        context 'when network timeouts are zero' do
+          let(:options) do
+            { socket_timeout: 0, connect_timeout: 0 }
+          end
+
+          it 'sets options to zeros' do
+            client.options[:socket_timeout].should == 0
+            client.options[:connect_timeout].should == 0
+          end
+
+          it 'connects and performs operations successfully' do
+            lambda do
+              client.database.command(ping: 1)
+            end.should_not raise_error
+          end
+        end
+
+        %i(socket_timeout connect_timeout).each do |option|
+          context "when #{option} is negative" do
+            let(:options) do
+              { option => -1 }
+            end
+
+            it 'fails client creation' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /#{option} must be a non-negative number/)
+            end
+          end
+
+          context "when #{option} is of the wrong type" do
+            let(:options) do
+              { option => '42' }
+            end
+
+            it 'fails client creation' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /#{option} must be a non-negative number/)
+            end
+          end
+        end
+
+        context "when :connect_timeout is very small" do
+          # The driver reads first and checks the deadline second.
+          # This means the read (in a monitor) can technically take more than
+          # the connect timeout. Restrict to TLS configurations to make
+          # the network I/O take longer.
+          require_tls
+
+          let(:options) do
+            { connect_timeout: 1e-6, server_selection_timeout: 2 }
+          end
+
+          it 'allows client creation' do
+            lambda do
+              client
+            end.should_not raise_error
+          end
+
+          it 'fails server selection due to very small timeout' do
+            lambda do
+              client.database.command(ping: 1)
+            end.should raise_error(Mongo::Error::NoServerAvailable)
+          end
+        end
+
+        context "when :socket_timeout is very small" do
+          # The driver reads first and checks the deadline second.
+          # This means the read (in a monitor) can technically take more than
+          # the connect timeout. Restrict to TLS configurations to make
+          # the network I/O take longer.
+          require_tls
+
+          let(:options) do
+            { socket_timeout: 1e-6, server_selection_timeout: 2 }
+          end
+
+          it 'allows client creation' do
+            lambda do
+              client
+            end.should_not raise_error
+          end
+
+          it 'fails operations due to very small timeout' do
+            lambda do
+              client.database.command(ping: 1)
+            end.should raise_error(Mongo::Error::SocketTimeoutError)
+          end
+        end
+      end
+
       context 'retry_writes option' do
         let(:client) do
           new_local_client_nmio(SpecConfig.instance.addresses, options)
@@ -1138,6 +1236,48 @@ describe Mongo::Client do
         end
       end
 
+      context ':bg_error_backtrace option' do
+        [true, false, nil, 42].each do |valid_value|
+          context "valid value: #{valid_value.inspect}" do
+            let(:options) do
+              {bg_error_backtrace: valid_value}
+            end
+
+            it 'is accepted' do
+              client.options[:bg_error_backtrace].should == valid_value
+            end
+          end
+        end
+
+        context 'invalid value type' do
+          let(:options) do
+            {bg_error_backtrace: 'yes'}
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /:bg_error_backtrace option value must be true, false, nil or a positive integer/)
+          end
+        end
+
+        context 'invalid value' do
+          [0, -1, 42.0].each do |invalid_value|
+            context "invalid value: #{invalid_value.inspect}" do
+              let(:options) do
+                {bg_error_backtrace: invalid_value}
+              end
+
+              it 'is rejected' do
+                lambda do
+                  client
+                end.should raise_error(ArgumentError, /:bg_error_backtrace option value must be true, false, nil or a positive integer/)
+              end
+            end
+          end
+        end
+      end
+
       describe ':read option' do
         [
           :primary, :primary_preferred, :secondary, :secondary_preferred,  :nearest
@@ -1243,6 +1383,73 @@ describe Mongo::Client do
       end
 =end
     end
+
+    context 'when making a block client' do
+      context 'when the block doesn\'t raise an error' do
+        let(:block_client) do
+          c = nil
+          Mongo::Client.new(
+            SpecConfig.instance.addresses,
+            SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db),
+          ) do |client|
+            c = client
+          end
+          c
+        end
+
+        it 'is closed after block' do
+          expect(block_client.cluster.connected?).to eq(false)
+        end
+      end
+
+      context 'when the block raises an error' do
+        it 'it is closed after the block' do
+          block_client_raise = nil
+          expect do
+            Mongo::Client.new(
+              SpecConfig.instance.addresses,
+              SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db),
+            ) do |client|
+              block_client_raise = client
+              raise "This is an error!"
+            end
+          end.to raise_error(StandardError, "This is an error!")
+          expect(block_client_raise.cluster.connected?).to eq(false)
+        end
+      end
+
+      context 'when the hosts given include the protocol' do
+        it 'raises an error on mongodb://' do
+          expect do
+            Mongo::Client.new(['mongodb://127.0.0.1:27017/test'])
+          end.to raise_error(ArgumentError, "Host 'mongodb://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+        end
+
+        it 'raises an error on mongodb+srv://' do
+          expect do
+            Mongo::Client.new(['mongodb+srv://127.0.0.1:27017/test'])
+          end.to raise_error(ArgumentError, "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+        end
+
+        it 'raises an error on multiple items' do
+          expect do
+            Mongo::Client.new(['127.0.0.1:27017', 'mongodb+srv://127.0.0.1:27017/test'])
+          end.to raise_error(ArgumentError, "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+        end
+
+        it 'raises an error only at beginning of string' do
+          expect do
+            Mongo::Client.new(['somethingmongodb://127.0.0.1:27017/test', 'mongodb+srv://127.0.0.1:27017/test'])
+          end.to raise_error(ArgumentError, "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+        end
+
+        it 'raises an error with different case' do
+          expect do
+            Mongo::Client.new(['MongOdB://127.0.0.1:27017/test'])
+          end.to raise_error(ArgumentError, "Host 'MongOdB://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+        end
+      end
+    end
   end
 
   shared_examples_for 'duplicated client with duplicated monitoring' do