mongo 2.11.2 → 2.13.0.beta1

data/spec/integration/connection_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'runners/sdam_monitoring'
 
 describe 'Connections' do
   clean_slate
@@ -12,17 +13,18 @@ describe 'Connections' do
   let(:server) { client.cluster.servers.first }
 
   describe '#connect!' do
-    # On JRuby 9.2.7.0, this line:
-    # expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
-    # ... appears to produce a moment in which Mongo::Socket#write is undefined
-    # entirely, resulting in this failure:
-    # RSpec::Expectations::ExpectationNotMetError: expected Mongo::Error::SocketError, got #<NameError: undefined method `write' for class `Mongo::Socket'>
-    fails_on_jruby
+
+    let(:connection) do
+      Mongo::Server::Connection.new(server, server.options)
+    end
 
     context 'network error during handshake' do
-      let(:connection) do
-        Mongo::Server::Connection.new(server, server.options)
-      end
+      # On JRuby 9.2.7.0, this line:
+      # expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+      # ... appears to produce a moment in which Mongo::Socket#write is undefined
+      # entirely, resulting in this failure:
+      # RSpec::Expectations::ExpectationNotMetError: expected Mongo::Error::SocketError, got #<NameError: undefined method `write' for class `Mongo::Socket'>
+      fails_on_jruby
 
       let(:exception) { Mongo::Error::SocketError }
 
@@ -120,6 +122,110 @@ describe 'Connections' do
           expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
         end
       end
