mongo 2.6.4 → 2.7.0.rc0

data/spec/integration/command_monitoring_spec.rb

@@ -1,40 +1,15 @@
 require 'spec_helper'
 
-class TestCommandMonitoringSubscriber
-  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 'Command monitoring' do
-  let(:subscriber) { TestCommandMonitoringSubscriber.new }
 
-  before do
-    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-  end
+  let(:subscriber) { EventSubscriber.new }
 
-  after do
-    Mongo::Monitoring::Global.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
+  let(:client) do
+    authorized_client.with(app_name: 'command monitoring spec').tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
   end
 
-  let(:client) { Mongo::Client.new(authorized_client.cluster.addresses.map(&:to_s), authorized_client.options) }
-
   it 'notifies on successful commands' do
     result = client.database.command(:ismaster => 1)
     expect(result.documents.first['ismaster']).to be true
@@ -89,4 +64,17 @@ describe 'Command monitoring' do
     expect(failed_event.address).to be_a(Mongo::Address)
     expect(failed_event.duration).to be_a(Float)
   end
+
+  context 'client with no established connections' do
+    # for simplicity use 3.6+ servers only, then we can assert
+    # scram auth commands
+    min_server_version '3.6'
+
+    it 'does not nest auth and find' do
+      expect(subscriber.started_events.length).to eq 0
+      client['test-collection'].find(a: 1).first
+      command_names = subscriber.started_events.map(&:command_name)
+      expect(command_names).to eq %w(saslStart saslContinue saslContinue find)
+    end
+  end
 end

data/spec/integration/connect_single_rs_name_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'Direct connection with RS name' do
+  before(:all) do
+    # preload
+    ClientRegistry.instance.close_all_clients
+    ClusterConfig.instance.replica_set_name
+    ClientRegistry.instance.close_all_clients
+  end
+
+  shared_examples_for 'passes RS name to topology' do
+    it 'passes RS name to topology' do
+      expect(client.cluster.topology.replica_set_name).to eq(replica_set_name)
+    end
+  end
+
+  let(:client) do
+    new_local_client(
+      [SpecConfig.instance.addresses.first],
+      SpecConfig.instance.test_options.merge(
+        replica_set: replica_set_name, connect: :direct))
+  end
+
+  context 'in replica set' do
+    require_topology :replica_set
+
+    context 'with correct RS name' do
+      let(:replica_set_name) { ClusterConfig.instance.replica_set_name }
+
+      it_behaves_like 'passes RS name to topology'
+
+      it 'creates a working client' do
+        expect do
+          client.database.command(ismaster: 1)
+        end.not_to raise_error
+      end
+    end
+
+    context 'with wrong RS name' do
+      let(:replica_set_name) { 'wrong' }
+
+      it_behaves_like 'passes RS name to topology'
+
+      it 'creates a client which raises on every operation' do
+        expect do
+          client.database.command(ismaster: 1)
+        end.to raise_error(Mongo::Error::NoServerAvailable, "Cluster topology specifies replica set name wrong, but the server has replica set name #{ClusterConfig.instance.replica_set_name}")
+      end
+    end
+  end
+
+  context 'in standalone' do
+    require_topology :single
+
+    context 'with any RS name' do
+      let(:replica_set_name) { 'any' }
+
+      it_behaves_like 'passes RS name to topology'
+
+      it 'creates a client which raises on every operation' do
+        expect do
+          client.database.command(ismaster: 1)
+        end.to raise_error(Mongo::Error::NoServerAvailable, 'Cluster topology specifies replica set name any, but the server has replica set name <nil>')
+      end
+    end
+  end
+end

