mongo 2.18.2 → 2.18.3

data/lib/mongo/server/app_metadata/truncator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2016-2023 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+    class AppMetadata
+      # Implements the metadata truncation logic described in the handshake
+      # spec.
+      #
+      # @api private
+      class Truncator
+        # @return [ BSON::Document ] the document being truncated.
+        attr_reader :document
+
+        # The max application metadata document byte size.
+        MAX_DOCUMENT_SIZE = 512
+
+        # Creates a new Truncator instance and tries enforcing the maximum
+        # document size on the given document.
+        #
+        # @param [ BSON::Document] document The document to (potentially)
+        #   truncate.
+        #
+        # @note The document is modified in-place; if you wish to keep the
+        #   original unchanged, you must deep-clone it prior to sending it to
+        #   a truncator.
+        def initialize(document)
+          @document = document
+          try_truncate!
+        end
+
+        # The current size of the document, in bytes, as a serialized BSON
+        # document.
+        #
+        # @return [ Integer ] the size of the document
+        def size
+          @document.to_bson.to_s.length
+        end
+
+        # Whether the document fits within the required maximum document size.
+        #
+        # @return [ true | false ] if the document is okay or not.
+        def ok?
+          size <= MAX_DOCUMENT_SIZE
+        end
+
+        private
+
+        # How many extra bytes must be trimmed before the document may be
+        # considered #ok?.
+        #
+        # @return [ Integer ] how many bytes larger the document is than the
+        #   maximum document size.
+        def excess
+          size - MAX_DOCUMENT_SIZE
+        end
+
+        # Attempt to truncate the document using the documented metadata
+        # priorities (see the handshake specification).
+        def try_truncate!
+          %i[ env_fields os_fields env platform ].each do |target|
+            break if ok?
+
+            send(:"try_truncate_#{target}!")
+          end
+        end
+
+        # Attempt to truncate or remove the {{:platform}} key from the
+        # document.
+        def try_truncate_platform!
+          @document.delete(:platform) unless try_truncate_string(@document[:platform])
+        end
+
+        # Attempt to truncate the keys in the {{:env}} subdocument.
+        def try_truncate_env_fields!
+          try_truncate_hash(@document[:env], reserved: %w[ name ])
+        end
+
+        # Attempt to truncate the keys in the {{:os}} subdocument.
+        def try_truncate_os_fields!
+          try_truncate_hash(@document[:os], reserved: %w[ type ])
+        end
+
+        # Remove the {{:env}} key from the document.
+        def try_truncate_env!
+          @document.delete(:env)
+        end
+
+        # A helper method for truncating a string (in-place) by whatever
+        # {{#excess}} is required.
+        #
+        # @param [ String ] string the string value to truncate.
+        #
+        # @note the parameter is modified in-place.
+        def try_truncate_string(string)
+          length = string&.length || 0
+
+          return false if excess > length
+
+          string[(length - excess)..-1] = ''
+        end
+
+        # A helper method for removing the keys of a Hash (in-place) until
+        # the document is the necessary size. The keys are considered in order
+        # (using the Hash's native key ordering), and each will be removed from
+        # the hash in turn, until the document is the necessary size.
+        #
+        # Any keys in the {{reserved}} list will be ignored.
+        #
+        # @param [ Hash | nil ] hash the Hash instance to consider.
+        # @param [ Array ] reserved the list of keys to ignore in the hash.
+        #
+        # @note the hash parameter is modified in-place.
+        def try_truncate_hash(hash, reserved: [])
+          return false unless hash
+
+          keys = hash.keys - reserved
+          keys.each do |key|
+            hash.delete(key)
+
+            return true if ok?
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mongo/server/app_metadata.rb

@@ -15,6 +15,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mongo/server/app_metadata/environment'
+require 'mongo/server/app_metadata/truncator'
+
 module Mongo
   class Server
     # Application metadata that is sent to the server during a handshake,
@@ -26,11 +29,6 @@ module Mongo
     class AppMetadata
       extend Forwardable
 
-      # The max application metadata document byte size.
-      #
-      # @since 2.4.0
-      MAX_DOCUMENT_SIZE = 512.freeze
-
       # The max application name byte size.
       #
       # @since 2.4.0
@@ -139,6 +137,23 @@ module Mongo
         document
       end
 
