mongo 2.4.3 → 2.5.0.beta

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -43,6 +43,10 @@ describe Mongo::Collection::View::MapReduce do
     {}
   end
 
+  let(:map_reduce_spec) do
+    map_reduce.send(:map_reduce_spec, double('session'))
+  end
+
   before do
     authorized_collection.insert_many(documents)
   end
@@ -66,6 +70,23 @@ describe Mongo::Collection::View::MapReduce do
       end
     end
 
+    context 'when provided a session' do
+
+      let(:view_options) do
+        { session: session }
+      end
+
+      let(:operation) do
+        map_reduce.to_a
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+    end
+
     context 'when out is in the options' do
 
       after do
@@ -134,19 +155,75 @@ describe Mongo::Collection::View::MapReduce do
           expect(new_map_reduce.count).to eq(2)
         end
 
-        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled?) do
+        context 'when provided a session' do
+
+          let(:view_options) do
+            { session: session }
+          end
+
+          let(:operation) do
+            new_map_reduce.to_a
+          end
+
+          let(:client) do
+            authorized_client
+          end
+
+          it_behaves_like 'an operation using a session'
+        end
+
+        context 'when the output collection is iterated' do
+
+          let(:view_options) do
+            { session: session }
+          end
+
+          let(:session) do
+            client.start_session
+          end
+
+          let(:view) do
+            Mongo::Collection::View.new(client[TEST_COLL], selector, view_options)
+          end
+
+          let(:client) do
+            authorized_client.with(monitoring: true).tap do |cl|
+              cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+            end
+          end
+
+          let(:subscriber) do
+            EventSubscriber.new
+          end
+
+          let(:find_command) do
+            subscriber.started_events[-1].command
+          end
+
+          before do
+            begin; client[TEST_COLL].create; rescue; end
+            begin; client.use('another-db')[TEST_COLL].create; rescue; end
+          end
+
+          it 'uses the session when iterating over the output collection', if: sessions_enabled? do
+            new_map_reduce.to_a
+            expect(find_command["lsid"]).to eq(BSON::Document.new(session.session_id))
+          end
+        end
+
+        context 'when another db is specified', if: (sessions_enabled? && !sharded? && !auth_enabled?) do
 
           let(:new_map_reduce) do
             map_reduce.out(db: 'another-db', replace: 'output_collection')
           end
 
-          it 'iterates over the documents in the result' do
+          it 'iterates over the documents in the result', if: (sessions_enabled? && !sharded? && !auth_enabled?) do
             new_map_reduce.each do |document|
               expect(document[:value]).to_not be_nil
             end
           end
 
-          it 'fetches the results from the collection' do
+          it 'fetches the results from the collection', if: (sessions_enabled? && !sharded? && !auth_enabled?)  do
             expect(new_map_reduce.count).to eq(2)
           end
         end
@@ -168,7 +245,7 @@ describe Mongo::Collection::View::MapReduce do
           expect(new_map_reduce.count).to eq(2)
         end
 
-        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled?) do
+        context 'when another db is specified', if: (!auth_enabled? && !sharded? && list_command_enabled?) do
 
           let(:new_map_reduce) do
             map_reduce.out(db: 'another-db', merge: 'output_collection')
@@ -202,7 +279,7 @@ describe Mongo::Collection::View::MapReduce do
           expect(new_map_reduce.count).to eq(2)
         end
 
-        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled?) do
+        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled? && !sharded?) do
 
           let(:new_map_reduce) do
             map_reduce.out(db: 'another-db', reduce: 'output_collection')
@@ -247,7 +324,7 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'includes the selector in the operation spec' do
-          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(selector)
+          expect(map_reduce_spec[:selector][:query]).to eq(selector)
         end
       end
 
@@ -264,7 +341,7 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'includes the selector in the operation spec' do
-          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(selector[:$query])
+          expect(map_reduce_spec[:selector][:query]).to eq(selector[:$query])
         end
       end
     end
@@ -302,7 +379,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the finalize function in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:finalize]).to eq(finalize)
+      expect(new_map_reduce.send(:map_reduce_spec, double('session'))[:selector][:finalize]).to eq(finalize)
     end
   end
 
@@ -317,7 +394,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the js mode value in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:jsMode]).to be(true)
+      expect(new_map_reduce.send(:map_reduce_spec, double('session'))[:selector][:jsMode]).to be(true)
     end
   end
 
@@ -336,13 +413,13 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the out value in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(location)
+      expect(new_map_reduce.send(:map_reduce_spec, double('session'))[:selector][:out]).to eq(location)
     end
 
     context 'when out is not defined' do
 
       it 'defaults to inline' do
-        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq('inline' => 1)
+        expect(map_reduce_spec[:selector][:out]).to eq('inline' => 1)
       end
     end
 
@@ -361,7 +438,7 @@ describe Mongo::Collection::View::MapReduce do
       end
 
       it 'includes the out value in the operation spec' do
-        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(location)
+        expect(map_reduce_spec[:selector][:out]).to eq(location)
       end
     end
 