data/spec/integration/connection_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+
+describe 'Connections' do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  let(:client) { ClientRegistry.instance.global_client('authorized') }
+  let(:server) { client.cluster.servers.first }
+
+  describe '#connect!' do
+    fails_on_jruby
+
+    context 'network error during handshake' do
+      let(:connection) do
+        Mongo::Server::Connection.new(server, server.options)
+      end
+
+      let(:exception) { Mongo::Error::SocketError }
+
+      let(:error) do
+        connection
+        expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+        expect do
+          connection.connect!
+        end.to raise_error(exception)
+      end
+
+      it 'sets server type to unknown' do
+        expect(server).not_to be_unknown
+        error
+
+        expect(server).to be_unknown
+      end
+
+      context 'with sdam event subscription' do
+        let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
+        let(:client) do
+          ClientRegistry.instance.global_client('authorized').with(app_name: 'connection_integration').tap do |client|
+            client.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
+            client.subscribe(Mongo::Monitoring::SERVER_CLOSED, subscriber)
+            client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, subscriber)
+            client.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING, subscriber)
+            client.subscribe(Mongo::Monitoring::TOPOLOGY_CHANGED, subscriber)
+          end
+        end
+
+        it 'publishes server description changed event' do
+          expect(subscriber.events).to be_empty
+
+          connection
+          subscriber.events.clear
+          error
+
+          event = subscriber.first_event('server_description_changed_event')
+          expect(event).not_to be_nil
+          expect(event.address).to eq(server.address)
+          expect(event.new_description).to be_unknown
+        end
+
+        it 'marks server unknown' do
+          expect(server).not_to be_unknown
+
+          connection
+          error
+
+          expect(server).to be_unknown
+        end
+
+        context 'in replica set topology' do
+          require_topology :replica_set
+
+          # need to use the primary here, otherwise a secondary will be
+          # changed to unknown which wouldn't alter topology
+          let(:server) { client.cluster.servers.detect { |s| s.primary? } }
+
+          it 'changes topology type' do
+            # wait for topology to get discovered
+            client.database.command(ismaster: 1)
+
+            expect(client.cluster.topology.class).to eql(Mongo::Cluster::Topology::ReplicaSetWithPrimary)
+
+            # stop background monitoring to prevent it from racing with the test
+            client.cluster.servers.each do |server|
+              server.monitor.stop!(true)
+            end
+
+            connection
+            error
+
+            expect(client.cluster.topology.class).to eql(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
+          end
+        end
+      end
+
+      context 'error during handshake to primary in a replica set' do
+        require_topology 'replica_set'
+
+        let(:server) { client.cluster.servers.detect { |server| server.primary? } }
+
+        before do
+          ClientRegistry.instance.close_all_clients
+          # insert to perform server selection and get topology to primary
+          client[:test].insert_one(foo: 'bar')
+        end
+
+        it 'sets cluster type to replica set without primary' do
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetWithPrimary)
+          error
+
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
+        end
+      end
+    end
+
+    describe 'wire protocol version range update' do
+      # 3.2 wire protocol is 4.
+      # Wire protocol < 2 means only scram auth is available,
+      # which is not supported by modern mongos.
+      # Instead of mucking with this we just limit this test to 3.2+
+      # so that we can downgrade protocol range to 0..3 instead of 0..1.
+      min_server_version '3.2'
+
+      let(:client) { ClientRegistry.instance.global_client('authorized').with(app_name: 'wire_protocol_update') }
+
+      it 'updates on ismaster response from non-monitoring connections' do
+        # connect server
+        client['test'].insert_one(test: 1)
+
+        # kill background threads so that they are not interfering with
+        # our mocked ismaster response
+        client.cluster.servers.each do |server|
+          server.monitor.stop!
+        end
+
+        server = client.cluster.servers.first
+        expect(server.features.server_wire_versions.max >= 4).to be true
+        max_version = server.features.server_wire_versions.max
+
+        # Depending on server version, ismaster here may return a
+        # description that compares equal to the one we got from a
+        # monitoring connection (pre-4.2) or not (4.2+).
+        # Since we do run SDAM flow on ismaster responses on
+        # non-monitoring connections, force descriptions to be different
+        # by setting the existing description here to unknown.
+        server.monitor.instance_variable_set('@description',
+          Mongo::Server::Description.new(server.address))
+
+        # now pretend an ismaster returned a different range
+        features = Mongo::Server::Description::Features.new(0..3)
+        # the second Features instantiation is for SDAM event publication
+        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
+
+        connection = Mongo::Server::Connection.new(server, server.options)
+        expect(connection.connect!).to be true
+
+        # ismaster response should update server description via sdam flow,
+        # which includes wire version range
+        expect(server.features.server_wire_versions.max).to eq(3)
+      end
+    end
+
+    describe 'SDAM flow triggered by ismaster on non-monitoring thread' do
+      # replica sets can transition between having and not having a primary
+      require_topology :replica_set
+
+      let(:client) do
+        # create a new client because we make manual state changes
+        ClientRegistry.instance.global_client('authorized').with(app_name: 'non-monitoring thread sdam')
+      end
+
+      it 'performs SDAM flow' do
+        client['foo'].insert_one(bar: 1)
+        client.cluster.servers.each do |server|
+          server.monitor.stop!(true)
+        end
+        expect(client.cluster.topology.class).to eq(Mongo::Cluster::Topology::ReplicaSetWithPrimary)
+
+        # need to connect to the primary for topology to change
+        server = client.cluster.servers.detect do |server|
+          server.primary?
+        end
+
+        # overwrite server description
+        server.monitor.instance_variable_set('@description', Mongo::Server::Description.new(
+          server.address))
+
+        # overwrite topology
+        client.cluster.instance_variable_set('@topology',
+          Mongo::Cluster::Topology::ReplicaSetNoPrimary.new(
+            client.cluster.topology.options, client.cluster.topology.monitoring, client.cluster))
+
+        # now create a connection.
+        connection = Mongo::Server::Connection.new(server, server.options)
+
+        # verify everything once again
+        expect(server).to be_unknown
+        expect(client.cluster.topology.class).to eq(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
+
+        # this should dispatch the sdam event
+        expect(connection.connect!).to be true
+
+        # back to primary
+        expect(server).to be_primary
+        expect(client.cluster.topology.class).to eq(Mongo::Cluster::Topology::ReplicaSetWithPrimary)
+      end
+    end
+  end
+end

data/spec/integration/cursor_reaping_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe 'Cursor reaping' do
+  # JRuby does reap cursors but GC.start does not force GC to run like it does
+  # in MRI, I don't currently know how to force GC to run in JRuby
+  only_mri
+
+  let(:client) { subscribed_client }
+  let(:collection) { client['cursor_reaping_spec'] }
+
+  before(:all) do
+    data = [{a: 1}] * 10
+    ClientRegistry.instance.global_client('subscribed')['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
+      expect(Mongo::Operation::KillCursors).not_to receive(:new)
+
+      # just the scope, no query is happening
+      collection.find.batch_size(2).no_cursor_timeout
+
+      events = EventSubscriber.started_events.select do |event|
+        event.command['killCursors']
+      end
+
+      expect(events).to be_empty
+    end
+
+    # this let block is a kludge to avoid copy pasting all of this code
+    let(:cursor_id_and_kill_event) do
+      expect(Mongo::Operation::KillCursors).to receive(:new).at_least(:once).and_call_original
+
+      cursor_id = nil
+
+      # scopes are weird, having this result in a let block
+      # makes it not garbage collected
+      2.times do
+        scope = collection.find.batch_size(2).no_cursor_timeout
+
+        # there is no API for retrieving the cursor
+        scope.each.first
+        # and keep the first cursor
+        cursor_id ||= scope.instance_variable_get('@cursor').id
+      end
+
+      expect(cursor_id).to be_a(Integer)
+      expect(cursor_id > 0).to be true
+
+      GC.start
+
+      # 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'].include?(cursor_id)
+      end
+
+      expect(started_event).not_to be_nil
+
+      succeeded_event = EventSubscriber.succeeded_events.detect do |event|
+        event.command_name == 'killCursors' && event.request_id == started_event.request_id
+      end
+
+      expect(succeeded_event).not_to be_nil
+
+      expect(succeeded_event.reply['ok']).to eq 1
+
+      [cursor_id, succeeded_event]
+    end
+
+    it 'is reaped' do
+      cursor_id_and_kill_event
+    end
+
+    context 'newer servers' do
+      min_server_version '3.2'
+
+      it 'is really killed' do
+        cursor_id, event = cursor_id_and_kill_event
+
+        expect(event.reply['cursorsKilled']).to eq([cursor_id])
+        expect(event.reply['cursorsNotFound']).to be_empty
+        expect(event.reply['cursorsAlive']).to be_empty
+        expect(event.reply['cursorsUnknown']).to be_empty
+      end
+    end
+  end
+end

data/spec/integration/docs_examples_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe 'aggregation examples in Ruby' do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
 
   let(:client) do
     authorized_client
@@ -87,7 +90,8 @@ describe 'aggregation examples in Ruby' do
     end
   end
 
-  context 'Aggregation Example 4 - $lookup, $filter, $match', if: op_msg_enabled? do
+  context 'Aggregation Example 4 - $lookup, $filter, $match' do
+    min_server_version '3.6'
 
     let(:example_code) do
 
@@ -138,11 +142,8 @@ describe 'aggregation examples in Ruby' do
   context 'runCommand Example 2' do
 
     before do
-      client[:restaurants].create
-    end
-
-    after do
       client[:restaurants].drop
+      client[:restaurants].create
     end
 
     let(:example_code) do