mongo 2.2.2 → 2.2.3

data/spec/mongo/cluster/topology/replica_set_spec.rb

@@ -160,6 +160,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
         let(:description) do
           double('description').tap do |d|
             allow(d).to receive(:replica_set_member?).and_return(false)
+            allow(d).to receive(:primary?).and_return(false)
           end
         end
 
@@ -179,6 +180,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
         double('description').tap do |d|
           allow(d).to receive(:replica_set_member?).and_return(true)
           allow(d).to receive(:replica_set_name).and_return('testing')
+          allow(d).to receive(:primary?).and_return(false)
         end
       end
 

data/spec/mongo/operation/result_spec.rb

@@ -208,6 +208,21 @@ describe Mongo::Operation::Result do
           expect(result).to_not be_successful
         end
       end
+
+      context 'when the query reply has the cursor_not_found flag set' do
+
+        let(:flags) do
+          [ :cursor_not_found ]
+        end
+
+        let(:documents) do
+          []
+        end
+
+        it 'returns false' do
+          expect(result).to_not be_successful
+        end
+      end
     end
 
     context 'when the reply is for a write command' do

data/spec/mongo/uri_spec.rb

@@ -524,11 +524,19 @@ describe 'invalid uris' do
         let(:mechanism) { 'GSSAPI' }
         let(:expected) { :gssapi }
 
-
         it 'sets the auth mechanism to :gssapi' do
           expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
       end
+
+      context 'scram-sha-1' do
+        let(:mechanism) { 'SCRAM-SHA-1' }
+        let(:expected) { :scram }
+
+        it 'sets the auth mechanism to :scram' do
+          expect(uri.uri_options[:auth_mech]).to eq(expected)
+        end
+      end
     end
 
     context 'auth source provided' do

data/spec/support/sdam/rs/primary_reports_new_member.yml

@@ -0,0 +1,163 @@
+description: "Primary reports a new member"
+
+uri: "mongodb://a/?replicaSet=rs"
+
+phases: [
+
+    # At first, a is a secondary.
+    {
+        responses: [
+
+                ["a:27017", {
+
+                    ok: 1,
+                    ismaster: false,
+                    secondary: true,
+                    setName: "rs",
+                    hosts: ["a:27017", "b:27017"]
+                }]
+        ],
+
+        outcome: {
+
+            servers: {
+
+                "a:27017": {
+
+                    type: "RSSecondary",
+                    setName: "rs"
+                },
+
+                "b:27017": {
+
+                    type: "Unknown",
+                    setName:
+                }
+            },
+
+            topologyType: "ReplicaSetNoPrimary",
+            setName: "rs"
+        }
+    },
+
+    # b is the primary.
+    {
+        responses: [
+
+                ["b:27017", {
+
+                    ok: 1,
+                    ismaster: true,
+                    setName: "rs",
+                    hosts: ["a:27017", "b:27017"]
+                }]
+        ],
+
+        outcome: {
+
+            servers: {
+
+                "a:27017": {
+
+                    type: "RSSecondary",
+                    setName: "rs"
+                },
+
+                "b:27017": {
+
+                    type: "RSPrimary",
+                    setName: "rs"
+                }
+            },
+
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs"
+        }
+    },
+
+    # Admin adds a secondary member c.
+    {
+        responses: [
+
+                ["b:27017", {
+
+                    ok: 1,
+                    ismaster: true,
+                    setName: "rs",
+                    hosts: ["a:27017", "b:27017", "c:27017"]
+                }]
+        ],
+
+        outcome: {
+
+            # c is new.
+            servers: {
+
+                "a:27017": {
+
+                    type: "RSSecondary",
+                    setName: "rs"
+                },
+
+                "b:27017": {
+
+                    type: "RSPrimary",
+                    setName: "rs"
+                },
+
+                "c:27017": {
+
+                    type: "Unknown",
+                    setName:
+                }
+            },
+
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs"
+        }
+    },
+
+    # c becomes secondary.
+    {
+        responses: [
+
+                ["c:27017", {
+
+                    ok: 1,
+                    ismaster: false,
+                    secondary: true,
+                    setName: "rs",
+                    primary: "b:27017",
+                    hosts: ["a:27017", "b:27017", "c:27017"]
+                }]
+        ],
+
+        outcome: {
+
+            # c is a secondary.
+            servers: {
+
+                "a:27017": {
+
+                    type: "RSSecondary",
+                    setName: "rs"
+                },
+
+                "b:27017": {
+
+                    type: "RSPrimary",
+                    setName: "rs"
+                },
+
+                "c:27017": {
+
+                    type: "RSSecondary",
+                    setName: "rs"
+                }
+            },
+
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs"
+        }
+    }
+]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Tyler Brock
@@ -32,7 +32,7 @@ cert_chain:
   EhIn2f8suSc9QAqYt7w4T+PMtjxWTVcXs+Uy2PbDtjhtEBz6ZsP6YSsOpJbrCjCV
   wZtXjpRUvWz86V5vjhHCTE8fqfEb85aeDwUCckPzpio=
   -----END CERTIFICATE-----
