mongo 2.13.0.rc1 → 2.13.3

data/spec/integration/client_authentication_options_spec.rb

@@ -256,6 +256,43 @@ describe 'Client authentication options' do
         expect(client.options[:auth_mech_properties]).to eq({ 'service_name' => 'mongodb' })
       end
     end
+
+    context 'when properties are given but not service name' do
+      context 'with URI options' do
+        let(:credentials) { "#{user}:#{pwd}@" }
+
+        context 'with default auth mech properties' do
+          let(:options) { '?authMechanism=GSSAPI&authMechanismProperties=service_realm:foo' }
+
+          it 'sets service name to mongodb' do
+            expect(client.options[:auth_mech_properties]).to eq(
+              'service_name' => 'mongodb',
+              'service_realm' => 'foo',
+            )
+          end
+        end
+      end
+
+      context 'with client options' do
+        let(:client_opts) do
+          {
+            auth_mech: :gssapi,
+            user: user,
+            password: pwd,
+            auth_mech_properties: {
+              service_realm: 'foo',
+            }.freeze,
+          }.freeze
+        end
+
+        it 'sets default auth mech properties' do
+          expect(client.options[:auth_mech_properties]).to eq(
+            'service_name' => 'mongodb',
+            'service_realm' => 'foo',
+          )
+        end
+      end
+    end
   end
 
   context 'with PLAIN auth mechanism' do

data/spec/integration/client_side_encryption/auto_encryption_bulk_writes_spec.rb

@@ -113,7 +113,7 @@ describe 'Bulk writes with auto-encryption enabled' do
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end
@@ -162,15 +162,19 @@ describe 'Bulk writes with auto-encryption enabled' do
       context 'when one operation is larger than 16MiB' do
         let(:requests) do
           [
-            { update_one: { filter: { _id: 1 }, update: { ssn: 'a' * (Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE - 100) } } },
+            { update_one: { filter: { _id: 1 }, update: { ssn: 'a' * (Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE) } } },
             { update_one: { filter: { _id: 2 }, update: { ssn: 'a' * size_limit } } },
           ]
         end
 
+        before do
+          expect(requests.first.to_bson.length).to be > Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE
+        end
+
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end
@@ -255,7 +259,7 @@ describe 'Bulk writes with auto-encryption enabled' do
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end
@@ -346,7 +350,7 @@ describe 'Bulk writes with auto-encryption enabled' do
       it 'raises an exception' do
         expect do
           perform_bulk_write
-        end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+        end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
       end
     end
   end

data/spec/integration/sdam_error_handling_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe 'SDAM error handling' do
-  clean_slate_for_all
+  clean_slate
 
   after do
     # Close all clients after every test to avoid leaking expectations into
