mongo 2.5.0.beta → 2.5.0

data/lib/mongo/uri/srv_protocol.rb

@@ -0,0 +1,158 @@
+# Copyright (C) 2017 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'resolv'
+
+module Mongo
+
+  class URI
+
+    # Parser for a URI using the mongodb+srv protocol, which specifies a DNS to query for SRV records.
+    # The driver will query the DNS server for SRV records on {hostname}.{domainname},
+    # prefixed with _mongodb._tcp
+    # The SRV records can then be used as the seedlist for a Mongo::Client.
+    # The driver also queries for a TXT record providing default connection string options.
+    # Only one TXT record is allowed, and only a subset of Mongo::Client options is allowed.
+    #
+    # Please refer to the Initial DNS Seedlist Discovery spec for details.
+    #
+    # https://github.com/mongodb/specifications/blob/master/source/initial-dns-seedlist-discovery
+    #
+    # @example Use the uri string to make a client connection.
+    #   client = Mongo::Client.new('mongodb+srv://test6.test.build.10gen.cc/')
+    #
+    # @since 2.5.0
+    class SRVProtocol < URI
+
+      # Gets the options hash that needs to be passed to a Mongo::Client on instantiation, so we
+      # don't have to merge the txt record options, credentials, and database in at that point -
+      # we only have a single point here.
+      #
+      # @example Get the client options.
+      #   uri.client_options
+      #
+      # @return [ Hash ] The options passed to the Mongo::Client
+      #
+      # @since 2.5.0
+      def client_options
+        opts = @txt_options.merge(ssl: true)
+        opts = opts.merge(uri_options).merge(:database => database)
+        @user ? opts.merge(credentials) : opts
+      end
+
+      private
+
+      RECORD_PREFIX = '_mongodb._tcp.'.freeze
+
+      DOT_PARTITION = '.'.freeze
+
+      VALID_TXT_OPTIONS = ['replicaset', 'authsource'].freeze
+
+      INVALID_HOST = "One and only one host is required in a connection string with the " +
+                       "'#{MONGODB_SRV_SCHEME}' protocol.".freeze
+
+      INVALID_PORT = "It is not allowed to specify a port in a connection string with the " +
+                       "'#{MONGODB_SRV_SCHEME}' protocol.".freeze
+
+      INVALID_DOMAIN = "The domain name must consist of at least two parts: the domain name, " +
+                         "and a TLD.".freeze
+
+      NO_SRV_RECORDS = "The DNS query returned no SRV records at hostname (%s)".freeze
+
+      MORE_THAN_ONE_TXT_RECORD_FOUND = "Only one TXT record is allowed. Querying hostname (%s) " +
+                                         "returned more than one result.".freeze
+
+      INVALID_TXT_RECORD_OPTION = "TXT records can only specify the options " +
+                                    "[#{VALID_TXT_OPTIONS.join(', ')}].".freeze
+
+      MISMATCHED_DOMAINNAME = "Parent domain name in SRV record result (%s) does not match " +
+                                 "that of the hostname (%s)".freeze
+
+      FORMAT = 'mongodb+srv://[username:password@]host[/[database][?options]]'.freeze
+
+      def scheme
+        MONGODB_SRV_SCHEME
+      end
+
+      def raise_invalid_error!(details)
+        raise Error::InvalidURI.new(@string, details, FORMAT)
+      end
+
+      def resolver
+        @resolver ||= Resolv::DNS.new
+      end
+
+      def parse_creds_hosts!(string)
+        hostname, creds = split_creds_hosts(string)
+        validate_hostname!(hostname)
+        records = get_records(hostname)
+        @txt_options = get_txt_opts(hostname) || {}
+        @servers = parse_servers!(records.join(','))
+        @user = parse_user!(creds)
+        @password = parse_password!(creds)
+      end
+
+      def validate_hostname!(hostname)
+        raise_invalid_error!(INVALID_HOST) if hostname.empty?
+        raise_invalid_error!(INVALID_HOST) if hostname.include?(HOST_DELIM)
+        raise_invalid_error!(INVALID_PORT) if hostname.include?(HOST_PORT_DELIM)
+        _, _, domain = hostname.partition(DOT_PARTITION)
+        raise_invalid_error!(INVALID_DOMAIN) unless domain.include?(DOT_PARTITION)
+      end
+
+      def get_records(hostname)
+        query_name = RECORD_PREFIX + hostname
+        records = resolver.getresources(query_name, Resolv::DNS::Resource::IN::SRV).collect do |record|
+          record_host = record.target.to_s
+          port = record.port
+          validate_record!(record_host, hostname)
+          "#{record_host}#{HOST_PORT_DELIM}#{port}"
+        end
+        raise Error::NoSRVRecords.new(NO_SRV_RECORDS % hostname) if records.empty?
+        records
+      end
+
+      def validate_record!(record_host, hostname)
+        domainname = hostname.split(DOT_PARTITION)[1..-1]
+        host_parts = record_host.split(DOT_PARTITION)
+        unless (host_parts.size > domainname.size) && (domainname == host_parts[-domainname.length..-1])
+          raise Error::MismatchedDomain.new(MISMATCHED_DOMAINNAME % [record_host, domainname])
+        end
+      end
+
+      def get_txt_opts(host)
+        records = resolver.getresources(host, Resolv::DNS::Resource::IN::TXT)
+        unless records.empty?
+          if records.size > 1
+            raise Error::InvalidTXTRecord.new(MORE_THAN_ONE_TXT_RECORD_FOUND % host)
+          end
+          options_string = records[0].strings.join
+          parse_txt_options!(options_string)
+        end
+      end
+
+      def parse_txt_options!(string)
+        return {} unless string
+        string.split(INDIV_URI_OPTS_DELIM).reduce({}) do |txt_options, opt|
+          raise Error::InvalidTXTRecord.new(INVALID_OPTS_VALUE_DELIM) unless opt.index(URI_OPTS_VALUE_DELIM)
+          key, value = opt.split(URI_OPTS_VALUE_DELIM)
+          raise Error::InvalidTXTRecord.new(INVALID_TXT_RECORD_OPTION) unless VALID_TXT_OPTIONS.include?(key.downcase)
+          strategy = URI_OPTION_MAP[key.downcase]
+          add_uri_option(strategy, value, txt_options)
+          txt_options
+        end
+      end
+    end
+  end
+end

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.5.0.beta'.freeze
+  VERSION = '2.5.0'.freeze
 end

