mongo 2.13.0.beta1 → 2.13.0.rc1

data/spec/integration/crud_spec.rb

@@ -127,13 +127,13 @@ describe 'CRUD operations' do
   describe 'upsert' do
     context 'with default write concern' do
       it 'upserts' do
-        collection.count_documents({}).should == 0
+        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
+        collection.count_documents.should == 1
       end
     end
 
@@ -147,7 +147,7 @@ describe 'CRUD operations' do
       end
 
       it 'upserts' do
-        unack_collection.count_documents({}).should == 0
+        unack_collection.count_documents.should == 0
 
         res = unack_collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
 
@@ -155,7 +155,7 @@ describe 'CRUD operations' do
         # persisted (hopefully)
         sleep 0.25
 
-        unack_collection.count_documents({}).should == 1
+        unack_collection.count_documents.should == 1
       end
     end
   end

data/spec/integration/docs_examples_spec.rb

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
 describe 'aggregation examples in Ruby' do
+  before(:all) do
+    # In sharded clusters we need to ensure the database exists before running
+    # the tests in this file.
+    ClientRegistry.instance.global_client('authorized')['_placeholder'].create
+  end
+
   let(:client) do
     authorized_client
   end

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

@@ -1,33 +1,14 @@
 require 'spec_helper'
 
-class TestHeartbeatSubscriber
-  def initialize
-    @started_events = []
-    @succeeded_events = []
-    @failed_events = []
-  end
-
-  attr_reader :started_events, :succeeded_events, :failed_events
-
-  def started(event)
-    @started_events << event
-  end
-
-  def succeeded(event)
-    @succeeded_events << event
-  end
-
-  def failed(event)
-    @failed_events << event
-  end
-end
-
 describe 'Heartbeat events' do
   class HeartbeatEventsSpecTestException < StandardError; end
 
+  # 4.4 has two monitors and thus issues heartbeats multiple times
+  max_server_version '4.2'
+
   clean_slate_for_all
 
-  let(:subscriber) { TestHeartbeatSubscriber.new }
+  let(:subscriber) { EventSubscriber.new }
 
   before do
     Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)

data/spec/integration/read_concern_spec.rb

@@ -17,7 +17,7 @@ describe 'read concern' do
 
   let(:sent_read_concern) do
     subscriber.clear_events!
-    collection.count_documents({})
+    collection.count_documents
     subscriber.started_events.find { |c| c.command_name == 'aggregate' }.command[:readConcern]
   end
 

data/spec/integration/retryable_errors_spec.rb

@@ -106,7 +106,7 @@ describe 'Failing retryable operations' do
           },
         }
 
-        if ClusterConfig.instance.short_server_version >= '4.3'
+        if ClusterConfig.instance.short_server_version >= '4.4'
           # Server versions 4.4 and newer will add the RetryableWriteError
           # label to all retryable errors, and the driver must not add the label
           # if it is not already present.

data/spec/integration/retryable_writes/shared/performs_legacy_retries.rb

@@ -26,7 +26,7 @@ module PerformsLegacyRetries
     end
 
     context 'for ETIMEDOUT' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       # shorten socket timeout so these tests take less time to run
       let(:socket_timeout) { 1 }
@@ -59,7 +59,7 @@ module PerformsLegacyRetries
     end
 
     context 'on server versions >= 4.4' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       context 'for OperationFailure with RetryableWriteError label' do
         before do

data/spec/integration/retryable_writes/shared/performs_modern_retries.rb

@@ -44,8 +44,8 @@ module PerformsModernRetries
 
     context 'for ETIMEDOUT' do
       # blockConnection option in failCommand was introduced in
-      # server version 4.3
-      min_server_fcv '4.3'
+      # server version 4.4
+      min_server_fcv '4.4'
 
       # shorten socket timeout so these tests take less time to run
       let(:socket_timeout) { 1 }
@@ -94,7 +94,7 @@ module PerformsModernRetries
     end
 
     context 'on server versions >= 4.4' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       context 'for OperationFailure with RetryableWriteError label' do
         before do

data/spec/integration/retryable_writes/shared/performs_no_retries.rb

@@ -25,7 +25,7 @@ module PerformsNoRetries
     end
 
     context 'for ETIMEDOUT' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
 
       # shorten socket timeout so these tests take less time to run
       let(:socket_timeout) { 1 }
@@ -58,7 +58,7 @@ module PerformsNoRetries
     end
 
     context 'on server versions >= 4.4' do
