mongo 2.11.0 → 2.11.5

data/spec/integration/client_construction_spec.rb

@@ -82,6 +82,20 @@ describe 'Client construction' do
       expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Single)
       expect(client.options[:connect]).to eq :direct
     end
+
+    context 'direct connection with mismached me' do
+      let(:address) { ClusterConfig.instance.alternate_address.to_s }
+
+      let(:client) do
+        new_local_client([address], SpecConfig.instance.test_options)
+      end
+
+      let(:server) { client.cluster.next_primary }
+
+      it 'sets server type to primary' do
+        expect(server.description).to be_primary
+      end
+    end
   end
 
   context 'in sharded topology' do

data/spec/integration/client_options_spec.rb

@@ -38,7 +38,7 @@ describe 'Client options' do
     end
   end
 
-  shared_examples_for 'auth mechanism that uses database or default auth source' do |default_auth_source:|
+  shared_examples_for 'auth mechanism that uses database or default auth source' do |default_auth_source|
     context 'where no database is provided' do
       context 'with URI options' do
         let(:credentials) { "#{user}:#{pwd}@" }
@@ -198,7 +198,7 @@ describe 'Client options' do
     let(:auth_mech_sym) { :mongodb_cr }
 
     it_behaves_like 'a supported auth mechanism'
-    it_behaves_like 'auth mechanism that uses database or default auth source', default_auth_source: 'admin'
+    it_behaves_like 'auth mechanism that uses database or default auth source', 'admin'
     it_behaves_like 'an auth mechanism that doesn\'t support auth_mech_properties'
   end
 
@@ -207,7 +207,7 @@ describe 'Client options' do
     let(:auth_mech_sym) { :scram }
 
     it_behaves_like 'a supported auth mechanism'
-    it_behaves_like 'auth mechanism that uses database or default auth source', default_auth_source: 'admin'
+    it_behaves_like 'auth mechanism that uses database or default auth source', 'admin'
     it_behaves_like 'an auth mechanism that doesn\'t support auth_mech_properties'
   end
 
@@ -216,7 +216,7 @@ describe 'Client options' do
     let(:auth_mech_sym) { :scram256 }
 
     it_behaves_like 'a supported auth mechanism'
-    it_behaves_like 'auth mechanism that uses database or default auth source', default_auth_source: 'admin'
+    it_behaves_like 'auth mechanism that uses database or default auth source', 'admin'
     it_behaves_like 'an auth mechanism that doesn\'t support auth_mech_properties'
   end
 
@@ -263,7 +263,7 @@ describe 'Client options' do
     let(:auth_mech_sym) { :plain }
 
     it_behaves_like 'a supported auth mechanism'
-    it_behaves_like 'auth mechanism that uses database or default auth source', default_auth_source: '$external'
+    it_behaves_like 'auth mechanism that uses database or default auth source', '$external'
     it_behaves_like 'an auth mechanism with ssl'
     it_behaves_like 'an auth mechanism that doesn\'t support auth_mech_properties'
   end

data/spec/integration/connection_spec.rb

@@ -12,17 +12,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 +121,53 @@ 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
     end
 
     describe 'wire protocol version range update' do

data/spec/integration/crud_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'CRUD operations' do
+  let(:collection) { authorized_client['crud_integration'] }
+
+  before do
+    collection.delete_many
+  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

@@ -59,7 +59,8 @@ describe 'Cursor reaping' do
       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)
+        event.command['killCursors'] &&
+        event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
       end
 
       expect(started_event).not_to be_nil

data/spec/integration/grid_fs_bucket_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'GridFS bucket integration' do
+  let(:fs) do
+    authorized_client.database.fs
+  end
+
+  describe 'UTF-8 string write' do
+    let(:data) { "hello\u2210" }
+
+    before do
+      data.length.should_not == data.bytesize
+    end
+
+    shared_examples 'round-trips' do
+      it 'round-trips' do
+        stream = fs.open_upload_stream('test') do |stream|
+          stream.write(data_to_write)
+        end
+
+        actual = nil
+        fs.open_download_stream(stream.file_id) do |stream|
+          actual = stream.read
+        end
+
+        actual.encoding.name.should == 'ASCII-8BIT'
+        actual.should == data.dup.force_encoding('binary')
+      end
+    end
+
+    context 'in binary encoding' do
+      let(:data_to_write) do
+        data.force_encoding('binary').freeze
+      end
+
+      it_behaves_like 'round-trips'
+    end
+
+    context 'in UTF-8 encoding' do
+      let(:data_to_write) do
+        data.encoding.name.should == 'UTF-8'
+        data.freeze
+      end
+
+      it_behaves_like 'round-trips'
+    end
+  end
+end