-date: 2016-01-25 00:00:00.000000000 Z
+date: 2016-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bson
@@ -59,6 +59,7 @@ files:
 - README.md
 - Rakefile
 - bin/mongo_console
+- lib/csasl/csasl.bundle
 - lib/mongo.rb
 - lib/mongo/address.rb
 - lib/mongo/address/ipv4.rb
@@ -488,6 +489,7 @@ files:
 - spec/support/sdam/rs/primary_disconnect_electionid.yml
 - spec/support/sdam/rs/primary_disconnect_setversion.yml
 - spec/support/sdam/rs/primary_mismatched_me.yml
+- spec/support/sdam/rs/primary_reports_new_member.yml
 - spec/support/sdam/rs/primary_to_no_primary_mismatched_me.yml
 - spec/support/sdam/rs/primary_wrong_set_name.yml
 - spec/support/sdam/rs/response_from_removed.yml
@@ -548,7 +550,6 @@ files:
 - spec/support/server_selection/selection/Single/read/SecondaryPreferred.yml
 - spec/support/server_selection/selection/Unknown/read/SecondaryPreferred.yml
 - spec/support/server_selection_rtt.rb
-- spec/support/shared/bulk_write.rb
 - spec/support/shared/cursor.rb
 - spec/support/shared/operation.rb
 - spec/support/shared/protocol.rb
@@ -575,7 +576,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby driver for MongoDB
@@ -776,6 +777,7 @@ test_files:
 - spec/support/sdam/rs/primary_disconnect_electionid.yml
 - spec/support/sdam/rs/primary_disconnect_setversion.yml
 - spec/support/sdam/rs/primary_mismatched_me.yml
+- spec/support/sdam/rs/primary_reports_new_member.yml
 - spec/support/sdam/rs/primary_to_no_primary_mismatched_me.yml
 - spec/support/sdam/rs/primary_wrong_set_name.yml
 - spec/support/sdam/rs/response_from_removed.yml
@@ -836,7 +838,6 @@ test_files:
 - spec/support/server_selection/selection/Unknown/read/SecondaryPreferred.yml
 - spec/support/server_selection.rb
 - spec/support/server_selection_rtt.rb
-- spec/support/shared/bulk_write.rb
 - spec/support/shared/cursor.rb
 - spec/support/shared/operation.rb
 - spec/support/shared/protocol.rb

data/spec/support/shared/bulk_write.rb