+      # Get BSON::Document to be used as value for `client` key in
+      # handshake document.
+      #
+      # @return [BSON::Document] Document describing client for handshake.
+      #
+      # @api private
+      def client_document
+        @client_document ||=
+          BSON::Document.new.tap do |doc|
+            doc[:application] = { name: @app_name } if @app_name
+            doc[:driver] = driver_doc
+            doc[:os] = os_doc
+            doc[:platform] = platform
+            env_doc.tap { |env| doc[:env] = env if env }
+          end
+      end
+
       private
 
       # Check whether it is possible to build a valid app metadata document
@@ -152,20 +167,6 @@ module Mongo
         true
       end
 
-      # Get BSON::Document to be used as value for `client` key in
-      # handshake document.
-      #
-      # @return [BSON::Document] Document describing client for handshake.
-      def full_client_document
-        BSON::Document.new.tap do |doc|
-          doc[:application] = { name: @app_name } if @app_name
-          doc[:driver] = driver_doc
-          doc[:os] = os_doc
-          doc[:platform] = platform
-        end
-      end
-
-
       # Get the metadata as BSON::Document to be sent to
       # as part of the handshake. The document should
       # be appended to a suitable handshake command.
@@ -173,30 +174,11 @@ module Mongo
       # @return [BSON::Document] Document for connection's handshake.
       def document
         @document ||= begin
-          client_document = full_client_document
-          while client_document.to_bson.to_s.size > MAX_DOCUMENT_SIZE do
-            if client_document[:os][:name] || client_document[:os][:architecture]
-              client_document[:os].delete(:name)
-              client_document[:os].delete(:architecture)
-            elsif client_document[:platform]
-              client_document.delete(:platform)
-            else
-              client_document = nil
-            end
+          client = Truncator.new(client_document).document
+          BSON::Document.new(compression: @compressors, client: client).tap do |doc|
+            doc[:saslSupportedMechs] = @request_auth_mech if @request_auth_mech
+            doc.update(Utils.transform_server_api(@server_api)) if @server_api
           end
-          document = BSON::Document.new(
-            {
-              compression: @compressors,
-              client: client_document,
-            }
-          )
-          document[:saslSupportedMechs] = @request_auth_mech if @request_auth_mech
-          if @server_api
-            document.update(
-              Utils.transform_server_api(@server_api)
-            )
-          end
-          document
         end
       end
 
@@ -223,6 +205,11 @@ module Mongo
         }
       end
 
+      def env_doc
+        env = Environment.new
+        env.faas? ? env.to_h : nil
+      end
+
       def type
         (RbConfig::CONFIG && RbConfig::CONFIG['host_os']) ?
           RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase : 'unknown'

data/lib/mongo/version.rb

@@ -20,5 +20,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.18.2'.freeze
+  VERSION = '2.18.3'.freeze
 end

data/spec/integration/connection/faas_env_spec.rb

