mongo 2.19.1 → 2.21.0

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

@@ -1,8 +1,52 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'spec_helper'
+require 'fileutils'
+
+MOCKED_DOCKERENV_PATH = File.expand_path(File.join(Dir.pwd, '.dockerenv-mocked'))
+
+module ContainerChecking
+  def mock_dockerenv_path
+    before do
+      allow_any_instance_of(Mongo::Server::AppMetadata::Environment)
+        .to receive(:dockerenv_path)
+        .and_return(MOCKED_DOCKERENV_PATH)
+    end
+  end
+
+  def with_docker
+    mock_dockerenv_path
+
+    around do |example|
+      File.write(MOCKED_DOCKERENV_PATH, 'placeholder')
+      example.run
+    ensure
+      File.delete(MOCKED_DOCKERENV_PATH)
+    end
+  end
+
+  def without_docker
+    mock_dockerenv_path
+
+    around do |example|
+      FileUtils.rm_f(MOCKED_DOCKERENV_PATH)
+      example.run
+    end
+  end
+
+  def with_kubernetes
+    local_env 'KUBERNETES_SERVICE_HOST' => 'kubernetes.default.svc.cluster.local'
+  end
+
+  def without_kubernetes
+    local_env 'KUBERNETES_SERVICE_HOST' => nil
+  end
+end
 
 describe Mongo::Server::AppMetadata::Environment do
+  extend ContainerChecking
+
   let(:env) { described_class.new }
 
   shared_examples_for 'running in a FaaS environment' do
@@ -17,6 +61,36 @@ describe Mongo::Server::AppMetadata::Environment do
     end
   end
 
+  shared_examples_for 'not running in a Docker container' do
+    it 'does not detect Docker' do
+      expect(env.container || {}).not_to include :runtime
+    end
+  end
+
+  shared_examples_for 'not running under Kubernetes' do
+    it 'does not detect Kubernetes' do
+      expect(env.container || {}).not_to include :orchestrator
+    end
+  end
+
+  shared_examples_for 'running under Kubernetes' do
+    it 'detects that Kubernetes is present' do
+      expect(env.container[:orchestrator]).to be == 'kubernetes'
+    end
+  end
+
+  shared_examples_for 'running in a Docker container' do
+    it 'detects that Docker is present' do
+      expect(env.container[:runtime]).to be == 'docker'
+    end
+  end
+
+  shared_examples_for 'running under Kerbenetes' do
+    it 'detects that kubernetes is present' do
+      expect(env.container['orchestrator']).to be == 'kubernetes'
+    end
+  end
+
   context 'when run outside of a FaaS environment' do
     it_behaves_like 'running outside a FaaS environment'
   end
@@ -204,6 +278,67 @@ describe Mongo::Server::AppMetadata::Environment do
           timeout_sec: 60, region: 'us-central1',
         }
       end
+
+      context 'when a container is present' do
+        with_kubernetes
+        with_docker
+
+        it 'includes a container key' do
+          expect(env.to_h[:container]).to be == {
+            runtime: 'docker',
+            orchestrator: 'kubernetes'
+          }
+        end
+      end
+
+      context 'when no container is present' do
+        without_kubernetes
+        without_docker
+
+        it 'does not include a container key' do
+          expect(env.to_h).not_to include(:container)
+        end
+      end
+    end
+  end
+
+  # have a specific test for this, since the tests that check
+  # for Docker use a mocked value for the .dockerenv path.
+  it 'should look for dockerenv in root directory' do
+    expect(described_class::DOCKERENV_PATH).to be == '/.dockerenv'
+  end
+
+  context 'when no container is present' do
+    without_kubernetes
+    without_docker
+
+    it_behaves_like 'not running in a Docker container'
+    it_behaves_like 'not running under Kubernetes'
+  end
+
+  context 'when container is present' do
+    context 'when kubernetes is present' do
+      without_docker
+      with_kubernetes
+
+      it_behaves_like 'not running in a Docker container'
+      it_behaves_like 'running under Kubernetes'
+    end
+
+    context 'when docker is present' do
+      with_docker
+      without_kubernetes
+
+      it_behaves_like 'running in a Docker container'
+      it_behaves_like 'not running under Kubernetes'
+    end
+
+    context 'when both kubernetes and docker are present' do
+      with_docker
+      with_kubernetes
+
+      it_behaves_like 'running in a Docker container'
+      it_behaves_like 'running under Kubernetes'
     end
   end
 end