data/lib/mongo/write_concern/normalizable.rb

@@ -47,6 +47,18 @@ module Mongo
         opts =  Options::Mapper.transform_keys_to_symbols(options)
         @options = Options::Mapper.transform_values_to_strings(opts).freeze
       end
+
+      # Is this write concern acknowledged.
+      #
+      # @example Whether this write concern object is acknowledged.
+      #   write_concern.acknowledged?
+      #
+      # @return [ true, false ] Whether this write concern is acknowledged.
+      #
+      # @since 2.5.0
+      def acknowledged?
+        !!get_last_error
+      end
     end
   end
 end

data/mongo.gemspec

@@ -29,6 +29,5 @@ Gem::Specification.new do |s|
   s.require_paths     = ['lib']
   s.bindir            = 'bin'
 
-  #s.add_dependency 'bson', '>=4.3.0', '<5.0.0'
-  s.add_dependency 'bson', '4.3.0.beta'
+  s.add_dependency 'bson', '>=4.3.0', '<5.0.0'
 end

data/spec/mongo/address_spec.rb

@@ -228,5 +228,17 @@ describe Mongo::Address do
         expect(address.socket(0.0)).not_to be_nil
       end
     end
+
+    context 'when creating a socket using the resolver' do
+
+      before do
+        address.instance_variable_set(:@resolver, nil)
+        address.send(:initialize_resolver!, (SSL ? SSL_OPTIONS : {}))
+      end
+
+      it 'uses the host, not the IP address' do
+        expect(address.socket(0.0).host).to eq(host)
+      end
+    end
   end
 end

