mongo 2.16.0 → 2.17.0

data/spec/mongo/server/monitor/connection_spec.rb

@@ -136,6 +136,28 @@ describe Mongo::Server::Monitor::Connection do
     end
   end
 
+  describe '#connect!' do
+
+    let(:options) do
+      SpecConfig.instance.test_options.merge(
+        app_metadata: monitor_app_metadata,
+      )
+    end
+
+    context 'when address resolution fails' do
+      let(:connection) { described_class.new(server.address, options) }
+
+      it 'propagates the exception' do
+        connection
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          connection.connect!
+        end.should raise_error(SocketError, 'Test exception')
+      end
+    end
+  end
+
   describe '#check_document' do
     context 'with API version' do
       let(:meta) do

data/spec/mongo/server/push_monitor_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Server::PushMonitor do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  let(:address) do
+    default_address
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:monitor_options) do
+    {}
+  end
+
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
+  let(:cluster) do
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:run_sdam_flow)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+    end
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, Mongo::Monitoring.new, listeners,
+      monitoring_io: false)
+  end
+
+  let(:monitor) do
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, listeners, Mongo::Monitoring.new,
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
+    )
+  end
+
+  let(:topology_version) do
+    Mongo::TopologyVersion.new('processId' => BSON::ObjectId.new, 'counter' => 1)
+  end
+
+  let(:check_document) do
+    {hello: 1}
+  end
+
+  let(:push_monitor) do
+    described_class.new(monitor, topology_version, monitor.monitoring,
+      **monitor.options.merge(check_document: check_document))
+  end
+
+  describe '#do_work' do
+    it 'works' do
+      lambda do
+        push_monitor.do_work
+      end.should_not raise_error
+    end
+
+    context 'network error during check' do
+      it 'does not propagate the exception' do
+        push_monitor
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+      end
+
+      it 'throttles checks' do
+        push_monitor
+
+        start = Mongo::Utils.monotonic_time
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        elapsed = Mongo::Utils.monotonic_time - start
+        elapsed.should > 0.5
+      end
+    end
+  end
+
+end

data/spec/mongo/server_selector_spec.rb

@@ -202,12 +202,7 @@ describe Mongo::ServerSelector do
   describe "#select_server" do
     require_no_linting
 
-    context 'when #select_in_replica_set returns a list of nils' do
-
-      let(:servers) do
-        [ make_server(:primary) ]
-      end
-
+    context 'replica set topology' do
       let(:cluster) do
         double('cluster').tap do |c|
           allow(c).to receive(:connected?).and_return(true)
@@ -223,19 +218,141 @@ describe Mongo::ServerSelector do
           allow(c).to receive(:scan!).and_return(true)
           allow(c).to receive(:options).and_return(server_selection_timeout: 0.1)
           allow(c).to receive(:server_selection_semaphore).and_return(nil)
+          allow(topology).to receive(:compatible?).and_return(true)
         end
       end
 
-      let(:read_pref) do
-        described_class.get(mode: :primary).tap do |pref|
-          allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+      let(:primary) do
+        make_server(:primary).tap do |server|
+          allow(server).to receive(:features).and_return(double("primary features"))
         end
       end
 
