mongo 2.4.3 → 2.5.0.beta

data/spec/mongo/cluster/app_metadata_spec.rb

@@ -95,8 +95,8 @@ describe Mongo::Cluster::AppMetadata do
           allow(app_metadata).to receive(:driver_doc).and_return('x'*500)
         end
 
-        it 'truncates the document to be just an ismaster command' do
-          expect(app_metadata.ismaster_bytes.length).to eq(Mongo::Server::Monitor::Connection::ISMASTER_BYTES.length)
+        it 'truncates the document to be just an ismaster command and the compressors', unless: compression_enabled? do
+          expect(app_metadata.ismaster_bytes.length).to eq(Mongo::Server::Monitor::Connection::ISMASTER_BYTES.length + 26)
         end
       end
     end

data/spec/mongo/cluster_spec.rb

@@ -510,4 +510,180 @@ describe Mongo::Cluster do
       end
     end
   end
+
+  describe '#logical_session_timeout' do
+
+    let(:listeners) do
+      Mongo::Event::Listeners.new
+    end
+
+    let(:monitoring) do
+      Mongo::Monitoring.new(monitoring: false)
+    end
+
+    let(:server_one) do
+      Mongo::Server.new(default_address, cluster, monitoring, listeners)
+    end
+
+    let(:server_two) do
+      Mongo::Server.new(default_address, cluster, monitoring, listeners)
+    end
+
+    let(:servers) do
+      [ server_one, server_two ]
+    end
+
+    before do
+      allow(cluster).to receive(:servers).and_return(servers)
+    end
+
+    context 'when one server has a nil logical session timeout value' do
+
+      before do
+        allow(server_one).to receive(:logical_session_timeout).and_return(7)
+        allow(server_two).to receive(:logical_session_timeout).and_return(nil)
+      end
+
+      it 'returns nil' do
+        expect(cluster.logical_session_timeout).to be(nil)
+      end
+    end
+
+    context 'when all servers have a logical session timeout value' do
+
+      before do
+        allow(server_one).to receive(:logical_session_timeout).and_return(7)
+        allow(server_two).to receive(:logical_session_timeout).and_return(3)
+      end
+
+      it 'returns the minimum' do
+        expect(cluster.logical_session_timeout).to be(3)
+      end
+    end
+
+    context 'when no servers have a logical session timeout value' do
+
+      before do
+        allow(server_one).to receive(:logical_session_timeout).and_return(nil)
+        allow(server_two).to receive(:logical_session_timeout).and_return(nil)
+      end
+
+      it 'returns nil' do
+        expect(cluster.logical_session_timeout).to be(nil)
+      end
+    end
+  end
+
+  describe '#cluster_time' do
+
+    let(:operation) do
+      client.command(ping: 1)
+    end
+
+    let(:second_operation) do
+      client.command(ping: 1)
+    end
+
+    it_behaves_like 'an operation updating cluster time'
+  end
+
+  describe '#update_cluster_time' do
+
+    let(:cluster) do
+      described_class.new(ADDRESSES, monitoring, TEST_OPTIONS.merge(heartbeat_frequency: 1000))
+    end
+
+    let(:result) do
+      double('result', cluster_time: cluster_time_doc)
+    end
+
+    context 'when the cluster_time variable is nil' do
+
+      before do
+        cluster.instance_variable_set(:@cluster_time, nil)
+        cluster.update_cluster_time(result)
+      end
+
+      context 'when the cluster time received is nil' do
+
+        let(:cluster_time_doc) do
+          nil
+        end
+
+        it 'does not set the cluster_time variable' do
+          expect(cluster.cluster_time).to be_nil
+        end
+      end
+
+      context 'when the cluster time received is not nil' do
+
+        let(:cluster_time_doc) do
+          BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1))
+        end
+
+        it 'sets the cluster_time variable to the cluster time doc' do
+          expect(cluster.cluster_time).to eq(cluster_time_doc)
+        end
+      end
+    end
+
+    context 'when the cluster_time variable has a value' do
+
+      before do
+        cluster.instance_variable_set(:@cluster_time, BSON::Document.new(
+            Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+        cluster.update_cluster_time(result)
+      end
+
+      context 'when the cluster time received is nil' do
+
+        let(:cluster_time_doc) do
+          nil
+        end
+
+        it 'does not update the cluster_time variable' do
+          expect(cluster.cluster_time).to eq(BSON::Document.new(
+              Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+        end
+      end
+
+      context 'when the cluster time received is not nil' do
+
+        context 'when the cluster time received is greater than the cluster_time variable' do
+
+          let(:cluster_time_doc) do
+            BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 2))
+          end
+
+          it 'sets the cluster_time variable to the cluster time' do
+            expect(cluster.cluster_time).to eq(cluster_time_doc)
+          end
+        end
+
+        context 'when the cluster time received is less than the cluster_time variable' do
+
+          let(:cluster_time_doc) do
+            BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(0, 1))
+          end
+
+          it 'does not set the cluster_time variable to the cluster time' do
+            expect(cluster.cluster_time).to eq(BSON::Document.new(
+                Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+          end
+        end
+
+        context 'when the cluster time received is equal to the cluster_time variable' do
+
+          let(:cluster_time_doc) do
+            BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1))
+          end
+
+          it 'does not change the cluster_time variable' do
+            expect(cluster.cluster_time).to eq(BSON::Document.new(
+                Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+          end
+        end
+      end
+    end
+  end
 end

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

@@ -26,6 +26,10 @@ describe Mongo::Collection::View::Aggregation do
     described_class.new(view, pipeline, options)
   end
 
+  let(:aggregation_spec) do
+    aggregation.send(:aggregate_spec, double('session'))
+  end
+
   after do
     authorized_collection.delete_many
   end
@@ -68,6 +72,23 @@ describe Mongo::Collection::View::Aggregation do
       authorized_collection.delete_many
     end
 
+    context 'when provided a session' do
+
+      let(:options) do
+        { session: session }
+      end
+
+      let(:operation) do
+        aggregation.to_a
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+    end
+
     context 'when a block is provided' do
 
       context 'when no batch size is provided' do
@@ -280,7 +301,7 @@ describe Mongo::Collection::View::Aggregation do
 
       it 'includes the read preference in the spec' do
         allow(authorized_collection).to receive(:read_preference).and_return(read_preference)
-        expect(aggregation.send(:aggregate_spec)[:read]).to eq(read_preference)
+        expect(aggregation_spec[:read]).to eq(read_preference)
       end
     end
 
@@ -291,7 +312,7 @@ describe Mongo::Collection::View::Aggregation do
       end
 
       it 'includes the option in the spec' do
-        expect(aggregation.send(:aggregate_spec)[:selector][:allowDiskUse]).to eq(true)
+        expect(aggregation_spec[:selector][:allowDiskUse]).to eq(true)
       end
 
       context 'when allow_disk_use is specified as an option' do
@@ -305,7 +326,7 @@ describe Mongo::Collection::View::Aggregation do
         end
 
         it 'includes the option in the spec' do
-          expect(aggregation.send(:aggregate_spec)[:selector][:allowDiskUse]).to eq(true)
+          expect(aggregation_spec[:selector][:allowDiskUse]).to eq(true)
         end
 
         context 'when #allow_disk_use is also called' do
@@ -319,7 +340,7 @@ describe Mongo::Collection::View::Aggregation do
           end
 
           it 'overrides the first option with the second' do
-            expect(aggregation.send(:aggregate_spec)[:selector][:allowDiskUse]).to eq(false)
+            expect(aggregation_spec[:selector][:allowDiskUse]).to eq(false)
           end
         end
       end
@@ -332,7 +353,7 @@ describe Mongo::Collection::View::Aggregation do
       end
 
       it 'includes the option in the spec' do
-        expect(aggregation.send(:aggregate_spec)[:selector][:maxTimeMS]).to eq(options[:max_time_ms])
+        expect(aggregation_spec[:selector][:maxTimeMS]).to eq(options[:max_time_ms])
       end
     end
 
@@ -345,7 +366,7 @@ describe Mongo::Collection::View::Aggregation do
         end
 
         it 'uses the batch_size on the view' do
-          expect(aggregation.send(:aggregate_spec)[:selector][:cursor][:batchSize]).to eq(view_options[:batch_size])
+          expect(aggregation_spec[:selector][:cursor][:batchSize]).to eq(view_options[:batch_size])
         end
       end
 
@@ -356,7 +377,7 @@ describe Mongo::Collection::View::Aggregation do
         end
 
         it 'includes the option in the spec' do
-          expect(aggregation.send(:aggregate_spec)[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
+          expect(aggregation_spec[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
         end
 
         context 'when  batch_size is also set on the view' do
@@ -366,7 +387,7 @@ describe Mongo::Collection::View::Aggregation do
           end
 
           it 'overrides the view batch_size with the option batch_size' do
-            expect(aggregation.send(:aggregate_spec)[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
+            expect(aggregation_spec[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
           end
         end
       end
@@ -379,7 +400,7 @@ describe Mongo::Collection::View::Aggregation do
       end
 
       it 'includes the option in the spec' do
-        expect(aggregation.send(:aggregate_spec)[:selector][:hint]).to eq(options['hint'])
+        expect(aggregation_spec[:selector][:hint]).to eq(options['hint'])
       end
     end
 
@@ -396,7 +417,7 @@ describe Mongo::Collection::View::Aggregation do
           end
 
           it 'sets a batch size document in the spec' do
-            expect(aggregation.send(:aggregate_spec)[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
+            expect(aggregation_spec[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
           end
         end
 
@@ -407,7 +428,7 @@ describe Mongo::Collection::View::Aggregation do
           end
 
           it 'sets an empty document in the spec' do
-            expect(aggregation.send(:aggregate_spec)[:selector][:cursor]).to eq({})
+            expect(aggregation_spec[:selector][:cursor]).to eq({})
           end
         end
 
@@ -422,7 +443,7 @@ describe Mongo::Collection::View::Aggregation do
         context 'when batch_size is set' do
 
           it 'does not set the cursor option in the spec' do
-            expect(aggregation.send(:aggregate_spec)[:selector][:cursor]).to be_nil
+            expect(aggregation_spec[:selector][:cursor]).to be_nil
           end
         end
       end

data/spec/mongo/collection/view/builder/find_command_spec.rb

@@ -9,7 +9,7 @@ describe Mongo::Collection::View::Builder::FindCommand do
     end
 
     let(:builder) do
-      described_class.new(view)
+      described_class.new(view, nil)
     end
 
     let(:specification) do
@@ -48,11 +48,25 @@ describe Mongo::Collection::View::Builder::FindCommand do
           no_cursor_timeout: true,
           await_data: true,
           allow_partial_results: true,
-          read_concern: { level: 'local' },
           collation: { locale: 'en_US' }
         }
       end
 
+      context 'when the operation has a session' do
+
+        let(:session) do
+          double('session')
+        end
+
+        let(:builder) do
+          described_class.new(view, session)
+        end
+
+        it 'adds the session to the specification' do
+          expect(builder.specification[:session]).to be(session)
+        end
+      end
+
       it 'maps the collection name' do
         expect(selector['find']).to eq(authorized_collection.name)
       end
@@ -109,10 +123,6 @@ describe Mongo::Collection::View::Builder::FindCommand do
         expect(selector['min']).to eq('name' => 'albert')
       end
 
-      it 'maps read concern' do
-        expect(selector['readConcern']).to eq('level' => 'local')
-      end
-
       it 'maps return key' do
         expect(selector['returnKey']).to be true
       end
@@ -451,5 +461,35 @@ describe Mongo::Collection::View::Builder::FindCommand do
         end
       end
     end
+
+    context 'when the collection has a read concern defined' do
+
+      let(:collection) do
+        authorized_collection.with(read_concern: { level: 'invalid' })
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, {})
+      end
+
+      it 'applies the read concern of the collection' do
+        expect(selector['readConcern']).to eq(BSON::Document.new(level: 'invalid'))
+      end
+    end
+
+    context 'when the collection does not have a read concern defined' do
+
+      let(:filter) do
+        {}
+      end
+
+      let(:options) do
+        {}
+      end
+
+      it 'does not apply a read concern' do
+        expect(selector['readConcern']).to be_nil
+      end
+    end
   end
 end

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

@@ -0,0 +1,814 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
+
+  let(:pipeline) do
+    []
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:view_options) do
+    {}
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection, {}, view_options)
+  end
+
+  let(:change_stream) do
+    described_class.new(view, pipeline, options)
+  end
+
+  let(:change_stream_document) do
+    change_stream.send(:pipeline)[0]['$changeStream']
+  end
+
+  let!(:sample_resume_token) do
+    stream = authorized_collection.watch
+    authorized_collection.insert_one(a: 1)
+    doc = stream.to_enum.next
+    stream.close
+    doc[:_id]
+  end
+
+  let(:command_selector) do
+    change_stream.send(:aggregate_spec, double('session'))[:selector]
+  end
+
+  let(:cursor) do
+    change_stream.instance_variable_get(:@cursor)
+  end
+
+  let(:error) do
+    begin
+      change_stream
+    rescue => e
+      e
+    end
+  end
+
+  after do
+    authorized_collection.delete_many
+    begin; change_stream.close; rescue; end
+  end
+
+  describe '#initialize' do
+
+    it 'sets the view' do
+      expect(change_stream.view).to be(view)
+    end
+
+    it 'sets the options' do
+      expect(change_stream.options).to eq(options)
+    end
+
+    context 'when full_document is provided' do
+
+      context "when the value is 'default'" do
+
+        let(:options) do
+          { full_document: 'default' }
+        end
+
+        it 'sets the fullDocument value to default' do
+          expect(change_stream_document[:fullDocument]).to eq('default')
+        end
+      end
+
+      context "when the value is 'updateLookup'" do
+
+        let(:options) do
+          { full_document: 'updateLookup' }
+        end
+
+        it 'sets the fullDocument value to updateLookup' do
+          expect(change_stream_document[:fullDocument]).to eq('updateLookup')
+        end
+      end
+    end
+
+    context 'when full_document is not provided' do
+
+      it "defaults to use the 'default' value" do
+        expect(change_stream_document[:fullDocument]).to eq('default')
+      end
+    end
+
+    context 'when resume_after is provided' do
+
+      let(:options) do
+        { resume_after: sample_resume_token }
+      end
+
+      it 'sets the resumeAfter value to the provided document' do
+        expect(change_stream_document[:resumeAfter]).to eq(sample_resume_token)
+      end
+    end
+
+    context 'when max_await_time_ms is provided' do
+
+      let(:options) do
+        { max_await_time_ms: 10 }
+      end
+
+      it 'sets the maxTimeMS value to the provided document' do
+        expect(command_selector[:maxTimeMS]).to eq(10)
+      end
+    end
+
+    context 'when batch_size is provided' do
+
+      let(:options) do
+        { batch_size: 5 }
+      end
+
+      it 'sets the batchSize value to the provided document' do
+        expect(command_selector[:cursor][:batchSize]).to eq(5)
+      end
+    end
+
+    context 'when collation is provided'  do
+
+      let(:options) do
+        { 'collation' => { locale: 'en_US', strength: 2 } }
+      end
+
+      it 'sets the collation value to the provided document' do
+        expect(error).to be_a(Mongo::Error::OperationFailure)
+        expect(error.message).to include('Only default collation is allowed')
+      end
+    end
+
+    context 'when a changeStream operator is provided by the user as well' do
+
+      let(:pipeline) do
+        [ { '$changeStream' => { fullDocument: 'default' } }]
+      end
+
+      it 'raises the error from the server' do
+        expect(error).to be_a(Mongo::Error::OperationFailure)
+        expect(error.message).to include('$changeStream is only valid as the first stage in a pipeline')
+      end
+    end
+
+    context 'when the collection has a readConcern' do
+
+      let(:collection) do
+        authorized_collection.with(read_concern: { level: 'majority' })
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, {}, options)
+      end
+
+      it 'uses the read concern of the collection' do
+        expect(command_selector[:readConcern]).to eq('level' => 'majority')
+      end
+    end
+
+    context 'when no pipeline is supplied' do
+
+      it 'uses an empty pipeline' do
+        expect(command_selector[:pipeline][0].keys).to eq(['$changeStream'])
+      end
+    end
+
+    context 'when other pipeline operators are supplied' do
+
+      context 'when the other pipeline operators are supported' do
+
+        let(:pipeline) do
+          [ { '$project' => { '_id' => 0 }}]
+        end
+
+        it 'uses the pipeline operators' do
+          expect(command_selector[:pipeline][1]).to eq(pipeline[0])
+        end
+      end
+
+      context 'when the other pipeline operators are not supported' do
+
+        let(:pipeline) do
+          [ { '$unwind' => '$test' }]
+        end
+
+        it 'sends the pipeline to the server without a custom error' do
+          expect(change_stream).to be_a(Mongo::Collection::View::ChangeStream)
+        end
+
+        context 'when the operation fails', if: sessions_enabled? && test_change_streams? do
+
+          let!(:before_last_use) do
+            session.instance_variable_get(:@server_session).last_use
+          end
+
+          let!(:before_operation_time) do
+            (session.instance_variable_get(:@operation_time) || 0)
+          end
+
+          let(:pipeline) do
+            [ { '$invalid' => '$test' }]
+          end
+
+          let(:options) do
+            { session: session }
+          end
+
+          let!(:operation_result) do
+            begin; change_stream; rescue => e; e; end
+          end
+
+          let(:session) do
+            client.start_session
+          end
+
+          let(:client) do
+            authorized_client
+          end
+
+          it 'raises an error' do
+            expect(operation_result.class).to eq(Mongo::Error::OperationFailure)
+          end
+
+          it 'updates the last use value' do
+            expect(session.instance_variable_get(:@server_session).last_use).not_to eq(before_last_use)
+          end
+
+          it 'updates the operation time value' do
+            expect(session.instance_variable_get(:@operation_time)).not_to eq(before_operation_time)
+          end
+        end
+      end
+    end
+
+    context 'when the initial batch is empty' do
+
+      before do
+        change_stream
+      end
+
+      it 'does not close the cursor' do
+        expect(cursor).to be_a(Mongo::Cursor)
+      end
+    end
+
+    context 'when provided a session', if: sessions_enabled? && test_change_streams? do
+
+      let(:options) do
+        { session: session }
+      end
+
+      let(:operation) do
+        change_stream
+        authorized_collection.insert_one(a: 1)
+        change_stream.to_enum.next
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      context 'when the session is created from the same client used for the operation' do
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:server_session) do
+          session.instance_variable_get(:@server_session)
+        end
+
+        let!(:before_last_use) do
+          server_session.last_use
+        end
+
+        let!(:before_operation_time) do
+          (session.instance_variable_get(:@operation_time) || 0)
+        end
+
+        let!(:operation_result) do
+          operation
+        end
+
+        it 'updates the last use value' do
+          expect(server_session.last_use).not_to eq(before_last_use)
+        end
+
+        it 'updates the operation time value' do
+          expect(session.instance_variable_get(:@operation_time)).not_to eq(before_operation_time)
+        end
+
+        it 'does not close the session when the operation completes' do
+          expect(session.ended?).to be(false)
+        end
+      end
+
+      context 'when a session from another client is provided' do
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:client) do
+          authorized_client.with(read: { mode: :secondary })
+        end
+
+        let(:operation_result) do
+          operation
+        end
+
+        it 'raises an exception' do
+          expect {
+            operation_result
+          }.to raise_exception(Mongo::Error::InvalidSession)
+        end
+      end
+
+      context 'when the session is ended before it is used' do
+
+        let(:session) do
+          client.start_session
+        end
+
+        before do
+          session.end_session
+        end
+
+        let(:operation_result) do
+          operation
+        end
+
+        it 'raises an exception' do
+          expect {
+            operation_result
+          }.to raise_exception(Mongo::Error::InvalidSession)
+        end
+      end
+    end
+  end
+
+  describe '#close' do
+
+    context 'when documents have not been retrieved and the stream is closed' do
+
+      before do
+        expect(cursor).to receive(:kill_cursors)
+        change_stream.close
+      end
+
+      it 'closes the cursor' do
+        expect(change_stream.instance_variable_get(:@cursor)).to be(nil)
+        expect(change_stream.closed?).to be(true)
+      end
+
+      it 'raises an error when the stream is attempted to be iterated' do
+        expect {
+          change_stream.to_enum.next
+        }.to raise_exception(StopIteration)
+      end
+    end
+
+    context 'when some documents have been retrieved and the stream is closed before sending getmore' do
+
+      before do
+        change_stream
+        authorized_collection.insert_one(a: 1)
+        enum.next
+        change_stream.close
+      end
+
+      let(:enum) do
+        change_stream.to_enum
+      end
+
+      it 'raises an error' do
+        expect {
+          enum.next
+        }.to raise_exception(StopIteration)
+      end
+    end
+  end
+
+  describe '#closed?' do
+
+    context 'when the change stream has not been closed' do
+
+      it 'returns false' do
+        expect(change_stream.closed?).to be(false)
+      end
+    end
+
+    context 'when the change stream has been closed' do
+
+      before do
+        change_stream.close
+      end
+
+      it 'returns false' do
+        expect(change_stream.closed?).to be(true)
+      end
+    end
+  end
+
+  context 'when the first response does not contain the resume token' do
+
+    let(:pipeline) do
+      [ { '$project' => { _id: 0 } }]
+    end
+
+    before do
+      change_stream
+      authorized_collection.insert_one(a: 1)
+    end
+
+    it 'raises an exception and closes the cursor' do
+      expect(cursor).to receive(:kill_cursors).and_call_original
+      expect {
+        change_stream.to_enum.next
+      }.to raise_exception(Mongo::Error::MissingResumeToken)
+    end
+  end
+
+  context 'when an error is encountered the first time the command is run' do
+
+    let(:primary_socket) do
+      primary = authorized_collection.client.cluster.servers.find { |s| s.primary? }
+      connection = primary.pool.checkout
+      primary.pool.checkin(connection)
+      connection.send(:socket)
+    end
+
+    context 'when the error is a resumable error' do
+
+      shared_examples_for 'a resumable change stream' do
+
+        before do
+          expect(primary_socket).to receive(:write).and_raise(error).once
+          expect(view.send(:server_selector)).to receive(:select_server).twice.and_call_original
+          change_stream
+          authorized_collection.insert_one(a: 1)
+        end
+
+        let(:document) do
+          change_stream.to_enum.next
+        end
+
+        it 'runs the command again while using the same read preference and caches the resume token' do
+          expect(document[:fullDocument][:a]).to eq(1)
+          expect(change_stream_document[:resumeAfter]).to eq(document[:_id])
+        end
+
+        context 'when provided a session' do
+
+          let(:options) do
+            { session: session}
+          end
+
+          let(:session) do
+            authorized_client.start_session
+          end
+
+          before do
+            change_stream.to_enum.next
+          end
+
+          it 'does not close the session' do
+            expect(session.ended?).to be(false)
+          end
+        end
+      end
+
+      context 'when the error is a SocketError' do
+
+        let(:error) do
+          Mongo::Error::SocketError
+        end
+
+        it_behaves_like 'a resumable change stream'
+      end
+
+      context 'when the error is a SocketTimeoutError' do
+
+        let(:error) do
+          Mongo::Error::SocketTimeoutError
+        end
+
+        it_behaves_like 'a resumable change stream'
+      end
+
+      context "when the error is a 'not master' error" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('not master')
+        end
+
+        it_behaves_like 'a resumable change stream'
+      end
+
+      context "when the error is a 'cursor not found (43)' error" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('cursor not found (43)')
+        end
+
+        it_behaves_like 'a resumable change stream'
+      end
+    end
+
+    context 'when the error is another server error' do
+
+      before do
+        expect(primary_socket).to receive(:write).and_raise(Mongo::Error::OperationFailure)
+        #expect twice because of kill_cursors in after block
+        expect(view.send(:server_selector)).to receive(:select_server).twice.and_call_original
+      end
+
+      it 'does not run the command again and instead raises the error' do
+        expect {
+          change_stream
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+
+      context 'when provided a session' do
+
+        let(:options) do
+          { session: session}
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        before do
+          begin; change_stream; rescue; end
+        end
+
+        it 'does not close the session' do
+          expect(session.ended?).to be(false)
+        end
+      end
+    end
+  end
+
+  context 'when a server error is encountered during a getmore' do
+
+    context 'when the error is a resumable error' do
+
+      shared_examples_for 'a change stream that encounters an error from a getmore' do
+
+        before do
+          change_stream
+          authorized_collection.insert_one(a: 1)
+          enum.next
+          authorized_collection.insert_one(a: 2)
+          expect(cursor).to receive(:get_more).once.and_raise(error)
+          expect(cursor).to receive(:kill_cursors).and_call_original
+          expect(Mongo::Operation::Commands::Aggregate).to receive(:new).and_call_original
+        end
+
+        let(:enum) do
+          change_stream.to_enum
+        end
+
+        let(:document) do
+          enum.next
+        end
+
+        it 'runs the command again while using the same read preference and caching the resume token' do
+          expect(document[:fullDocument][:a]).to eq(2)
+          expect(change_stream_document[:resumeAfter]).to eq(document[:_id])
+        end
+
+        context 'when provided a session' do
+
+          let(:options) do
+            { session: session}
+          end
+
+          let(:session) do
+            authorized_client.start_session
+          end
+
+          before do
+            enum.next
+          end
+
+          it 'does not close the session' do
+            expect(session.ended?).to be(false)
+          end
+        end
+      end
+
+      context 'when the error is a SocketError' do
+
+        let(:error) do
+          Mongo::Error::SocketError
+        end
+
+        it_behaves_like 'a change stream that encounters an error from a getmore'
+      end
+
+      context 'when the error is a SocketTimeoutError' do
+
+        let(:error) do
+          Mongo::Error::SocketTimeoutError
+        end
+
+        it_behaves_like 'a change stream that encounters an error from a getmore'
+      end
+
+      context "when the error is a not 'master error'" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('not master')
+        end
+
+        it_behaves_like 'a change stream that encounters an error from a getmore'
+      end
+
+      context "when the error is a not 'cursor not found error'" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('cursor not found (43)')
+        end
+
+        it_behaves_like 'a change stream that encounters an error from a getmore'
+      end
+    end
+
+    context 'when the error is another server error' do
+
+      before do
+        change_stream
+        authorized_collection.insert_one(a: 1)
+        enum.next
+        authorized_collection.insert_one(a: 2)
+        expect(cursor).to receive(:get_more).and_raise(Mongo::Error::OperationFailure)
+        expect(cursor).to receive(:kill_cursors).and_call_original
+        expect(Mongo::Operation::Commands::Aggregate).not_to receive(:new)
+      end
+
+      let(:enum) do
+        change_stream.to_enum
+      end
+
+      it 'does not run the command again and instead raises the error' do
+        expect {
+          enum.next
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+
+      context 'when provided a session' do
+
+        let(:options) do
+          { session: session}
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        before do
+          begin; enum.next; rescue; end
+        end
+
+        it 'does not close the session' do
+          expect(session.ended?).to be(false)
+        end
+      end
+    end
+  end
+
+  context 'when a server error is encountered during the command following an error during getmore' do
+
+    context 'when the error is a resumable error' do
+
+      shared_examples_for 'a change stream that sent getmores, that then encounters an error when resuming' do
+
+        before do
+          change_stream
+          authorized_collection.insert_one(a: 1)
+          enum.next
+          authorized_collection.insert_one(a: 2)
+          expect(cursor).to receive(:get_more).and_raise(error)
+          expect(cursor).to receive(:kill_cursors).and_call_original
+          expect(change_stream).to receive(:send_initial_query).and_raise(error).once.ordered
+        end
+
+        let(:enum) do
+          change_stream.to_enum
+        end
+
+        let(:document) do
+          enum.next
+        end
+
+        it 'raises the error' do
+          expect {
+            document
+          }.to raise_exception(error)
+        end
+
+        context 'when provided a session' do
+
+          let(:options) do
+            { session: session}
+          end
+
+          let(:session) do
+            authorized_client.start_session
+          end
+
+          before do
+            begin; document; rescue; end
+          end
+
+          it 'does not close the session' do
+            expect(session.ended?).to be(false)
+          end
+        end
+      end
+
+      context 'when the error is a SocketError' do
+
+        let(:error) do
+          Mongo::Error::SocketError
+        end
+
+        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+      end
+
+      context 'when the error is a SocketTimeoutError' do
+
+        let(:error) do
+          Mongo::Error::SocketTimeoutError
+        end
+
+        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+      end
+
+      context "when the error is a 'not master error'" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('not master')
+        end
+
+        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+      end
+
+      context "when the error is a not 'cursor not found error'" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('cursor not found (43)')
+        end
+
+        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+      end
+    end
+
+    context 'when the error is another server error' do
+
+      before do
+        change_stream
+        authorized_collection.insert_one(a: 1)
+        enum.next
+        authorized_collection.insert_one(a: 2)
+        expect(cursor).to receive(:get_more).and_raise(Mongo::Error::OperationFailure.new('not master'))
+        expect(cursor).to receive(:kill_cursors).and_call_original
+        expect(change_stream).to receive(:send_initial_query).and_raise(Mongo::Error::OperationFailure).once.ordered
+      end
+
+      let(:enum) do
+        change_stream.to_enum
+      end
+
+      it 'does not run the command again and instead raises the error' do
+        expect {
+          enum.next
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+
+      context 'when provided a session' do
+
+        let(:options) do
+          { session: session}
+        end
+
+        let(:session) do
+          authorized_client.start_session
+        end
+
+        before do
+          begin; enum.next; rescue; end
+        end
+
+        it 'does not close the session' do
+          expect(session.ended?).to be(false)
+        end
+      end
+    end
+  end
+end