@@ -472,7 +549,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the scope object in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:scope]).to eq(object)
+      expect(new_map_reduce.send(:map_reduce_spec, double('session'))[:selector][:scope]).to eq(object)
     end
   end
 
@@ -491,7 +568,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the verbose option in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:verbose]).to eq(verbose)
+      expect(new_map_reduce.send(:map_reduce_spec, double('session'))[:selector][:verbose]).to eq(verbose)
     end
   end
 
@@ -506,7 +583,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the limit in the operation spec' do
-      expect(map_reduce.send(:map_reduce_spec)[:selector][:limit]).to be(limit)
+      expect(map_reduce_spec[:selector][:limit]).to be(limit)
     end
   end
 
@@ -521,7 +598,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the sort object in the operation spec' do
-      expect(map_reduce.send(:map_reduce_spec)[:selector][:sort][:name]).to eq(sort[:name])
+      expect(map_reduce_spec[:selector][:sort][:name]).to eq(sort[:name])
     end
   end
 
@@ -533,7 +610,7 @@ describe Mongo::Collection::View::MapReduce do
 
     it 'includes the read preference in the spec' do
       allow(authorized_collection).to receive(:read_preference).and_return(read_preference)
-      expect(map_reduce.send(:map_reduce_spec)[:read]).to eq(read_preference)
+      expect(map_reduce_spec[:read]).to eq(read_preference)
     end
   end
 

data/spec/mongo/collection/view/readable_spec.rb

@@ -1134,28 +1134,19 @@ describe Mongo::Collection::View::Readable do
 
   describe '#read' do
 
-    context 'when providing a hash' do
-
-      it 'converts to a read preference' do
-        expect(view.read(:mode => :primary_preferred).read).to be_a(
-          Mongo::ServerSelector::PrimaryPreferred
-        )
-      end
-    end
-
     context 'when a read pref is specified' do
 
       let(:options) do
-        { :read => Mongo::ServerSelector.get(:mode => :secondary) }
+        { :read => { :mode => :secondary } }
       end
 
       let(:new_read) do
-        Mongo::ServerSelector.get(:mode => :secondary_preferred)
+        { :mode => :secondary_preferred }
       end
 
       it 'sets the read preference' do
         new_view = view.read(new_read)
-        expect(new_view.read).to eq(new_read)
+        expect(new_view.read).to eq(BSON::Document.new(new_read))
       end
 
       it 'returns a new View' do

data/spec/mongo/collection_spec.rb

@@ -123,7 +123,7 @@ describe Mongo::Collection do
       end
 
       it 'sets the new read options on the new collection' do
-        expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+        expect(new_collection.read_preference).to eq(new_options[:read])
       end
 
       context 'when the client has a server selection timeout setting' do
@@ -144,7 +144,7 @@ describe Mongo::Collection do
         end
 
         it 'sets the new read options on the new collection' do
-          expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+          expect(new_collection.read_preference).to eq(new_options[:read])
           expect(new_collection.read_preference).not_to eq(client.read_preference)
         end
       end
@@ -156,7 +156,7 @@ describe Mongo::Collection do
         end
 
         it 'sets the new read options on the new collection' do
-          expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+          expect(new_collection.read_preference).to eq(new_options[:read])
         end
 
         it 'passes the server_selection_timeout setting to the cluster' do
@@ -182,7 +182,7 @@ describe Mongo::Collection do
       context 'when the client has a write concern set' do
 
         let(:client) do
-          Mongo::Client.new(ADDRESSES, TEST_OPTIONS.merge(write: { w: 10 }))
+          Mongo::Client.new(ADDRESSES, TEST_OPTIONS.merge(write: INVALID_WRITE_CONCERN))
         end
 
         it 'sets the new write options on the new collection' do
@@ -205,7 +205,7 @@ describe Mongo::Collection do
       end
 
       it 'sets the new read options on the new collection' do
-        expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+        expect(new_collection.read_preference).to eq(new_options[:read])
       end
 
       it 'sets the new write options on the new collection' do
@@ -230,7 +230,7 @@ describe Mongo::Collection do
         end
 
         it 'sets the new read options on the new collection' do
-          expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+          expect(new_collection.read_preference).to eq(new_options[:read])
           expect(new_collection.read_preference).not_to be(client.read_preference)
         end
       end
@@ -250,6 +250,96 @@ describe Mongo::Collection do
     end
   end
 