@@ -0,0 +1,63 @@
+# 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_URL' => '*.vercel.app',
+    '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/find_options_spec.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Find operation options' do
+  require_mri
+  require_no_auth
+  min_server_fcv '4.4'
+
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  let(:seeds) do
+    [ SpecConfig.instance.addresses.first ]
+  end
+
+  let(:client_options) do
+    {}
+  end
+
+  let(:collection_options) do
+    {}
+  end
+
+  let(:client) do
+    ClientRegistry.instance.new_local_client(
+      seeds,
+      SpecConfig.instance.test_options
+        .merge(database: SpecConfig.instance.test_db)
+        .merge(client_options)
+    ).tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:collection) do
+    client['find_options', collection_options]
+  end
+
+  let(:find_command) do
+    subscriber.started_events.find { |cmd| cmd.command_name == 'find' }
+  end
+
+  let(:should_create_collection) { true }
+
+  before do
+    client['find_options'].drop
+    collection.create if should_create_collection
+    collection.insert_many([ { a: 1 }, { a: 2 }, { a: 3 } ])
+  end
+
+  describe 'collation' do
+    let(:client_options) do
+      {}
+    end
+
+    let(:collation) do
+      { 'locale' => 'en_US' }
+    end
+
+    context 'when defined on the collection' do
+      let(:collection_options) do
+        { collation: collation }
+      end
+
+      it 'uses the collation defined on the collection' do
+        collection.find.to_a
+        expect(find_command.command['collation']).to be_nil
+      end
+    end
+
+    context 'when defined on the operation' do
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the collation defined on the collection' do
+        collection.find({}, collation: collation).to_a
+        expect(find_command.command['collation']).to eq(collation)
+      end
+    end
+
+    context 'when defined on both collection and operation' do
+      let(:collection_options) do
+        { 'locale' => 'de_AT' }
+      end
+
+      let(:should_create_collection) { false }
+
+      it 'uses the collation defined on the collection' do
+        collection.find({}, collation: collation).to_a
+        expect(find_command.command['collation']).to eq(collation)
+      end
+    end
+  end
+
+  describe 'read concern' do
+    context 'when defined on the client' do
+      let(:client_options) do
+        { read_concern: { level: :local } }
+      end
+
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the read concern defined on the client' do
+        collection.find.to_a
+        expect(find_command.command['readConcern']).to eq('level' => 'local')
+      end
+
+      context 'when defined on the collection' do
+        let(:collection_options) do
+          { read_concern: { level: :majority } }
+        end
+
+        it 'uses the read concern defined on the collection' do
+          collection.find.to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'majority')
+        end
+
+        context 'when defined on the operation' do
+          let(:operation_read_concern) do
+            { level: :available }
+          end
+
+          it 'uses the read concern defined on the operation' do
+            collection.find({}, read_concern: operation_read_concern).to_a
+            expect(find_command.command['readConcern']).to eq('level' => 'available')
+          end
+        end
+      end
+
+      context 'when defined on the operation' do
+        let(:collection_options) do
+          {}
+        end
+
+        let(:operation_read_concern) do
+          { level: :available }
+        end
+
+        it 'uses the read concern defined on the operation' do
+          collection.find({}, read_concern: operation_read_concern).to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'available')
+        end
+      end
+    end
+
+    context 'when defined on the collection' do
+      let(:client_options) do
+        {}
+      end
+
+      let(:collection_options) do
+        { read_concern: { level: :majority } }
+      end
+
+      it 'uses the read concern defined on the collection' do
+        collection.find.to_a
+        expect(find_command.command['readConcern']).to eq('level' => 'majority')
+      end
+
+      context 'when defined on the operation' do
+        let(:operation_read_concern) do
+          { level: :available }
+        end
+
+        it 'uses the read concern defined on the operation' do
+          collection.find({}, read_concern: operation_read_concern).to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'available')
+        end
+      end
+    end
+  end
+
+  describe 'read preference' do
+    require_topology :replica_set
+
+    context 'when defined on the client' do
+      let(:client_options) do
+        { read: { mode: :secondary } }
+      end
+
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the read preference defined on the client' do
+        collection.find.to_a
+        expect(find_command.command['$readPreference']).to eq('mode' => 'secondary')
+      end
+
+      context 'when defined on the collection' do
+        let(:collection_options) do
+          { read: { mode: :secondary_preferred } }
+        end
+
+        it 'uses the read concern defined on the collection' do
+          collection.find.to_a
+          expect(find_command.command['$readPreference']).to eq('mode' => 'secondaryPreferred')
+        end
+      end
+    end
+  end
+
+  describe 'cursor type' do
+    let(:collection_options) do
+      { capped: true, size: 1000 }
+    end
+
+    context 'when cursor type is :tailable' do
+      it 'sets the cursor type to tailable' do
+        collection.find({}, cursor_type: :tailable).first
+        expect(find_command.command['tailable']).to be true
+        expect(find_command.command['awaitData']).to be_falsey
+      end
+    end
+
+    context 'when cursor type is :tailable_await' do
+      it 'sets the cursor type to tailable' do
+        collection.find({}, cursor_type: :tailable_await).first
+        expect(find_command.command['tailable']).to be true
+        expect(find_command.command['awaitData']).to be true
+      end
+    end
+  end
+end

data/spec/integration/ocsp_verifier_spec.rb

@@ -352,7 +352,7 @@ describe Mongo::Socket::OcspVerifier do
 
     it 'verifies' do
       # TODO This test will fail if the certificate expires
-      verifier.verify.should be true
+      expect(verifier.verify).to be(true), "If atlas-ocsp certificates have expired, run spec/support/certificates/retrieve-atlas-cert to get a new ones"
     end
   end
 end

data/spec/lite_spec_helper.rb

@@ -110,6 +110,15 @@ RSpec.configure do |config|
   config.include(MongosMacros)
   config.extend(Mongo::Macros)
 
+  # Used for spec/solo/*
+  def require_solo
+    before(:all) do
+      unless %w(1 true yes).include?(ENV['SOLO'])
+        skip 'Set SOLO=1 in environment to run solo tests'
+      end
+    end
+  end
+
   if SpecConfig.instance.ci?
     SdamFormatterIntegration.subscribe
     config.add_formatter(JsonExtFormatter, File.join(File.dirname(__FILE__), '../tmp/rspec.json'))

