mongo 2.13.0 → 2.15.0.alpha

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/reconnect_spec.rb

@@ -65,7 +65,7 @@ describe 'Client after reconnect' do
     end
 
     let(:client) do
-      new_local_client(uri, SpecConfig.instance.ssl_options.merge(
+      new_local_client(uri, SpecConfig.instance.monitoring_options.merge(
         server_selection_timeout: 3.86, logger: logger))
     end
 

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(

data/spec/integration/sdam_error_handling_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe 'SDAM error handling' do
-  clean_slate_for_all
+  clean_slate
 
   after do
     # Close all clients after every test to avoid leaking expectations into
@@ -19,6 +19,7 @@ describe 'SDAM error handling' 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)
@@ -28,6 +29,14 @@ describe 'SDAM error handling' do
   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
@@ -38,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
@@ -197,6 +214,74 @@ describe 'SDAM error handling' do
     end
   end
 
+  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
+
+    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
 

data/spec/integration/sdam_events_spec.rb

@@ -67,9 +67,8 @@ describe 'SDAM events' do
         started_events.length.should <= 10
 
         succeeded_events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
-        # Since we gracefully close the client, we expect each heartbeat
-        # to complete.
-        started_events.length.should == succeeded_events.length
+        started_events.length.should > 1
+        (succeeded_events.length..succeeded_events.length+1).should include(started_events.length)
       end
     end
 
@@ -105,10 +104,12 @@ describe 'SDAM events' do
         (succeeded_awaited = events.select(&:awaited?)).should_not be_empty
         (succeeded_regular = events.reject(&:awaited?)).should_not be_empty
 
-        # Since we gracefully close the client, we expect each heartbeat
-        # to complete.
-        started_awaited.length.should == succeeded_awaited.length
-        started_regular.length.should == succeeded_regular.length
+        # There may be in-flight ismasters that don't complete, both
+        # regular and awaited.
+        started_awaited.length.should > 1
+        (succeeded_awaited.length..succeeded_awaited.length+1).should include(started_awaited.length)
+        started_regular.length.should > 1
+        (succeeded_regular.length..succeeded_regular.length+1).should include(started_regular.length)
       end
     end
   end

data/spec/integration/server_selection_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'Server selection' do
+  context 'replica set' do
+    require_topology :replica_set
+    # 2.6 server does not provide replSetGetConfig and hence we cannot add
+    # the tags to the members.
+    min_server_version '3.0'
+
+    context 'when mixed case tag names are used' do
+      # For simplicity this test assumes our Evergreen configuration:
+      # nodes are started from port 27017 onwards and there are more than
+      # one of them.
+
+      let(:desired_index) do
+        if authorized_client.cluster.next_primary.address.port == 27017
+          1
+        else
+          0
+        end
+      end
+
+      let(:client) do
+        new_local_client(SpecConfig.instance.addresses,
+          SpecConfig.instance.authorized_test_options.merge(
+            server_selection_timeout: 4,
+            read: {mode: :secondary, tag_sets: [nodeIndex: desired_index.to_s]},
+          ))
+      end
+
+      it 'selects the server' do
+        client['nonexistent'].count.should == 0
+      end
+    end
+  end
+end

data/spec/integration/size_limit_spec.rb

@@ -62,30 +62,31 @@ describe 'BSON & command size limits' do
     authorized_collection.insert_one(document)
   end
 
-  context 'on server versions >= 3.6' do
-    min_server_fcv '3.6'
+  it 'fails on the driver when a document larger than 16MiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+1)
 
-    it 'fails on the driver when a document larger than 16MiB is inserted' do
-      document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
-      expect(document.to_bson.length).to eq(max_document_size+1)
-
-      lambda do
-        authorized_collection.insert_one(document)
-      end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-    end
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
   end
 
-  context 'on server versions <= 3.4' do
-    max_server_fcv '3.4'
+  it 'fails on the driver when an update larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.update_one({ _id: 'foo' }, document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
 
-    it 'fails on the server when a document larger than 16MiB is inserted' do
-      document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
-      expect(document.to_bson.length).to eq(max_document_size+1)
+  it 'fails on the driver when an delete larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
 
-      lambda do
-        authorized_collection.insert_one(document)
-      end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
-    end
+    lambda do
+      authorized_collection.delete_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
   end
 
   it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do