mongo 2.18.1 → 2.18.3

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/session.rb

@@ -522,7 +522,7 @@ module Mongo
     #
     # @option options [ Integer ] :max_commit_time_ms The maximum amount of
     #   time to allow a single commitTransaction command to run, in milliseconds.
-    # @option options [ Hash ] read_concern The read concern options hash,
+    # @option options [ Hash ] :read_concern The read concern options hash,
     #   with the following optional keys:
     #   - *:level* -- the read preference level as a symbol; valid values
     #      are *:local*, *:majority*, and *:snapshot*

data/lib/mongo/version.rb

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

data/spec/integration/command_spec.rb

@@ -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/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
@@ -1773,28 +1773,28 @@ describe Mongo::Client do
             expect do
               client = new_local_client_nmio(['127.0.0.1:27017'],
                 :read => {:mode => :bogus})
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: {"mode"=>:bogus}: mode bogus is not one of recognized modes')
+            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read preference value: {"mode"=>:bogus}: mode bogus is not one of recognized modes')
           end
 
           it 'rejects bogus read preference as string' do
             expect do
               client = new_local_client_nmio(['127.0.0.1:27017'],
                 :read => {:mode => 'bogus'})
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: {"mode"=>"bogus"}: mode bogus is not one of recognized modes')
+            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read preference value: {"mode"=>"bogus"}: mode bogus is not one of recognized modes')
           end
 
           it 'rejects read option specified as a string' do
             expect do
               client = new_local_client_nmio(['127.0.0.1:27017'],
                 :read => 'primary')
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: primary: must be a hash')
+            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read preference value: "primary": the read preference must be specified as a hash: { mode: "primary" }')
           end
 
           it 'rejects read option specified as a symbol' do
             expect do
               client = new_local_client_nmio(['127.0.0.1:27017'],
                 :read => :primary)
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: primary: must be a hash')
+            end.to raise_error(Mongo::Error::InvalidReadOption, "Invalid read preference value: :primary: the read preference must be specified as a hash: { mode: :primary }")
           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/collection_crud_spec.rb

@@ -362,6 +362,42 @@ describe Mongo::Collection do
       expect(result.inserted_ids.size).to eq(2)
     end
 
+    context 'when an enumerable is used instead of an array' do
+
+      context 'when the enumerable is not empty' do
+
+        let(:source_data) do
+          [{ name: 'test1' }, { name: 'test2' }]
+        end
+
+        let(:result) do
+          authorized_collection.insert_many(source_data.lazy)
+        end
+
+        it 'should accepts them without raising an error' do
+          expect { result }.to_not raise_error
+          expect(result.inserted_count).to eq(source_data.size)
+        end
+      end
+
+      context 'when the enumerable is empty' do
+
+        let(:source_data) do
+          []
+        end
+
+        let(:result) do
+          authorized_collection.insert_many(source_data.lazy)
+        end
+
+        it 'should raise ArgumentError' do
+          expect do
+            result
+          end.to raise_error(ArgumentError, /Bulk write requests cannot be empty/)
+        end
+      end
+    end
+
     context 'when a session is provided' do
 
       let(:session) do
@@ -4412,4 +4448,24 @@ describe Mongo::Collection do
       expect(result).to be_nil
     end
   end
+
+  context "when creating collection with view_on and pipeline" do
+    before do
+      authorized_client["my_view"].drop
+      authorized_collection.insert_one({ bar: "here!" })
+      authorized_client["my_view",
+        view_on: authorized_collection.name,
+        pipeline: [ { :'$project' => { "baz": "$bar" } } ]
+      ].create
+    end
+
+    it "the view has a document" do
+      expect(authorized_client["my_view"].find.to_a.length).to eq(1)
+    end
+
+    it "applies the pipeline" do
+      expect(authorized_client["my_view"].find.first).to have_key("baz")
+      expect(authorized_client["my_view"].find.first["baz"]).to eq("here!")
+    end
+  end
 end