mongo 2.11.6 → 2.12.0.rc0

data/spec/integration/client_side_encryption/views_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Client-Side Encryption' do
+  describe 'Prose tests: Data key and double encryption' do
+    require_libmongocrypt
+    require_enterprise
+    min_server_fcv '4.2'
+
+    include_context 'define shared FLE helpers'
+
+    let(:client) do
+      new_local_client(
+        SpecConfig.instance.addresses,
+        SpecConfig.instance.test_options
+      )
+    end
+
+    let(:client_encrypted) do
+      new_local_client(
+        SpecConfig.instance.addresses,
+        SpecConfig.instance.test_options.merge(
+          auto_encryption_options: {
+            kms_providers: local_kms_providers,
+            key_vault_namespace: 'admin.datakeys',
+          },
+          database: :db,
+        )
+      )
+    end
+
+    before do
+      client.use(:db)[:view].drop
+      client.use(:db).database.command(create: "view", viewOn: "coll")
+    end
+
+    it 'does not perform encryption on views' do
+      expect do
+        client_encrypted[:view].insert_one({})
+      end.to raise_error(Mongo::Error::CryptError, /cannot auto encrypt a view/)
+    end
+  end
+end

data/spec/integration/client_update_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Mongo::Client do
+  clean_slate
+
+  context 'auto encryption options' do
+    require_libmongocrypt
+    min_server_fcv '4.2'
+    require_enterprise
+
+    include_context 'define shared FLE helpers'
+    include_context 'with local kms_providers'
+
+    before do
+      authorized_client.use(:admin)[:datakeys].drop
+      authorized_client.use(:admin)[:datakeys].insert_one(data_key)
+      authorized_client.use(:auto_encryption)[:users].drop
+      authorized_client.use(:auto_encryption)[:users,
+        {
+          'validator' => { '$jsonSchema' => schema_map }
+        }
+      ].create
+    end
+
+    describe '#with' do
+      let(:old_client) do
+        new_local_client(
+          SpecConfig.instance.addresses,
+          SpecConfig.instance.test_options.merge(
+            auto_encryption_options: {
+              kms_providers: kms_providers,
+              key_vault_namespace: key_vault_namespace,
+            },
+            database: :auto_encryption
+          ),
+        )
+      end
+
+      let!(:new_client) do
+        old_client.with(auto_encryption_options: new_auto_encryption_options)
+      end
+
+      context 'with new auto_encryption_options' do
+        let(:new_auto_encryption_options) do
+          {
+            kms_providers: kms_providers,
+            key_vault_namespace: key_vault_namespace,
+            schema_map: { 'auto_encryption.users' => schema_map },
+          }
+        end
+
+        it 'creates a new client' do
+          expect(new_client).not_to eq(old_client)
+        end
+
+        it 'maintains the old client\'s auto encryption options' do
+          expect(old_client.encrypter.options[:schema_map]).to be_nil
+        end
+
+        it 'updates the client\'s auto encryption options' do
+          expect(new_client.encrypter.options[:schema_map]).to eq('auto_encryption.users' => schema_map)
+        end
+
+        it 'shares a cluster with the old client' do
+          expect(old_client.cluster).to eq(new_client.cluster)
+        end
+
+        it 'allows the original client to keep encrypting' do
+          old_client[:users].insert_one(ssn: ssn)
+          document = authorized_client.use(:auto_encryption)[:users].find.first
+          expect(document['ssn']).to be_ciphertext
+        end
+
+        it 'allows the new client to keep encrypting' do
+          old_client[:users].insert_one(ssn: ssn)
+          document = authorized_client.use(:auto_encryption)[:users].find.first
+          expect(document['ssn']).to be_ciphertext
+        end
+      end
+
+      context 'with nil auto_encryption_options' do
+        let(:new_auto_encryption_options) { nil }
+
+        it 'removes auto encryption options' do
+          expect(new_client.encrypter).to be_nil
+        end
+
+        it 'allows original client to keep encrypting' do
+          old_client[:users].insert_one(ssn: ssn)
+          document = authorized_client.use(:auto_encryption)[:users].find.first
+          expect(document['ssn']).to be_ciphertext
+        end
+      end
+    end
+
+    describe '#use' do
+      let(:old_client) do
+        new_local_client(
+          SpecConfig.instance.addresses,
+          SpecConfig.instance.test_options.merge(
+            auto_encryption_options: {
+              kms_providers: kms_providers,
+              key_vault_namespace: key_vault_namespace,
+            }
+          )
+        )
+      end
+
+      let(:new_client) do
+        old_client.use(:auto_encryption)
+      end
+
+      it 'creates a new client with encryption enabled' do
+        new_client[:users].insert_one(ssn: ssn)
+        document = authorized_client.use(:auto_encryption)[:users].find.first
+        expect(document['ssn']).to be_ciphertext
+      end
+    end
+  end
+end