-      it 'raises a NoServerAvailable error' do
-        expect do
-          read_pref.select_server(cluster)
-        end.to raise_exception(Mongo::Error::NoServerAvailable)
+      let(:secondary) do
+        make_server(:secondary).tap do |server|
+          allow(server).to receive(:features).and_return(double("secondary features"))
+        end
+      end
+
+      context "when #select_in_replica_set returns a list of nils" do
+        let(:servers) do
+          [ primary ]
+        end
+
+        let(:read_pref) do
+          described_class.get(mode: :primary).tap do |pref|
+            allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+          end
+        end
+
+        it 'raises a NoServerAvailable error' do
+          expect do
+            read_pref.select_server(cluster)
+          end.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+
+      context "write_aggregation is true" do
+
+        before do
+          # It does not matter for this context whether primary supports secondary wites or not,
+          # but we need to mock out this call.
+          allow(primary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+        end
+
+        context "read preference is primary" do
+          let(:selector) { Mongo::ServerSelector::Primary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is primary preferred" do
+          let(:selector) { Mongo::ServerSelector::PrimaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is secondary preferred" do
+          let(:selector) { Mongo::ServerSelector::SecondaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
+
+        context "read preference is secondary" do
+          let(:selector) { Mongo::ServerSelector::Secondary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+
+          context "no secondaries in cluster" do
+            let(:servers) do
+              [ primary ]
+            end
+
+            it "selects a primary" do
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
       end
     end
 
@@ -381,8 +498,12 @@ describe Mongo::ServerSelector do
         let(:servers) { [unknown, mongos] }
         let(:selector) { described_class.primary }
 
-        it 'returns the mongos' do
-          expect(selector.select_server(cluster)).to eq(mongos)
+        [true, false].each do |write_aggregation|
+          context "write_aggregation is #{write_aggregation}" do
+            it 'returns the mongos' do
+              expect(selector.select_server(cluster, write_aggregation: write_aggregation)).to eq(mongos)
+            end
+          end
         end
       end
     end

data/spec/mongo/socket/ssl_spec.rb

@@ -306,67 +306,40 @@ describe Mongo::Socket::SSL, retry: 3 do
       end
     end
 
-    context 'when ruby version is < 2.4.1' do
-      ruby_version_lt '2.4.1'
-
-      context 'when a key is passed, but it is not of the right type' do
-
-        let(:ssl_options) do
-          key = "This is a string not a key"
-          {
-              :ssl => true,
-              :ssl_key_object => key,
-              :ssl_cert => SpecConfig.instance.client_cert_path,
-              :ssl_verify => false
-          }
-        end
-
-        it 'raises a TypeError' do
-          expect do
-            socket
-          end.to raise_exception(TypeError)
-        end
-      end
-    end
-
     # Note that as of MRI 2.4, Creating a socket with the wrong key type raises
     # a NoMethodError because #private? is attempted to be called on the key.
     # In jruby 9.2 a TypeError is raised.
     # In jruby 9.1 a OpenSSL::PKey::PKeyError is raised.
-    context 'when ruby version is >= 2.4.1' do
-      ruby_version_gte '2.4.1'
+    context 'when a key is passed, but it is not of the right type' do
 
-      context 'when a key is passed, but it is not of the right type' do
+      let(:ssl_options) do
+        key = "This is a string not a key"
+        {
+            :ssl => true,
+            :ssl_key_object => key,
+            :ssl_cert => SpecConfig.instance.client_cert_path,
+            :ssl_verify => false
+        }
+      end
 
-        let(:ssl_options) do
-          key = "This is a string not a key"
-          {
-              :ssl => true,
-              :ssl_key_object => key,
-              :ssl_cert => SpecConfig.instance.client_cert_path,
-              :ssl_verify => false
-          }
-        end
-
-        let(:expected_exception) do
-          if SpecConfig.instance.jruby?
-            if RUBY_VERSION >= '2.5.0'
-              # jruby 9.2
-              TypeError
-            else
-              # jruby 9.1
-              OpenSSL::OpenSSLError
-            end
+      let(:expected_exception) do
+        if SpecConfig.instance.jruby?
+          if RUBY_VERSION >= '2.5.0'
+            # jruby 9.2
+            TypeError
           else
-            NoMethodError
+            # jruby 9.1
+            OpenSSL::OpenSSLError
           end
+        else
+          NoMethodError
         end
+      end
 
-        it 'raises a NoMethodError' do
-          expect do
-            socket
-          end.to raise_exception(expected_exception)
-        end
+      it 'raises a NoMethodError' do
+        expect do
+          socket
+        end.to raise_exception(expected_exception)
       end
     end
 
@@ -403,13 +376,8 @@ describe Mongo::Socket::SSL, retry: 3 do
         context 'when a bad key is provided' do
 
           let(:expected_exception) do
-            if RUBY_VERSION >= '2.4.0'
-              # OpenSSL::PKey::PKeyError: Could not parse PKey: no start line
-              [OpenSSL::OpenSSLError, /Could not parse PKey/]
-            else
-              # ArgumentError: Could not parse PKey: no start line
-              [ArgumentError, /Could not parse PKey/]
-            end
+            # OpenSSL::PKey::PKeyError: Could not parse PKey: no start line
+            [OpenSSL::OpenSSLError, /Could not parse PKey/]
           end
 
           let(:ssl_options) do

data/spec/mongo/utils_spec.rb

@@ -39,18 +39,4 @@ describe Mongo::Utils do
       }
     end
   end
-
-  describe '#slice_hash' do
-    it do
-      hash = {'key1' => 1, :key2 => 's', :key3 => true}
-      expect(
-        described_class.slice_hash(hash, 'key1', :key3)
-      ).to eq(
-        {
-          'key1' => 1,
-          :key3 => true
-        }
-      )
-    end
-  end
 end

data/spec/runners/crud/verifier.rb

@@ -110,8 +110,7 @@ EOT
         expected_command = expected_event.delete('command')
         actual_command = actual_event.delete('command')
 
-        # Hash#compact is ruby 2.4+
-        expected_presence = expected_command.select { |k, v| !v.nil? }
+        expected_presence = expected_command.compact
         expected_absence = expected_command.select { |k, v| v.nil? }
 
         expected_presence.each do |k, v|

data/spec/runners/unified/assertions.rb

@@ -62,7 +62,7 @@ module Unified
     def assert_outcome
       return unless outcome
 
-      client = ClientRegistry.instance.global_client('authorized')
+      client = ClientRegistry.instance.global_client('root_authorized')
       outcome.each do |spec|
         spec = UsingHash[spec]
         collection = client.use(spec.use!('databaseName'))[spec.use!('collectionName')]
@@ -217,6 +217,8 @@ module Unified
         BSON::ObjectId === object
       when 'date'
         Time === object
+      when 'double'
+        Float === object
       else
         raise NotImplementedError, "Unhandled type #{type}"
       end

data/spec/runners/unified/crud_operations.rb

@@ -8,7 +8,9 @@ module Unified
     def find(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
+        opts = {
+          let: args.use('let'),
+        }
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
@@ -29,7 +31,11 @@ module Unified
     def count_documents(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        collection.find(args.use!('filter')).count_documents
+        opts = {}
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        collection.find(args.use!('filter')).count_documents(**opts)
       end
     end
 
@@ -47,7 +53,11 @@ module Unified
     def distinct(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        req = collection.find(args.use!('filter')).distinct(args.use!('fieldName'))
+        opts = {}
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        req = collection.find(args.use!('filter'), **opts).distinct(args.use!('fieldName'), **opts)
         result = req.to_a
       end
     end
@@ -57,10 +67,15 @@ module Unified
       use_arguments(op) do |args|
         filter = args.use!('filter')
         update = args.use!('update')
-        opts = {}
+        opts = {
+          let: args.use('let'),
+        }
         if return_document = args.use('returnDocument')
           opts[:return_document] = return_document.downcase.to_sym
         end
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
         collection.find_one_and_update(filter, update, **opts)
       end
     end
@@ -70,7 +85,13 @@ module Unified
       use_arguments(op) do |args|
         filter = args.use!('filter')
         update = args.use!('replacement')
-        collection.find_one_and_replace(filter, update)
+        opts = {
+          let: args.use('let'),
+        }
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        collection.find_one_and_replace(filter, update, **opts)
       end
     end
 
@@ -78,7 +99,13 @@ module Unified
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
         filter = args.use!('filter')
-        collection.find_one_and_delete(filter)
+        opts = {
+          let: args.use('let'),
+        }
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        collection.find_one_and_delete(filter, **opts)
       end
     end
 
@@ -96,25 +123,37 @@ module Unified
     def insert_many(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        options = {}
+        opts = {}
         unless (ordered = args.use('ordered')).nil?
-          options[:ordered] = ordered
+          opts[:ordered] = ordered
+        end
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
         end
-        collection.insert_many(args.use!('documents'), **options)
+        collection.insert_many(args.use!('documents'), **opts)
       end
     end
 
     def update_one(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        collection.update_one(args.use!('filter'), args.use!('update'))
+        opts = {
+          let: args.use('let'),
+        }
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        collection.update_one(args.use!('filter'), args.use!('update'), **opts)
       end
     end
 
     def update_many(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        collection.update_many(args.use!('filter'), args.use!('update'))
+        opts = {
+          let: args.use('let'),
+        }
+        collection.update_many(args.use!('filter'), args.use!('update'), **opts)
       end
     end
 
@@ -132,14 +171,23 @@ module Unified
     def delete_one(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        collection.delete_one(args.use!('filter'))
+        opts = {
+          let: args.use('let'),
+        }
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        collection.delete_one(args.use!('filter'), **opts)
       end
     end
 
     def delete_many(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        collection.delete_many(args.use!('filter'))
+        opts = {
+          let: args.use('let'),
+        }
+        collection.delete_many(args.use!('filter'), **opts)
       end
     end
 
@@ -157,6 +205,22 @@ module Unified
       end
     end
 
+    def aggregate(op)
+      obj = entities.get_any(op.use!('object'))
+      args = op.use!('arguments')
+      pipeline = args.use!('pipeline')
+      opts = {
+        let: args.use('let'),
+      }
+      if session = args.use('session')
+        opts[:session] = entities.get(:session, session)
+      end
+      unless args.empty?
+        raise NotImplementedError, "Unhandled spec keys: #{args} in #{test_spec}"
+      end
+      obj.aggregate(pipeline, **opts).to_a
+    end
+
     private
 
     def convert_bulk_write_spec(spec)
@@ -192,15 +256,5 @@ module Unified
       end
       {Utils.underscore(op) =>out}
     end
-
-    def aggregate(op)
-      obj = entities.get_any(op.use!('object'))
-      args = op.use!('arguments')
-      pipeline = args.use!('pipeline')
-      unless args.empty?
-        raise NotImplementedError, "Unhandled spec keys: #{test_spec}"
-      end
-      obj.aggregate(pipeline).to_a
-    end
   end
 end