+  describe '#read_preference' do
+
+    let(:collection) do
+      described_class.new(authorized_client.database, :users, options)
+    end
+
+    let(:options) { {} }
+
+    context 'when a read preference is set in the options' do
+
+      let(:options) do
+        { read: { mode: :secondary } }
+      end
+
+      it 'returns the read preference' do
+        expect(collection.read_preference).to eq(options[:read])
+      end
+    end
+
+    context 'when a read preference is not set in the options' do
+
+      context 'when the database has a read preference set' do
+
+        let(:client) do
+          authorized_client.with(read: { mode: :secondary_preferred })
+        end
+
+        let(:collection) do
+          described_class.new(client.database, :users, options)
+        end
+
+        it 'returns the database read preference' do
+          expect(collection.read_preference).to eq(BSON::Document.new({ mode: :secondary_preferred }))
+        end
+      end
+
+      context 'when the database does not have a read preference' do
+
+        it 'returns nil' do
+          expect(collection.read_preference).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#server_selector' do
+
+    let(:collection) do
+      described_class.new(authorized_client.database, :users, options)
+    end
+
+    let(:options) { {} }
+
+    context 'when a read preference is set in the options' do
+
+      let(:options) do
+        { read: { mode: :secondary } }
+      end
+
+      it 'returns the server selector for that read preference' do
+        expect(collection.server_selector).to be_a(Mongo::ServerSelector::Secondary)
+      end
+    end
+
+    context 'when a read preference is not set in the options' do
+
+      context 'when the database has a read preference set' do
+
+        let(:client) do
+          authorized_client.with(read: { mode: :secondary_preferred })
+        end
+
+        let(:collection) do
+          described_class.new(client.database, :users, options)
+        end
+
+        it 'returns the server selector for that read preference' do
+          expect(collection.server_selector).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+        end
+      end
+
+      context 'when the database does not have a read preference' do
+
+        it 'returns a primary server selector' do
+          expect(collection.server_selector).to be_a(Mongo::ServerSelector::Primary)
+        end
+      end
+    end
+  end
+
   describe '#capped?' do
 
     let(:database) do
@@ -525,9 +615,40 @@ describe Mongo::Collection do
           it_behaves_like 'a collection command with a collation option'
         end
       end
+
+      context 'when a session is provided' do
+
+        let(:collection) do
+          authorized_client[:specs]
+        end
+
+        let(:operation) do
+          collection.create(session: session)
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        let(:failed_operation) do
+          authorized_client[:specs, invalid: true].create(session: session)
+        end
+
+        after do
+          collection.drop
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
     end
   end
 
+
   describe '#drop' do
 
     let(:database) do
@@ -539,10 +660,37 @@ describe Mongo::Collection do
     end
 
     context 'when the collection exists' do
+
       before do
         collection.create
       end
 
+      context 'when a session is provided' do
+
+        let(:operation) do
+          collection.drop(session: session)
+        end
+
+        let(:failed_operation) do
+          collection.with(write: INVALID_WRITE_CONCERN).drop(session: session)
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        after do
+          collection.drop
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when the collection does not have a write concern set' do
 
         let!(:response) do
@@ -609,6 +757,19 @@ describe Mongo::Collection do
 
   describe '#find' do
 
+    describe 'updating cluster time' do
+
+      let(:operation) do
+        client[TEST_COLL].find.first
+      end
+
+      let(:second_operation) do
+        client[TEST_COLL].find.first
+      end
+
+      it_behaves_like 'an operation updating cluster time'
+    end
+
     context 'when provided a filter' do
 
       let(:view) do
@@ -707,6 +868,28 @@ describe Mongo::Collection do
         authorized_collection.find({}, options)
       end
 
+      context 'when a session is provided' do
+
+        let(:operation) do
+          authorized_collection.find({}, session: session).to_a
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:failed_operation) do
+          authorized_collection.find({ '$._id' => 1 }, session: session).to_a
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when provided :allow_partial_results' do
 
         let(:options) do
@@ -859,6 +1042,28 @@ describe Mongo::Collection do
       expect(result.inserted_ids.size).to eq(2)
     end
 
+    context 'when a session is provided' do
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.insert_many([{ name: 'test1' }, { name: 'test2' }], session: session)
+      end
+
+      let(:failed_operation) do
+        authorized_collection.insert_many([{ _id: 'test1' }, { _id: 'test1' }], session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
     context 'when a document contains invalid keys' do
 
       let(:docs) do
@@ -929,6 +1134,40 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when the documents are sent with OP_MSG', if: op_msg_enabled? do
+
+      let(:client) do
+        authorized_client.with(heartbeat_frequency: 100).tap do |cl|
+          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
+      end
+
+      let(:subscriber) do
+        EventSubscriber.new
+      end
+
+      let(:documents) do
+        [{ '_id' => 1, 'name' => '1'*16777191 }, { '_id' => 'y' }]
+      end
+
+      before do
+        client[TEST_COLL].insert_many(documents)
+      end
+
+      after do
+        client.close
+      end
+
+      let(:insert_events) do
+        subscriber.started_events.select { |e| e.command_name == :insert }
+      end
+
+      it 'sends the documents in one OP_MSG' do
+        expect(insert_events.size).to eq(1)
+        expect(insert_events[0].command['documents']).to eq(documents)
+      end
+    end
+
     context 'when collection has a validator', if: find_command_enabled? do
 
       around(:each) do |spec|
@@ -970,7 +1209,7 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.insert_many(
-                [{ x: 1 }, { x: 2 }], :bypass_document_validation => true)
+              [{ x: 1 }, { x: 2 }], :bypass_document_validation => true)
           end
 
           it 'inserts successfully' do
@@ -983,6 +1222,19 @@ describe Mongo::Collection do
 
   describe '#insert_one' do
 