data/spec/mongo/auth/user/view_spec.rb

@@ -200,15 +200,11 @@ describe Mongo::Auth::User::View do
 
       context 'when removal was not successful' do
 
-        it 'raises an exception', if: write_command_enabled? do
+        it 'raises an exception' do
           expect {
             view.remove('notauser')
           }.to raise_error(Mongo::Error::OperationFailure)
         end
-
-        it 'does not raise an exception', unless: write_command_enabled? do
-          expect(view.remove('notauser').written_count).to eq(0)
-        end
       end
     end
 

data/spec/mongo/bulk_write_spec.rb

@@ -31,6 +31,14 @@ describe Mongo::BulkWrite do
     [{ 'i.y' => 3}]
   end
 
+  let(:collection) do
+    authorized_collection
+  end
+
+  let(:client) do
+    authorized_client
+  end
+
   describe '#execute' do
     shared_examples_for 'an executable bulk write' do
 
@@ -135,39 +143,27 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
-
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:extra_options) do
+                {session: session}
               end
 
-              context 'when a session is provided' do
-
-                let(:extra_options) do
-                  { session: session }
-                end
-
-                let(:client) do
-                  collection_invalid_write_concern.client
-                end
-
-                let(:failed_operation) do
-                  bulk_write_invalid_write_concern.execute
-                end
+              let(:client) do
+                collection_invalid_write_concern.client
+              end
 
-                it_behaves_like 'a failed operation using a session'
+              let(:failed_operation) do
+                bulk_write_invalid_write_concern.execute
               end
+
+              it_behaves_like 'a failed operation using a session'
             end
           end
         end
@@ -206,39 +202,27 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
-
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:extra_options) do
+                {session: session}
               end
 
-              context 'when a session is provided' do
-
-                let(:extra_options) do
-                  { session: session }
-                end
-
-                let(:client) do
-                  collection_invalid_write_concern.client
-                end
-
-                let(:failed_operation) do
-                  bulk_write_invalid_write_concern.execute
-                end
+              let(:client) do
+                collection_invalid_write_concern.client
+              end
 
-                it_behaves_like 'a failed operation using a session'
+              let(:failed_operation) do
+                bulk_write_invalid_write_concern.execute
               end
+
+              it_behaves_like 'a failed operation using a session'
             end
           end
         end
@@ -281,39 +265,27 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
-
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:extra_options) do
+                {session: session}
               end
 
-              context 'when a session is provided' do
-
-                let(:extra_options) do
-                  { session: session }
-                end
-
-                let(:client) do
-                  collection_invalid_write_concern.client
-                end
-
-                let(:failed_operation) do
-                  bulk_write_invalid_write_concern.execute
-                end
+              let(:client) do
+                collection_invalid_write_concern.client
+              end
 
-                it_behaves_like 'a failed operation using a session'
+              let(:failed_operation) do
+                bulk_write_invalid_write_concern.execute
               end
+
+              it_behaves_like 'a failed operation using a session'
             end
 
             context 'when the write has a collation specified' do
@@ -558,39 +530,28 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
 
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:extra_options) do
+                {session: session}
               end
 
-              context 'when a session is provided' do
-
-                let(:extra_options) do
-                  { session: session }
-                end
-
-                let(:client) do
-                  collection_invalid_write_concern.client
-                end
-
-                let(:failed_operation) do
-                  bulk_write_invalid_write_concern.execute
-                end
+              let(:client) do
+                collection_invalid_write_concern.client
+              end
 
-                it_behaves_like 'a failed operation using a session'
+              let(:failed_operation) do
+                bulk_write_invalid_write_concern.execute
               end
+
+              it_behaves_like 'a failed operation using a session'
             end
           end
 
@@ -709,39 +670,27 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
-
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:extra_options) do
+                {session: session}
               end
 