data/spec/integration/command_monitoring_spec.rb

@@ -21,6 +21,7 @@ describe 'Command monitoring' do
     started_event = started_events.first
     expect(started_event.command_name).to eql('ismaster')
     expect(started_event.address).to be_a(Mongo::Address)
+    expect(started_event.command).to have_key('$db')
 
     succeeded_events = subscriber.succeeded_events.select do |event|
       event.command_name == 'ismaster'
@@ -30,6 +31,7 @@ describe 'Command monitoring' do
     expect(succeeded_event.command_name).to eql('ismaster')
     expect(succeeded_event.reply).to be_a(BSON::Document)
     expect(succeeded_event.reply['ismaster']).to eql(true)
+    expect(succeeded_event.reply['ok']).to eq(1)
     expect(succeeded_event.address).to be_a(Mongo::Address)
     expect(succeeded_event.duration).to be_a(Float)
 
@@ -109,7 +111,7 @@ describe 'Command monitoring' do
 
       subscriber.clear_events!
       expect do
-        command.execute(server)
+        command.execute(server, client: nil)
       end.to raise_error(Mongo::Error::OperationFailure, /Not enough data-bearing nodes \(100\)/)
 
       expect(subscriber.started_events.length).to eq(1)

data/spec/integration/command_spec.rb

@@ -47,7 +47,10 @@ describe 'Command' do
 
       let(:expected_payload) do
         {
-          'command' => {'commitTransaction' => 1},
+          'command' => {
+            'commitTransaction' => 1,
+            '$db' => 'admin',
+          },
           'command_name' => 'commitTransaction',
           'database_name' => 'admin',
           'request_id' => 42,
@@ -75,6 +78,7 @@ describe 'Command' do
               'commitTransaction' => 1,
               'lsid' => session.session_id,
               'txnNumber' => BSON::Int64.new(123),
+              '$db' => 'admin',
             },
             'command_name' => 'commitTransaction',
             'database_name' => 'admin',
@@ -93,6 +97,7 @@ describe 'Command' do
         let(:expected_payload) do
           {
             'command' => {
+              '$db' => 'admin',
               'commitTransaction' => 1,
               'writeConcern' => {'w' => 'majority'},
             },
@@ -121,17 +126,46 @@ describe 'Command' do
         )
       end
 
-      let(:expected_payload) do
-        {
-          'command' => {'find' => 'collection_name'},
-          'command_name' => 'find',
-          'database_name' => 'foo',
-          'request_id' => 42,
-        }
+      context 'OP_MSG-capable servers' do
+        min_server_fcv '3.6'
+
+        let(:expected_payload) do
+          {
+            'command' => {
+              '$db' => 'foo',
+              'find' => 'collection_name',
+            },
+            'command_name' => 'find',
+            'database_name' => 'foo',
+            'request_id' => 42,
+          }
+        end
+
+        it 'returns expected payload' do
+          expect(payload).to eq(expected_payload)
+        end
       end
 
