mongo 2.18.1 → 2.18.3

data/spec/mongo/collection_spec.rb

@@ -647,7 +647,11 @@ describe Mongo::Collection do
     context 'when the collection is capped' do
 
       let(:collection) do
-        described_class.new(database, :specs, :capped => true, :size => 1024)
+        described_class.new(database, :specs, :capped => true, :size => 4096, :max => 512)
+      end
+
+      let(:collstats) do
+        database.read_command(:collstats => :specs).documents.first
       end
 
       before do
@@ -658,6 +662,12 @@ describe Mongo::Collection do
       it 'returns true' do
         expect(collection).to be_capped
       end
+
+      it "applies the options" do
+        expect(collstats["capped"]).to be true
+        expect(collstats["max"]).to eq(512)
+        expect(collstats["maxSize"]).to eq(4096)
+      end
     end
 
     context 'when the collection is not capped' do

data/spec/mongo/crypt/kms_spec.rb

@@ -33,7 +33,6 @@ describe Mongo::Crypt::KMS do
         %i(
           ssl_verify_certificate
           ssl_verify_hostname
-          ssl_verify_ocsp_endpoint
         ).each do |insecure_opt|
           expect {
             Mongo::Crypt::KMS::Validations.validate_tls_options(
@@ -46,14 +45,18 @@ describe Mongo::Crypt::KMS do
       end
 
       it 'allows valid options' do
-        options = {
-          aws: {
-            ssl: true,
-            ssl_cert_string: 'Content is not validated',
-
-          }
-        }
+        expect do
+          Mongo::Crypt::KMS::Validations.validate_tls_options(
+            {
+              aws: {
+                ssl: true,
+                ssl_cert_string: 'Content is not validated',
+                ssl_verify_ocsp_endpoint: false
+              }
+            }
+          )
+        end.not_to raise_error
       end
     end
   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

data/spec/mongo/protocol/caching_hash_spec.rb

@@ -34,49 +34,4 @@ describe Mongo::Protocol::CachingHash do
       end
     end
   end
-
-  describe "#needs_validation?" do
-
-    before do
-      hash.to_bson(BSON::ByteBuffer.new, validation)
-    end
-
-    let(:needs_validation?) do
-      hash.send(:needs_validation?, validating_keys)
-    end
-
-    context "when calling to_bson without validation" do
-      let(:validation) { false }
-
-      context "validating_keys is true" do
-        let(:validating_keys) { true }
-
-        it "is true" do
-          expect(needs_validation?).to be true
-        end
-      end
-
-      context "validating_keys is false" do
-        let(:validating_keys) { false }
-
-        it "is false" do
-          expect(needs_validation?).to be false
-        end
-      end
-    end
-
-    context "when calling to_bson with validation" do
-      let(:validation) { true }
-
-      [true, false].each do |b|
-        context "validating_keys is #{b}" do
-          let(:validating_keys) { b }
-
-          it "is false" do
-            expect(needs_validation?).to be false
-          end
-        end
-      end
-    end
-  end
 end

data/spec/mongo/protocol/msg_spec.rb

@@ -403,10 +403,8 @@ describe Mongo::Protocol::Msg do
         { validating_keys: true }
       end
 
-      it 'checks the sequence document keys' do
-        expect {
-          message.serialize
-        }.to raise_exception(BSON::String::IllegalKey)
+      it 'does not check the sequence document keys' do
+        expect(message.serialize).to be_a(BSON::ByteBuffer)
       end
     end
 

data/spec/mongo/server/app_metadata/environment_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongo::Server::AppMetadata::Environment do
+  let(:env) { described_class.new }
+
+  shared_examples_for 'running in a FaaS environment' do
+    it 'reports that a FaaS environment is detected' do
+      expect(env.faas?).to be true
+    end
+  end
+
+  shared_examples_for 'running outside a FaaS environment' do
+    it 'reports that no FaaS environment is detected' do
+      expect(env.faas?).to be false
+    end
+  end
+
+  context 'when run outside of a FaaS environment' do
+    it_behaves_like 'running outside a FaaS environment'
+  end
+
+  context 'when run in a FaaS environment' do
+    context 'when environment is invalid due to type mismatch' do
+      local_env(
+        'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+        'AWS_REGION' => 'us-east-2',
+        'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => 'big'
+      )
+
+      it_behaves_like 'running outside a FaaS environment'
+
+      it 'fails due to type mismatch' do
+        expect(env.error).to match(/AWS_LAMBDA_FUNCTION_MEMORY_SIZE must be integer/)
+      end
+    end
+
+    context 'when environment is invalid due to long string' do
+      local_env(
+        'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+        'AWS_REGION' => 'a' * 512,
+        'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024'
+      )
+
+      it_behaves_like 'running outside a FaaS environment'
+
+      it 'fails due to long string' do
+        expect(env.error).to match(/too long/)
+      end
+    end
+
+    context 'when environment is invalid due to multiple providers' do
+      local_env(
+        'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+        'AWS_REGION' => 'us-east-2',
+        'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024',
+        'FUNCTIONS_WORKER_RUNTIME' => 'ruby'
+      )
+
+      it_behaves_like 'running outside a FaaS environment'
+
+      it 'fails due to multiple providers' do
+        expect(env.error).to match(/too many environments/)
+      end
+    end
+
+    context 'when environment is invalid due to missing variable' do
+      local_env(
+        'AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7',
+        'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024'
+      )
+
+      it_behaves_like 'running outside a FaaS environment'
+
+      it 'fails due to missing variable' do
+        expect(env.error).to match(/missing environment variable/)
+      end
+    end
+
+    context 'when FaaS environment is AWS' do
+      shared_examples_for 'running in an AWS environment' do
+        context 'when environment is valid' do
+          local_env(
+            'AWS_REGION' => 'us-east-2',
+            'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024'
+          )
+
+          it_behaves_like 'running in a FaaS environment'
+
+          it 'recognizes AWS' do
+            expect(env.name).to be == 'aws.lambda'
+            expect(env.fields[:region]).to be == 'us-east-2'
+            expect(env.fields[:memory_mb]).to be == 1024
+          end
+        end
+      end
+
+      # per DRIVERS-2623, AWS_EXECUTION_ENV must be prefixed
+      # with 'AWS_Lambda_'.
+      context 'when AWS_EXECUTION_ENV is invalid' do
+        local_env(
+          'AWS_EXECUTION_ENV' => 'EC2',
+          'AWS_REGION' => 'us-east-2',
+          'AWS_LAMBDA_FUNCTION_MEMORY_SIZE' => '1024'
+        )
+
+        it_behaves_like 'running outside a FaaS environment'
+      end
+
+      context 'when AWS_EXECUTION_ENV is detected' do
+        local_env('AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7')
+        it_behaves_like 'running in an AWS environment'
+      end
+
+      context 'when AWS_LAMBDA_RUNTIME_API is detected' do
+        local_env('AWS_LAMBDA_RUNTIME_API' => 'lambda.aws.amazon.com/api')
+        it_behaves_like 'running in an AWS environment'
+      end
+    end
+
+    context 'when FaaS environment is Azure' do
+      local_env('FUNCTIONS_WORKER_RUNTIME' => 'ruby')
+
+      it_behaves_like 'running in a FaaS environment'
+
+      it 'recognizes Azure' do
+        expect(env.name).to be == 'azure.func'
+      end
+    end
+
+    context 'when FaaS environment is GCP' do
+      local_env(
+        'FUNCTION_MEMORY_MB' => '1024',
+        'FUNCTION_TIMEOUT_SEC' => '60',
+        'FUNCTION_REGION' => 'us-central1'
+      )
+
+      shared_examples_for 'running in a GCP environment' do
+        it_behaves_like 'running in a FaaS environment'
+
+        it 'recognizes GCP' do
+          expect(env.name).to be == 'gcp.func'
+          expect(env.fields[:region]).to be == 'us-central1'
+          expect(env.fields[:memory_mb]).to be == 1024
+          expect(env.fields[:timeout_sec]).to be == 60
+        end
+      end
+
+      context 'when K_SERVICE is present' do
+        local_env('K_SERVICE' => 'servicename')
+        it_behaves_like 'running in a GCP environment'
+      end
+
+      context 'when FUNCTION_NAME is present' do
+        local_env('FUNCTION_NAME' => 'functionName')
+        it_behaves_like 'running in a GCP environment'
+      end
+    end
+
+    context 'when FaaS environment is Vercel' do
+      local_env(
+        'VERCEL' => '1',
+        'VERCEL_URL' => '*.vercel.app',
+        'VERCEL_REGION' => 'cdg1'
+      )
+
+      it_behaves_like 'running in a FaaS environment'
+
+      it 'recognizes Vercel' do
+        expect(env.name).to be == 'vercel'
+        expect(env.fields[:url]).to be == '*.vercel.app'
+        expect(env.fields[:region]).to be == 'cdg1'
+      end
+    end
+
+    context 'when converting environment to a hash' do
+      local_env(
+        'K_SERVICE' => 'servicename',
+        'FUNCTION_MEMORY_MB' => '1024',
+        'FUNCTION_TIMEOUT_SEC' => '60',
+        'FUNCTION_REGION' => 'us-central1'
+      )
+
+      it 'includes name and all fields' do
+        expect(env.to_h).to be == {
+          name: 'gcp.func', memory_mb: 1024,
+          timeout_sec: 60, region: 'us-central1',
+        }
+      end
+    end
+  end
+end

data/spec/mongo/server/app_metadata/truncator_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Quoted from specifications/source/mongodb-handshake/handshake.rst:
+#
+# Implementors SHOULD cumulatively update fields in the following order
+# until the document is under the size limit:
+#
+# 1. Omit fields from env except env.name.
+# 2. Omit fields from os except os.type.
+# 3. Omit the env document entirely.
+# 4. Truncate platform.
+
+describe Mongo::Server::AppMetadata::Truncator do
+  let(:truncator) { described_class.new(Marshal.load(Marshal.dump(metadata))) }
+
+  let(:app_name) { 'application' }
+  let(:driver) { { name: 'driver', version: '1.2.3' } }
+  let(:os) { { type: 'Darwin', name: 'macOS', architecture: 'arm64', version: '13.4' } }
+  let(:platform) { { platform: 'platform' } }
+  let(:env) { { name: 'aws.lambda', region: 'region', memory_mb: 1024 } }
+
+  let(:metadata) do
+    BSON::Document.new.tap do |doc|
+      doc[:application] = { name: app_name }
+      doc[:driver] = driver
+      doc[:os] = os
+      doc[:platform] = platform
+      doc[:env] = env
+    end
+  end
+
+  let(:untruncated_length) { metadata.to_bson.to_s.length }
+  let(:truncated_length) { truncator.document.to_bson.to_s.length }
+
+  shared_examples_for 'a truncated document' do
+    it 'is shorter' do
+      expect(truncated_length).to be < untruncated_length
+    end
+
+    it 'is not be longer than the maximum document size' do
+      expect(truncated_length).to be <= described_class::MAX_DOCUMENT_SIZE
+    end
+  end
+
+  describe 'MAX_DOCUMENT_SIZE' do
+    it 'is 512 bytes' do
+      # This test is an additional check that MAX_DOCUMENT_SIZE
+      # has not been accidentially changed.
+      expect(described_class::MAX_DOCUMENT_SIZE).to be == 512
+    end
+  end
+
+  context 'when document does not need truncating' do
+    it 'does not truncate anything' do
+      expect(truncated_length).to be == untruncated_length
+    end
+  end
+
+  context 'when modifying env is sufficient' do
+    context 'when a single value is too long' do
+      let(:env) { { name: 'name', a: 'a' * 1000, b: 'b' } }
+
+      it 'preserves name' do
+        expect(truncator.document[:env][:name]).to be == 'name'
+      end
+
+      it 'removes the too-long entry and keeps name' do
+        expect(truncator.document[:env].keys).to be == %w[ name b ]
+      end
+
+      it_behaves_like 'a truncated document'
+    end
+
+    context 'when multiple values are too long' do
+      let(:env) { { name: 'name', a: 'a' * 1000, b: 'b', c: 'c' * 1000, d: 'd' } }
+
+      it 'preserves name' do
+        expect(truncator.document[:env][:name]).to be == 'name'
+      end
+
+      it 'removes all other entries until size is satisifed' do
+        expect(truncator.document[:env].keys).to be == %w[ name d ]
+      end
+
+      it_behaves_like 'a truncated document'
+    end
+  end
+
+  context 'when modifying os is sufficient' do
+    context 'when a single value is too long' do
+      let(:os) { { type: 'type', a: 'a' * 1000, b: 'b' } }
+
+      it 'truncates env' do
+        expect(truncator.document[:env].keys).to be == %w[ name ]
+      end
+
+      it 'preserves type' do
+        expect(truncator.document[:os][:type]).to be == 'type'
+      end
+
+      it 'removes the too-long entry and keeps type' do
+        expect(truncator.document[:os].keys).to be == %w[ type b ]
+      end
+
+      it_behaves_like 'a truncated document'
+    end
+
+    context 'when multiple values are too long' do
+      let(:os) { { type: 'type', a: 'a' * 1000, b: 'b', c: 'c' * 1000, d: 'd' } }
+
+      it 'truncates env' do
+        expect(truncator.document[:env].keys).to be == %w[ name ]
+      end
+
+      it 'preserves type' do
+        expect(truncator.document[:os][:type]).to be == 'type'
+      end
+
+      it 'removes all other entries until size is satisifed' do
+        expect(truncator.document[:os].keys).to be == %w[ type d ]
+      end
+
+      it_behaves_like 'a truncated document'
+    end
+  end
+
+  context 'when truncating os is insufficient' do
+    let(:env) { { name: 'n' * 1000 } }
+
+    it 'truncates os' do
+      expect(truncator.document[:os].keys).to be == %w[ type ]
+    end
+
+    it 'removes env' do
+      expect(truncator.document.key?(:env)).to be false
+    end
+
+    it_behaves_like 'a truncated document'
+  end
+
+  context 'when platform is too long' do
+    let(:platform) { 'n' * 1000 }
+
+    it 'truncates os' do
+      expect(truncator.document[:os].keys).to be == %w[ type ]
+    end
+
+    it 'removes env' do
+      expect(truncator.document.key?(:env)).to be false
+    end
+
+    it 'truncates platform' do
+      expect(truncator.document[:platform].length).to be < 1000
+    end
+  end
+end

data/spec/mongo/server/app_metadata_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe Mongo::Server::AppMetadata do
+  let(:max_size) { described_class::Truncator::MAX_DOCUMENT_SIZE }
 
   let(:app_metadata) do
     described_class.new(cluster.options)
@@ -13,14 +14,6 @@ describe Mongo::Server::AppMetadata do
     authorized_client.cluster
   end
 
-  describe 'MAX_DOCUMENT_SIZE' do
-    it 'should be 512 bytes' do
-      # This test is an additional check that MAX_DOCUMENT_SIZE
-      # has not been accidentially changed.
-      expect(described_class::MAX_DOCUMENT_SIZE).to eq(512)
-    end
-  end
-
   describe '#initialize' do
 
     context 'when the cluster has an app name option set' do
@@ -34,7 +27,7 @@ describe Mongo::Server::AppMetadata do
       end
 
       it 'sets the app name' do
-        expect(app_metadata.send(:full_client_document)[:application][:name]).to eq('app_metadata_test')
+        expect(app_metadata.client_document[:application][:name]).to eq('app_metadata_test')
       end
 
       context 'when the app name exceeds the max length of 128' do
@@ -58,77 +51,70 @@ describe Mongo::Server::AppMetadata do
     context 'when the cluster does not have an app name option set' do
 
       it 'does not set the app name' do
-        expect(app_metadata.send(:full_client_document)[:application]).to be(nil)
+        expect(app_metadata.client_document[:application]).to be(nil)
       end
     end
 
     context 'when the client document exceeds the max of 512 bytes' do
-      # Server api parameters change metadata length
-      require_no_required_api_version
-
-      context 'when the os.type length is too long' do
-
-        before do
-          allow(app_metadata).to receive(:type).and_return('x'*500)
+      shared_examples_for 'a truncated document' do
+        it 'is too long before validation' do
+          expect(app_metadata.client_document.to_bson.to_s.size).to be > max_size
         end
 
-        it 'truncates the document' do
-          expect(
-            app_metadata.validated_document.to_bson.to_s.size
-          ).to be < described_class::MAX_DOCUMENT_SIZE
+        it 'is acceptable after validation' do
+          app_metadata.validated_document # force validation
+          expect(app_metadata.client_document.to_bson.to_s.size).to be <= max_size
         end
       end
 
       context 'when the os.name length is too long' do
-
         before do
           allow(app_metadata).to receive(:name).and_return('x'*500)
         end
 
-        it 'truncates the document' do
-          expect(
-            app_metadata.validated_document.to_bson.to_s.size
-          ).to be < described_class::MAX_DOCUMENT_SIZE
-        end
+        it_behaves_like 'a truncated document'
       end
 
       context 'when the os.architecture length is too long' do
-
         before do
           allow(app_metadata).to receive(:architecture).and_return('x'*500)
         end
 
-        it 'truncates the document' do
-          expect(
-            app_metadata.validated_document.to_bson.to_s.size
-          ).to be < described_class::MAX_DOCUMENT_SIZE
-        end
+        it_behaves_like 'a truncated document'
       end
 
       context 'when the platform length is too long' do
-
         before do
           allow(app_metadata).to receive(:platform).and_return('x'*500)
         end
 
-        it 'truncates the document' do
-          expect(
-            app_metadata.validated_document.to_bson.to_s.size
-          ).to be < described_class::MAX_DOCUMENT_SIZE
-        end
+        it_behaves_like 'a truncated document'
       end
+    end
 
-      context 'when the driver info is too long' do
-        require_no_compression
+    context 'when run outside of a FaaS environment' do
+      it 'should exclude the :env key from the client document' do
+        expect(app_metadata.client_document.key?(:env)).to be false
+      end
+    end
 
-        before do
-          allow(app_metadata).to receive(:driver_doc).and_return('x'*500)
+    context 'when run inside of a FaaS environment' do
+      context 'when the environment is invalid' do
+        # invalid, because it is missing the other required fields
+        local_env('AWS_EXECUTION_ENV' => 'AWS_Lambda_ruby2.7')
+
+        it 'should exclude the :env key from the client document' do
+          expect(app_metadata.client_document.key?(:env)).to be false
         end
+      end
+
+      context 'when the environment is valid' do
+        # valid, because Azure requires only the one field
+        local_env('FUNCTIONS_WORKER_RUNTIME' => 'ruby')
 
-        it 'truncates the document' do
-          expect(
-            app_metadata.validated_document.to_bson.to_s.size
-          ).to be < described_class::MAX_DOCUMENT_SIZE
+        it 'should include the :env key in the client document' do
+          expect(app_metadata.client_document.key?(:env)).to be true
+          expect(app_metadata.client_document[:env][:name]).to be == "azure.func"
         end
       end
     end

data/spec/mongo/socket/ssl_spec.rb

@@ -592,14 +592,8 @@ describe Mongo::Socket::SSL do
         )
       end
 
-      around do |example|
-        saved = ENV['SSL_CERT_FILE']
-        ENV['SSL_CERT_FILE'] = SpecConfig.instance.local_ca_cert_path
-        begin
-          example.run
-        ensure
-          ENV['SSL_CERT_FILE'] = saved
-        end
+      local_env do
+        { 'SSL_CERT_FILE' => SpecConfig.instance.local_ca_cert_path }
       end
 
       it 'uses the default cert store' do

data/spec/runners/crud/requirement.rb

@@ -109,9 +109,9 @@ module Mongo
           end
         end
         if @auth == true
-          ok &&= cc.auth_enabled?
+          ok &&= SpecConfig.instance.auth?
         elsif @auth == false
-          ok &&= !cc.auth_enabled?
+          ok &&= !SpecConfig.instance.auth?
         end
         if @csfle
           ok &&= !!(ENV['LIBMONGOCRYPT_PATH'] || ENV['FLE'])

data/spec/shared/lib/mrss/docker_runner.rb

@@ -231,6 +231,10 @@ module Mrss
       distro =~ /debian|ubuntu/
     end
 
+    def ubuntu?
+      distro=~ /ubuntu/
+    end
+
     def preload?
       !!@options[:preload]
     end