@@ -19,6 +19,7 @@ describe 'SDAM error handling' do
     new_local_client(SpecConfig.instance.addresses,
       SpecConfig.instance.all_test_options.merge(
         socket_timeout: 3, connect_timeout: 3,
+        heartbeat_frequency: 100,
         # Uncomment to print all events to stdout:
         #sdam_proc: Utils.subscribe_all_sdam_proc(diagnostic_subscriber),
         **Utils.disable_retries_client_options)
@@ -28,6 +29,14 @@ describe 'SDAM error handling' do
   let(:server) { client.cluster.next_primary }
 
   shared_examples_for 'marks server unknown' do
+    before do
+      server.monitor.stop!
+    end
+
+    after do
+      client.close
+    end
+
     it 'marks server unknown' do
       expect(server).not_to be_unknown
       RSpec::Mocks.with_temporary_scope do
@@ -38,6 +47,14 @@ describe 'SDAM error handling' do
   end
 
   shared_examples_for 'does not mark server unknown' do
+    before do
+      server.monitor.stop!
+    end
+
+    after do
+      client.close
+    end
+
     it 'does not mark server unknown' do
       expect(server).not_to be_unknown
       RSpec::Mocks.with_temporary_scope do

data/spec/integration/sdam_events_spec.rb

@@ -67,9 +67,8 @@ describe 'SDAM events' do
         started_events.length.should <= 10
 
         succeeded_events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
-        # Since we gracefully close the client, we expect each heartbeat
-        # to complete.
-        started_events.length.should == succeeded_events.length
+        started_events.length.should > 1
+        (succeeded_events.length..succeeded_events.length+1).should include(started_events.length)
       end
     end
 
@@ -105,10 +104,12 @@ describe 'SDAM events' do
         (succeeded_awaited = events.select(&:awaited?)).should_not be_empty
         (succeeded_regular = events.reject(&:awaited?)).should_not be_empty
 
-        # Since we gracefully close the client, we expect each heartbeat
-        # to complete.
-        started_awaited.length.should == succeeded_awaited.length
-        started_regular.length.should == succeeded_regular.length
+        # There may be in-flight ismasters that don't complete, both
+        # regular and awaited.
+        started_awaited.length.should > 1
+        (succeeded_awaited.length..succeeded_awaited.length+1).should include(started_awaited.length)
+        started_regular.length.should > 1
+        (succeeded_regular.length..succeeded_regular.length+1).should include(started_regular.length)
       end
     end
   end

data/spec/integration/secondary_reads_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe 'Secondary reads' do
+  before do
+    root_authorized_client.use('sr')['secondary_reads'].drop
+    root_authorized_client.use('sr')['secondary_reads'].insert_one(test: 1)
+  end
+
+  shared_examples 'performs reads as per read preference' do
+
+    %i(primary primary_preferred).each do |mode|
+
+      context mode.inspect do
+
+        let(:client) do
+          root_authorized_client.with(read: {mode: mode}).use('sr')
+        end
+
+        it 'reads from primary' do
+          start_stats = get_read_counters
+
+          30.times do
+            client['secondary_reads'].find.to_a
+          end
+
+          end_stats = get_read_counters
+
+          end_stats[:secondary].should be_within(10).of(start_stats[:secondary])
+          end_stats[:primary].should >= start_stats[:primary] + 30
+        end
+      end
+    end
+
+    %i(secondary secondary_preferred).each do |mode|
+
+      context mode.inspect do
+        let(:client) do
+          root_authorized_client.with(read: {mode: mode}).use('sr')
+        end
+
+        it 'reads from secondaries' do
+          start_stats = get_read_counters
+
+          30.times do
+            client['secondary_reads'].find.to_a
+          end
+
+          end_stats = get_read_counters
+
+          end_stats[:primary].should be_within(10).of(start_stats[:primary])
+          end_stats[:secondary].should >= start_stats[:secondary] + 30
+        end
+      end
+    end
+  end
+
+  context 'replica set' do
+    require_topology :replica_set
+
+    include_examples 'performs reads as per read preference'
+  end
+
+  context 'sharded cluster' do
+    require_topology :sharded
+
+    include_examples 'performs reads as per read preference'
+  end
+
+  def get_read_counters
+    client = ClientRegistry.instance.global_client('root_authorized')
+    addresses = []
+    if client.cluster.sharded?
+      doc = client.use('admin').command(listShards: 1).documents.first
+      doc['shards'].each do |shard|
+        addresses += shard['host'].split('/').last.split(',')
+      end
+    else
+      client.cluster.servers.each do |server|
+        next unless server.primary? || server.secondary?
+        addresses << server.address.seed
+      end
+    end
+    stats = Hash.new(0)
+    addresses.each do |address|
+      ClientRegistry.instance.new_local_client(
+        [address],
+        SpecConfig.instance.all_test_options.merge(connect: :direct),
+      ) do |c|
+        server = c.cluster.servers.first
+        next unless server.primary? || server.secondary?
+        stat = c.command(serverStatus: 1).documents.first
+        queries = stat['opcounters']['query']
+        if server.primary?
+          stats[:primary] += queries
+        else
+          stats[:secondary] += queries
+        end
+      end
+    end
+    stats
+  end
+end

data/spec/integration/size_limit_spec.rb

@@ -62,13 +62,31 @@ describe 'BSON & command size limits' do
     authorized_collection.insert_one(document)
   end
 
-  it 'fails on the server when a document larger than 16MiB is inserted' do
+  it 'fails on the driver 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.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'fails on the driver when an update larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.update_one({ _id: 'foo' }, document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'fails on the driver when an delete larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.delete_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
   end
 
   it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do
@@ -81,10 +99,6 @@ 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}" }

data/spec/lite_spec_helper.rb

@@ -104,7 +104,7 @@ RSpec.configure do |config|
     end
   end
 
-  if SpecConfig.instance.ci?
+  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
     # Allow a max of 30 seconds per test.
     # Tests should take under 10 seconds ideally but it seems
     # we have some that run for more than 10 seconds in CI.

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

@@ -0,0 +1,42 @@
+require 'lite_spec_helper'
+
+AWS_REGION_TEST_CASES = {
+  'sts.amazonaws.com' => 'us-east-1',
+  'sts.us-west-2.amazonaws.com' => 'us-west-2',
+  'sts.us-west-2.amazonaws.com.ch' => 'us-west-2',
+  'example.com' => 'com',
+  'localhost' => 'us-east-1',
+  'sts..com' => Mongo::Error::InvalidServerAuthHost,
+  '.amazonaws.com' => Mongo::Error::InvalidServerAuthHost,
+  'sts.amazonaws.' => Mongo::Error::InvalidServerAuthHost,
+  '' => Mongo::Error::InvalidServerAuthResponse,
+  'x' * 256 => Mongo::Error::InvalidServerAuthHost,
+}
+
+describe 'AWS auth region tests' do
+
+  AWS_REGION_TEST_CASES.each do |host, expected_region|
+    context "host '#{host}'" do
+      let(:request) do
+        Mongo::Auth::Aws::Request.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: host,
+          server_nonce: 'server_nonce',
+        )
+      end
+
+      if expected_region.is_a?(String)
+        it 'derives expected region' do
+          request.region.should == expected_region
+        end
+      else
+        it 'fails with an error' do
+          lambda do
+            request.region
+          end.should raise_error(expected_region)
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
-describe Mongo::Auth::Aws::Request do 
+describe Mongo::Auth::Aws::Request do
 
-  describe "#formatted_time" do 
-    context "when time is provided and frozen" 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', 
+      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
         )
@@ -24,12 +24,12 @@ describe Mongo::Auth::Aws::Request do
       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', 
+    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
@@ -40,37 +40,37 @@ describe Mongo::Auth::Aws::Request do
     end
   end
 
-  describe "#signature" do 
-    context "when time is provided and frozen" do 
+  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', 
+      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 
+
+      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', 
+    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 
+
+      it 'doesn\'t raise error on signature' do
         expect { request.signature }.to_not raise_error
       end
-    end    
+    end
   end
 end