-      it 'returns expected payload' do
-        expect(payload).to eq(expected_payload)
+      # Servers using legacy wire protocol message do not have $db in payload.
+      # $db is added to the payload later when the command monitoring event is
+      # published.
+      context 'pre-OP_MSG servers' do
+        max_server_version '3.4'
+
+        let(:expected_payload) do
+          {
+            'command' => {
+              'find' => 'collection_name',
+            },
+            'command_name' => 'find',
+            'database_name' => 'foo',
+            'request_id' => 42,
+          }
+        end
+
+        it 'returns expected payload' do
+          expect(payload).to eq(expected_payload)
+        end
       end
     end
 

data/spec/integration/connection_spec.rb

@@ -168,6 +168,63 @@ describe 'Connections' do
           it_behaves_like 'is 1 per connection'
         end
       end
+
+      context 'when socket connection fails' do
+
+        before do
+          server
+        end
+
+        let(:socket_cls) { ::Socket }
+
+        let(:socket) do
+          double('socket').tap do |socket|
+            allow(socket).to receive(:setsockopt)
+            allow(socket).to receive(:set_encoding)
+            allow(socket).to receive(:getsockopt)
+            expect(socket).to receive(:connect).and_raise(IOError, 'test error')
+
+            # This test is testing for the close call:
+            expect(socket).to receive(:close)
+          end
+        end
+
+        it 'closes the socket' do
+          RSpec::Mocks.with_temporary_scope do
+            expect(::Socket).to receive(:new).with(
+              Socket::AF_INET, Socket::SOCK_STREAM, 0).and_return(socket)
+
+            lambda do
+              connection.connect!
+            end.should raise_error(Mongo::Error::SocketError, /test error/)
+          end
+        end
+
+        context 'with tls' do
+          require_tls
+
+          let(:socket) do
+            double('socket').tap do |socket|
+              allow(socket).to receive(:hostname=)
+              allow(socket).to receive(:sync_close=)
+              expect(socket).to receive(:connect).and_raise(IOError, 'test error')
+
+              # This test is testing for the close call:
+              expect(socket).to receive(:close)
+            end
+          end
+
+          it 'closes the SSL socket' do
+            RSpec::Mocks.with_temporary_scope do
+              expect(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(socket)
+
+              lambda do
+                connection.connect!
+              end.should raise_error(Mongo::Error::SocketError, /test error/)
+            end
+          end
+        end
+      end
     end
 
     describe 'wire protocol version range update' do

data/spec/integration/reconnect_spec.rb

@@ -54,9 +54,7 @@ describe 'Client after reconnect' do
   context 'SRV monitor thread' do
 
     let(:uri) do
-      "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true".tap do |uri|
-        puts "Constructed URI: #{uri}"
-      end
+      "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}"
     end
 
     # Debug logging to troubleshoot failures in Evergreen
@@ -68,8 +66,8 @@ describe 'Client after reconnect' do
 
     let(:client) do
       ClientRegistry.instance.register_local_client(
-        Mongo::Client.new(uri, server_selection_timeout: 3.86,
-          logger: logger))
+        Mongo::Client.new(uri, SpecConfig.instance.ssl_options.merge(
+          server_selection_timeout: 3.86, logger: logger)))
     end
 
     let(:wait_for_discovery) do
@@ -134,7 +132,10 @@ describe 'Client after reconnect' do
 
       let(:client) do
         ClientRegistry.instance.register_local_client(
-          Mongo::Client.new(uri, server_selection_timeout: 3.89,
+          Mongo::Client.new(uri,
+            timeout: 5,
+            connect_timeout: 5,
+            server_selection_timeout: 3.89,
             resolv_options: {
               nameserver: 'localhost',
               nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],

data/spec/integration/size_limit_spec.rb

@@ -0,0 +1,94 @@
+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
+    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