mongo 2.13.0.beta1 → 2.14.0

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,90 @@ 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 > 1
+        (succeeded_events.length-1..succeeded_events.length).should include(started_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
+
+        # There may be in-flight ismasters that don't complete, both
+        # regular and awaited.
+        started_awaited.length.should > 1
+        (succeeded_awaited.length-1..succeeded_awaited.length).should include(started_awaited.length)
+        started_regular.length.should > 1
+        (succeeded_regular.length-1..succeeded_regular.length).should include(started_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

data/spec/integration/server_monitor_spec.rb

@@ -5,7 +5,11 @@ describe 'Server::Monitor' do
   let(:client) do
     new_local_client([ClusterConfig.instance.primary_address_str],
       SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options.merge(
-        heartbeat_frequency: 1)))
+        monitor_options)))
+  end
+
+  let(:monitor_options) do
+    {heartbeat_frequency: 1}
   end
 
   it 'refreshes server descriptions in background', retry: 3 do
@@ -25,4 +29,24 @@ describe 'Server::Monitor' do
 
     expect(server.description).not_to be_unknown
   end
+
+  context 'server-pushed ismaster' do
+    min_server_fcv '4.4'
+    require_topology :replica_set
+
+    let(:monitor_options) do
+      {heartbeat_frequency: 20}
+    end
+
+    it 'updates server description' do
+      starting_primary_address = client.cluster.next_primary.address
+
+      ClusterTools.instance.step_down
+
+      sleep 2
+
+      new_primary_address = client.cluster.next_primary.address
+      new_primary_address.should_not == starting_primary_address
+    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/size_limit_spec.rb

@@ -36,7 +36,7 @@ describe 'BSON & command size limits' do
     end
 
     authorized_collection.insert_many(documents)
-    authorized_collection.count_documents({}).should == 8
+    authorized_collection.count_documents.should == 8
   end
 
   # This test ensures that document which are too big definitely fail insertion.
@@ -49,7 +49,7 @@ describe 'BSON & command size limits' do
     lambda do
       authorized_collection.insert_many(documents)
     end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-    authorized_collection.count_documents({}).should == 0
+    authorized_collection.count_documents.should == 0
   end
 
   it 'allows user-provided documents to be exactly 16MiB' do
@@ -62,13 +62,31 @@ describe 'BSON & command size limits' do
     authorized_collection.insert_one(document)
   end
 
-  it 'fails on the server when a document larger than 16MiB is inserted' do
+  it 'fails on the driver when a document larger than 16MiB is inserted' do
     document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
     expect(document.to_bson.length).to eq(max_document_size+1)
 
     lambda do
       authorized_collection.insert_one(document)
-    end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'fails on the driver when an update larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.update_one({ _id: 'foo' }, document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'fails on the driver when an delete larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.delete_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
   end
 
   it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do
@@ -89,6 +107,6 @@ describe 'BSON & command size limits' do
     end
 
     authorized_collection.insert_many(documents)
-    authorized_collection.count_documents({}).should == 3
+    authorized_collection.count_documents.should == 3
   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/integration/ssl_uri_options_spec.rb

@@ -20,6 +20,6 @@ describe 'SSL connections with URI options' do
 
   it 'successfully connects and runs an operation' do
     client = new_local_client(uri)
-    expect { client[:foo].count_documents({}) }.not_to raise_error
+    expect { client[:foo].count_documents }.not_to raise_error
   end
-end
+end

data/spec/integration/transactions_examples_spec.rb

@@ -4,28 +4,42 @@ describe 'Transactions examples' do
   require_wired_tiger
   require_transaction_support
 
+  let(:client) do
+    authorized_client.with(read_concern: {level: :majority}, write: {w: :majority})
+  end
+
   let(:hr) do
-    authorized_client.use(:hr).database
+    client.use(:hr).database
   end
 
   let(:reporting) do
-    authorized_client.use(:reporting).database
+    client.use(:reporting).database
   end
 
   before(:each) do
     hr[:employees].insert_one(employee: 3, status: 'Active')
+
+    # Sanity check since this test likes to fail
+    employee = hr[:employees].find({ employee: 3 }, limit: 1).first
+    expect(employee).to_not be_nil
+
     reporting[:events].insert_one(employee: 3, status: { new: 'Active', old: nil})
   end
 
   after(:each) do
     hr.drop
     reporting.drop
+
+    # Work around https://jira.mongodb.org/browse/SERVER-53015
+    ::Utils.mongos_each_direct_client do |client|
+      client.database.command(flushRouterConfig: 1)
+    end
   end
 
   context 'individual examples' do
 
     let(:session) do
-      authorized_client.start_session
+      client.start_session
     end
 
     # Start Transactions Intro Example 1
@@ -142,10 +156,6 @@ describe 'Transactions examples' do
 
   context 'Transactions Retry Example 3 (combined example)' do
 
-    let(:client) do
-      authorized_client
-    end
-
     let(:run_transaction) do
 
       # Start Transactions Retry Example 3