data/spec/mongo/server/app_metadata_spec.rb

@@ -87,8 +87,18 @@ describe Mongo::Server::AppMetadata do
     end
 
     context 'when run outside of a FaaS environment' do
-      it 'excludes the :env key from the client document' do
-        expect(app_metadata.client_document.key?(:env)).to be false
+      context 'when a container is present' do
+        local_env 'KUBERNETES_SERVICE_HOST' => 'something'
+
+        it 'includes the :env key in the client document' do
+          expect(app_metadata.client_document.key?(:env)).to be true
+        end
+      end
+
+      context 'when no container is present' do
+        it 'excludes the :env key from the client document' do
+          expect(app_metadata.client_document.key?(:env)).to be false
+        end
       end
     end
 

data/spec/mongo/server/connection_spec.rb

@@ -265,6 +265,10 @@ describe Mongo::Server::Connection do
       context 'when #authenticate! raises an exception' do
         require_auth
 
+        # because the mock/stub flow here doesn't cover the flow used by
+        # the X.509 authentication mechanism...
+        forbid_x509_auth
+
         let(:server_options) do
           Mongo::Client.canonicalize_ruby_options(
             SpecConfig.instance.all_test_options,
@@ -579,6 +583,28 @@ describe Mongo::Server::Connection do
       end
     end
 
+    context 'when the server returns unknown saslSupportedMechs' do
+      min_server_version '4.0'
+
+      let(:connection) do
+        described_class.new(server, server.options.merge(connection_pool: pool))
+      end
+
+      before do
+        expect_any_instance_of(Mongo::Server::PendingConnection).to receive(:get_handshake_response).and_wrap_original do |original_method, *args|
+          original_method.call(*args).tap do |result|
+            if result.documents.first.fetch('saslSupportedMechs', nil).is_a?(Array)
+              result.documents.first['saslSupportedMechs'].append('unknownMechanism')
+            end
+          end
+        end
+      end
+
+      it 'does not raise an error' do
+        expect { connection.connect! }.not_to raise_error
+      end
+    end
+
   end
 
   describe '#disconnect!' do

data/spec/mongo/server/round_trip_time_calculator_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require 'spec_helper'
+
+describe Mongo::Server::RoundTripTimeCalculator do
+  let(:calculator) { Mongo::Server::RoundTripTimeCalculator.new }
+
+  describe '#update_average_round_trip_time' do
+    context 'no existing average rtt' do
+      it 'updates average rtt' do
+        calculator.instance_variable_set('@last_round_trip_time', 5)
+        calculator.update_average_round_trip_time
+        expect(calculator.average_round_trip_time).to eq(5)
+      end
+    end
+
+    context 'with existing average rtt' do
+      it 'averages with existing average rtt' do
+        calculator.instance_variable_set('@last_round_trip_time', 5)
+        calculator.instance_variable_set('@average_round_trip_time', 10)
+        calculator.update_average_round_trip_time
+        expect(calculator.average_round_trip_time).to eq(9)
+      end
+    end
+  end
+
+  describe '#update_minimum_round_trip_time' do
+    context 'with no samples' do
+      it 'sets minimum_round_trip_time to zero' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(0)
+      end
+    end
+
+    context 'with one sample' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 5)
+      end
+
+      it 'sets minimum_round_trip_time to zero' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(0)
+      end
+    end
+
+    context 'with two samples' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 10)
+        calculator.instance_variable_set('@rtts', [5])
+      end
+
+      it 'sets minimum_round_trip_time to zero' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(0)
+      end
+    end
+
+    context 'with samples less than maximum' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 10)
+        calculator.instance_variable_set('@rtts', [5, 4, 120])
+      end
+
+      it 'properly sets minimum_round_trip_time' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(4)
+      end
+    end
+
+    context 'with more than maximum samples' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 2)
+        calculator.instance_variable_set('@rtts', [1, 20, 15, 4, 5, 6, 7, 39, 8, 4])
+      end
+
+      it 'properly sets minimum_round_trip_time' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(2)
+      end
+    end
+
+  end
+
+  describe '#measure' do
+    context 'block does not raise' do
+      it 'updates average rtt' do
+        expect(calculator).to receive(:update_average_round_trip_time)
+        calculator.measure do
+        end
+      end
+
+      it 'updates minimum rtt' do
+        expect(calculator).to receive(:update_minimum_round_trip_time)
+        calculator.measure do
+        end
+      end
+    end
+
+    context 'block raises' do
+      it 'does not update average rtt' do
+        expect(calculator).not_to receive(:update_average_round_trip_time)
+        expect do
+          calculator.measure do
+            raise "Problem"
+          end
+        end.to raise_error(/Problem/)
+      end
+
+      it 'does not update minimum rtt' do
+        expect(calculator).not_to receive(:update_minimum_round_trip_time)
+        expect do
+          calculator.measure do
+            raise "Problem"
+          end
+        end.to raise_error(/Problem/)
+      end
+    end
+  end
+end