+    describe 'updating cluster time' do
+
+      let(:operation) do
+        client[TEST_COLL].insert_one({ name: 'testing' })
+      end
+
+      let(:second_operation) do
+        client[TEST_COLL].insert_one({ name: 'testing' })
+      end
+
+      it_behaves_like 'an operation updating cluster time'
+    end
+
     let(:result) do
       authorized_collection.insert_one({ name: 'testing' })
     end
@@ -999,6 +1251,29 @@ describe Mongo::Collection do
       expect(result.inserted_id).to_not be_nil
     end
 
+    context 'when a session is provided' do
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.insert_one({ name: 'testing' }, session: session)
+      end
+
+      let(:failed_operation) do
+        authorized_collection.insert_one({ _id: 'testing' })
+        authorized_collection.insert_one({ _id: 'testing' }, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
     context 'when the document contains invalid keys' do
 
       let(:doc) do
@@ -1098,7 +1373,7 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.insert_one(
-                { x: 1 }, :bypass_document_validation => true)
+              { x: 1 }, :bypass_document_validation => true)
           end
 
           it 'inserts successfully' do
@@ -1144,6 +1419,28 @@ describe Mongo::Collection do
       expect(index_names).to include(*'name_1', '_id_')
     end
 
+    context 'when a session is provided' do
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.indexes(batch_size: batch_size, session: session).collect { |i| i['name'] }
+      end
+
+      let(:failed_operation) do
+        authorized_collection.indexes(batch_size: -100, session: session).collect { |i| i['name'] }
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
     context 'when batch size is specified' do
 
       let(:batch_size) { 1 }
@@ -1156,6 +1453,19 @@ describe Mongo::Collection do
 
   describe '#aggregate' do
 
+    describe 'updating cluster time' do
+
+      let(:operation) do
+        client[TEST_COLL].aggregate([]).first
+      end
+
+      let(:second_operation) do
+        client[TEST_COLL].aggregate([]).first
+      end
+
+      it_behaves_like 'an operation updating cluster time'
+    end
+
     it 'returns an Aggregation object' do
       expect(authorized_collection.aggregate([])).to be_a(Mongo::Collection::View::Aggregation)
     end
@@ -1170,6 +1480,28 @@ describe Mongo::Collection do
         expect(authorized_collection.aggregate([], options).options).to eq(BSON::Document.new(options))
       end
 
+      context 'when a session is provided' do
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:operation) do
+          authorized_collection.aggregate([], session: session).to_a
+        end
+
+        let(:failed_operation) do
+          authorized_collection.aggregate([ { '$invalid' => 1 }], session: session).to_a
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when a hint is provided' do
 
         let(:options) do
@@ -1251,6 +1583,28 @@ describe Mongo::Collection do
         expect(authorized_collection.count({}, limit: 5)).to eq(5)
       end
 
+      context 'when a session is provided' do
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:operation) do
+          authorized_collection.count({}, session: session)
+        end
+
+        let(:failed_operation) do
+          authorized_collection.count({ '$._id' => 1 }, session: session)
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when a collation is specified' do
 
         let(:selector) do
@@ -1327,6 +1681,28 @@ describe Mongo::Collection do
       it 'passes the options to the distinct command' do
         expect(authorized_collection.distinct(:field, {}, max_time_ms: 100).sort).to eq([ 'test1', 'test2', 'test3' ])
       end
+
+      context 'when a session is provided' do
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:operation) do
+          authorized_collection.distinct(:field, {}, session: session)
+        end
+
+        let(:failed_operation) do
+          authorized_collection.distinct(:field, { '$._id' => 1 }, session: session)
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
     end
 
     context 'when a collation is specified' do
@@ -1401,9 +1777,9 @@ describe Mongo::Collection do
 
       before do
         authorized_collection.insert_many([
-                                              { field: 'test1' },
-                                              { field: 'test1' },
-                                              { field: 'test1' }
+                                            { field: 'test1' },
+                                            { field: 'test1' },
+                                            { field: 'test1' }
                                           ])
       end
 