-              context 'when a session is provided' do
-
-                let(:extra_options) do
-                  { session: session }
-                end
-
-                let(:client) do
-                  collection_invalid_write_concern.client
-                end
-
-                let(:failed_operation) do
-                  bulk_write_invalid_write_concern.execute
-                end
+              let(:client) do
+                collection_invalid_write_concern.client
+              end
 
-                it_behaves_like 'a failed operation using a session'
+              let(:failed_operation) do
+                bulk_write_invalid_write_concern.execute
               end
+
+              it_behaves_like 'a failed operation using a session'
             end
           end
 
@@ -863,39 +812,27 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
-
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:operation) do
+                result
               end
 
-              context 'when a session is provided' do
-
-                let(:operation) do
-                  result
-                end
-
-                let(:client) do
-                  authorized_client
-                end
-
-                let(:extra_options) do
-                  { session: session }
-                end
+              let(:client) do
+                authorized_client
+              end
 
-                it_behaves_like 'an operation using a session'
+              let(:extra_options) do
+                {session: session}
               end
+
+              it_behaves_like 'an operation using a session'
             end
           end
 
@@ -992,16 +929,11 @@ describe Mongo::BulkWrite do
             authorized_collection.insert_one({ _id: 0 })
           end
 
-          it 'replaces the document', if: write_command_enabled? do
+          it 'replaces the document' do
             expect(result.modified_count).to eq(1)
             expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
           end
 
-          it 'replaces the document', unless: write_command_enabled? do
-            expect(result.modified_count).to be_nil
-            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
-          end
-
           context 'when a session is provided' do
 
             let(:operation) do
@@ -1021,39 +953,27 @@ describe Mongo::BulkWrite do
 
           context 'when there is a write concern error' do
 
-            context 'when the server version is < 2.6' do
-
-              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::BulkWriteError)
-              end
+            it 'raises an OperationFailure', if: standalone? do
+              expect {
+                bulk_write_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
             end
 
-            context 'when the server version has write commands enabled' do
+            context 'when a session is provided' do
 
-              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                expect {
-                  bulk_write_invalid_write_concern.execute
-                }.to raise_error(Mongo::Error::OperationFailure)
+              let(:extra_options) do
+                {session: session}
               end
 
-              context 'when a session is provided' do
-
-                let(:extra_options) do
-                  { session: session }
-                end
-
-                let(:client) do
-                  collection_invalid_write_concern.client
-                end
-
-                let(:failed_operation) do
-                  bulk_write_invalid_write_concern.execute
-                end
+              let(:client) do
+                collection_invalid_write_concern.client
+              end
 
-                it_behaves_like 'a failed operation using a session'
+              let(:failed_operation) do
+                bulk_write_invalid_write_concern.execute
               end
+
+              it_behaves_like 'a failed operation using a session'
             end
           end
 
@@ -1087,14 +1007,10 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(0)
               end
 
-              it 'reports the modified count', if: collation_enabled? && write_command_enabled? do
+              it 'reports the modified count', if: collation_enabled? do
                 expect(result.modified_count).to eq(1)
               end
 
-              it 'returns nil for the modified count', if: collation_enabled? && !write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count', if: collation_enabled? do
                 expect(result.matched_count).to eq(1)
               end
@@ -1151,14 +1067,10 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil as the modified count', unless: write_command_enabled?  do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(0)
             end
@@ -1194,14 +1106,10 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(1)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(1)
             end
@@ -1241,68 +1149,60 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(0)
               end
 
-              it 'reports the modified count', if: write_command_enabled? do
+              it 'reports the modified count' do
                 expect(result.modified_count).to eq(0)
               end
 
-              it 'returns nil for the modified count', unless: write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count' do
                 expect(result.matched_count).to eq(1)
               end
             end
 
-            context 'when the number of updates exceeds the max batch size', if: write_command_enabled? do
+            context 'when the number of updates exceeds the max batch size' do
+
+              let(:batch_size) do
+                11
+              end
+
+              before do
+                allow(client.cluster.next_primary).to receive(:max_write_batch_size).and_return(batch_size - 1)
+              end
 
               let(:requests) do
-                1001.times.collect do |i|
+                batch_size.times.collect do |i|
                   { update_one: { filter: { a: i }, update: { "$set" => { a: i, b: 3 }}, upsert: true }}
                 end
               end
 
               it 'updates the documents and reports the correct number of upserted ids' do
-                expect(result.upserted_ids.size).to eq(1001)
-                expect(authorized_collection.find(b: 3).count).to eq(1001)
+                expect(result.upserted_ids.size).to eq(batch_size)
+                expect(authorized_collection.find(b: 3).count).to eq(batch_size)
               end
             end
 
             context 'when there is a write concern error' do
 
-              context 'when the server version is < 2.6' do
-
-                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::BulkWriteError)
-                end
+              it 'raises an OperationFailure', if: standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
               end
 
