mongo 2.17.1 → 2.18.1

data/spec/mongo/session_spec.rb

@@ -268,6 +268,21 @@ describe Mongo::Session do
         end.to raise_error(Mongo::Error::SessionEnded)
       end
     end
+
+    context "when the sesion is not materialized" do
+      let(:session) { authorized_client.get_session(implicit: true) }
+
+      before do
+        expect(session.materialized?).to be false
+      end
+
+      it "raises SessionNotMaterialized" do
+
+        expect do
+          session.session_id
+        end.to raise_error(Mongo::Error::SessionNotMaterialized)
+      end
+    end
   end
 
   describe '#txn_num' do
@@ -312,12 +327,12 @@ describe Mongo::Session do
   end
 
   describe '#start_session' do
-    context 'when block doesn\'t raise an error' do 
-      it 'closes the session after the block' do 
+    context 'when block doesn\'t raise an error' do
+      it 'closes the session after the block' do
         block_session = nil
-        authorized_client.start_session do |session| 
+        authorized_client.start_session do |session|
           expect(session.ended?).to be false
-          block_session = session 
+          block_session = session
         end
         expect(block_session.ended?).to be true
       end
@@ -326,7 +341,7 @@ describe Mongo::Session do
     context 'when block raises an error' do
       it 'closes the session after the block' do
         block_session = nil
-        expect do 
+        expect do
           authorized_client.start_session do |session|
             block_session = session
             raise 'This is an error!'
@@ -338,11 +353,16 @@ describe Mongo::Session do
 
     context 'when block returns value' do
       it 'is returned by the function' do
-        res = authorized_client.start_session do |session| 
+        res = authorized_client.start_session do |session|
           4
         end
         expect(res).to be 4
       end
     end
+
+    it 'returns a session with session id' do
+      session = authorized_client.start_session
+      session.session_id.should be_a(BSON::Document)
+    end
   end
 end

data/spec/mongo/session_transaction_spec.rb

@@ -148,7 +148,8 @@ describe Mongo::Session do
           collection.insert_one(a: 1)
         end
 
-        it 'times out', retry: 3 do
+        retry_test
+        it 'times out' do
           start = Mongo::Utils.monotonic_time
 
           10.times do |i|

data/spec/mongo/socket/ssl_spec.rb

@@ -5,7 +5,8 @@ require 'spec_helper'
 
 # this test performs direct network connections without retries.
 # In case of intermittent network issues, retry the entire failing test.
-describe Mongo::Socket::SSL, retry: 3 do
+describe Mongo::Socket::SSL do
+  retry_test
   clean_slate_for_all
   require_tls
 
@@ -332,7 +333,12 @@ describe Mongo::Socket::SSL, retry: 3 do
             OpenSSL::OpenSSLError
           end
         else
-          NoMethodError
+          # MRI
+          if RUBY_VERSION >= '3.1.0'
+            TypeError
+          else
+            NoMethodError
+          end
         end
       end
 
@@ -359,13 +365,18 @@ describe Mongo::Socket::SSL, retry: 3 do
         context 'when a bad certificate is provided' do
 
           let(:expected_exception) do
-            # OpenSSL::X509::CertificateError: nested asn1 error
-            [OpenSSL::OpenSSLError, /asn1 error/i]
+            if RUBY_VERSION >= '3.1.0'
+              # OpenSSL::X509::CertificateError: PEM_read_bio_X509: no start line
+              OpenSSL::X509::CertificateError
+            else
+              # OpenSSL::X509::CertificateError: nested asn1 error
+              [OpenSSL::OpenSSLError, /asn1 error/i]
+            end
           end
 
           let(:ssl_options) do
             super().merge(
-              :ssl_cert => COMMAND_MONITORING_TESTS.first,
+              :ssl_cert => CRUD_TESTS.first,
               :ssl_key => nil,
             )
           end
@@ -383,7 +394,7 @@ describe Mongo::Socket::SSL, retry: 3 do
           let(:ssl_options) do
             super().merge(
               :ssl_cert => nil,
-              :ssl_key => COMMAND_MONITORING_TESTS.first,
+              :ssl_key => CRUD_TESTS.first,
             )
           end
 
@@ -401,7 +412,7 @@ describe Mongo::Socket::SSL, retry: 3 do
 
           let(:ssl_options) do
             super().merge(
-              :ssl_cert => COMMAND_MONITORING_TESTS.first,
+              :ssl_cert => CRUD_TESTS.first,
               :ssl_key => nil,
             )
           end

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -6,6 +6,7 @@ require 'lite_spec_helper'
 describe Mongo::URI::SRVProtocol do
   require_external_connectivity
   clean_slate_for_all_if_possible