-      min_server_fcv '4.3'
+      min_server_fcv '4.4'
       # These tests will be implemented in a follow-up PR
     end
 

data/spec/integration/sdam_error_handling_spec.rb

@@ -3,11 +3,27 @@ require 'spec_helper'
 describe 'SDAM error handling' do
   clean_slate_for_all
 
+  after do
+    # Close all clients after every test to avoid leaking expectations into
+    # subsequent tests because we set global assertions on sockets.
+    ClientRegistry.instance.close_all_clients
+  end
+
   # These tests operate on specific servers, and don't work in a multi
   # shard cluster where multiple servers are equally eligible
   require_no_multi_shard
 
-  let(:client) { authorized_client_without_any_retries }
+  let(:diagnostic_subscriber) { VerboseEventSubscriber.new }
+
+  let(:client) do
+    new_local_client(SpecConfig.instance.addresses,
+      SpecConfig.instance.all_test_options.merge(
+        socket_timeout: 3, connect_timeout: 3,
+        # Uncomment to print all events to stdout:
+        #sdam_proc: Utils.subscribe_all_sdam_proc(diagnostic_subscriber),
+        **Utils.disable_retries_client_options)
+    )
+  end
 
   let(:server) { client.cluster.next_primary }
 
@@ -148,6 +164,9 @@ describe 'SDAM error handling' do
     end
 
     context 'network error' do
+      # With 4.4 servers we set up two monitoring connections, hence global
+      # socket expectations get hit twice.
+      max_server_version '4.2'
 
       let(:operation) do
         expect_any_instance_of(Mongo::Socket).to receive(:read).and_raise(exception)
@@ -181,13 +200,6 @@ describe 'SDAM error handling' do
   describe 'when there is an error on monitoring connection' do
     clean_slate_for_all
 
-    let(:client) do
-      new_local_client(SpecConfig.instance.addresses,
-        SpecConfig.instance.test_options.merge(
-          connect_timeout: 1, socket_timeout: 1,
-      ))
-    end
-
     let(:subscriber) { EventSubscriber.new }
 
     let(:set_subscribers) do
@@ -209,6 +221,7 @@ describe 'SDAM error handling' do
       it 'marks server unknown' do
         expect(server).not_to be_unknown
 
+        #subscriber.clear_events!
         events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
         events.should be_empty
 
@@ -228,6 +241,7 @@ describe 'SDAM error handling' do
 
     shared_examples_for 'clears connection pool - cmap event' do
       it 'clears connection pool' do
+        #subscriber.clear_events!
         events = subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared)
         events.should be_empty
 
@@ -245,6 +259,7 @@ describe 'SDAM error handling' do
     end
 
     shared_examples_for 'marks server unknown and clears connection pool' do
+=begin These tests are not reliable
       context 'via object inspection' do
         let(:expect_server_state_change) do
           server.summary.should =~ /unknown/i
@@ -254,6 +269,7 @@ describe 'SDAM error handling' do
         it_behaves_like 'marks server unknown'
         it_behaves_like 'clears connection pool'
       end
+=end
 
       context 'via events' do
         # When we use events we do not need to examine object state, therefore
@@ -268,16 +284,22 @@ describe 'SDAM error handling' do
       end
     end
 
-    context 'network timeout' do
-      let(:exception) { Mongo::Error::SocketTimeoutError }
+    context 'via stubs' do
+      # With 4.4 servers we set up two monitoring connections, hence global
+      # socket expectations get hit twice.
+      max_server_version '4.2'
 
-      it_behaves_like 'marks server unknown and clears connection pool'
-    end
+      context 'network timeout' do
+        let(:exception) { Mongo::Error::SocketTimeoutError }
 
-    context 'non-timeout network error' do
-      let(:exception) { Mongo::Error::SocketError }
+        it_behaves_like 'marks server unknown and clears connection pool'
+      end
 
-      it_behaves_like 'marks server unknown and clears connection pool'
+      context 'non-timeout network error' do
+        let(:exception) { Mongo::Error::SocketError }
+
+        it_behaves_like 'marks server unknown and clears connection pool'
+      end
     end
 
     context 'non-timeout network error via fail point' do

data/spec/integration/sdam_events_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
-require 'runners/sdam_monitoring'
 
 describe 'SDAM events' do
