mongo 2.12.4 → 2.14.0.rc1

data/spec/integration/query_cache_transactions_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe 'QueryCache with transactions' do
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  end
+
+  before do
+    authorized_collection.delete_many
+    subscriber.clear_events!
+  end
+
+  # These tests do not currently use the session registry because transactions
+  # leak sessions independently of the query cache. This will be resolved by
+  # RUBY-2391.
+
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:authorized_collection) { client['collection_spec'] }
+
+  describe 'in transactions' do
+    require_transaction_support
+    require_wired_tiger
+
+    let(:collection) { authorized_client['test'] }
+
+    let(:events) do
+      subscriber.command_started_events('find')
+    end
+
+    before do
+      Utils.create_collection(authorized_client, 'test')
+    end
+
+    context 'with convenient API' do
+      context 'when same query is performed inside and outside of transaction' do
+        it 'performs one query' do
+          collection.find.to_a
+
+          session = authorized_client.start_session
+          session.with_transaction do
+            collection.find({}, session: session).to_a
+          end
+
+          expect(subscriber.command_started_events('find').length).to eq(1)
+        end
+      end
+
+      context 'when transaction has a different read concern' do
+        it 'performs two queries' do
+          collection.find.to_a
+
+          session = authorized_client.start_session
+          session.with_transaction(
+           read_concern: { level: :snapshot }
+          ) do
+            collection.find({}, session: session).to_a
+          end
+
+          expect(subscriber.command_started_events('find').length).to eq(2)
+        end
+      end
+
+      context 'when transaction has a different read preference' do
+        it 'performs two queries' do
+          collection.find.to_a
+
+          session = authorized_client.start_session
+          session.with_transaction(
+           read: { mode: :primary }
+          ) do
+            collection.find({}, session: session).to_a
+          end
+
+          expect(subscriber.command_started_events('find').length).to eq(2)
+        end
+      end
+
+      context 'when transaction is committed' do
+        it 'clears the cache' do
+          session = authorized_client.start_session
+          session.with_transaction do
+            collection.insert_one({ test: 1 }, session: session)
+            collection.insert_one({ test: 2 }, session: session)
+
+            expect(collection.find({}, session: session).to_a.length).to eq(2)
+            expect(collection.find({}, session: session).to_a.length).to eq(2)
+
+            # The driver caches the queries within the transaction
+            expect(subscriber.command_started_events('find').length).to eq(1)
+            session.commit_transaction
+          end
+
+          expect(collection.find.to_a.length).to eq(2)
+
+          # The driver clears the cache and runs the query again
+          expect(subscriber.command_started_events('find').length).to eq(2)
+        end
+      end
+
+      context 'when transaction is aborted' do
+        it 'clears the cache' do
+          session = authorized_client.start_session
+          session.with_transaction do
+            collection.insert_one({ test: 1 }, session: session)
+            collection.insert_one({ test: 2 }, session: session)
+
+            expect(collection.find({}, session: session).to_a.length).to eq(2)
+            expect(collection.find({}, session: session).to_a.length).to eq(2)
+
+            # The driver caches the queries within the transaction
+            expect(subscriber.command_started_events('find').length).to eq(1)
+            session.abort_transaction
+          end
+
+          expect(collection.find.to_a.length).to eq(0)
+
+          # The driver clears the cache and runs the query again
+          expect(subscriber.command_started_events('find').length).to eq(2)
+        end
+      end
+    end
+
+    context 'with low-level API' do
+      context 'when transaction is committed' do
+        it 'clears the cache' do
+          session = authorized_client.start_session
+          session.start_transaction
+
+          collection.insert_one({ test: 1 }, session: session)
+          collection.insert_one({ test: 2 }, session: session)
+
+          expect(collection.find({}, session: session).to_a.length).to eq(2)
+          expect(collection.find({}, session: session).to_a.length).to eq(2)
+
+          # The driver caches the queries within the transaction
+          expect(subscriber.command_started_events('find').length).to eq(1)
+
+          session.commit_transaction
+
+          expect(collection.find.to_a.length).to eq(2)
+
+          # The driver clears the cache and runs the query again
+          expect(subscriber.command_started_events('find').length).to eq(2)
+        end
+      end
+
+      context 'when transaction is aborted' do
+        it 'clears the cache' do
+          session = authorized_client.start_session
+          session.start_transaction
+
+          collection.insert_one({ test: 1 }, session: session)
+          collection.insert_one({ test: 2 }, session: session)
+
+          expect(collection.find({}, session: session).to_a.length).to eq(2)
+          expect(collection.find({}, session: session).to_a.length).to eq(2)
+
+          # The driver caches the queries within the transaction
+          expect(subscriber.command_started_events('find').length).to eq(1)
+
+          session.abort_transaction
+
+          expect(collection.find.to_a.length).to eq(0)
+
+          # The driver clears the cache and runs the query again
+          expect(subscriber.command_started_events('find').length).to eq(2)
+        end
+      end
+    end
+  end
+end

