mongo 2.18.2 → 2.18.3

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

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

@@ -209,6 +209,14 @@ module Mrss
       end
     end
 
+    def require_no_fallbacks
+      before(:all) do
+        if %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
+          skip 'Set TEST_I18N_FALLBACKS=0 environment variable to run these tests'
+        end
+      end
+    end
+
     # This is a macro for retrying flaky tests on CI that occasionally fail.
     # Note that the tests will only be retried on CI.
     #

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

@@ -24,6 +24,21 @@ module Mrss
 
     attr_reader :desired_version, :arch
 
+    def target_arch
+      # can't use RbConfig::CONFIG["arch"] because JRuby doesn't
+      # return anything meaningful there.
+      #
+      # also, need to use `uname -a` instead of (e.g.) `uname -p`
+      # because debian (at least) does not return anything meaningful
+      # for `uname -p`.
+      uname = `uname -a`.strip
+      @target_arch ||= case uname
+        when /aarch/ then "aarch64"
+        when /x86/   then "x86_64"
+        else raise "unsupported architecture #{uname.inspect}"
+        end
+    end
+
     def download_url
       @download_url ||= begin
         version, version_ok = detect_version(current_catalog)
@@ -40,35 +55,13 @@ module Mrss
         end
         dl = version['downloads'].detect do |dl|
           dl['archive']['url'].index("enterprise-#{arch}") &&
-          dl['arch'] == 'x86_64'
+          dl['arch'] == target_arch
         end
         unless dl
           raise MissingDownloadUrl, "No download for #{arch} for #{version['version']}"
         end
         url = dl['archive']['url']
       end
-    rescue MissingDownloadUrl
-      if %w(2.6 3.0).include?(desired_version) && arch == 'ubuntu1604'
-        # 2.6 and 3.0 are only available for ubuntu1204 and ubuntu1404.
-        # Those ubuntus have ancient Pythons that don't work due to not
-        # implementing recent TLS protocols.
-        # Because of this we test on ubuntu1604 which has a newer Python.
-        # But we still need to retrieve ubuntu1404-targeting builds.
-        url = self.class.new('3.2', arch).download_url
-        unless url.include?('3.2.')
-          raise 'URL not in expected format'
-        end
-        url = case desired_version
-        when '2.6'
-          url.sub(/\b3\.2\.\d+/, '2.6.12')
-        when '3.0'
-          url.sub(/\b3\.2\.\d+/, '3.0.15')
-        else
-          raise NotImplementedError
-        end.sub('ubuntu1604', 'ubuntu1404')
-      else
-        raise
-      end
     end
 
     private