-              context 'when the server version has write commands enabled' do
+              context 'when a session is provided' do
 
-                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::OperationFailure)
+                let(:extra_options) do
+                  {session: session}
                 end
 
-                context 'when a session is provided' do
-
-                  let(:extra_options) do
-                    { session: session }
-                  end
-
-                  let(:client) do
-                    collection_invalid_write_concern.client
-                  end
-
-                  let(:failed_operation) do
-                    bulk_write_invalid_write_concern.execute
-                  end
+                let(:client) do
+                  collection_invalid_write_concern.client
+                end
 
-                  it_behaves_like 'a failed operation using a session'
+                let(:failed_operation) do
+                  bulk_write_invalid_write_concern.execute
                 end
+
+                it_behaves_like 'a failed operation using a session'
               end
             end
           end
@@ -1326,40 +1226,24 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(1)
             end
 
-            it 'reports the modified_count count', if: write_command_enabled? do
+            it 'reports the modified_count count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil for the modified_count count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(0)
             end
 
-            it 'reports the upserted id', if: write_command_enabled? do
+            it 'reports the upserted id' do
               expect(result.upserted_ids).to eq([0])
             end
 
             context 'when there is a write concern error' do
 
-              context 'when the server version is < 2.6' do
-
-                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::BulkWriteError)
-                end
-              end
-
-              context 'when the server version has write commands enabled' do
-
-                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::OperationFailure)
-                end
+              it 'raises an OperationFailure', if: standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
               end
             end
           end
@@ -1394,14 +1278,10 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(0)
               end
 
-              it 'reports the modified count', if: collation_enabled? && write_command_enabled? do
+              it 'reports the modified count', if: collation_enabled? do
                 expect(result.modified_count).to eq(1)
               end
 
-              it 'returns nil for the modified count', if: collation_enabled? && !write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count', if: collation_enabled? do
                 expect(result.matched_count).to eq(1)
               end
@@ -1458,14 +1338,10 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(0)
             end
@@ -1508,14 +1384,10 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(0)
               end
 
-              it 'reports the modified count', if: collation_enabled? && write_command_enabled? do
+              it 'reports the modified count', if: collation_enabled? do
                 expect(result.modified_count).to eq(2)
               end
 
-              it 'returns nil for the modified count', if: collation_enabled? && !write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count', if: collation_enabled? do
                 expect(result.matched_count).to eq(2)
               end
@@ -1577,14 +1449,10 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(0)
             end
@@ -1618,19 +1486,14 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(2)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(2)
             end
 
-
             context 'when there is a mix of updates and matched without an update' do
 
               let(:requests) do
@@ -1659,14 +1522,10 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(0)
               end
 
-              it 'reports the modified count', if: write_command_enabled? do
+              it 'reports the modified count' do
                 expect(result.modified_count).to eq(1)
               end
 
-              it 'returns nil for the modified count', unless: write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count' do
                 expect(result.matched_count).to eq(2)
               end
