mongo 2.12.4 → 2.14.0.rc1

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

@@ -9,40 +9,56 @@ describe 'Server' do
   let(:view) { Mongo::Collection::View.new(collection) }
 
   describe 'operations when client/cluster are disconnected' do
-    # Server versions lower than 3.4 use the legacy find result
-    min_server_fcv '3.4'
-
-    context 'normal server' do
-      it 'can be used for reads' do
-        result = view.send(:send_initial_query, server)
-        expect(result).to be_a(Mongo::Operation::Find::Result)
+    shared_examples 'it performs read operations and receives the correct result type' do
+      context 'normal server' do
+        it 'can be used for reads' do
+          result = view.send(:send_initial_query, server)
+          expect(result).to be_a(result_class)
+        end
       end
-    end
 
-    context 'known server in disconnected cluster' do
-      before do
-        client.close
-        expect(server).not_to be_unknown
+      context 'known server in disconnected cluster' do
+        before do
+          client.close
+          expect(server).not_to be_unknown
+        end
+
+        it 'can be used for reads' do
+          result = view.send(:send_initial_query, server)
+          expect(result).to be_a(result_class)
+        end
       end
 
-      it 'can be used for reads' do
-        result = view.send(:send_initial_query, server)
-        expect(result).to be_a(Mongo::Operation::Find::Result)
+      context 'unknown server in disconnected cluster' do
+        before do
+          client.close
+          server.unknown!
+          expect(server).to be_unknown
+        end
+
+        it 'can be used for reads' do
+          result = view.send(:send_initial_query, server)
+          expect(result).to be_a(result_class)
+        end
       end
     end
 
-    context 'unknown server in disconnected cluster' do
-      before do
-        client.close
-        server.unknown!
-        expect(server).to be_unknown
-      end
+    context 'for servers with FCV >= 3.4' do
+      min_server_fcv '3.2'
 
-      it 'can be used for reads' do
-        result = view.send(:send_initial_query, server)
-        # Driver falls back to the oldest MongoDB protocol
-        expect(result).to be_a(Mongo::Operation::Find::Legacy::Result)
-      end
+      let(:result_class) { Mongo::Operation::Find::Result }
+
+      it_behaves_like 'it performs read operations and receives the correct result type'
+    end
+
+    context 'for servers with FCV < 3.4' do
+      # Find command was introduced in server version 3.2, so older versions should
+      # receive legacy result types.
+      max_server_fcv '3.0'
+
+      let(:result_class) { Mongo::Operation::Find::Legacy::Result }
+
+      it_behaves_like 'it performs read operations and receives the correct result type'
     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
@@ -107,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/step_down_spec.rb

@@ -29,11 +29,11 @@ describe 'Step down behavior' do
     end
   end
 
-  let(:event_subscriber) { EventSubscriber.new }
+  let(:subscriber) { EventSubscriber.new }
 
   let(:test_client) do
     authorized_client_without_any_retries.with(server_selection_timeout: 20).tap do |client|
-      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, event_subscriber)
+      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
     end
   end
 
@@ -48,8 +48,8 @@ describe 'Step down behavior' do
 
     let(:subscribed_client) do
       test_client.tap do |client|
-        client.subscribe(Mongo::Monitoring::COMMAND, EventSubscriber)
-        client.subscribe(Mongo::Monitoring::CONNECTION_POOL, EventSubscriber)
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
       end
     end
 
@@ -65,13 +65,13 @@ describe 'Step down behavior' do
     it 'continues through step down' do
 
       subscribed_client.cluster.next_primary.pool.clear
-      event_subscriber.clear_events!
+      subscriber.clear_events!
 
       # get the first item
       item = enum.next
       expect(item['test']).to eq(1)
 
-      connection_created_events = EventSubscriber.published_events.select do |event|
+      connection_created_events = subscriber.published_events.select do |event|
         event.is_a?(Mongo::Monitoring::Event::Cmap::ConnectionCreated)
       end
       expect(connection_created_events).not_to be_empty
@@ -79,7 +79,7 @@ describe 'Step down behavior' do
       current_primary = subscribed_client.cluster.next_primary
       ClusterTools.instance.change_primary
 
-      EventSubscriber.clear_events!
+      subscriber.clear_events!
 
       # exhaust the batch
       9.times do
@@ -90,14 +90,14 @@ describe 'Step down behavior' do
       item = enum.next
       expect(item['test']).to eq(1)
 
-      get_more_events = EventSubscriber.started_events.select do |event|
+      get_more_events = subscriber.started_events.select do |event|
         event.command['getMore']
       end
 
       expect(get_more_events.length).to eq(1)
 
       # getMore should have been sent on the same connection as find
-      connection_created_events = EventSubscriber.published_events.select do |event|
+      connection_created_events = subscriber.published_events.select do |event|
         event.is_a?(Mongo::Monitoring::Event::Cmap::ConnectionCreated)
       end
       expect(connection_created_events).to be_empty
@@ -155,13 +155,13 @@ describe 'Step down behavior' do
       let(:fail_point_code) { 10107 }
 
       it 'keeps connection open' do
-        event_subscriber.clear_events!
+        subscriber.clear_events!
 
         expect do
           collection.insert_one(test: 1)
         end.to raise_error(Mongo::Error::OperationFailure, /10107/)
 
-        expect(event_subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(0)
+        expect(subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(0)
       end
     end
 
@@ -174,13 +174,13 @@ describe 'Step down behavior' do
       let(:fail_point_code) { 10107 }
 
       it 'closes the connection' do
-        event_subscriber.clear_events!
+        subscriber.clear_events!
 
         expect do
           collection.insert_one(test: 1)
         end.to raise_error(Mongo::Error::OperationFailure, /10107/)
 
-        expect(event_subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
+        expect(subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
       end
     end
 
@@ -191,13 +191,13 @@ describe 'Step down behavior' do
       let(:fail_point_code) { 11600 }
 
       it 'closes the connection' do
-        event_subscriber.clear_events!
+        subscriber.clear_events!
 
         expect do
           collection.insert_one(test: 1)
         end.to raise_error(Mongo::Error::OperationFailure, /11600/)
 
-        expect(event_subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
+        expect(subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
       end
     end
   end