data/spec/mongo/session/session_pool_spec.rb

@@ -17,21 +17,6 @@ describe Mongo::Session::SessionPool do
     end
   end
 
-  describe '.create' do
-
-    let!(:pool) do
-      described_class.create(cluster)
-    end
-
-    it 'creates a session pool' do
-      expect(pool).to be_a(Mongo::Session::SessionPool)
-    end
-
-    it 'adds the pool as an instance variable on the cluster' do
-      expect(cluster.session_pool).to eq(pool)
-    end
-  end
-
   describe '#initialize' do
 
     let(:pool) do
@@ -181,7 +166,7 @@ describe Mongo::Session::SessionPool do
   describe '#end_sessions' do
 
     let(:pool) do
-      described_class.create(client.cluster)
+      client.cluster.session_pool
     end
 
     let!(:session_a) do

data/spec/mongo/session_transaction_spec.rb

@@ -26,6 +26,17 @@ describe Mongo::Session do
     collection.delete_many
   end
 
+  describe 'start_transaction' do
+    context 'when topology is sharded and server is < 4.2' do
+      max_server_fcv '4.1'
+      require_topology :sharded
+
+      it 'raises an error' do
+        expect { session.start_transaction }.to raise_error(Mongo::Error::TransactionsNotSupported, /sharded transactions require server version/)
+      end
+    end
+  end
+
   describe '#abort_transaction' do
     require_topology :replica_set
 
@@ -75,6 +86,8 @@ describe Mongo::Session do
   end
 
   describe '#with_transaction' do
+    require_topology :replica_set
+
     context 'callback successful' do
       it 'commits' do
         session.with_transaction do
@@ -123,6 +136,7 @@ describe Mongo::Session do
         expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 1)
         expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 2)
         expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
+        allow(session).to receive('check_transactions_supported!').and_return true
 
         expect do
           session.with_transaction do
@@ -156,6 +170,7 @@ describe Mongo::Session do
             expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + i)
           end
           expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
+          allow(session).to receive('check_transactions_supported!').and_return true
 
           exc = Mongo::Error::OperationFailure.new('timeout test')
           exc.add_label(label)

data/spec/mongo/socket/ssl_spec.rb

@@ -103,16 +103,6 @@ describe Mongo::Socket::SSL do
           expect(socket).to be_alive
         end
       end
-
-      context 'when connecting the tcp socket raises an exception' do
-
-        it 'raises an exception' do
-          expect_any_instance_of(::Socket).to receive(:connect).and_raise(Mongo::Error::SocketTimeoutError)
-          expect do
-            socket
-          end.to raise_error(Mongo::Error::SocketTimeoutError)
-        end
-      end
     end
 
     context 'when a certificate and key are provided as strings' do

