mongo 2.17.4 → 2.21.0

data/spec/integration/client_side_encryption/unique_index_on_key_alt_names_prose_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# No need to rewrite legacy tests to use shorter examples, unless/until we
+# revisit these tests and need to make more significant changes.
+# rubocop:disable RSpec/ExampleLength
+describe 'Decryption events' do
+  require_enterprise
+  min_server_fcv '4.2'
+  require_libmongocrypt
+  include_context 'define shared FLE helpers'
+  min_server_version '7.0.0-rc0'
+
+  let(:client) do
+    ClientRegistry.instance.new_local_client(
+      SpecConfig.instance.addresses,
+      SpecConfig.instance.test_options.merge(
+        database: SpecConfig.instance.test_db
+      )
+    )
+  end
+
+  let(:client_encryption) do
+    Mongo::ClientEncryption.new(
+      client,
+      key_vault_namespace: "#{key_vault_db}.#{key_vault_coll}",
+      kms_providers: local_kms_providers
+    )
+  end
+
+  let(:existing_key_alt_name) do
+    'def'
+  end
+
+  let(:existing_key_id) do
+    client_encryption.create_data_key('local', key_alt_names: [ existing_key_alt_name ])
+  end
+
+  before do
+    client.use(key_vault_db)[key_vault_coll].drop
+    client.use(key_vault_db).command(
+      createIndexes: key_vault_coll,
+      indexes: [
+        {
+          name: 'keyAltNames_1',
+          key: { keyAltNames: 1 },
+          unique: true,
+          partialFilterExpression: { keyAltNames: { '$exists' => true } },
+        },
+      ],
+      writeConcern: { w: 'majority' }
+    )
+    # Force key creation
+    existing_key_id
+  end
+
+  it 'tests create_data_key' do
+    expect do
+      client_encryption.create_data_key('local', key_alt_names: [ 'abc' ])
+    end.not_to raise_error
+
+    expect do
+      client_encryption.create_data_key('local', key_alt_names: [ existing_key_alt_name ])
+    end.to raise_error(Mongo::Error::OperationFailure, /E11000/) # duplicate key error
+  end
+
+  it 'tests add_key_alt_name' do
+    key_id = client_encryption.create_data_key('local')
+    expect do
+      client_encryption.add_key_alt_name(key_id, 'abc')
+    end.not_to raise_error
+
+    expect do
+      key_document = client_encryption.add_key_alt_name(key_id, 'abc')
+      expect(key_document['keyAltNames']).to include('abc')
+    end.not_to raise_error
+
+    expect do
+      client_encryption.add_key_alt_name(key_id, existing_key_alt_name)
+    end.to raise_error(Mongo::Error::OperationFailure, /E11000/) # duplicate key error
+
+    expect do
+      key_document = client_encryption.add_key_alt_name(existing_key_id, existing_key_alt_name)
+      expect(key_document['keyAltNames']).to include(existing_key_alt_name)
+    end.not_to raise_error
+  end
+end
+# rubocop:enable RSpec/ExampleLength

