mongo 2.13.0.beta1 → 2.14.0

data/spec/integration/query_cache_transactions_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe 'QueryCache with transactions' do
+  # Work around https://jira.mongodb.org/browse/HELP-10518
+  before(:all) do
+    client = ClientRegistry.instance.global_client('authorized')
+    Utils.create_collection(client, 'test')
+
+    Utils.mongos_each_direct_client do |client|
+      client['test'].distinct('foo').to_a
+    end
+  end
+
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  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
+
+  before do
+    collection.delete_many
+
+    # Work around https://jira.mongodb.org/browse/HELP-10518
+    client.start_session do |session|
+      session.with_transaction do
+        collection.find({}, session: session).to_a
+      end
+    end
+    subscriber.clear_events!
+  end
+
+  describe 'in transactions' do
+    require_transaction_support
+    require_wired_tiger
+
+    let(:collection) { client['test'] }
+
+    let(:events) do
+      subscriber.command_started_events('find')
+    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 = 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 = 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 = 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 = 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 = 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 = 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 = 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/retryable_errors_spec.rb

@@ -106,7 +106,7 @@ describe 'Failing retryable operations' do
           },
         }
 
-        if ClusterConfig.instance.short_server_version >= '4.3'
+        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.

data/spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb

@@ -8,6 +8,7 @@ describe 'Retryable Writes' do
   require_fail_command
   require_wired_tiger
   require_no_multi_shard