data/spec/mongo/uri_spec.rb

@@ -266,15 +266,6 @@ describe Mongo::URI do
       end
     end
 
-    context 'no slash after hosts, and options' do
-
-      let(:string) { 'mongodb://example.com?tls=true' }
-
-      it 'raises an error' do
-        expect { uri }.to raise_error(Mongo::Error::InvalidURI, %r,MongoDB URI must have a slash \(/\) after the hosts if options are given,)
-      end
-    end
-
     context 'mongodb://example.com/?w' do
 
       let(:string) { 'mongodb://example.com/?w' }

data/spec/runners/change_streams/test.rb

@@ -111,7 +111,7 @@ module Mongo
       def run
         change_stream = begin
           @target.watch(@pipeline, ::Utils.snakeize_hash(@options))
-        rescue Mongo::Error::OperationFailure => e
+        rescue Mongo::Error::OperationFailure::Family => e
           return {
             result: {
               error: {
@@ -146,7 +146,7 @@ module Mongo
         begin
           change = enum.next
           changes << change
-        rescue Mongo::Error::OperationFailure => e
+        rescue Mongo::Error::OperationFailure::Family => e
           return {
             result: {
               error: {

data/spec/runners/crud/operation.rb

@@ -355,7 +355,7 @@ module Mongo
           if coll.indexes.map { |doc| doc['name'] }.include?(ixn = arguments.fetch('index'))
             raise "Index #{ixn} exists in collection #{cn} in database #{dn}, but must not"
           end
-        rescue Mongo::Error::OperationFailure => e
+        rescue Mongo::Error::OperationFailure::Family => e
           if e.to_s =~ /ns does not exist/
             # Success.
           else

data/spec/runners/crud/test.rb

@@ -110,14 +110,6 @@ module Mongo
         end
         setup_fail_point(client)
       end
-
-      def actual_collection_contents(client)
-        unless @spec.collection_name
-          raise ArgumentError, 'Spec does not specify a global collection'
-        end
-
-        client[@spec.collection_name, read_concern: {level: :majority}].find.to_a
-      end
     end
   end
 end

data/spec/runners/crud/verifier.rb

@@ -134,7 +134,7 @@ EOT
           expect(actual).not_to be nil
         when Hash
           if actual.is_a?(Hash) && actual['error'] &&
-            !expected.keys.any? { |key| key.start_with?('error') }
+            !expected.keys.any? { |key| key.start_with?('error') || key == 'isTimeoutError' }
           then
             raise RSpec::Expectations::ExpectationNotMetError.new,
               "Expected operation not to fail but it failed: #{actual.inspect}"
@@ -143,6 +143,8 @@ EOT
 
           expected.each do |k, v|
             case k
+            when 'isTimeoutError'
+              expect(actual['errorContains']).to eq('Mongo::Error::TimeoutError')
             when 'errorContains'
               expect(actual['errorContains'].downcase).to include(v.downcase)
             when 'errorLabelsContain'

data/spec/runners/crud.rb

@@ -26,7 +26,7 @@ require 'runners/crud/operation'
 require 'runners/crud/verifier'
 
 def collection_data(collection)
-  collection.find.to_a
+  collection.find.sort(_id: 1).to_a
 end
 
 def crud_execute_operations(spec, test, num_ops, event_subscriber, expect_error,

data/spec/runners/transactions/operation.rb

@@ -43,12 +43,10 @@ module Mongo
         end
 
         result
-      rescue Mongo::Error::OperationFailure => e
-        result = e.instance_variable_get(:@result)
-        if result.nil?
-          raise "OperationFailure had nil result: #{e}"
-        end
-        err_doc = result.send(:first_document)
+      rescue Mongo::Error::OperationFailure::Family => e
+        raise "OperationFailure had nil result: #{e}" if e.result.nil?
+
+        err_doc = e.result.send(:first_document)
         error_code_name = err_doc['codeName'] || err_doc['writeConcernError'] && err_doc['writeConcernError']['codeName']
         if error_code_name.nil?
           # Sometimes the server does not return the error code name,

data/spec/runners/transactions/test.rb

@@ -132,7 +132,6 @@ module Mongo
         @test_client ||= begin
           sdam_proc = lambda do |test_client|
             test_client.subscribe(Mongo::Monitoring::COMMAND, command_subscriber)
-
             test_client.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING, sdam_subscriber)
             test_client.subscribe(Mongo::Monitoring::SERVER_OPENING, sdam_subscriber)
             test_client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, sdam_subscriber)
@@ -321,6 +320,9 @@ module Mongo
         # without auto_encryption_options for querying results.
         result_collection_name = outcome&.collection_name || @spec.collection_name
         @result_collection = support_client.use(@spec.database_name)[result_collection_name]
+
+        # DRIVERS-2816, adjusted for legacy spec runner
+        @cluster_time = support_client.command(ping: 1).cluster_time
       end
 
       def teardown_test
@@ -358,12 +360,19 @@ module Mongo
         end
       end
 
+      def new_session(options)
+        test_client.start_session(options || {}).tap do |s|
+          # DRIVERS-2816, adjusted for legacy spec runner
+          s.advance_cluster_time(@cluster_time)
+        end
+      end
+
       def session0
-        @session0 ||= test_client.start_session(@session_options[:session0] || {})
+        @session0 ||= new_session(@session_options[:session0])
       end
 
       def session1
-        @session1 ||= test_client.start_session(@session_options[:session1] || {})
+        @session1 ||= new_session(@session_options[:session1])
       end
     end
   end

data/spec/runners/unified/ambiguous_operations.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Unified
+  module AmbiguousOperations
+    def find(op)
+      entities.get(:collection, op['object'])
+      crud_find(op)
+    rescue Unified::Error::EntityMissing
+      entities.get(:bucket, op['object'])
+      gridfs_find(op)
+    end
+  end
+end

data/spec/runners/unified/assertions.rb

@@ -251,11 +251,11 @@ module Unified
         end
       when Hash
         if expected.keys == %w($$unsetOrMatches) && expected.values.first.keys == %w(insertedId)
-          actual_v = actual.inserted_id
+          actual_v = get_actual_value(actual, 'inserted_id')
           expected_v = expected.values.first.values.first
           assert_value_matches(actual_v, expected_v, 'inserted_id')
         elsif expected.keys == %w(insertedId)
-          actual_v = actual.inserted_id
+          actual_v = get_actual_value(actual, 'inserted_id')
           expected_v = expected.values.first
           assert_value_matches(actual_v, expected_v, 'inserted_id')
         else
@@ -270,7 +270,7 @@ module Unified
               if k.start_with?('$$')
                 assert_value_matches(actual, expected, k)
               else
-                actual_v = actual[k]
+                actual_v = get_actual_value(actual, k)
                 if Hash === expected_v && expected_v.length == 1 && expected_v.keys.first.start_with?('$$')
                   assert_value_matches(actual_v, expected_v, k)
                 else
@@ -290,6 +290,19 @@ module Unified
       end
     end
 
+    # The actual value may be of different types depending on the operation.
+    # In order to avoid having to write a lot of code to handle the different
+    # types, we use this method to get the actual value.
+    def get_actual_value(actual, key)
+      if Hash === actual
+        actual[key]
+      elsif Mongo::Operation::Result === actual && !actual.respond_to?(key.to_sym)
+        actual.documents.first[key]
+      else
+        actual.send(key)
+      end
+    end
+
     def assert_type(object, type)
       ok = [*type].reduce(false) { |acc, x| acc || type_matches?(object, x) }
 
@@ -366,6 +379,10 @@ module Unified
           unless actual == result
             raise Error::ResultMismatch, "Actual value #{actual} does not match entity #{expected_v} with value #{result}"
           end
+        when '$$lte'
+          if actual.nil? || actual >= expected_v
+            raise Error::ResultMismatch, "Actual value #{actual} should be less than #{expected_v}"
+          end
         else
           raise NotImplementedError, "Unknown operator #{operator}"
         end