@@ -1444,6 +1820,28 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when a session is provided' do
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.delete_one({}, session: session)
+      end
+
+      let(:failed_operation) do
+        authorized_collection.delete_one({ '$._id' => 1}, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
     context 'when a collation is provided' do
 
       let(:selector) do
@@ -1581,6 +1979,28 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when a session is provided' do
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.delete_many({}, session: session)
+      end
+
+      let(:failed_operation) do
+        authorized_collection.delete_many({ '$._id' => 1}, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
     context 'when a collation is specified' do
 
       let(:selector) do
@@ -1717,16 +2137,42 @@ describe Mongo::Collection do
       }.to raise_error(Mongo::Error::OperationFailure)
     end
 
-    context 'when a read concern is provided', if: find_command_enabled? do
+    context 'when a session is provided' do
 
-      let(:result) do
-        authorized_collection.with(options).parallel_scan(2)
+      let(:cursors) do
+        authorized_collection.parallel_scan(2, session: session)
       end
 
-      context 'when the read concern is valid' do
+      let(:session) do
+        authorized_client.start_session
+      end
 
-        let(:options) do
-          { read_concern: { level: 'local' }}
+      let(:operation) do
+        cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
+      end
+
+      let(:failed_operation) do
+        authorized_collection.parallel_scan(-2, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
+    context 'when a read concern is provided', if: find_command_enabled? do
+
+      let(:result) do
+        authorized_collection.with(options).parallel_scan(2)
+      end
+
+      context 'when the read concern is valid' do
+
+        let(:options) do
+          { read_concern: { level: 'local' }}
         end
 
         it 'sends the read concern' do
@@ -1787,7 +2233,7 @@ describe Mongo::Collection do
       context 'when the read concern is valid' do
 
         let(:options) do
-          { max_time_ms: 2 }
+          { max_time_ms: 5 }
         end
 
         it 'sends the max time ms value' do
@@ -1966,7 +2412,7 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.replace_one(
-                { a: 1 }, { x: 1 }, :bypass_document_validation => true)
+              { a: 1 }, { x: 1 }, :bypass_document_validation => true)
           end
 
           it 'replaces successfully' do
@@ -2074,6 +2520,36 @@ describe Mongo::Collection do
         expect(authorized_collection.find(name: 'bang').count).to eq(1)
       end
     end
+
+    context 'when a session is provided' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.replace_one(selector, { name: 'doink' }, session: session)
+      end
+
+      let(:failed_operation) do
+        authorized_collection.replace_one({ '$._id' => 1 }, { name: 'doink' }, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
   end
 
   describe '#update_many' do
@@ -2113,7 +2589,7 @@ describe Mongo::Collection do
 
       let(:response) do
         authorized_collection.update_many(selector, { '$set'=> { field: 'testing' } },
-                         upsert: false)
+                                          upsert: false)
       end
 
       let(:updated) do
@@ -2137,7 +2613,7 @@ describe Mongo::Collection do
 
       let!(:response) do
         authorized_collection.update_many(selector, { '$set'=> { field: 'testing' } },
-                         upsert: true)
+                                          upsert: true)
       end
 
       let(:updated) do
@@ -2176,6 +2652,106 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when arrayFilters is provided' do
+
+      let(:selector) do
+        { '$or' => [{ _id: 0 }, { _id: 1 }]}
+      end
+
+      context 'when the server supports arrayFilters', if: array_filters_enabled? do
+
+        before do
+          authorized_collection.insert_many([{
+                                               _id: 0, x: [
+                                                 { y: 1 },
+                                                 { y: 2 },
+                                                 { y: 3 }
+                                               ]
+                                             },
+                                             {
+                                               _id: 1,
+                                               x: [
+                                                 { y: 3 },
+                                                 { y: 2 },
+                                                 { y: 1 }
+                                               ]
+                                             }])
+        end
+
+        let(:result) do
+          authorized_collection.update_many(selector,
+                                            { '$set' => { 'x.$[i].y' => 5 } },
+                                            options)
+        end
+
+        context 'when a Symbol key is used' do
+
+          let(:options) do
+            { array_filters: [{ 'i.y' => 3 }] }
+          end
+
+          it 'applies the arrayFilters' do
+            expect(result.matched_count).to eq(2)
+            expect(result.modified_count).to eq(2)
+
+            docs = authorized_collection.find(selector, sort: { _id: 1 }).to_a
+            expect(docs[0]['x']).to eq ([{ 'y' => 1 },  { 'y' => 2 }, { 'y' => 5 }])
+            expect(docs[1]['x']).to eq ([{ 'y' => 5 },  { 'y' => 2 }, { 'y' => 1 }])
+          end
+        end
+
+        context 'when a String key is used' do
+          let(:options) do
+            { 'array_filters' => [{ 'i.y' => 3 }] }
+          end
+
+          it 'applies the arrayFilters' do
+            expect(result.matched_count).to eq(2)
+            expect(result.modified_count).to eq(2)
+
+            docs = authorized_collection.find({}, sort: { _id: 1 }).to_a
+            expect(docs[0]['x']).to eq ([{ 'y' => 1 },  { 'y' => 2 }, { 'y' => 5 }])
+            expect(docs[1]['x']).to eq ([{ 'y' => 5 },  { 'y' => 2 }, { 'y' => 1 }])
+          end
+        end
+      end
+
+      context 'when the server does not support arrayFilters', unless: array_filters_enabled? do
+
+        let(:result) do
+          authorized_collection.update_many(selector,
+                                           { '$set' => { 'x.$[i].y' => 5 } },
+                                           options)
+        end
+
+        context 'when a Symbol key is used' do
+
+          let(:options) do
+            { array_filters: [{ 'i.y' => 3 }] }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedArrayFilters)
+          end
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'array_filters' => [{ 'i.y' => 3 }] }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedArrayFilters)
+          end
+        end
+      end
+    end
+
     context 'when the updates fail' do
 
       let(:result) do
@@ -2208,7 +2784,7 @@ describe Mongo::Collection do
 
         let(:result) do
           collection_with_validator.update_many(
-              { :a => { '$gt' => 0 } }, '$inc' => { :a => 1 } )
+            { :a => { '$gt' => 0 } }, '$inc' => { :a => 1 } )
         end
 
         it 'updates successfully' do
