mongo 2.13.1 → 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/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

@@ -197,6 +197,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/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/srv_monitoring_spec.rb

@@ -76,6 +76,37 @@ describe 'SRV Monitoring' do
       require 'support/dns'
     end
 
+    around do |example|
+      # Speed up the tests by listening on the fake ports we are using.
+      done = false
+
+      servers = []
+      threads = [27998, 27999].map do |port|
+        Thread.new do
+          server = TCPServer.open(port)
+          servers << server
+          begin
+            loop do
+              break if done
+              server.accept.close rescue nil
+            end
+          ensure
+            server.close
+          end
+        end
+      end
+
+      begin
+        example.run
+      ensure
+        done = true
+        servers.map(&:close)
+
+        threads.map(&:kill)
+        threads.map(&:join)
+      end
+    end
+
     let(:uri) do
       "mongodb+srv://test-fake.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true"
     end
@@ -88,11 +119,15 @@ describe 'SRV Monitoring' do
       new_local_client(uri,
         SpecConfig.instance.ssl_options.merge(
           server_selection_timeout: 3.16,
-          timeout: 8.11,
+          socket_timeout: 8.11,
           connect_timeout: 8.12,
           resolv_options: {
-            nameserver: 'localhost',
-            nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
+            # Using localhost instead of 127.0.0.1 here causes Ruby's resolv
+            # client to drop responses.
+            nameserver: '127.0.0.1',
+            # TODO figure out why the address & port here need to be given
+            # twice - if given once, DNS resolution fails.
+            nameserver_port: [['127.0.0.1', 5300], ['127.0.0.1', 5300]],
           },
           logger: logger,
         ),

data/spec/integration/srv_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe 'SRV lookup' do
+  context 'end to end' do
+
+    # JRuby apparently does not implement non-blocking UDP I/O which is used
+    # by RubyDNS:
+    # NotImplementedError: recvmsg_nonblock is not implemented
+    fails_on_jruby
+
+    before(:all) do
+      require 'support/dns'
+    end
+
+    let(:uri) do
+      "mongodb+srv://test-fake.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true"
+    end
+
+    let(:client) do
+      new_local_client(uri,
+        SpecConfig.instance.ssl_options.merge(
+          server_selection_timeout: 3.16,
+          timeout: 4.11,
+          connect_timeout: 4.12,
+          resolv_options: {
+            nameserver: 'localhost',
+            nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
+          },
+        ),
+      )
+    end
+
+    context 'DNS resolver not responding' do
+      it 'fails to create client' do
+        lambda do
+          client
+        end.should raise_error(Mongo::Error::NoSRVRecords, /The DNS query returned no SRV records for 'test-fake.test.build.10gen.cc'/)
+      end
+
+      it 'times out in connect_timeout' do
+        start_time = Time.now
+
+        lambda do
+          client
+        end.should raise_error(Mongo::Error::NoSRVRecords)
+
+        elapsed_time = Time.now - start_time
+        elapsed_time.should > 4
+        # The number of queries performed depends on local DNS search suffixes,
+        # therefore we cannot reliably assert how long it would take for this
+        # resolution to time out.
+        #elapsed_time.should < 8
+      end
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -49,6 +49,7 @@ end
 autoload :Benchmark, 'benchmark'
 autoload :IceNine, 'ice_nine'
 autoload :Timecop, 'timecop'
+autoload :ChildProcess, 'childprocess'
 
 if BSON::Environment.jruby?
   require 'concurrent-ruby'
@@ -60,7 +61,7 @@ end
 require 'support/utils'
 require 'support/spec_config'
 
-Mongo::Logger.logger = Logger.new($stdout)
+Mongo::Logger.logger = Logger.new(STDOUT)
 unless SpecConfig.instance.client_debug?
   Mongo::Logger.logger.level = Logger::INFO
 end
@@ -76,6 +77,7 @@ require 'support/crypt'
 require 'support/json_ext_formatter'
 require 'support/sdam_formatter_integration'
 require 'support/background_thread_registry'
+require 'support/session_registry'
 
 if SpecConfig.instance.mri?
   require 'timeout_interrupt'