+  require_warning_clean
 
   let(:client) do
     authorized_client.with(

data/spec/integration/retryable_writes/shared/performs_legacy_retries.rb

@@ -2,6 +2,8 @@ require_relative './adds_diagnostics'
 
 module PerformsLegacyRetries
   shared_examples 'it performs legacy retries' do
+    require_warning_clean
+
     context 'for connection error' do
       before do
         client.use('admin').command(
@@ -26,7 +28,7 @@ module PerformsLegacyRetries
     end
 
     context 'for ETIMEDOUT' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       # shorten socket timeout so these tests take less time to run
       let(:socket_timeout) { 1 }
@@ -59,7 +61,7 @@ module PerformsLegacyRetries
     end
 
     context 'on server versions >= 4.4' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       context 'for OperationFailure with RetryableWriteError label' do
         before do

data/spec/integration/retryable_writes/shared/performs_modern_retries.rb

@@ -44,8 +44,8 @@ module PerformsModernRetries
 
     context 'for ETIMEDOUT' do
       # blockConnection option in failCommand was introduced in
-      # server version 4.3
-      min_server_fcv '4.3'
+      # server version 4.4
+      min_server_fcv '4.4'
 
       # shorten socket timeout so these tests take less time to run
       let(:socket_timeout) { 1 }
@@ -94,7 +94,7 @@ module PerformsModernRetries
     end
 
     context 'on server versions >= 4.4' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       context 'for OperationFailure with RetryableWriteError label' do
         before do

data/spec/integration/retryable_writes/shared/performs_no_retries.rb

@@ -25,7 +25,7 @@ module PerformsNoRetries
     end
 
     context 'for ETIMEDOUT' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       # shorten socket timeout so these tests take less time to run
       let(:socket_timeout) { 1 }
@@ -58,7 +58,7 @@ module PerformsNoRetries
     end
 
     context 'on server versions >= 4.4' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
       # These tests will be implemented in a follow-up PR
     end
 

data/spec/integration/sdam_error_handling_spec.rb

@@ -3,15 +3,40 @@ require 'spec_helper'
 describe 'SDAM error handling' do
   clean_slate_for_all
 
+  after do
+    # Close all clients after every test to avoid leaking expectations into
+    # subsequent tests because we set global assertions on sockets.
+    ClientRegistry.instance.close_all_clients
+  end
+
   # These tests operate on specific servers, and don't work in a multi
   # shard cluster where multiple servers are equally eligible
   require_no_multi_shard
 
-  let(:client) { authorized_client_without_any_retries }
+  let(:diagnostic_subscriber) { VerboseEventSubscriber.new }
+
+  let(:client) do
+    new_local_client(SpecConfig.instance.addresses,
+      SpecConfig.instance.all_test_options.merge(
+        socket_timeout: 3, connect_timeout: 3,
+        heartbeat_frequency: 100,
+        # Uncomment to print all events to stdout:
+        #sdam_proc: Utils.subscribe_all_sdam_proc(diagnostic_subscriber),
+        **Utils.disable_retries_client_options)
+    )
+  end
 
   let(:server) { client.cluster.next_primary }
 
   shared_examples_for 'marks server unknown' do
+    before do
+      server.monitor.stop!
+    end
+
+    after do
+      client.close
+    end
+
     it 'marks server unknown' do
       expect(server).not_to be_unknown
       RSpec::Mocks.with_temporary_scope do
@@ -22,6 +47,14 @@ describe 'SDAM error handling' do
   end
 
   shared_examples_for 'does not mark server unknown' do
+    before do
+      server.monitor.stop!
+    end
+
+    after do
+      client.close
+    end
+
     it 'does not mark server unknown' do
       expect(server).not_to be_unknown
       RSpec::Mocks.with_temporary_scope do
@@ -148,6 +181,9 @@ describe 'SDAM error handling' do
     end
 
     context 'network error' do
+      # With 4.4 servers we set up two monitoring connections, hence global
+      # socket expectations get hit twice.
+      max_server_version '4.2'
 
       let(:operation) do
         expect_any_instance_of(Mongo::Socket).to receive(:read).and_raise(exception)
@@ -178,15 +214,76 @@ describe 'SDAM error handling' do
     end
   end
 
-  describe 'when there is an error on monitoring connection' do
-    clean_slate_for_all
+  describe 'when there is an error during connection establishment' do
+    require_topology :single
+
+    # The push monitor creates sockets unpredictably and interferes with this
+    # test.
+    max_server_version '4.2'
+
+    # When TLS is used there are two socket classes and we can't simply
+    # mock the base Socket class.
+    require_no_tls
+
+    {
+      SystemCallError => Mongo::Error::SocketError,
+      Errno::ETIMEDOUT => Mongo::Error::SocketTimeoutError,
+    }.each do |raw_error_cls, mapped_error_cls|
+      context raw_error_cls.name do
+        let(:socket) do
+          double('mock socket').tap do |socket|
+            allow(socket).to receive(:set_encoding)
+            allow(socket).to receive(:setsockopt)
+            allow(socket).to receive(:getsockopt)
+            allow(socket).to receive(:connect)
+            allow(socket).to receive(:close)
+            socket.should receive(:write).and_raise(raw_error_cls, 'mocked failure')
+          end
+        end
+
+        it 'marks server unknown' do
+          server = client.cluster.next_primary
+          client.cluster.servers.map(&:disconnect!)
+
+          RSpec::Mocks.with_temporary_scope do
+
+            Socket.should receive(:new).with(any_args).ordered.once.and_return(socket)
+
+            lambda do
+              client.command(ping: 1)
+            end.should raise_error(mapped_error_cls, /mocked failure/)
+
+            server.should be_unknown
+          end
+        end
+
+        it 'recovers' do
+          server = client.cluster.next_primary
+          # If we do not kill the monitor, the client will recover automatically.
+
+          RSpec::Mocks.with_temporary_scope do
+
+            Socket.should receive(:new).with(any_args).ordered.once.and_return(socket)
+            Socket.should receive(:new).with(any_args).ordered.once.and_call_original
+
+            lambda do
+              client.command(ping: 1)
+            end.should raise_error(mapped_error_cls, /mocked failure/)
+
+            client.command(ping: 1)
+          end
+        end
+      end
+    end
 
-    let(:client) do
-      new_local_client(SpecConfig.instance.addresses,
-        SpecConfig.instance.test_options.merge(
-          connect_timeout: 1, socket_timeout: 1,
-      ))
+    after do
+      # Since we stopped monitoring on the client, close it.
+      ClientRegistry.instance.close_all_clients
     end
+  end
+
+  describe 'when there is an error on monitoring connection' do
+    clean_slate_for_all
 
     let(:subscriber) { EventSubscriber.new }
 
@@ -209,6 +306,7 @@ describe 'SDAM error handling' do
       it 'marks server unknown' do
         expect(server).not_to be_unknown
 
+        #subscriber.clear_events!
         events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
         events.should be_empty
 
@@ -228,6 +326,7 @@ describe 'SDAM error handling' do
 
     shared_examples_for 'clears connection pool - cmap event' do
       it 'clears connection pool' do
+        #subscriber.clear_events!
         events = subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared)
         events.should be_empty
 
@@ -245,6 +344,7 @@ describe 'SDAM error handling' do
     end
 
     shared_examples_for 'marks server unknown and clears connection pool' do
+=begin These tests are not reliable
       context 'via object inspection' do
         let(:expect_server_state_change) do
           server.summary.should =~ /unknown/i
@@ -254,6 +354,7 @@ describe 'SDAM error handling' do
         it_behaves_like 'marks server unknown'
         it_behaves_like 'clears connection pool'
       end
+=end
 
       context 'via events' do
         # When we use events we do not need to examine object state, therefore
@@ -268,16 +369,22 @@ describe 'SDAM error handling' do
       end
     end
 
-    context 'network timeout' do
-      let(:exception) { Mongo::Error::SocketTimeoutError }
+    context 'via stubs' do
+      # With 4.4 servers we set up two monitoring connections, hence global
+      # socket expectations get hit twice.
+      max_server_version '4.2'
 
-      it_behaves_like 'marks server unknown and clears connection pool'
-    end
+      context 'network timeout' do
+        let(:exception) { Mongo::Error::SocketTimeoutError }
 
-    context 'non-timeout network error' do
-      let(:exception) { Mongo::Error::SocketError }
+        it_behaves_like 'marks server unknown and clears connection pool'
+      end
 
-      it_behaves_like 'marks server unknown and clears connection pool'
+      context 'non-timeout network error' do
+        let(:exception) { Mongo::Error::SocketError }
+
+        it_behaves_like 'marks server unknown and clears connection pool'
+      end
     end
 
     context 'non-timeout network error via fail point' do