@@ -2222,7 +2798,7 @@ describe Mongo::Collection do
 
           let(:result2) do
             collection_with_validator.update_many(
-                { :a => { '$gt' => 0 } }, '$unset' => { :a => '' })
+              { :a => { '$gt' => 0 } }, '$unset' => { :a => '' })
           end
 
           it 'raises OperationFailure' do
@@ -2236,8 +2812,8 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.update_many(
-                { :a => { '$gt' => 0 } }, { '$unset' => { :a => '' } },
-                :bypass_document_validation => true)
+              { :a => { '$gt' => 0 } }, { '$unset' => { :a => '' } },
+              :bypass_document_validation => true)
           end
 
           it 'updates successfully' do
@@ -2346,6 +2922,37 @@ describe Mongo::Collection do
         expect(result.written_count).to eq(0)
       end
     end
+
+    context 'when a session is provided' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:operation) do
+        authorized_collection.update_many(selector, { '$set' => {other: 'doink'} }, session: session)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+        authorized_collection.insert_one(name: 'baNG')
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:failed_operation) do
+        authorized_collection.update_many({ '$._id' => 1 }, { '$set' => {other: 'doink'} }, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
   end
 
   describe '#update_one' do
@@ -2385,7 +2992,7 @@ describe Mongo::Collection do
 
       let(:response) do
         authorized_collection.update_one(selector, { '$set'=> { field: 'testing' } },
-                        upsert: false)
+                                         upsert: false)
       end
 
       let(:updated) do
@@ -2409,7 +3016,7 @@ describe Mongo::Collection do
 
       let!(:response) do
         authorized_collection.update_one(selector, { '$set'=> { field: 'testing' } },
-                        upsert: true)
+                                         upsert: true)
       end
 
       let(:updated) do
@@ -2480,7 +3087,7 @@ describe Mongo::Collection do
 
         let(:result) do
           collection_with_validator.update_one(
-              { :a => { '$gt' => 0 } }, '$inc' => { :a => 1 } )
+            { :a => { '$gt' => 0 } }, '$inc' => { :a => 1 } )
         end
 
         it 'updates successfully' do
@@ -2494,7 +3101,7 @@ describe Mongo::Collection do
 
           let(:result2) do
             collection_with_validator.update_one(
-                { :a => { '$gt' => 0 } }, '$unset' => { :a => '' })
+              { :a => { '$gt' => 0 } }, '$unset' => { :a => '' })
           end
 
           it 'raises OperationFailure' do
@@ -2508,8 +3115,8 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.update_one(
-                { :a => { '$gt' => 0 } }, { '$unset' => { :a => '' } },
-                :bypass_document_validation => true)
+              { :a => { '$gt' => 0 } }, { '$unset' => { :a => '' } },
+              :bypass_document_validation => true)
           end
 
           it 'updates successfully' do
@@ -2616,6 +3223,148 @@ describe Mongo::Collection do
         expect(result.written_count).to eq(0)
       end
     end