@@ -1,731 +0,0 @@
-shared_examples 'a bulk write object' do
-
-  context 'when no operations are provided' do
-
-    let(:operations) do
-      []
-    end
-
-    it 'raises an error' do
-      expect {
-        bulk.execute
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  context 'when invalid operations are provided' do
-
-    let(:operations) do
-      [{ :not_an_op => {}}]
-    end
-
-    it 'raises an error' do
-      expect {
-        bulk.execute
-      }.to raise_error(Mongo::Error::InvalidBulkOperationType)
-    end
-  end
-
-  context 'when an insert_one operation is provided' do
-
-    context 'when there is a write failure' do
-
-      let(:operations) do
-        [{ insert_one: { _id: 1 }}, { insert_one: { _id: 1 }}]
-      end
-
-      it 'raises a BulkWriteError' do
-        expect {
-          bulk.execute
-        }.to raise_error(Mongo::Error::BulkWriteError)
-      end
-    end
-
-    context 'when a document is provided' do
-
-      let(:operations) do
-        [{ insert_one: { name: 'test' }}]
-      end
-
-      it 'returns n_inserted of 1' do
-        expect(bulk.execute.inserted_count).to eq(1)
-      end
-
-      it 'only inserts that document' do
-        bulk.execute
-        expect(authorized_collection.find.first['name']).to eq('test')
-      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_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_invalid_write_concern.execute
-            }.to raise_error(Mongo::Error::OperationFailure)
-          end
-        end
-      end
-    end
-
-    context 'when an invalid object is provided' do
-
-      let(:operations) do
-        [{ insert_one: [] }]
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_error(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-  end
-
-  context 'delete_one' do
-
-    let(:docs) do
-      [ { a: 1 }, { a: 1 } ]
-    end
-
-    let(:expected) do
-      [{ 'a' => 1 }]
-    end
-
-    before do
-      authorized_collection.insert_many(docs)
-    end
-
-    let(:operations) do
-      [ { delete_one: { a: 1 }},
-        { delete_one: { a: 2 }}
-      ]
-    end
-
-    context 'when no selector is specified' do
-
-      let(:operations) do
-        [{ delete_one: nil }]
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when multiple documents match delete selector' do
-
-      it 'reports n_removed correctly' do
-        expect(bulk.execute.deleted_count).to eq(1)
-      end
-
-      it 'deletes only matching documents' do
-        bulk.execute
-        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-      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_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_invalid_write_concern.execute
-            }.to raise_error(Mongo::Error::OperationFailure)
-          end
-        end
-      end
-    end
-  end
-
-  context 'when a delete_many operation is provided' do
-
-    let(:docs) do
-      [{ a: 1 }, { a: 1 }]
-    end
-
-    before do
-      authorized_collection.insert_many(docs)
-    end
-
-    let(:operations) do
-      [{ delete_many: { a: 1 }}]
-    end
-
-    context 'when no selector is specified' do
-
-      let(:operations) do
-        [{ delete_many: nil }]
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when a selector is specified' do
-
-      context 'when multiple documents match delete selector' do
-
-        it 'reports n_removed correctly' do
-          expect(bulk.execute.deleted_count).to eq(2)
-        end
-
-        it 'deletes all matching documents' do
-          bulk.execute
-          expect(authorized_collection.find.to_a).to be_empty
-        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_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_invalid_write_concern.execute
-              }.to raise_error(Mongo::Error::OperationFailure)
-            end
-          end
-        end
-      end
-
-      context 'when only one document matches delete selector' do
-
-        let(:docs) do
-          [{ a: 1 }, { a: 2 }]
-        end
-
-        let(:expected) do
-          [{ 'a' => 2 }]
-        end
-
-        it 'reports n_removed correctly' do
-          expect(bulk.execute.deleted_count).to eq(1)
-        end
-
-        it 'deletes all matching documents' do
-          bulk.execute
-          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-        end
-      end
-    end
-  end
-
-  context 'when a replace_one operation is provided' do
-
-    let(:docs) do
-      [{ a: 1 }, { a: 1 }]
-    end
-
-    let(:expected) do
-      [{ 'a' => 2 }, { 'a' => 1 }]
-    end
-
-    before do
-      authorized_collection.insert_many(docs)
-    end
-
-    let(:replacement) do
-      { a: 2 }
-    end
-
-    let(:operations) do
-      [{ replace_one: { find: { a: 1 },
-                        replacement: replacement,
-                        upsert: false }
-      }]
-    end
-
-    context 'when a replace document is not specified' do
-
-      let(:operations) do
-        [{ replace_one: { find: { a: 1 },
-                          replacement: nil,
-                          upsert: false }
-        }]
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when there are $-operator top-level keys' do
-
-      let(:operations) do
-        [{ replace_one: { find: { a: 1 },
-                          replacement: { :$set => { a: 3 }},
-                          upsert: false }
-        }]
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-
-    end
-
-    context 'when a replace document is specified' do
-
-      it 'applies the replacement to only one matching document' do
-        bulk.execute
-        expect(authorized_collection.find(replacement).count).to eq(1)
-      end
-
-      it 'reports n_matched correctly' do
-        expect(bulk.execute.matched_count).to eq(1)
-      end
-
-      it 'only applies the replacement to one matching document' do
-        bulk.execute
-        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-      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_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_invalid_write_concern.execute
-            }.to raise_error(Mongo::Error::OperationFailure)
-          end
-        end
-      end
-
-      context 'when upsert is true' do
-
-        let(:operations) do
-          [{ replace_one: { find: { a: 4 },
-                            replacement: replacement,
-                            upsert: true }
-          }]
-        end
-
-        let(:expected) do
-          [{ 'a' => 1 }, { 'a' => 1 }, { 'a' => 2 }]
-        end
-
-        it 'upserts the replacement document' do
-          bulk.execute
-          expect(authorized_collection.find(replacement).count).to eq(1)
-        end
-
-        it 'reports n_matched correctly' do
-          expect(bulk.execute.matched_count).to eq(0)
-        end
-
-        it 'does not replace any documents' do
-          bulk.execute
-          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-        end
-      end
-    end
-  end
-
-  context 'when an update_one operation is provided' do
-
-    let(:docs) do
-      [{ a: 1 }, { a: 1 }]
-    end
-
-    let(:update) do
-      { :$set => { a: 2 }}
-    end
-
-    let(:operations) do
-      [{ update_one: { find: { a: 1 },
-                       update: update,
-                       upsert: false }
-      }]
-    end
-
-    before do
-      authorized_collection.insert_many(docs)
-    end
-
-    let(:expected) do
-      [{ 'a' => 2 },  { 'a' => 1 }]
-    end
-
-    context 'when there is a write failure' do
-
-      let(:operations) do
-        [{ update_one: { find: { a: 1 },
-                         update: { '$st' => { field: 'blah' } },
-                         upsert: false }
-         }]
-      end
-
-      it 'raises a BulkWriteError' do
-        expect {
-          bulk.execute
-        }.to raise_error(Mongo::Error::BulkWriteError)
-      end
-    end
-
-    context 'when an update document is not specified' do
-
-      let(:operations) do
-        [{ update_one: [{ a: 1 }]}]
-      end
-
-      let(:operations) do
-        [{ update_one: { find: { a: 1 },
-                         upsert: false }
-        }]
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when an invalid update document is specified' do
-
-      let(:update) do
-        { a: 2 }
-      end
-
-      it 'raises an exception' do
-        expect {
-          bulk.execute
-        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when a valid update document is specified' do
-
-      it 'reports n_modified correctly', if: write_command_enabled?  do
-        expect(bulk.execute.modified_count).to eq(1)
-      end
-
-      it 'reports n_modified correctly', unless: write_command_enabled?  do
-        expect(bulk.execute.modified_count).to eq(nil)
-      end
-
-      it 'reports n_upserted correctly' do
-        expect(bulk.execute.upserted_count).to eq(0)
-      end
-
-      it 'reports n_matched correctly' do
-        expect(bulk.execute.matched_count).to eq(1)
-      end
-
-      it 'applies the correct writes' do
-        bulk.execute
-        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-      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_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_invalid_write_concern.execute
-            }.to raise_error(Mongo::Error::OperationFailure)
-          end
-        end
-      end
-
-      context 'when upsert is true' do
-
-        let(:operations) do
-          [{ update_one: { find: { a: 3 },
-                           update: update,
-                           upsert: true }
-          }]
-        end
-
-        let(:expected) do
-          [{ 'a' => 1 },  { 'a' => 1 }, { 'a' => 2 }]
-        end
-
-        it 'reports n_modified correctly', if: write_command_enabled?  do
-          expect(bulk.execute.modified_count).to eq(0)
-        end
-
-        it 'reports n_modified correctly', unless: write_command_enabled?  do
-          expect(bulk.execute.modified_count).to eq(nil)
-        end
-
-        it 'reports n_upserted correctly' do
-          expect(bulk.execute.upserted_count).to eq(1)
-        end
-
-        it 'returns the upserted ids', if: write_command_enabled? do
-          expect(bulk.execute.upserted_ids.size).to eq(1)
-        end
-
-        it 'reports n_matched correctly' do
-          expect(bulk.execute.matched_count).to eq(0)
-        end
-
-        it 'applies the correct writes' do
-          bulk.execute
-          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-        end
-      end
-    end
-  end
-
-  context 'when an update_many operation is provided' do
-
-    let(:docs) do
-      [{ a: 1 }, { a: 1 }]
-    end
-
-    let(:update) do
-      { :$set => { a: 2 }}
-    end
-
-    let(:operations) do
-      [{ update_many: { find: { a: 1 },
-                        update: update,
-                        upsert: false }
-      }]
-    end
-
-    let(:expected) do
-      [{ 'a' => 2 },  { 'a' => 2 }]
-    end
-
-    before do
-      authorized_collection.insert_many(docs)
-    end
-
-    context 'when there is a write failure' do
-
-      let(:operations) do
-        [{ update_many: { find: { a: 1 },
-                          update: { '$st' => { field: 'blah' } },
-                          upsert: false }
-         }]
-      end
-
-      it 'raises an BulkWriteError' do
-        expect {
-          bulk.execute
-        }.to raise_error(Mongo::Error::BulkWriteError)
-      end
-    end
-
-    context 'when an update document is not specified' do
-
-      let(:operations) do
-        [{ update_many: { find: { a: 1 },
-                          upsert: false }
-        }]
-      end
-
-      it 'raises an exception' do
-        expect do
-          bulk.execute
-        end.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when an invalid update document is specified' do
-
-      let(:update) do
-        { a: 2 }
-      end
-
-      it 'raises an exception' do
-        expect do
-          bulk.execute
-        end.to raise_exception(Mongo::Error::InvalidBulkOperation)
-      end
-    end
-
-    context 'when a valid update document is specified' do
-
-      it 'reports n_modified correctly', if: write_command_enabled?  do
-        expect(bulk.execute.modified_count).to eq(2)
-      end
-
-      it 'reports n_modified correctly', unless: write_command_enabled?  do
-        expect(bulk.execute.modified_count).to eq(nil)
-      end
-
-      it 'reports n_upserted correctly' do
-        expect(bulk.execute.upserted_count).to eq(0)
-      end
-
-      it 'reports n_matched correctly' do
-        expect(bulk.execute.matched_count).to eq(2)
-      end
-
-      it 'applies the correct writes' do
-        bulk.execute
-        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-      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_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_invalid_write_concern.execute
-            }.to raise_error(Mongo::Error::OperationFailure)
-          end
-        end
-      end
-
-      context 'when upsert is true' do
-
-        let(:operations) do
-          [{ update_many: { find: { a: 3 },
-                            update: update,
-                            upsert: true }
-          }]
-        end
-
-        let(:expected) do
-          [ { 'a' => 1 },  { 'a' => 1 }, { 'a' => 2 } ]
-        end
-
-        it 'reports n_modified correctly', if: write_command_enabled?  do
-          expect(bulk.execute.modified_count).to eq(0)
-        end
-
-        it 'reports n_modified correctly', unless: write_command_enabled?  do
-          expect(bulk.execute.modified_count).to eq(nil)
-        end
-
-        it 'reports n_upserted correctly' do
-          expect(bulk.execute.upserted_count).to eq(1)
-        end
-
-        it 'reports n_matched correctly' do
-          expect(bulk.execute.matched_count).to eq(0)
-        end
-
-        it 'applies the correct writes' do
-          bulk.execute
-          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
-        end
-      end
-    end
-  end
-
-  context 'when the operations need to be split' do
-
-    before do
-      6000.times do |i|
-        authorized_collection.insert_one(x: i)
-      end
-    end
-
-    let(:operations) do
-      [].tap do |ops|
-        3000.times do |i|
-          ops << { update_one: { find: { x: i },
-                                 update: { '$set' => { x: 6000-i } },
-                                 upsert: false }
-                 }
-        end
-        ops << { :insert_one => { test: 'emily' } }
-        3000.times do |i|
-          ops << { update_one: { find:  { x: 3000+i },
-                                 update: { '$set' => { x: 3000-i } },
-                                 upsert: false }
-                 }
-        end
-      end
-    end
-
-    it 'completes all operations' do
-      bulk.execute
-      expect(authorized_collection.find(x: { '$lte' => 3000 }).to_a.size).to eq(3000)
-    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_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_invalid_write_concern.execute
-          }.to raise_error(Mongo::Error::OperationFailure)
-        end
-      end
-    end
-  end
-end