data/spec/integration/client_side_encryption/views_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -24,7 +24,7 @@ describe 'Client-Side Encryption' do
         SpecConfig.instance.test_options.merge(
           auto_encryption_options: {
             kms_providers: local_kms_providers,
-            key_vault_namespace: 'admin.datakeys',
+            key_vault_namespace: 'keyvault.datakeys',
             # Spawn mongocryptd on non-default port for sharded cluster tests
             extra_options: extra_options,
           },

data/spec/integration/client_side_operations_timeout/encryption_prose_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'CSOT for encryption' do
+  require_libmongocrypt
+  require_no_multi_mongos
+  min_server_fcv '4.2'
+
+  include_context 'define shared FLE helpers'
+  include_context 'with local kms_providers'
+
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  describe 'mongocryptd' do
+    before do
+      Process.spawn(
+        'mongocryptd',
+        '--pidfilepath=bypass-spawning-mongocryptd.pid', '--port=23000', '--idleShutdownTimeoutSecs=60',
+        %i[ out err ] => '/dev/null'
+      )
+    end
+
+    let(:client) do
+      Mongo::Client.new('mongodb://localhost:23000/?timeoutMS=1000').tap do |client|
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      end
+    end
+
+    let(:ping_command) do
+      subscriber.started_events.find do |event|
+        event.command_name == 'ping'
+      end&.command
+    end
+
+    after do
+      client.close
+    end
+
+    it 'does not set maxTimeMS for commands sent to mongocryptd' do
+      expect do
+        client.use('admin').command(ping: 1)
+      end.to raise_error(Mongo::Error::OperationFailure)
+
+      expect(ping_command).not_to have_key('maxTimeMS')
+    end
+  end
+
+  describe 'ClientEncryption' do
+    let(:key_vault_client) do
+      ClientRegistry.instance.new_local_client(
+        SpecConfig.instance.addresses,
+        SpecConfig.instance.test_options.merge(timeout_ms: 20)
+      )
+    end
+
+    let(:client_encryption) do
+      Mongo::ClientEncryption.new(
+        key_vault_client,
+        key_vault_namespace: key_vault_namespace,
+        kms_providers: local_kms_providers
+      )
+    end
+
+    describe '#createDataKey' do
+      before do
+        authorized_client.use(key_vault_db)[key_vault_coll].drop
+        authorized_client.use(key_vault_db)[key_vault_coll].create
+        authorized_client.use(:admin).command({
+                                                configureFailPoint: 'failCommand',
+                                                mode: {
+                                                  times: 1
+                                                },
+                                                data: {
+                                                  failCommands: [ 'insert' ],
+                                                  blockConnection: true,
+                                                  blockTimeMS: 30
+                                                }
+                                              })
+      end
+
+      after do
+        authorized_client.use(:admin).command({
+                                                configureFailPoint: 'failCommand',
+                                                mode: 'off',
+                                              })
+        key_vault_client.close
+      end
+
+      it 'fails with timeout error' do
+        expect do
+          client_encryption.create_data_key('local')
+        end.to raise_error(Mongo::Error::TimeoutError)
+      end
+    end
+
+    describe '#encrypt' do
+      let!(:data_key_id) do
+        client_encryption.create_data_key('local')
+      end
+
+      before do
+        authorized_client.use(:admin).command({
+                                                configureFailPoint: 'failCommand',
+                                                mode: {
+                                                  times: 1
+                                                },
+                                                data: {
+                                                  failCommands: [ 'find' ],
+                                                  blockConnection: true,
+                                                  blockTimeMS: 30
+                                                }
+                                              })
+      end
+
+      after do
+        authorized_client.use(:admin).command({
+                                                configureFailPoint: 'failCommand',
+                                                mode: 'off',
+                                              })
+      end
+
+      it 'fails with timeout error' do
+        expect do
+          client_encryption.encrypt('hello', key_id: data_key_id,
+                                             algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic')
+        end.to raise_error(Mongo::Error::TimeoutError)
+      end
+    end
+  end
+end

data/spec/integration/client_spec.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
 describe 'Client' do
+  # TODO after the client is closed, operations should fail with an exception
+  # that communicates this state, instead of failing with server selection or
+  # pool errors. RUBY-3102, RUBY-3174.
   context 'after client is disconnected' do
     let(:client) { authorized_client.with(server_selection_timeout: 1) }
 
@@ -16,8 +19,10 @@ describe 'Client' do
       expect(resp).to be_a(Mongo::Operation::Result)
     end
 
-    it 'is still usable for operations that can use sessions' do
-      client['collection'].insert_one(test: 1)
+    context 'operation that can use sessions' do
+      it 'is still usable for operations' do
+        client['collection'].insert_one(test: 1)
+      end
     end
 
     context 'after all servers are marked unknown' do

data/spec/integration/client_update_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -15,8 +15,8 @@ describe Mongo::Client do
     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(:keyvault)[:datakeys, write_concern: { w: :majority }].drop
+      authorized_client.use(:keyvault)[:datakeys, write_concern: { w: :majority }].insert_one(data_key)
       authorized_client.use(:auto_encryption)[:users].drop
       authorized_client.use(:auto_encryption)[:users,
         {
@@ -52,6 +52,10 @@ describe Mongo::Client do
         # actually require a clean slate. https://jira.mongodb.org/browse/RUBY-2138
         clean_slate
 
+        before do
+          authorized_client.reconnect if authorized_client.closed?
+        end
+
         it 'raises an exception' do
           expect do
             new_client

data/spec/integration/collection_indexes_prose_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/command_monitoring_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/command_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -12,7 +12,7 @@ describe 'Command' do
 
     let(:payload) do
       server.with_connection do |connection|
-        command.send(:final_operation, connection).send(:message, connection).payload.dup.tap do |payload|
+        command.send(:final_operation).send(:message, connection).payload.dup.tap do |payload|
           if payload['request_id'].is_a?(Integer)
             payload['request_id'] = 42
           end
@@ -150,28 +150,6 @@ describe 'Command' do
           expect(payload).to eq(expected_payload)
         end
       end
-
-      # 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
 
   end

data/spec/integration/connect_single_rs_name_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/connection/faas_env_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Test Plan scenarios from the handshake spec
+SCENARIOS = {
+  'Valid AWS' => {
+    'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+    'AWS_REGION' => 'us-east-2',
+    'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024',
+  },
+
+  'Valid Azure' => {
+    'FUNCTIONS_WORKER_RUNTIME' => 'ruby',
+  },
+
+  'Valid GCP' => {
+    'K_SERVICE' => 'servicename',
+    'FUNCTION_MEMORY_MB' => '1024',
+    'FUNCTION_TIMEOUT_SEC' => '60',
+    'FUNCTION_REGION' => 'us-central1',
+  },
+
+  'Valid Vercel' => {
+    'VERCEL' => '1',
+    'VERCEL_REGION' => 'cdg1',
+  },
+
+  'Invalid - multiple providers' => {
+    'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+    'AWS_REGION' => 'us-east-2',
+    'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024',
+    'FUNCTIONS_WORKER_RUNTIME' => 'ruby',
+  },
+
+  'Invalid - long string' => {
+    'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+    'AWS_REGION' => 'a' * 512,
+    'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024',
+  },
+
+  'Invalid - wrong types' => {
+    'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+    'AWS_REGION' => 'us-east-2',
+    'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => 'big',
+  },
+}.freeze
+
+describe 'Connect under FaaS Env' do
+  clean_slate
+
+  SCENARIOS.each do |name, env|
+    context "when given #{name}" do
+      local_env(env)
+
+      it 'connects successfully' do
+        resp = authorized_client.database.command(ping: 1)
+        expect(resp).to be_a(Mongo::Operation::Result)
+      end
+    end
+  end
+end

data/spec/integration/connection_pool_populator_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -26,6 +26,8 @@ describe 'Connection pool populator integration' do
 
   declare_topology_double
 
+  retry_test
+
   let(:app_metadata) do
     Mongo::Server::AppMetadata.new(options)
   end
@@ -77,24 +79,27 @@ describe 'Connection pool populator integration' do
 
     context 'when min size is zero' do
 
-      it 'does not start the background thread' do
+      it 'does start the background thread' do
         pool
         sleep 2
 
         expect(pool.size).to eq(0)
-        expect(pool.instance_variable_get('@populator').running?).to be false
+        expect(pool.instance_variable_get('@populator')).to be_running
       end
     end
   end
 
   describe '#clear' do
     context 'when a min size is provided' do
+      require_no_linting
+
        let(:options) do
         { min_pool_size: 1 }
       end
 
       it 'repopulates the pool periodically only up to min size' do
-        pool
+        pool.ready
+        expect(pool.instance_variable_get('@populator')).to be_running
 
         sleep 2
         expect(pool.size).to eq(1)
@@ -102,8 +107,21 @@ describe 'Connection pool populator integration' do
         first_connection = pool.check_out
         pool.check_in(first_connection)
 
-        pool.clear
+        RSpec::Mocks.with_temporary_scope do
+          allow(pool.server).to receive(:unknown?).and_return(true)
+          if server.load_balancer?
+            pool.clear(service_id: first_connection.service_id)
+          else
+            pool.clear
+          end
+        end
+
+        ::Utils.wait_for_condition(3) do
+          pool.size == 0
+        end
+        expect(pool.size).to eq(0)
 
+        pool.ready
         sleep 2
         expect(pool.size).to eq(1)
         expect(pool.available_count).to eq(1)
@@ -258,7 +276,7 @@ describe 'Connection pool populator integration' do
           receive(:create_and_add_connection).twice.and_raise(Mongo::Error::SocketError)
         pool
         sleep 2
-        expect(pool.populator.running?).to be true
+        expect(pool.populator).to be_running
       end
     end
 
@@ -268,7 +286,7 @@ describe 'Connection pool populator integration' do
           receive(:create_and_add_connection).and_raise(Mongo::Error)
         pool
         sleep 2
-        expect(pool.populator.running?).to be true
+        expect(pool.populator).to be_running
       end
     end
   end
@@ -282,6 +300,10 @@ describe 'Connection pool populator integration' do
       it 'populates the parent and child pools' do
         client = ClientRegistry.instance.new_local_client([SpecConfig.instance.addresses.first],
           server_options.merge(min_pool_size: 2, max_pool_size: 5))
+
+        # force initialization of the pool
+        client.cluster.servers.first.pool
+
         # let pool populate
         sleep 2
         server = client.cluster.next_primary

data/spec/integration/connection_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/crud_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -240,6 +240,18 @@ describe 'CRUD operations' do
   end
 
   describe 'insert' do
+    context 'user documents' do
+      let(:doc) do
+        IceNine.deep_freeze(test: 42)
+      end
+
+      it 'does not mutate user documents' do
+        lambda do
+          collection.insert_one(doc)
+        end.should_not raise_error
+      end
+    end
+
     context 'inserting a BSON::Int64' do
       before do
         collection.insert_one(int64: BSON::Int64.new(42))

data/spec/integration/cursor_pinning_spec.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
 describe 'Cursor pinning' do
-  let(:client) { authorized_client }
+  let(:client) do
+    authorized_client.tap do |client|
+      client.reconnect if client.closed?
+    end
+  end
   let(:collection_name) { 'cursor_pinning' }
   let(:collection) { client[collection_name] }
 
@@ -48,73 +52,28 @@ describe 'Cursor pinning' do
   context 'lb' do
     require_topology :load_balanced
 
-    # In load-balanced topology, we cannot create new connections to a
-    # particular service.
+    # In load-balanced topology, a cursor retains the connection used to create
+    # it until the cursor is closed.
 
-    context 'when no connection is available' do
+    context 'when connection is available' do
+      require_multi_mongos
 
-      it 'raises ConnectionCheckOutTimeout' do
-        server.pool.size.should == 0
+      let(:client) { authorized_client.with(max_pool_size: 2) }
 
+      it 'does not return connection to the pool if cursor not drained' do
+        expect(server.pool).not_to receive(:check_in)
         enum = collection.find({}, batch_size: 1).to_enum
-        # Still zero because we haven't iterated
-        server.pool.size.should == 0
-
+        # Get the first element only; cursor is not drained, so there should
+        # be no check_in of the connection.
         enum.next
-        server.pool.size.should == 1
-
-        # Grab the connection that was used
-        server.with_connection do
-          # This requires a new connection, but we cannot make one.
-          lambda do
-            enum.next
-          end.should raise_error(Mongo::Error::ConnectionCheckOutTimeout)
-
-          server.pool.size.should == 1
-        end
       end
-    end
-
-    context 'when connection is available' do
-      require_multi_mongos
-
-      let(:client) { authorized_client.with(max_pool_size: 4) }
-
-      it 'uses the available connection' do
-        server.pool.size.should == 0
-
-        # Create 4 connections.
-
-        enums = []
-        connections = []
-        service_ids = []
-
-        4.times do
-          view = collection.find({}, batch_size: 1)
-          enum = view.to_enum
-
-          enum.next
-
-          enums << enum
-          service_ids << view.cursor.initial_result.connection_description.service_id
-          connections << server.pool.check_out
-        end
-
-        service_ids.uniq.length.should be > 1
-
-        server.pool.size.should == 4
-
-        connections.each do |c|
-          server.pool.check_in(c)
-        end
 
-        # At this point, in theory, all connections are equally likely to
-        # be chosen, but we have cursors referencing more than one
-        # distinct service.
-        # Iterate each cursor to ensure they all continue to work.
-        enums.each do |enum|
-          enum.next
-        end
+      it 'returns connection to the pool when cursor is drained' do
+        view = collection.find({}, batch_size: 1)
+        enum = view.to_enum
+        expect_any_instance_of(Mongo::Cursor).to receive(:check_in_connection)
+        # Drain the cursor
+        enum.each { |it| it.nil? }
       end
     end
   end

data/spec/integration/cursor_reaping_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -24,7 +24,7 @@ describe 'Cursor reaping' do
   let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
-    authorized_client.tap do |client|
+    authorized_client.with(max_pool_size: 10).tap do |client|
       client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
     end
   end