+
+
+    context 'when arrayFilters is provided' do
+
+      let(:selector) do
+        { _id: 0}
+      end
+
+      context 'when the server supports arrayFilters', if: array_filters_enabled? do
+
+        before do
+          authorized_collection.insert_one(_id: 0, x: [{ y: 1 }, { y: 2 }, {y: 3 }])
+        end
+
+        let(:result) do
+          authorized_collection.update_one(selector,
+                                           { '$set' => { 'x.$[i].y' => 5 } },
+                                           options)
+        end
+
+        context 'when a Symbol key is used' do
+
+          let(:options) do
+            { array_filters: [{ 'i.y' => 3 }] }
+          end
+
+          it 'applies the arrayFilters' do
+            expect(result.matched_count).to eq(1)
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(selector).first['x'].last['y']).to eq(5)
+          end
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'array_filters' => [{ 'i.y' => 3 }] }
+          end
+
+          it 'applies the arrayFilters' do
+            expect(result.matched_count).to eq(1)
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(selector).first['x'].last['y']).to eq(5)
+          end
+        end
+      end
+
+      context 'when the server does not support arrayFilters', unless: array_filters_enabled? do
+
+        let(:result) do
+          authorized_collection.update_one(selector,
+                                           { '$set' => { 'x.$[i].y' => 5 } },
+                                           options)
+        end
+
+        context 'when a Symbol key is used' do
+
+          let(:options) do
+            { array_filters: [{ 'i.y' => 3 }] }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedArrayFilters)
+          end
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'array_filters' => [{ 'i.y' => 3 }] }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedArrayFilters)
+          end
+        end
+      end
+    end
+
+    context 'when the documents are sent with OP_MSG', if: op_msg_enabled? do
+
+      let(:client) do
+        authorized_client.with(heartbeat_frequency: 100).tap do |cl|
+          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
+      end
+
+      let(:subscriber) do
+        EventSubscriber.new
+      end
+
+      let(:documents) do
+        [{ '_id' => 1, 'name' => '1'*16777191 }, { '_id' => 'y' }]
+      end
+
+      before do
+        authorized_collection.insert_many([{ field: 'test1' }, { field: 'test1' }])
+        client[TEST_COLL].update_one({ a: 1 }, {'$set' => { 'name' => '1'*16777149 }})
+      end
+
+      after do
+        client.close
+      end
+
+      let(:update_events) do
+        subscriber.started_events.select { |e| e.command_name == :update }
+      end
+
+      it 'sends the documents in one OP_MSG' do
+        expect(update_events.size).to eq(1)
+      end
+    end
+
+    context 'when a session is provided' do
+
+      before do
+        authorized_collection.insert_many([{ field: 'test1' }, { field: 'test1' }])
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:operation) do
+        authorized_collection.update_one({ field: 'test' }, { '$set'=> { field: 'testing' } }, session: session)
+      end
+
+      let(:failed_operation) do
+        authorized_collection.update_one({ '$._id' => 1 }, { '$set'=> { field: 'testing' } }, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
   end
 
   describe '#find_one_and_delete' do
@@ -2630,6 +3379,28 @@ describe Mongo::Collection do
 
     context 'when a matching document is found' do
 
+      context 'when a session is provided' do
+
+        let(:operation) do
+          authorized_collection.find_one_and_delete(selector, session: session)
+        end
+
+        let(:failed_operation) do
+          authorized_collection.find_one_and_delete({ '$._id' => 1 }, session: session)
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when no options are provided' do
 
         let!(:document) do
@@ -2830,6 +3601,28 @@ describe Mongo::Collection do
         end
       end
 
+      context 'when a session is provided' do
+
+        let(:operation) do
+          authorized_collection.find_one_and_update(selector, { '$set' => { field: 'testing' }}, session: session)
+        end
+
+        let(:failed_operation) do
+          authorized_collection.find_one_and_update({ '$._id' => 1 }, { '$set' => { field: 'testing' }}, session: session)
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when no options are provided' do
 
         let(:document) do
@@ -2979,7 +3772,7 @@ describe Mongo::Collection do
 
         let(:result) do
           collection_with_validator.find_one_and_update(
-              { a: 1 }, { '$inc' => { :a => 1 } }, :return_document => :after)
+            { a: 1 }, { '$inc' => { :a => 1 } }, :return_document => :after)
         end
 
         it 'updates successfully' do
@@ -2993,7 +3786,7 @@ describe Mongo::Collection do
 
           let(:result2) do
             collection_with_validator.find_one_and_update(
-                { a: 1 }, { '$unset' => { :a => '' } }, :return_document => :after)
+              { a: 1 }, { '$unset' => { :a => '' } }, :return_document => :after)
           end
 
           it 'raises OperationFailure' do
@@ -3007,9 +3800,9 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.find_one_and_update(
-                { a: 1 }, { '$unset' => { :a => '' } },
-                :bypass_document_validation => true,
-                :return_document => :after)
+              { a: 1 }, { '$unset' => { :a => '' } },
+              :bypass_document_validation => true,
+              :return_document => :after)
           end
 
           it 'updates successfully' do
@@ -3024,8 +3817,8 @@ describe Mongo::Collection do
       it 'uses the write concern' do
         expect {
           authorized_collection.find_one_and_update(selector,
-                                         { '$set' => { field: 'testing' }},
-                                         write_concern: { w: 2 })
+                                                    { '$set' => { field: 'testing' }},
+                                                    write_concern: { w: 2 })
         }.to raise_error(Mongo::Error::OperationFailure)
       end
     end
@@ -3114,6 +3907,86 @@ describe Mongo::Collection do
         expect(result).to be_nil
       end
     end
+
+    context 'when arrayFilters is provided' do
+
+      let(:selector) do
+        { _id: 0 }
+      end
+
+      context 'when the server supports arrayFilters', if: array_filters_enabled? do
+
+        before do
+          authorized_collection.insert_one(_id: 0, x: [{ y: 1 }, { y: 2 }, { y: 3 }])
+        end
+
+        let(:result) do
+          authorized_collection.find_one_and_update(selector,
+                                                    { '$set' => { 'x.$[i].y' => 5 } },
+                                                    options)
+        end
+
+        context 'when a Symbol key is used' do
+
+          let(:options) do
+            { array_filters: [{ 'i.y' => 3 }] }
+          end
+
+
+          it 'applies the arrayFilters' do
+            expect(result['x']).to eq([{ 'y' => 1 }, { 'y' => 2 }, { 'y' => 3 }])
+            expect(authorized_collection.find(selector).first['x'].last['y']).to eq(5)
+          end
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'array_filters' => [{ 'i.y' => 3 }] }
+          end
+
+          it 'applies the arrayFilters' do
+            expect(result['x']).to eq([{ 'y' => 1 }, { 'y' => 2 }, { 'y' => 3 }])
+            expect(authorized_collection.find(selector).first['x'].last['y']).to eq(5)
+          end
+        end
+      end
+
+      context 'when the server selected does not support arrayFilters', unless: array_filters_enabled? do
+
+        let(:result) do
+          authorized_collection.find_one_and_update(selector,
+                                                    { '$set' => { 'x.$[i].y' => 5 } },
+                                                    options)
+        end
+
+        context 'when a Symbol key is used' do
+
+          let(:options) do
+            { array_filters: [{ 'i.y' => 3 }] }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedArrayFilters)
+          end
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'array_filters' => [{ 'i.y' => 3 }] }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedArrayFilters)
+          end
+        end
+      end
+    end
   end
 
   describe '#find_one_and_replace' do