data/spec/mongo/address_spec.rb

@@ -305,7 +305,7 @@ describe Mongo::Address do
         RSpec::Mocks.with_temporary_scope do
           resolved_address = double('address')
           # This test's expectation
-          expect(resolved_address).to receive(:socket).with(0, connect_timeout: 10)
+          expect(resolved_address).to receive(:socket).with(0, { connect_timeout: 10 })
 
           expect(Mongo::Address::IPv4).to receive(:new).and_return(resolved_address)
 

data/spec/mongo/client_construction_spec.rb

@@ -953,7 +953,7 @@ describe Mongo::Client do
         end
 
         it 'includes the platform info in the app metadata' do
-          expect(app_metadata.send(:full_client_document)[:platform]).to match(/mongoid-6\.0\.2/)
+          expect(app_metadata.client_document[:platform]).to match(/mongoid-6\.0\.2/)
         end
       end
 
@@ -980,7 +980,7 @@ describe Mongo::Client do
           end
 
           it 'does not include the platform info in the app metadata' do
-            expect(app_metadata.send(:full_client_document)[:platform]).to eq(platform_string)
+            expect(app_metadata.client_document[:platform]).to eq(platform_string)
           end
         end
 
@@ -999,7 +999,7 @@ describe Mongo::Client do
           end
 
           it 'does not include the platform info in the app metadata' do
-            expect(app_metadata.send(:full_client_document)[:platform]).to eq(platform_string)
+            expect(app_metadata.client_document[:platform]).to eq(platform_string)
           end
         end
       end

data/spec/mongo/client_spec.rb

@@ -947,7 +947,7 @@ describe Mongo::Client do
           before do
             sessions_checked_out = 0
 
-            allow_any_instance_of(Mongo::Server).to receive(:with_connection).and_wrap_original do |m, *args, &block|
+            allow_any_instance_of(Mongo::Server).to receive(:with_connection).and_wrap_original do |m, *args, **kwargs, &block|
               m.call(*args) do |connection|
                 sessions_checked_out = 0
                 res = block.call(connection)
@@ -955,14 +955,6 @@ describe Mongo::Client do
                 res
               end
             end
-
-            allow_any_instance_of(Mongo::Session).to receive(:materialize).and_wrap_original do |m, *args|
-              sessions_checked_out += 1
-              m.call(*args).tap do
-                checked_out_connections = args[0].connection_pool.instance_variable_get("@checked_out_connections")
-                expect(checked_out_connections.length).to eq 1
-              end
-            end
           end
 
           it 'doesn\'t have any live sessions' do

data/spec/mongo/cluster_spec.rb

@@ -480,7 +480,7 @@ describe Mongo::Cluster do
       end
 
       it 'constructs an AppMetadata object with the app_name' do
-        expect(cluster.app_metadata.send(:full_client_document)[:application]).to eq('name' => 'cluster_test')
+        expect(cluster.app_metadata.client_document[:application]).to eq('name' => 'cluster_test')
       end
     end
 
@@ -491,7 +491,7 @@ describe Mongo::Cluster do
       end
 
       it 'constructs an AppMetadata object with no app_name' do
-        expect(cluster.app_metadata.send(:full_client_document)[:application]).to be_nil
+        expect(cluster.app_metadata.client_document[:application]).to be_nil
       end
     end
   end

data/spec/mongo/crypt_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongo::Crypt do
+  describe '.validate_ffi!' do
+    context 'when ffi is available' do
+      context 'when ffi is loaded' do
+        it 'does not raise' do
+          expect do
+            described_class.validate_ffi!
+          end.not_to raise_error
+        end
+      end
+    end
+    # There is no reasonably simple way to test the path where ffi is not
+    # available. The ffi gem is a part of our standard test dependencies, so
+    # it's always available. So, we would need a dedicated configuration
+    # just to test this feature; it seems to be an overhead.
+  end
+end

data/spec/mongo/index/view_spec.rb

@@ -960,6 +960,7 @@ describe Mongo::Index::View do
         min_server_fcv '5.0'
 
         it 'passes wildcardProjection correctly' do
+          skip 'https://jira.mongodb.org/browse/RUBY-3216'
           expect(indexes[:wildcardProjection]).to eq({ '_id' => false, 'rating' => true })
         end
       end