+  retry_test
 
   let(:scheme) { 'mongodb+srv://' }
   let(:uri) { described_class.new(string) }
@@ -263,15 +264,68 @@ describe Mongo::URI::SRVProtocol do
     end
 
     describe '#servers' do
-      let(:string) { "#{scheme}#{servers}" }
+      let(:string) { "#{scheme}#{servers}#{options}" }
+      let(:servers) { 'test1.test.build.10gen.cc' }
+      let(:options) { '' }
 
       context 'single server' do
         let(:servers) { 'test5.test.build.10gen.cc' }
-
         it 'returns an array with the parsed server' do
           expect(uri.servers).to eq(['localhost.test.build.10gen.cc:27017'])
         end
       end
+
+      context 'multiple servers' do
+        let(:hosts) { ['localhost.test.build.10gen.cc:27017', 'localhost.test.build.10gen.cc:27018'] }
+
+        context 'without srvMaxHosts' do
+          it 'returns an array with the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'with srvMaxHosts' do
+          let(:options) { '/?srvMaxHosts=1' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 1
+            expect(hosts.include?(uri.servers.first)).to be true
+          end
+        end
+
+        context 'with srvMaxHosts > total hosts' do
+          let(:options) { '/?srvMaxHosts=3' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'with srvMaxHosts == total hosts' do
+          let(:options) { '/?srvMaxHosts=2' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'with srvMaxHosts=0' do
+          let(:options) { '/?srvMaxHosts=0' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'when setting the srvServiceName' do
+          let(:servers) { 'test22.test.build.10gen.cc' }
+          let(:options) { '/?srvServiceName=customname' }
+
+          it 'returns an array with the parsed server' do
+            uri.servers.should =~ hosts
+          end
+        end
+      end
     end
 
     describe '#client_options' do
@@ -894,6 +948,51 @@ describe Mongo::URI::SRVProtocol do
         end
       end
 
+      context 'when providing srvMaxHosts' do
+        let(:srv_max_hosts) { 1 }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'sets the srv max hosts option' do
+          expect(uri.uri_options[:srv_max_hosts]).to eq(srv_max_hosts)
+        end
+      end
+
+      context 'when providing srvMaxHosts as 0' do
+        let(:srv_max_hosts) { 0 }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'doesn\'t set the srv max hosts option' do
+          expect(uri.uri_options[:srv_max_hosts]).to eq(srv_max_hosts)
+        end
+      end
+
+      context 'when providing invalid integer to srvMaxHosts' do
+        let(:srv_max_hosts) { -1 }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'does not set the srv max hosts option' do
+          expect(uri.uri_options).to_not have_key(:srv_max_hosts)
+        end
+      end
+
+      context 'when providing invalid type to srvMaxHosts' do
+        let(:srv_max_hosts) { "foo" }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'does not set the srv max hosts option' do
+          expect(uri.uri_options).to_not have_key(:srv_max_hosts)
+        end
+      end
+
+      context 'when providing srvServiceName' do
+        let(:srv_service_name) { "mongodb" }
+        let(:options) { "srvServiceName=#{srv_service_name}" }
+
+        it 'sets the srv service name option' do
+          expect(uri.uri_options[:srv_service_name]).to eq(srv_service_name)
+        end
+      end
+
       context 'ssl' do
         let(:options) { "ssl=#{ssl}" }
 

data/spec/mongo/uri_spec.rb

@@ -1178,6 +1178,31 @@ describe Mongo::URI do
       end
     end
 
+    context 'when providing srvMaxHosts with non-SRV URI' do
+
+      let(:srv_max_hosts) { 5 }
+      let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+      it 'raises an error' do
+        lambda do
+          uri
+        end.should raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when providing srvServiceName with non-SRV URI' do
+
+      let(:scheme) { "mongodb+srv://" }
+      let(:srv_service_name) { "customname" }
+      let(:options) { "srvServiceName=#{srv_service_name}" }
+
+      it 'raises an error' do
+        lambda do
+          uri
+        end.should raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
     context 'when providing waitQueueTimeoutMS' do
 
       let(:wait_queue_timeout) { 500 }

data/spec/runners/connection_string.rb

@@ -182,6 +182,14 @@ module Mongo
       def write_concern_expectation
         @spec['writeConcern']
       end
+
+      def num_seeds
+        @spec['numSeeds']
+      end
+
+      def num_hosts
+        @spec['numHosts']
+      end
     end
 
     class Host

data/spec/runners/crud/operation.rb

@@ -274,7 +274,14 @@ module Mongo
 
       def create_collection(database, context)
         opts = transformed_options(context)
-        database[arguments.fetch('collection')].create(session: opts[:session])
+        database[arguments.fetch('collection')]
+          .create(
+            {
+              session: opts[:session],
+              encrypted_fields: opts[:encrypted_fields],
+              validator: opts[:validator],
+            }.compact
+          )
       end
 
       def rename(collection, context)
@@ -285,11 +292,13 @@ module Mongo
       end
 
       def drop(collection, context)
-        collection.drop
+        opts = transformed_options(context)
+        collection.drop(encrypted_fields: opts[:encrypted_fields])
       end
 
       def drop_collection(database, context)
-        database[arguments.fetch('collection')].drop
+        opts = transformed_options(context)
+        database[arguments.fetch('collection')].drop(encrypted_fields: opts[:encrypted_fields])
       end
 
       def create_index(collection, context)

data/spec/runners/crud/requirement.rb

@@ -4,7 +4,7 @@
 module Mongo
   module CRUD
     class Requirement
-      YAML_KEYS = %w(auth minServerVersion maxServerVersion topology topologies serverParameters serverless).freeze
+      YAML_KEYS = %w(auth minServerVersion maxServerVersion topology topologies serverParameters serverless csfle).freeze
 
       def initialize(spec)
         spec = spec.dup
@@ -49,6 +49,7 @@ module Mongo
           nil
         end
         @auth = spec['auth']
+        @csfle = !!spec['csfle'] if spec['csfle']
       end
 
       attr_reader :min_server_version
@@ -75,11 +76,11 @@ module Mongo
       def satisfied?
         cc = ClusterConfig.instance
         ok = true
-        if short_min_server_version
-          ok &&= cc.fcv_ish >= short_min_server_version
+        if min_server_version
+          ok &&= Gem::Version.new(cc.fcv_ish) >= Gem::Version.new(min_server_version)
         end
         if max_server_version
-          ok &&= cc.short_server_version <= max_server_version
+          ok &&= Gem::Version.new(cc.server_version) <= Gem::Version.new(max_server_version)
         end
         if topologies
           ok &&= topologies.include?(cc.topology)
@@ -112,6 +113,10 @@ module Mongo
         elsif @auth == false
           ok &&= !cc.auth_enabled?
         end
+        if @csfle
+          ok &&= !!(ENV['LIBMONGOCRYPT_PATH'] || ENV['FLE'])
+          ok &&= Gem::Version.new(cc.fcv_ish) >= Gem::Version.new('4.2.0')
+        end
         ok
       end
 

data/spec/runners/crud/spec.rb

@@ -20,6 +20,7 @@ module Mongo
         # Introduced with Client-Side Encryption tests
         @json_schema = BSON::ExtJSON.parse_obj(@spec['json_schema'])
         @key_vault_data = BSON::ExtJSON.parse_obj(@spec['key_vault_data'])
+        @encrypted_fields = BSON::ExtJSON.parse_obj(@spec['encrypted_fields'])
 
         @requirements = if run_on = @spec['runOn']
           run_on.map do |spec|
@@ -46,6 +47,10 @@ module Mongo
       #   running each test.
       attr_reader :key_vault_data
 
+      # @return [ Hash ]  An encryptedFields option that should be set on the
+      #   collection (using createCollection) before each test run.
+      attr_reader :encrypted_fields
+
       def collection_name
         # Older spec tests do not specify a collection name, thus
         # we provide a default here

data/spec/runners/crud/test.rb

@@ -96,7 +96,7 @@ module Mongo
         elsif @data.is_a?(Array)
           collection = client[spec.collection_name, write_concern: {w: :majority}]
           collection.delete_many
-          collection.insert_many(@data)
+          collection.insert_many(@data) unless @data.empty?
         elsif @data.is_a?(Hash)
           converter = DataConverter.new
           @data.each do |collection_name, data|

data/spec/runners/crud/verifier.rb

@@ -159,6 +159,12 @@ EOT
               verify_hash_items_equal(expected, actual, k)
             end
           end
+        when Array
+          expect(actual).to be_a(Array)
+          expect(actual.size).to eq(expected.size)
+          expected.zip(actual).each do |pair|
+            verify_result(pair.first, pair.last)
+          end
         else
           expect(actual).to eq(expected)
         end

data/spec/runners/transactions/spec.rb

@@ -19,9 +19,9 @@ module Mongo
   module Transactions
 
     class Spec < Mongo::CRUD::Spec
-      def tests
+      def tests(expectations_bson_types: true)
         @tests.map do |test|
-          Mongo::Transactions::TransactionsTest.new(self, @data, test)
+          Mongo::Transactions::TransactionsTest.new(self, @data, test, expectations_bson_types: expectations_bson_types)
         end
       end
     end

data/spec/runners/transactions/test.rb

@@ -22,6 +22,7 @@ module Mongo
     #
     # @since 2.6.0
     class TransactionsTest < CRUD::CRUDTestBase
+      include MongosMacros
 
       attr_reader :expected_results
       attr_reader :skip_reason
@@ -39,10 +40,10 @@ module Mongo
       # @param [ Hash ] test The test specification.
       #
       # @since 2.6.0
-      def initialize(crud_spec, data, test)
+      def initialize(crud_spec, data, test, expectations_bson_types: true)
         test = IceNine.deep_freeze(test)
         @spec = crud_spec
-        @data = data
+        @data = data || []
         @description = test['description']
         @client_options = {
           # Disable legacy read & write retries, so that when spec tests
@@ -70,7 +71,8 @@ module Mongo
           Operation.new(self, op)
         end
 
-        @expectations = BSON::ExtJSON.parse_obj(test['expectations'], mode: :bson)
+        mode = if expectations_bson_types then :bson else nil end
+        @expectations = BSON::ExtJSON.parse_obj(test['expectations'], mode: mode)
 
         if test['outcome']
           @outcome = Mongo::CRUD::Outcome.new(BSON::ExtJSON.parse_obj(test['outcome'], mode: :bson))
@@ -232,19 +234,20 @@ module Mongo
           end
         end
 
+        key_vault_coll = support_client
+        .use(:keyvault)[:datakeys]
+        .with(write: { w: :majority })
+
+        key_vault_coll.drop
         # Insert data into the key vault collection if required to do so by
         # the tests.
         if @spec.key_vault_data && !@spec.key_vault_data.empty?
-          key_vault_coll = support_client
-            .use(:admin)[:datakeys]
-            .with(write: { w: :majority })
-
-          key_vault_coll.drop
           key_vault_coll.insert_many(@spec.key_vault_data)
         end
 
+        encrypted_fields = @spec.encrypted_fields if @spec.encrypted_fields
         coll = support_client[@spec.collection_name].with(write: { w: :majority })
-        coll.drop
+        coll.drop(encrypted_fields: encrypted_fields)
 
         # Place a jsonSchema validator on the collection if required to do so
         # by the tests.
@@ -254,19 +257,19 @@ module Mongo
           {}
         end
 
-        support_client.command(
+        create_collection_spec = {
           create: @spec.collection_name,
           validator: collection_validator,
           writeConcern: { w: 'majority' }
-        )
+        }
+
+        create_collection_spec[:encryptedFields] = encrypted_fields if encrypted_fields
+        support_client.command(create_collection_spec)
 
         coll.insert_many(@data) unless @data.empty?
 
-        $distinct_ran ||= {}
-        $distinct_ran[@spec.database_name] ||= if description =~ /distinct/ || @operations.any? { |op| op.name == 'distinct' }
-          ::Utils.mongos_each_direct_client do |direct_client|
-            direct_client.use(@spec.database_name)['test'].distinct('foo').to_a
-          end
+        if description =~ /distinct/ || @operations.any? { |op| op.name == 'distinct' }
+          run_mongos_distincts(@spec.database_name, 'test')
         end
 
         admin_support_client.command(@fail_point_command) if @fail_point_command

data/spec/runners/transactions.rb

@@ -19,7 +19,8 @@ require 'runners/transactions/operation'
 require 'runners/transactions/spec'
 require 'runners/transactions/test'
 
-def define_transactions_spec_tests(test_paths)
+def define_transactions_spec_tests(test_paths, expectations_bson_types: true)
+  config_override :validate_update_replace, true
 
   test_paths.each do |file|
 
@@ -29,7 +30,7 @@ def define_transactions_spec_tests(test_paths)
 
       define_spec_tests_with_requirements(spec) do |req|
 
-        spec.tests.each do |test|
+        spec.tests(expectations_bson_types: expectations_bson_types).each do |test|
 
           context(test.description) do
 
@@ -51,16 +52,18 @@ def define_transactions_spec_tests(test_paths)
               end
             end
 
-            before(:all) do
-              if req.satisfied?
-                test.setup_test
+            unless req.satisfied?
+              before(:all) do
+                skip "Requirements not satisfied"
               end
             end
 
+            before(:all) do
+              test.setup_test
+            end
+
             after(:all) do
-              if req.satisfied?
-                test.teardown_test
-              end
+              test.teardown_test
             end
 
             let(:results) do