mongo 2.13.3 → 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

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

@@ -67,8 +67,9 @@ describe 'SDAM events' do
         started_events.length.should <= 10
 
         succeeded_events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
-        started_events.length.should > 1
-        (succeeded_events.length..succeeded_events.length+1).should include(started_events.length)
+        # Since we gracefully close the client, we expect each heartbeat
+        # to complete.
+        started_events.length.should == succeeded_events.length
       end
     end
 
@@ -104,12 +105,10 @@ describe 'SDAM events' do
         (succeeded_awaited = events.select(&:awaited?)).should_not be_empty
         (succeeded_regular = events.reject(&:awaited?)).should_not be_empty
 
-        # 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)
+        # 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
       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/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'
@@ -104,7 +106,7 @@ RSpec.configure do |config|
     end
   end
 
-  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
+  if SpecConfig.instance.ci?
     # Allow a max of 30 seconds per test.
     # Tests should take under 10 seconds ideally but it seems
     # we have some that run for more than 10 seconds in CI.

data/spec/mongo/address_spec.rb

@@ -234,7 +234,7 @@ describe Mongo::Address do
       end
 
       let(:address) do
-        Mongo::Address.new(custom_hostname)
+        Mongo::Address.new("#{custom_hostname}:#{SpecConfig.instance.any_port}")
       end
 
       before do

data/spec/mongo/caching_cursor_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Mongo::CachingCursor do
+
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  end
+
+  let(:authorized_collection) do
+    authorized_client['caching_cursor']
+  end
+
+  before do
+    authorized_collection.drop
+  end
+
+  let(:server) do
+    view.send(:server_selector).select_server(authorized_client.cluster)
+  end
+
+  let(:reply) do
+    view.send(:send_initial_query, server)
+  end
+
+  let(:cursor) do
+    described_class.new(view, reply, server)
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection)
+  end
+
+  before do
+    authorized_collection.delete_many
+    3.times { |i| authorized_collection.insert_one(_id: i) }
+  end
+
+  describe '#cached_docs' do
+    context 'when no query has been performed' do
+      it 'returns nil' do
+        expect(cursor.cached_docs).to be_nil
+      end
+    end
+
+    context 'when a query has been performed' do
+      it 'returns the number of documents' do
+        cursor.to_a
+        expect(cursor.cached_docs.length).to eq(3)
+        expect(cursor.cached_docs).to eq([{ '_id' => 0 }, { '_id' => 1 }, { '_id' => 2 }])
+      end
+    end
+  end
+
+  describe '#try_next' do
+    it 'fetches the next document' do
+      expect(cursor.try_next).to eq('_id' => 0)
+      expect(cursor.try_next).to eq('_id' => 1)
+      expect(cursor.try_next).to eq('_id' => 2)
+    end
+  end
+
+  describe '#each' do
+    it 'iterates the cursor' do
+      result = cursor.each.to_a
+      expect(result.length).to eq(3)
+      expect(result).to eq([{ '_id' => 0 }, { '_id' => 1 }, { '_id' => 2 }])
+    end
+  end
+end

data/spec/mongo/client_construction_spec.rb

@@ -496,6 +496,7 @@ describe Mongo::Client do
         end
 
         context 'when the compressor is not supported by the driver' do
+          require_warning_clean
 
           let(:options) do
             { compressors: ['snoopy'] }
@@ -674,7 +675,7 @@ describe Mongo::Client do
       context 'when providing a custom logger' do
 
         let(:logger) do
-          Logger.new($stdout).tap do |l|
+          Logger.new(STDOUT).tap do |l|
             l.level = Logger::FATAL
           end
         end
@@ -1343,6 +1344,46 @@ describe Mongo::Client do
         end
       end
 
+      context 'when setting read concern options' do
+        min_server_fcv '3.2'
+
+        context 'when read concern is valid' do
+          let(:options) do
+            { read_concern: { level: :local } }
+          end
+
+          it 'does not warn' do
+            expect(Mongo::Logger.logger).to_not receive(:warn)
+            new_local_client_nmio(SpecConfig.instance.addresses, options)
+          end
+        end
+
+        context 'when read concern has an invalid key' do
+          skip_if_linting
+
+          let(:options) do
+            { read_concern: { hello: :local } }
+          end
+
+          it 'logs a warning' do
+            expect(Mongo::Logger.logger).to receive(:warn).with(/Read concern has invalid keys: hello/)
+            new_local_client_nmio(SpecConfig.instance.addresses, options)
+          end
+        end
+
+        context 'when read concern has a non-user-settable key' do
+          let(:options) do
+            { read_concern: { after_cluster_time: 100 } }
+          end
+
+          it 'raises an exception' do
+            expect do
+              new_local_client_nmio(SpecConfig.instance.addresses, options)
+            end.to raise_error(Mongo::Error::InvalidReadConcern, 'The after_cluster_time read_concern option cannot be specified by the user')
+          end
+        end
+      end
+
       context 'when an invalid option is provided' do
 
         let(:options) do
@@ -1494,6 +1535,18 @@ describe Mongo::Client do
           end
         end
       end
+
+      context ':auth_mech_properties option' do
+        context 'is nil' do
+          let(:options) do
+            {auth_mech_properties: nil}
+          end
+
+          it 'creates the client without the option' do
+            client.options.should_not have_key(:auth_mech_properties)
+          end
+        end
+      end
     end
 
     context 'when making a block client' do