data/spec/integration/read_concern_spec.rb

@@ -17,7 +17,7 @@ describe 'read concern' do
 
   let(:sent_read_concern) do
     subscriber.clear_events!
-    collection.count_documents({})
+    collection.count_documents
     subscriber.started_events.find { |c| c.command_name == 'aggregate' }.command[:readConcern]
   end
 

data/spec/integration/read_preference_spec.rb

@@ -77,11 +77,11 @@ describe 'Read preference' do
       it_behaves_like 'does not send read preference when reading'
     end
 
-    context 'RS, sharded cluster' do
+    context 'replica set' do
       # Supposedly read preference should only be sent in a sharded cluster
       # topology. However, transactions spec tests contain read preference
       # assertions also when they are run in RS topologies.
-      require_topology :sharded, :replica_set
+      require_topology :replica_set
 
       context 'pre-OP_MSG server' do
         max_server_version '3.4'
@@ -95,6 +95,13 @@ describe 'Read preference' do
         it_behaves_like 'sends expected read preference when reading'
       end
     end
+
+    context 'sharded cluster' do
+      # Driver does not send $readPreference document to mongos when
+      # specified mode is primary.
+      require_topology :sharded
+      it_behaves_like 'does not send read preference when reading'
+    end
   end
 
   shared_examples_for 'sends expected read preference' do
@@ -264,18 +271,41 @@ describe 'Read preference' do
     shared_examples_for 'sends expected read preference' do
       it_behaves_like 'non-transactional read preference examples'
 
-      it 'sends expected read preference when starting transaction' do
-        collection.insert_one(hello: 'world')
+      context 'on sharded cluster' do
+        require_topology :sharded
 
-        session = client.start_session(session_options)
-        session.with_transaction(tx_options) do
-          res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
-          expect(res).to eq(1)
+        it 'does not send read preference' do
+          # Driver does not send $readPreference document to mongos when
+          # specified mode is primary.
+          collection.insert_one(hello: 'world')
+
+          session = client.start_session(session_options)
+          session.with_transaction(tx_options) do
+            res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
+            expect(res).to eq(1)
+          end
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          expect(actual_preference).to be_nil
         end
+      end
 
-        event = subscriber.single_command_started_event('find')
-        actual_preference = event.command['$readPreference']
-        expect(actual_preference).to eq(expected_read_preference)
+      context 'on replica set' do
+        require_topology :replica_set
+        it 'sends expected read preference when starting transaction' do
+          collection.insert_one(hello: 'world')
+
+          session = client.start_session(session_options)
+          session.with_transaction(tx_options) do
+            res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
+            expect(res).to eq(1)
+          end
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          expect(actual_preference).to eq(expected_read_preference)
+        end
       end
     end
 

data/spec/integration/reconnect_spec.rb

@@ -65,9 +65,8 @@ describe 'Client after reconnect' do
     end
 
     let(:client) do