+
+      describe 'number of sockets created' do
+
+        before do
+          server
+        end
+
+        shared_examples_for 'is 1 per connection' do
+          it 'is 1 per connection' do
+            # Instantiating a connection object should not create any sockets
+            RSpec::Mocks.with_temporary_scope do
+              expect(socket_cls).not_to receive(:new)
+
+              connection
+            end
+
+            # When the connection connects, exactly one socket should be created
+            # (and subsequently connected)
+            RSpec::Mocks.with_temporary_scope do
+              expect(socket_cls).to receive(:new).and_call_original
+
+              connection.connect!
+            end
+          end
+        end
+
+        let(:socket_cls) { ::Socket }
+
+        it_behaves_like 'is 1 per connection'
+
+        context 'connection to Unix domain socket' do
+          # Server does not allow Unix socket connections when TLS is enabled
+          require_no_tls
+
+          let(:port) { SpecConfig.instance.any_port }
+
+          let(:client) do
+            new_local_client(["/tmp/mongodb-#{port}.sock"], connect: :direct).tap do |client|
+              stop_monitoring(client)
+            end
+          end
+
+          let(:socket_cls) { ::UNIXSocket }
+
+          it_behaves_like 'is 1 per connection'
+        end
+      end
+
+      context 'when socket connection fails' do
+
+        before do
+          server
+        end
+
+        let(:socket_cls) { ::Socket }
+
+        let(:socket) do
+          double('socket').tap do |socket|
+            allow(socket).to receive(:setsockopt)
+            allow(socket).to receive(:set_encoding)
+            allow(socket).to receive(:getsockopt)
+            expect(socket).to receive(:connect).and_raise(IOError, 'test error')
+
+            # This test is testing for the close call:
+            expect(socket).to receive(:close)
+          end
+        end
+
+        it 'closes the socket' do
+          RSpec::Mocks.with_temporary_scope do
+            expect(::Socket).to receive(:new).with(
+              Socket::AF_INET, Socket::SOCK_STREAM, 0).and_return(socket)
+
+            lambda do
+              connection.connect!
+            end.should raise_error(Mongo::Error::SocketError, /test error/)
+          end
+        end
+
+        context 'with tls' do
+          require_tls
+
+          let(:socket) do
+            double('socket').tap do |socket|
+              allow(socket).to receive(:hostname=)
+              allow(socket).to receive(:sync_close=)
+              expect(socket).to receive(:connect).and_raise(IOError, 'test error')
+
+              # This test is testing for the close call:
+              expect(socket).to receive(:close)
+            end
+          end
+
+          it 'closes the SSL socket' do
+            RSpec::Mocks.with_temporary_scope do
+              expect(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(socket)
+
+              lambda do
+                connection.connect!
+              end.should raise_error(Mongo::Error::SocketError, /test error/)
+            end
+          end
+        end
+      end
     end
 
     describe 'wire protocol version range update' do

data/spec/integration/crud_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe 'CRUD operations' do
+  let(:collection) { authorized_client['crud_integration'] }
+
+  before do
+    collection.delete_many
+  end
+
+  describe 'find' do
+    context 'when allow_disk_use is true' do
+      # Other cases are adequately covered by spec tests.
+      context 'on server version < 3.2' do
+        max_server_fcv '3.0'
+
+        it 'raises an exception' do
+          expect do
+            collection.find({}, { allow_disk_use: true }).first
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the allow_disk_use option on this command./)
+        end
+      end
+    end
+
+    context 'when allow_disk_use is false' do
+      # Other cases are adequately covered by spec tests.
+      context 'on server version < 3.2' do
+        max_server_fcv '3.0'
+
+        it 'raises an exception' do
+          expect do
+            collection.find({}, { allow_disk_use: false }).first
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the allow_disk_use option on this command./)
+        end
+      end
+    end
+  end
+
+  describe 'insert' do
+    context 'inserting a BSON::Int64' do
+      before do
+        collection.insert_one(int64: BSON::Int64.new(42))
+      end
+
+      it 'is stored as the correct type' do
+        # 18 is the number that represents the Int64 type for the $type
+        # operator; string aliases in the $type operator are only supported on
+        # server versions 3.2 and newer.
+        result = collection.find(int64: { '$type' => 18 }).first
+        expect(result).not_to be_nil
+        expect(result['int64']).to eq(42)
+      end
+    end
+
+    context 'inserting a BSON::Int32' do
+      before do
+        collection.insert_one(int32: BSON::Int32.new(42))
+      end
+
+      it 'is stored as the correct type' do
+        # 16 is the number that represents the Int32 type for the $type
+        # operator; string aliases in the $type operator are only supported on
+        # server versions 3.2 and newer.
+        result = collection.find(int32: { '$type' => 16 }).first
+        expect(result).not_to be_nil
+        expect(result['int32']).to eq(42)
+      end
+    end
+
+    context 'with automatic encryption' do
+      require_libmongocrypt
+      require_enterprise
+      min_server_fcv '4.2'
+
+      include_context 'define shared FLE helpers'
+      include_context 'with local kms_providers'
+
+      let(:encrypted_collection) do
+        new_local_client(
+          SpecConfig.instance.addresses,
+          SpecConfig.instance.test_options.merge(
+            auto_encryption_options: {
+              kms_providers: kms_providers,
+              key_vault_namespace: key_vault_namespace,
+              schema_map: { 'auto_encryption.users' => schema_map },
+              # Spawn mongocryptd on non-default port for sharded cluster tests
+              extra_options: extra_options,
+            },
+            database: 'auto_encryption'
+          )
+        )['users']
+      end
+
+      let(:collection) { authorized_client.use('auto_encryption')['users'] }
+
+      context 'inserting a BSON::Int64' do
+        before do
+          encrypted_collection.insert_one(ssn: '123-456-7890', int64: BSON::Int64.new(42))
+        end
+
+        it 'is stored as the correct type' do
+          # 18 is the number that represents the Int64 type for the $type
+          # operator; string aliases in the $type operator are only supported on
+          # server versions 3.2 and newer.
+          result = collection.find(int64: { '$type' => 18 }).first
+          expect(result).not_to be_nil
+          expect(result['int64']).to eq(42)
+        end
+      end
+
+      context 'inserting a BSON::Int32' do
+        before do
+          encrypted_collection.insert_one(ssn: '123-456-7890', int32: BSON::Int32.new(42))
+        end
+
+        it 'is stored as the correct type' do
+          # 16 is the number that represents the Int32 type for the $type
+          # operator; string aliases in the $type operator are only supported on
+          # server versions 3.2 and newer.
+          result = collection.find(int32: { '$type' => 16 }).first
+          expect(result).not_to be_nil
+          expect(result['int32']).to eq(42)
+        end
+      end
+    end
+  end
+
+  describe 'upsert' do
+    context 'with default write concern' do
+      it 'upserts' do
+        collection.count_documents({}).should == 0
+
+        res = collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
+
+        res.documents.first['upserted'].length.should == 1
+
+        collection.count_documents({}).should == 1
+      end
+    end
+
+    context 'unacknowledged write' do
+      let(:unack_collection) do
+        collection.with(write_concern: {w: 0})
+      end
+
+      before do
+        unack_collection.write_concern.acknowledged?.should be false
+      end
+
+      it 'upserts' do
+        unack_collection.count_documents({}).should == 0
+
+        res = unack_collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
+
+        # since write concern is unacknowledged, wait for the data to be
+        # persisted (hopefully)
+        sleep 0.25
+
+        unack_collection.count_documents({}).should == 1
+      end
+    end
+  end
+end

data/spec/integration/cursor_reaping_spec.rb

@@ -5,19 +5,23 @@ describe 'Cursor reaping' do
   # in MRI, I don't currently know how to force GC to run in JRuby
   only_mri
 
-  let(:client) { subscribed_client }
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
   let(:collection) { client['cursor_reaping_spec'] }
 
-  before(:all) do
+  before do
     data = [{a: 1}] * 10
-    ClientRegistry.instance.global_client('subscribed')['cursor_reaping_spec'].insert_many(data)
+    authorized_client['cursor_reaping_spec'].delete_many
+    authorized_client['cursor_reaping_spec'].insert_many(data)
   end
 
   context 'a no-timeout cursor' do