@@ -1674,22 +1533,10 @@ describe Mongo::BulkWrite do
 
             context 'when there is a write concern error' do
 
-              context 'when the server version is < 2.6' do
-
-                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::BulkWriteError)
-                end
-              end
-
-              context 'when the server version has write commands enabled' do
-
-                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::OperationFailure)
-                end
+              it 'raises an OperationFailure', if: standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
               end
             end
           end
@@ -1705,33 +1552,24 @@ describe Mongo::BulkWrite do
               bulk_write.execute
             end
 
-            it 'updates the document', if: write_command_enabled? do
+            it 'updates the document' do
               expect(result.modified_count).to eq(0)
               expect(authorized_collection.find(name: { '$in' => ['test', 'test1'] }).count).to eq(2)
             end
 
-            it 'updates the document', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-              expect(authorized_collection.find(name: { '$in' => ['test', 'test1'] }).count).to eq(2)
-            end
-
             it 'reports the upserted count' do
               expect(result.upserted_count).to eq(2)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(0)
             end
 
-            it 'reports the upserted id', if: write_command_enabled? do
+            it 'reports the upserted id' do
               expect(result.upserted_ids).to eq([0, 1])
             end
 
@@ -1757,7 +1595,7 @@ describe Mongo::BulkWrite do
                 expect(authorized_collection.find(a: 4).count).to eq(1)
               end
 
-              it 'reports the upserted id', if: write_command_enabled? do
+              it 'reports the upserted id' do
                 expect(result.upserted_ids).to eq([3])
               end
 
@@ -1765,14 +1603,10 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(1)
               end
 
-              it 'reports the modified count', if: write_command_enabled? do
+              it 'reports the modified count' do
                 expect(result.modified_count).to eq(1)
               end
 
-              it 'returns nil for the modified count', unless: write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count' do
                 expect(result.matched_count).to eq(2)
               end
@@ -1780,22 +1614,10 @@ describe Mongo::BulkWrite do
 
             context 'when there is a write concern error' do
 
-              context 'when the server version is < 2.6' do
-
-                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::BulkWriteError)
-                end
-              end
-
-              context 'when the server version has write commands enabled' do
-
-                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::OperationFailure)
-                end
+              it 'raises an OperationFailure', if: standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
               end
             end
           end
@@ -1834,14 +1656,10 @@ describe Mongo::BulkWrite do
                 expect(result.upserted_count).to eq(0)
               end
 
-              it 'reports the modified count', if: collation_enabled? && write_command_enabled? do
+              it 'reports the modified count', if: collation_enabled? do
                 expect(result.modified_count).to eq(2)
               end
 
-              it 'returns nil for the modified count', if: collation_enabled? && !write_command_enabled? do
-                expect(result.modified_count).to be_nil
-              end
-
               it 'reports the matched count', if: collation_enabled? do
                 expect(result.matched_count).to eq(2)
               end
@@ -1899,14 +1717,10 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to be(0)
             end
@@ -1938,36 +1752,20 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(2)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
             it 'reports the matched count' do
               expect(result.matched_count).to eq(2)
             end
 
             context 'when there is a write concern error' do
 
-              context 'when the server version is < 2.6' do
-
-                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::BulkWriteError)
-                end
-              end
-
-              context 'when the server version has write commands enabled' do
-
-                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::OperationFailure)
-                end
+              it 'raises an OperationFailure', if: standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
               end
             end
           end
@@ -1995,36 +1793,20 @@ describe Mongo::BulkWrite do
               expect(result.matched_count).to eq(0)
             end
 
-            it 'reports the modified count', if: write_command_enabled? do
+            it 'reports the modified count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'returns nil for the modified count', unless: write_command_enabled? do
-              expect(result.modified_count).to be_nil
-            end
-
-            it 'reports the upserted id', if: write_command_enabled? do
+            it 'reports the upserted id' do
               expect(result.upserted_ids).to eq([0])
             end
 
             context 'when there is a write concern error' do
 