-  let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
+  let(:subscriber) { EventSubscriber.new }
 
   describe 'server closed event' do
     it 'is published when client is closed' do
@@ -12,11 +11,11 @@ describe 'SDAM events' do
 
       # get the client connected
       client.database.command(ismaster: 1)
-      expect(subscriber.events).to be_empty
+      expect(subscriber.succeeded_events).to be_empty
 
       client.close
 
-      expect(subscriber.events).not_to be_empty
+      expect(subscriber.succeeded_events).not_to be_empty
       event = subscriber.first_event('server_closed_event')
       expect(event).not_to be_nil
     end
@@ -30,15 +29,87 @@ describe 'SDAM events' do
 
       # get the client connected
       client.database.command(ismaster: 1)
-      expect(subscriber.events).to be_empty
+      expect(subscriber.succeeded_events).to be_empty
 
       client.close
 
-      expect(subscriber.events).not_to be_empty
+      expect(subscriber.succeeded_events).not_to be_empty
       event = subscriber.first_event('topology_closed_event')
       expect(event).not_to be_nil
 
       expect(event.topology).to eql(client.cluster.topology)
     end
   end
+
+  describe 'heartbeat event' do
+    require_topology :single
+
+    context 'pre-4.4 servers' do
+      max_server_version '4.2'
+
+      let(:client) do
+        new_local_client(SpecConfig.instance.addresses,
+          # Heartbeat interval is bound by 500 ms
+          SpecConfig.instance.test_options.merge(heartbeat_frequency: 0.5),
+        ).tap do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+      end
+
+      it 'is published every heartbeat interval' do
+        client
+        sleep 4
+        client.close
+
+        started_events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
+        # Expect about 8 events, maybe 9 or 7
+        started_events.length.should >= 6
+        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
+      end
+    end
+
+    context '4.4+ servers' do
+      min_server_fcv '4.4'
+
+      let(:client) do
+        new_local_client(SpecConfig.instance.addresses,
+          # Heartbeat interval is bound by 500 ms
+          SpecConfig.instance.test_options.merge(heartbeat_frequency: 0.5),
+        ).tap do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+      end
+
+      it 'is published up to twice every heartbeat interval' do
+        client
+        sleep 3
+        client.close
+
+        events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
+        # We could have up to 16 events and should have no fewer than 8 events.
+        # Whenever an awaited ismaster succeeds while the regular monitor is
+        # waiting, the regular monitor's next scan is pushed forward.
+        events.length.should >= 6
+        events.length.should <= 18
+        (started_awaited = events.select(&:awaited?)).should_not be_empty
+        (started_regular = events.reject(&:awaited?)).should_not be_empty
+
+        events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
+        events.length.should >= 6
+        events.length.should <= 18
+        (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
+      end
+    end
+  end
 end

data/spec/integration/sdam_prose_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe 'SDAM prose tests' do
+  # The "streaming protocol tests" are covered by the tests in
+  # sdam_events_spec.rb.
+
+  describe 'RTT tests' do
+    min_server_fcv '4.4'
+    require_topology :single
+
+    let(:subscriber) { EventSubscriber.new }
+
+    let(:client) do
+      new_local_client(SpecConfig.instance.addresses,
+        # Heartbeat interval is bound by 500 ms
+        SpecConfig.instance.test_options.merge(
+          heartbeat_frequency: 0.5,
+          app_name: 'streamingRttTest',
+        ),
+      ).tap do |client|
+        client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+      end
+    end
+
+    it 'updates RTT' do
+      server = client.cluster.next_primary
+
+      sleep 2
+
+      events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
+      events.each do |event|
+        event.round_trip_time.should be_a(Numeric)
+        event.round_trip_time.should > 0
+      end
+
+      root_authorized_client.use('admin').database.command(
+        configureFailPoint: 'failCommand',
+        mode: {times: 1000},
+        data: {
+          failCommands: ["isMaster"],
+          blockConnection: true,
+          blockTimeMS: 500,
+          appName: "streamingRttTest",
+        },
+      )
+
+      deadline = Time.now + 10
+      loop do
+        if server.average_round_trip_time > 0.25
+          break
+        end
+        if Time.now >= deadline
+          raise "Failed to witness RTT growing to >= 250 ms in 10 seconds"
+        end
+        sleep 0.2
+      end
+    end
+
+    after do
+      root_authorized_client.use('admin').database.command(
+        configureFailPoint: 'failCommand', mode: 'off')
+    end
+  end
+end