-    before do
-      EventSubscriber.clear_events!
-    end
-
     it 'reaps nothing when we do not query' do
       # this is a base line test to ensure that the reaps in the other test
       # aren't done on some global cursor
@@ -26,7 +30,7 @@ describe 'Cursor reaping' do
       # just the scope, no query is happening
       collection.find.batch_size(2).no_cursor_timeout
 
-      events = EventSubscriber.started_events.select do |event|
+      events = subscriber.started_events.select do |event|
         event.command['killCursors']
       end
 
@@ -58,13 +62,14 @@ describe 'Cursor reaping' do
       # force periodic executor to run because its frequency is not configurable
       client.cluster.instance_variable_get('@periodic_executor').execute
 
-      started_event = EventSubscriber.started_events.detect do |event|
-        event.command['killCursors'] && event.command['cursors'].map(&:value).include?(cursor_id)
+      started_event = subscriber.started_events.detect do |event|
+        event.command['killCursors'] &&
+        event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
       end
 
       expect(started_event).not_to be_nil
 
-      succeeded_event = EventSubscriber.succeeded_events.detect do |event|
+      succeeded_event = subscriber.succeeded_events.detect do |event|
         event.command_name == 'killCursors' && event.request_id == started_event.request_id
       end
 

data/spec/integration/fork_reconnect_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe 'fork reconnect' do
+  require_fork
+  only_mri
+
+  # On multi-shard sharded clusters a succeeding write request does not
+  # guarantee that the next operation will succeed (since it could be sent to
+  # another shard with a dead connection).
+  require_no_multi_shard
+
+  # On Ruby 2.3 $?.exitstatus is sometimes nil after Process.wait returns which
+  # is not supposed to happen.
+  ruby_version_gte '2.4'
+
+  let(:client) { authorized_client }
+  let(:server) { client.cluster.next_primary }
+
+  describe 'monitoring connection' do
+    let(:monitor) do
+      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options)
+    end
+
+    it 'reconnects' do
+      monitor.send(:do_scan).should be_a(Hash)
+
+      socket = monitor.connection.send(:socket).send(:socket)
+      (socket.is_a?(Socket) || socket.is_a?(OpenSSL::SSL::SSLSocket)).should be true
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        monitor.send(:do_scan).should be_a(Hash)
+
+        child_socket = monitor.connection.send(:socket).send(:socket)
+        # fileno of child_socket may equal to fileno of socket,
+        # as socket would've been closed first and file descriptors can be
+        # reused by the kernel.
+        child_socket.object_id.should_not == socket.object_id
+
+        # Exec so that we do not close any clients etc. in the child.
+        exec('/bin/true')
+      end
+
+      # Connection should remain serviceable in the parent.
+      # The operation here will be invoked again, since the earlier invocation
+      # was in the child process.
+      monitor.send(:do_scan).should be_a(Hash)
+
+      # The child closes the connection's socket, but this races with the
+      # parent. The parent can retain the original socket for a while.
+    end
+  end
+
+  describe 'non-monitoring connection' do
+    let(:connection) do
+      Mongo::Server::Connection.new(server, server.options)
+    end
+
+    let(:operation) do
+      connection.ping.should be true
+    end
+
+    it 'does not reconnect' do
+      connection.connect!
+
+      socket = connection.send(:socket).send(:socket)
+      (socket.is_a?(Socket) || socket.is_a?(OpenSSL::SSL::SSLSocket)).should be true
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          operation
+
+          child_socket = connection.send(:socket).send(:socket)
+          # fileno of child_socket may equal to fileno of socket,
+          # as socket would've been closed first and file descriptors can be
+          # reused by the kernel.
+          child_socket.object_id.should == socket.object_id
+        end
+      end
+
+      # The child closes the connection's socket, but this races with the
+      # parent. The parent can retain the original socket for a while.
+    end
+  end
+
+  describe 'connection pool' do
+
+    it 'creates a new connection in child' do
+      conn_id = server.with_connection do |connection|
+        connection.id
+      end
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          new_conn_id = server.with_connection do |connection|
+            connection.id
+          end
+
+          new_conn_id.should_not == conn_id
+        end
+      end
+
+      parent_conn_id = server.with_connection do |connection|
+        connection.id
+      end
+
+      parent_conn_id.should == conn_id
+    end
+  end
+
+  describe 'client' do
+    it 'works after fork' do
+      # Perform a write so that we discover the current primary.
+      # Previous test may have stepped down the server that authorized client
+      # considers the primary.
+      # In standalone deployments there are no retries, hence execute the
+      # operation twice manually.
+      client['foo'].insert_one(test: 1) rescue nil
+      client['foo'].insert_one(test: 1)
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          client.database.command(ismaster: 1).should be_a(Mongo::Operation::Result)
+        end
+      end
+
+      # Perform a read which can be retried, so that the socket close
+      # performed by the child is recovered from.
+      client['foo'].find(test: 1)
+    end
+  end
+end