@@ -3139,6 +4012,28 @@ describe Mongo::Collection do
         end
       end
 
+      context 'when a session is provided' do
+
+        let(:operation) do
+          authorized_collection.find_one_and_replace(selector, { field: 'testing' }, session: session)
+        end
+
+        let(:failed_operation) do
+          authorized_collection.find_one_and_replace({ '$._id' => 1}, { field: 'testing' }, session: session)
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when return_document options are provided' do
 
         context 'when return_document is :after' do
@@ -3262,7 +4157,7 @@ describe Mongo::Collection do
 
         let(:result) do
           collection_with_validator.find_one_and_replace(
-              { a: 1 }, { a: 5 }, :return_document => :after)
+            { a: 1 }, { a: 5 }, :return_document => :after)
         end
 
         it 'replaces successfully when document is valid' do
@@ -3276,7 +4171,7 @@ describe Mongo::Collection do
 
           let(:result2) do
             collection_with_validator.find_one_and_replace(
-                { a: 1 }, { x: 5 }, :return_document => :after)
+              { a: 1 }, { x: 5 }, :return_document => :after)
           end
 
           it 'raises OperationFailure' do
@@ -3290,8 +4185,8 @@ describe Mongo::Collection do
 
           let(:result3) do
             collection_with_validator.find_one_and_replace(
-                { a: 1 }, { x: 1 }, :bypass_document_validation => true,
-                :return_document => :after)
+              { a: 1 }, { x: 1 }, :bypass_document_validation => true,
+              :return_document => :after)
           end
 
           it 'replaces successfully' do
@@ -3398,4 +4293,115 @@ describe Mongo::Collection do
       end
     end
   end
+
+  describe '#watch' do
+
+    context 'when change streams can be tested', if: test_change_streams? do
+
+      let(:change_stream) do
+        authorized_collection.watch
+      end
+
+      let(:enum) do
+        change_stream.to_enum
+      end
+
+      before do
+        change_stream
+        authorized_collection.insert_one(a: 1)
+      end
+
+      context 'when no options are provided' do
+
+        context 'when the operation type is an insert' do
+
+          it 'returns the change' do
+            expect(enum.next[:fullDocument][:a]).to eq(1)
+          end
+        end
+
+        context 'when the operation type is an update' do
+
+          before do
+            authorized_collection.update_one({ a: 1 }, { '$set' => { a: 2 } })
+          end
+
+          let(:change_doc) do
+            enum.next
+            enum.next
+          end
+
+          it 'returns the change' do
+            expect(change_doc[:operationType]).to eq('update')
+            expect(change_doc[:updateDescription][:updatedFields]).to eq('a' => 2)
+          end
+        end
+      end
+
+      context 'when options are provided' do
+
+        context 'when full_document is updateLookup' do
+
+          let(:change_stream) do
+            authorized_collection.watch([], full_document: 'updateLookup').to_enum
+          end
+
+          before do
+            authorized_collection.update_one({ a: 1 }, { '$set' => { a: 2 } })
+          end
+
+          let(:change_doc) do
+            enum.next
+            enum.next
+          end
+
+          it 'returns the change' do
+            expect(change_doc[:operationType]).to eq('update')
+            expect(change_doc[:fullDocument][:a]).to eq(2)
+          end
+        end
+
+        context 'when batch_size is provided' do
+
+          before do
+            authorized_collection.insert_one(a: 2)
+            authorized_collection.insert_one(a: 3)
+          end
+
+          let(:change_stream) do
+            authorized_collection.watch([], batch_size: 2)
+          end
+
+          it 'returns the documents in the batch size specified' do
+            expect(change_stream.instance_variable_get(:@cursor)).to receive(:get_more).once.and_call_original
+            enum.next
+            enum.next
+          end
+        end
+
+        context 'when collation is provided' do
+          # pending 'server support for collation with the $changeStream operator'
+          #
+          # before do
+          #   authorized_collection.update_one({ a: 1 }, { '$set' => { a: 2 } })
+          # end
+          #
+          # let(:change_doc) do
+          #   change_stream.next
+          #   change_stream.next
+          # end
+          #
+          # let(:change_stream) do
+          #   authorized_collection.watch([ { '$match' => { operationType: 'UPDATE'}}],
+          #                               collation: { locale: 'en_US', strength: 2 } ).to_enum
+          # end
+          #
+          # it 'returns the change' do
+          #   expect(change_doc[:operationType]).to eq('update')
+          #   expect(change_doc[:fullDocument][:a]).to eq(2)
+          # end
+        end
+      end
+    end
+  end
 end