data/spec/integration/retryable_errors_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Retryable writes tests' do
+describe 'Failing retryable operations' do
   # Requirement for fail point
   min_server_fcv '4.0'
 
@@ -9,22 +9,12 @@ describe 'Retryable writes tests' do
   end
 
   let(:collection) do
-    client['retryable-writes-error-spec']
+    client['retryable-errors-spec']
   end
 
-  context 'when retry fails' do
+  context 'when operation fails' do
     require_topology :replica_set
 
-    let(:fail_point_command) do
-      {
-        configureFailPoint: 'failCommand',
-        mode: {times: 1},
-        data: {
-          failCommands: ['find'],
-          errorCode: 11600,
-        },
-      }
-    end
 
     let(:clear_fail_point_command) do
       {
@@ -34,17 +24,13 @@ describe 'Retryable writes tests' do
     end
 
     after do
-      ClusterTools.instance.direct_client_for_each_server do |client|
+      ClusterTools.instance.direct_client_for_each_data_bearing_server do |client|
         client.use(:admin).database.command(clear_fail_point_command)
       end
     end
 
     let(:collection) do
-      client['retryable-writes-error-spec', read: {mode: :secondary_preferred}]
-    end
-
-    let(:events) do
-      events = EventSubscriber.command_started_events('find')
+      client['retryable-errors-spec', read: {mode: :secondary_preferred}]
     end
 
     let(:first_server) do
@@ -59,41 +45,220 @@ describe 'Retryable writes tests' do
       end
     end
 
-    let(:perform_read) do
-      client.cluster.servers_list.each do |server|
-        server.monitor.stop!
+    shared_context 'read operation' do
+      let(:fail_point_command) do
+        {
+          configureFailPoint: 'failCommand',
+          mode: {times: 1},
+          data: {
+            failCommands: ['find'],
+            errorCode: 11600,
+          },
+        }
+      end
+
+      let(:set_fail_point) do
+        client.cluster.servers_list.each do |server|
+          server.monitor.stop!
+        end
+
+        ClusterTools.instance.direct_client_for_each_data_bearing_server do |client|
+          client.use(:admin).database.command(fail_point_command)
+        end
+      end
+
+      let(:operation_exception) do
+        set_fail_point
+
+        begin
+          collection.find(a: 1).to_a
+        rescue Mongo::Error::OperationFailure => exception
+        else
+          fail('Expected operation to fail')
+        end
+
+        puts exception.message
+
+        exception
+      end
+
+      let(:events) do
+        EventSubscriber.command_started_events('find')
+      end
+    end
+
+    shared_context 'write operation' do
+      let(:fail_point_command) do
+        {
+          configureFailPoint: 'failCommand',
+          mode: {times: 2},
+          data: {
+            failCommands: ['insert'],
+            errorCode: 11600,
+          },
+        }
       end
 
-      ClusterTools.instance.direct_client_for_each_server do |client|
+      let(:set_fail_point) do
         client.use(:admin).database.command(fail_point_command)
       end
 
-      begin
-        collection.find(a: 1).to_a
-      rescue Mongo::Error::OperationFailure => @exception
-      else
-        fail('Expected operation to fail')
+      let(:operation_exception) do
+        set_fail_point
+
+        begin
+          collection.insert_one(a: 1)
+        rescue Mongo::Error::OperationFailure => exception
+        else
+          fail('Expected operation to fail')
+        end
+
+        #puts exception.message
+
+        exception
+      end
+
+      let(:events) do
+        EventSubscriber.command_started_events('insert')
+      end
+    end
+
+    shared_examples_for 'failing retry' do
+
+      it 'indicates second attempt' do
+        expect(operation_exception.message).to include('attempt 2')
+        expect(operation_exception.message).not_to include('attempt 1')
+        expect(operation_exception.message).not_to include('attempt 3')
+      end
+
+      it 'publishes two events' do
+
+        expect(events.length).to eq(2)
+      end
+    end
+
+    shared_examples_for 'failing single attempt' do
+
+      it 'does not indicate attempt' do
+        expect(operation_exception.message).not_to include('attempt 1')
+        expect(operation_exception.message).not_to include('attempt 2')
+        expect(operation_exception.message).not_to include('attempt 3')
+      end
+
+      it 'publishes one event' do
+
+        expect(events.length).to eq(1)
+      end
+    end
+
+    shared_examples_for 'failing retry on the same server' do
+      it 'is reported on the server of the second attempt' do
+        expect(operation_exception.message).to include(second_server.address.seed)
+      end
+    end
+
+    shared_examples_for 'failing retry on a different server' do
+      it 'is reported on the server of the second attempt' do
+        expect(operation_exception.message).not_to include(first_server.address.seed)
+        expect(operation_exception.message).to include(second_server.address.seed)
       end
 
-      puts @exception.message
+      it 'marks servers used in both attempts unknown' do
+        operation_exception
+
+        expect(first_server).to be_unknown
+
+        expect(second_server).to be_unknown
+      end
 
-      expect(events.length).to eq(2)
-      expect(events.first.address.seed).not_to eq(events.last.address.seed)
+      it 'publishes events for the different server addresses' do
+
+        expect(events.length).to eq(2)
+        expect(events.first.address.seed).not_to eq(events.last.address.seed)
+      end
     end
 
-    it 'is reported on the server of the second attempt' do
-      perform_read
+    shared_examples_for 'modern retry' do
+      it 'indicates modern retry' do
+        expect(operation_exception.message).to include('modern retry')
+        expect(operation_exception.message).not_to include('legacy retry')
+        expect(operation_exception.message).not_to include('retries disabled')
+      end
+    end
 
-      expect(@exception.message).not_to include(first_server.address.seed)
-      expect(@exception.message).to include(second_server.address.seed)
+    shared_examples_for 'legacy retry' do
+      it 'indicates legacy retry' do
+        expect(operation_exception.message).to include('legacy retry')
+        expect(operation_exception.message).not_to include('modern retry')
+        expect(operation_exception.message).not_to include('retries disabled')
+      end
     end
 
-    it 'marks servers used in both attempts unknown' do
-      perform_read
+    shared_examples_for 'disabled retry' do
+      it 'indicates retries are disabled' do
+        expect(operation_exception.message).to include('retries disabled')
+        expect(operation_exception.message).not_to include('legacy retry')
+        expect(operation_exception.message).not_to include('modern retry')
+      end
+    end
+
+    context 'when read is retried and retry fails' do
+      include_context 'read operation'
+
+      context 'modern read retries' do
+        require_wired_tiger_on_36
 
-      expect(first_server).to be_unknown
+        let(:client) do
+          subscribed_client.with(retry_reads: true)
+        end
 
-      expect(second_server).to be_unknown
+        it_behaves_like 'failing retry'
+        it_behaves_like 'modern retry'
+      end
+
+      context 'legacy read retries' do
+        let(:client) do
+          subscribed_client.with(retry_reads: false, read_retry_interval: 0)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'legacy retry'
+      end
+    end
+
+    context 'when read retries are disabled' do
+      let(:client) do
+        subscribed_client.with(retry_reads: false, max_read_retries: 0)
+      end
+
+      include_context 'read operation'
+
+      it_behaves_like 'failing single attempt'
+      it_behaves_like 'disabled retry'
+    end
+
+    context 'when write is retried and retry fails' do
+      include_context 'write operation'
+
+      context 'modern write retries' do
+        require_wired_tiger_on_36
+
+        let(:client) do
+          subscribed_client.with(retry_writes: true)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'modern retry'
+      end
+
+      context 'legacy write' do
+        let(:client) do
+          subscribed_client.with(retry_writes: false)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'legacy retry'
+      end
     end
   end
 end