-      ClientRegistry.instance.register_local_client(
-        Mongo::Client.new(uri, SpecConfig.instance.ssl_options.merge(
-          server_selection_timeout: 3.86, logger: logger)))
+      new_local_client(uri, SpecConfig.instance.ssl_options.merge(
+        server_selection_timeout: 3.86, logger: logger))
     end
 
     let(:wait_for_discovery) do

data/spec/integration/retryable_errors_spec.rb

@@ -4,8 +4,16 @@ describe 'Failing retryable operations' do
   # Requirement for fail point
   min_server_fcv '4.0'
 
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client_options) do
+    {}
+  end
+
   let(:client) do
-    subscribed_client
+    authorized_client.with(client_options).tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
   end
 
   let(:collection) do
@@ -83,13 +91,13 @@ describe 'Failing retryable operations' do
       end
 
       let(:events) do
-        EventSubscriber.command_started_events('find')
+        subscriber.command_started_events('find')
       end
     end
 
     shared_context 'write operation' do
       let(:fail_point_command) do
-        {
+        command = {
           configureFailPoint: 'failCommand',
           mode: {times: 2},
           data: {
@@ -97,6 +105,15 @@ describe 'Failing retryable operations' do
             errorCode: 11600,
           },
         }
+
+        if ClusterConfig.instance.short_server_version >= '4.4'
+          # Server versions 4.4 and newer will add the RetryableWriteError
+          # label to all retryable errors, and the driver must not add the label
+          # if it is not already present.
+          command[:data][:errorLabels] = ['RetryableWriteError']
+        end
+
+        command
       end
 
       let(:set_fail_point) do
@@ -119,7 +136,7 @@ describe 'Failing retryable operations' do
       end
 
       let(:events) do
-        EventSubscriber.command_started_events('insert')
+        subscriber.command_started_events('insert')
       end
     end
 
@@ -132,6 +149,7 @@ describe 'Failing retryable operations' do
       end
 
       it 'publishes two events' do
+        operation_exception
 
         expect(events.length).to eq(2)
       end
@@ -146,6 +164,7 @@ describe 'Failing retryable operations' do
       end
 
       it 'publishes one event' do
+        operation_exception
 
         expect(events.length).to eq(1)
       end
@@ -208,8 +227,8 @@ describe 'Failing retryable operations' do
       context 'modern read retries' do
         require_wired_tiger_on_36
 
-        let(:client) do
-          subscribed_client.with(retry_reads: true)
+        let(:client_options) do
+          {retry_reads: true}
         end
 
         it_behaves_like 'failing retry'
@@ -217,8 +236,8 @@ describe 'Failing retryable operations' do
       end
 
       context 'legacy read retries' do
-        let(:client) do
-          subscribed_client.with(retry_reads: false, read_retry_interval: 0)
+        let(:client_options) do
+          {retry_reads: false, read_retry_interval: 0}
         end
 
         it_behaves_like 'failing retry'
@@ -227,8 +246,8 @@ describe 'Failing retryable operations' do
     end
 
     context 'when read retries are disabled' do
-      let(:client) do
-        subscribed_client.with(retry_reads: false, max_read_retries: 0)
+      let(:client_options) do
+        {retry_reads: false, max_read_retries: 0}
       end
 
       include_context 'read operation'
@@ -243,8 +262,8 @@ describe 'Failing retryable operations' do
       context 'modern write retries' do
         require_wired_tiger_on_36
 
-        let(:client) do
-          subscribed_client.with(retry_writes: true)
+        let(:client_options) do
+          {retry_writes: true}
         end
 
         it_behaves_like 'failing retry'
@@ -252,8 +271,8 @@ describe 'Failing retryable operations' do
       end
 
       context 'legacy write' do
-        let(:client) do
-          subscribed_client.with(retry_writes: false)
+        let(:client_options) do
+          {retry_writes: false}
         end
 
         it_behaves_like 'failing retry'

data/spec/integration/{retryable_writes_spec.rb → retryable_writes/retryable_writes_36_and_older_spec.rb}

@@ -19,6 +19,12 @@ describe 'Retryable writes integration tests' do
   # eligible servers as would be the case in a multi-shard sharded cluster
   require_no_multi_shard
 
+  # Note: these tests are deprecated in favor of the tests in the file
+  # spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb
+  # If you are changing functionality in the driver that only impacts server
+  # versions 4.0 or newer, test that functionality in the other test file.
+  max_server_fcv '3.6'
+
   before do
     authorized_collection.delete_many
   end
@@ -26,7 +32,7 @@ describe 'Retryable writes integration tests' do
   let(:check_collection) do
     # Verify data in the collection using another client instance to avoid
     # having the verification read trigger cluster scans on the writing client
-    subscribed_client[TEST_COLL]
+    root_authorized_client[TEST_COLL]
   end
 
   let(:primary_connection) do
@@ -43,7 +49,7 @@ describe 'Retryable writes integration tests' do
       before do
         wait_for_all_servers(client.cluster)
 
-        allow(primary_socket).to receive(:write).and_raise(error)
+        allow(primary_socket).to receive(:do_write).and_raise(error.dup)
       end
 
       context 'when the error is retryable' do
@@ -52,10 +58,10 @@ describe 'Retryable writes integration tests' do
           expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
         end
 
-        context 'when the error is a SocketError' do
+        context 'when the error is a socket error' do
 
           let(:error) do
-            Mongo::Error::SocketError
+            IOError.new('first error')
           end
 
           it 'retries writes' do
@@ -64,10 +70,10 @@ describe 'Retryable writes integration tests' do
           end
         end
 
-        context 'when the error is a SocketTimeoutError' do
+        context 'when the error is a socket timeout error' do
 
           let(:error) do
-            Mongo::Error::SocketTimeoutError
+            Errno::ETIMEDOUT.new
           end
 
           it 'retries writes' do
@@ -126,7 +132,7 @@ describe 'Retryable writes integration tests' do
     context 'when the operation fails on the first attempt and again on the second attempt' do
 
       before do
-        allow(primary_socket).to receive(:write).and_raise(error)
+        allow(primary_socket).to receive(:do_write).and_raise(error.dup)
       end
 
       context 'when the selected server does not support retryable writes' do
@@ -134,33 +140,38 @@ describe 'Retryable writes integration tests' do
         before do
           legacy_primary = double('legacy primary', :retry_writes? => false)
           expect(collection).to receive(:select_server).and_return(primary_server, legacy_primary)
-          expect(primary_socket).to receive(:write).and_raise(error)
+          expect(primary_socket).to receive(:do_write).and_raise(error.dup)
         end
 
-        context 'when the error is a SocketError' do
+        context 'when the error is a socket error' do
 
           let(:error) do
+            IOError.new('first error')
+          end
+
+          let(:exposed_error_class) do
             Mongo::Error::SocketError
           end
 
           it 'does not retry writes and raises the original error' do
             expect do
               operation
-            end.to raise_error(error)
+            end.to raise_error(exposed_error_class, /first error/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
 
-        context 'when the error is a SocketTimeoutError' do
+        context 'when the error is a socket timeout error' do
 
           let(:error) do
-            Mongo::Error::SocketTimeoutError
+            Errno::ETIMEDOUT.new('first error')
           end
 
           it 'does not retry writes and raises the original error' do
             expect do
               operation
-            end.to raise_error(error)
+            # The exception message is different because of added diagnostics.
+            end.to raise_error(Mongo::Error::SocketTimeoutError, /first error/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
@@ -174,18 +185,18 @@ describe 'Retryable writes integration tests' do
           it 'does not retry writes and raises the original error' do
             expect do
               operation
-            end.to raise_error(error)
+            end.to raise_error(Mongo::Error::OperationFailure, /not master/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
       end
 
       [
-        [Mongo::Error::SocketError],
-        [Mongo::Error::SocketTimeoutError],
-        [Mongo::Error::OperationFailure, 'not master'],
-        [Mongo::Error::OperationFailure, 'node is recovering'],
-      ].each do |error_cls, error_msg|
+        [IOError, 'first error', Mongo::Error::SocketError],
+        [Errno::ETIMEDOUT, 'first error', Mongo::Error::SocketTimeoutError],
+        [Mongo::Error::OperationFailure, 'first error: not master', Mongo::Error::OperationFailure],
+        [Mongo::Error::OperationFailure, 'first error: node is recovering', Mongo::Error::OperationFailure],
+      ].each do |error_cls, error_msg, exposed_first_error_class|
         # Note: actual exception instances must be different between tests
 
         context "when the first error is a #{error_cls}/#{error_msg}" do
@@ -200,20 +211,24 @@ describe 'Retryable writes integration tests' do
                                                            primary_connection.send(:ssl_options))
             good_socket = primary_connection.address.socket(primary_connection.socket_timeout,
                                                             primary_connection.send(:ssl_options))
-            allow(bad_socket).to receive(:write).and_raise(second_error)
+            allow(bad_socket).to receive(:do_write).and_raise(second_error.dup)
             allow(primary_connection.address).to receive(:socket).and_return(bad_socket, good_socket)
           end
 
-          context 'when the second error is a SocketError' do
+          context 'when the second error is a socket error' do
 
             let(:second_error) do
+              IOError.new('second error')
+            end
+
+            let(:exposed_error_class) do
               Mongo::Error::SocketError
             end
 
             it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(second_error)
+              end.to raise_error(exposed_error_class, /second error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
 
@@ -230,16 +245,20 @@ describe 'Retryable writes integration tests' do
             end
           end
 
-          context 'when the second error is a SocketTimeoutError' do
+          context 'when the second error is a socket timeout error' do
 
             let(:second_error) do
+              Errno::ETIMEDOUT.new('second error')
+            end
+
+            let(:exposed_error_class) do
               Mongo::Error::SocketTimeoutError
             end
 
             it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(second_error)
+              end.to raise_error(exposed_error_class, /second error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -247,13 +266,13 @@ describe 'Retryable writes integration tests' do
           context 'when the second error is a retryable OperationFailure' do
 
             let(:second_error) do
-              Mongo::Error::OperationFailure.new('not master')
+              Mongo::Error::OperationFailure.new('second error: not master')
             end
 
             it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(second_error)
+              end.to raise_error(Mongo::Error, /second error: not master/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -267,41 +286,26 @@ describe 'Retryable writes integration tests' do
             it 'does not retry writes and raises the first error' do
               expect do
                 operation
-              end.to raise_error(error)
+              end.to raise_error(exposed_first_error_class, /first error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
 
-          context 'when the second error is a another error' do
+          # The driver shouldn't be producing non-Mongo::Error derived errors,
+          # but if those are produced (like ArgumentError), they would be
+          # immediately propagated to the application.
+          context 'when the second error is another error' do
 
             let(:second_error) do
-              StandardError
+              StandardError.new('second error')
             end
 
-            it 'raises the first error' do
+            it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(error)
+              end.to raise_error(StandardError, /second error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
-
-            it 'indicates server used for operation' do
-              expect do
-                operation
-              end.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
-            end
-
-            it 'indicates first attempt' do
-              expect do
-                operation
-              end.to raise_error(Mongo::Error, /attempt 1/)
-            end
-
-            it 'indicates retry was performed' do
-              expect do
-                operation
-              end.to raise_error(Mongo::Error, /later retry failed: StandardError/)
-            end
           end
         end
       end
@@ -315,7 +319,7 @@ describe 'Retryable writes integration tests' do
     end
 
     before do
-      expect(primary_socket).to receive(:write).exactly(:once).and_raise(Mongo::Error::SocketError)
+      expect(primary_socket).to receive(:do_write).exactly(:once).and_raise(Mongo::Error::SocketError)
     end
 
     it 'does not retry writes' do
@@ -337,7 +341,7 @@ describe 'Retryable writes integration tests' do
     end
 
     before do
-      expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
+      expect(primary_socket).to receive(:do_write).and_raise(Mongo::Error::SocketError)
     end
 
     it 'does not retry writes' do