-              context 'when the server version is < 2.6' do
-
-                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::BulkWriteError)
-                end
-              end
-
-              context 'when the server version has write commands enabled' do
-
-                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
-                  expect {
-                    bulk_write_invalid_write_concern.execute
-                  }.to raise_error(Mongo::Error::OperationFailure)
-                end
+              it 'raises an OperationFailure', if: standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
               end
             end
           end
@@ -2033,10 +1815,18 @@ describe Mongo::BulkWrite do
 
       context 'when the operations need to be split' do
 
+        let(:batch_size) do
+          11
+        end
+
+        before do
+          allow(client.cluster.next_primary).to receive(:max_write_batch_size).and_return(batch_size - 1)
+        end
+
         context 'when a write error occurs' do
 
           let(:requests) do
-            1001.times.map do |i|
+            batch_size.times.map do |i|
               { insert_one: { _id: i }}
             end
           end
@@ -2058,14 +1848,14 @@ describe Mongo::BulkWrite do
 
           it 'sets the document index on the error' do
             requests.push({ insert_one: { _id: 5 }})
-            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(1001)
+            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(batch_size)
           end
         end
 
         context 'when no write errors occur' do
 
           let(:requests) do
-            1001.times.map do |i|
+            batch_size.times.map do |i|
               { insert_one: { _id: i }}
             end
           end
@@ -2075,11 +1865,11 @@ describe Mongo::BulkWrite do
           end
 
           it 'inserts the documents' do
-            expect(result.inserted_count).to eq(1001)
+            expect(result.inserted_count).to eq(batch_size)
           end
 
           it 'combines the inserted ids' do
-            expect(result.inserted_ids.size).to eq(1001)
+            expect(result.inserted_ids.size).to eq(batch_size)
           end
 
           context 'when a session is provided' do
@@ -2098,6 +1888,47 @@ describe Mongo::BulkWrite do
 
             it_behaves_like 'an operation using a session'
           end
+
+          context 'when retryable writes are supported', if: (sessions_enabled? && (replica_set? || sharded?)) do
+
+            let(:client) do
+              authorized_client.with(heartbeat_frequency: 100, retry_writes: true).tap do |cl|
+                cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+              end
+            end
+
+            let(:collection) do
+              client[authorized_collection.name]
+            end
+
+            let(:subscriber) do
+              EventSubscriber.new
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            let(:first_txn_number) do
+              subscriber.started_events[-2].command['txnNumber'].instance_variable_get(:@integer)
+            end
+
+            let(:second_txn_number) do
+              subscriber.started_events[-1].command['txnNumber'].instance_variable_get(:@integer)
+            end
+
+            it 'inserts the documents' do
+              expect(result.inserted_count).to eq(batch_size)
+            end
+
+            it 'combines the inserted ids' do
+              expect(result.inserted_ids.size).to eq(batch_size)
+            end
+
+            it 'increments the transaction number' do
+              expect(first_txn_number + 1). to eq(second_txn_number)
+            end
+          end
         end
       end
 
@@ -2139,7 +1970,7 @@ describe Mongo::BulkWrite do
     context 'when the bulk write is unordered' do
 
       let(:bulk_write) do
-        described_class.new(authorized_collection, requests, options)
+        described_class.new(collection, requests, options)
       end
 
       let(:options) do
@@ -2160,7 +1991,7 @@ describe Mongo::BulkWrite do
     context 'when the bulk write is ordered' do
 
       let(:bulk_write) do
-        described_class.new(authorized_collection, requests, options)
+        described_class.new(collection, requests, options)
       end
 
       let(:options) do
@@ -2313,7 +2144,7 @@ describe Mongo::BulkWrite do
               ops, :bypass_document_validation => true)
         end
 
-        it 'executes successfully', if: write_command_enabled? do
+        it 'executes successfully' do
           expect(result2.modified_count).to eq(2)
           expect(result2.inserted_count).to eq(1)
         end