mongo 2.16.1 → 2.17.0

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

data/spec/runners/unified/ddl_operations.rb

@@ -7,7 +7,13 @@ module Unified
 
     def list_databases(op)
       client = entities.get(:client, op.use!('object'))
-      client.list_databases
+      use_arguments(op) do |args|
+        opts = {}
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        client.list_databases({}, false, **opts)
+      end
     end
 
     def create_collection(op)
@@ -28,6 +34,17 @@ module Unified
       end
     end
 
+    def list_collections(op)
+      database = entities.get(:database, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = {}
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        database.list_collections(**opts)
+      end
+    end
+
     def drop_collection(op)
       database = entities.get(:database, op.use!('object'))
       use_arguments(op) do |args|
@@ -58,6 +75,17 @@ module Unified
       assert_collection_exists(op, false)
     end
 
+    def list_indexes(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = {}
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+        collection.indexes(**opts).to_a
+      end
+    end
+
     def create_index(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|

data/spec/runners/unified/entity_map.rb

@@ -3,6 +3,8 @@
 
 module Unified
   class EntityMap
+    extend Forwardable
+
     def initialize
       @map = {}
     end
@@ -35,8 +37,6 @@ module Unified
       raise Error::EntityMissing, "There is no #{id} known"
     end
 
-    def [](type)
-      @map[type]
-    end
+    def_delegators :@map, :[], :fetch
   end
 end

data/spec/runners/unified/support_operations.rb

@@ -13,7 +13,12 @@ module Unified
 
         cmd = args.use!('command')
 
-        database.command(cmd)
+        opts = {}
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
+        end
+
+        database.command(cmd, **opts)
       end
     end
 

data/spec/runners/unified/test.rb

@@ -160,13 +160,24 @@ module Unified
           end
         when 'database'
           client = entities.get(:client, spec.use!('client'))
-          client.use(spec.use!('databaseName')).database
+          opts = Utils.snakeize_hash(spec.use('databaseOptions') || {})
+            .merge(database: spec.use!('databaseName'))
+          if opts.key?(:read_preference)
+            opts[:read] = opts.delete(:read_preference)
+            if opts[:read].key?(:max_staleness_seconds)
+              opts[:read][:max_staleness] = opts[:read].delete(:max_staleness_seconds)
+            end
+          end
+          client.with(opts).database
         when 'collection'
           database = entities.get(:database, spec.use!('database'))
           # TODO verify
           opts = Utils.snakeize_hash(spec.use('collectionOptions') || {})
           if opts.key?(:read_preference)
             opts[:read] = opts.delete(:read_preference)
+            if opts[:read].key?(:max_staleness_seconds)
+              opts[:read][:max_staleness] = opts[:read].delete(:max_staleness_seconds)
+            end
           end
           database[spec.use!('collectionName'), opts]
         when 'bucket'
@@ -195,7 +206,8 @@ module Unified
     def set_initial_data
       @spec['initialData']&.each do |entity_spec|
         spec = UsingHash[entity_spec]
-        collection = root_authorized_client.use(spec.use!('databaseName'))[spec.use!('collectionName')]
+        collection = root_authorized_client.with(write_concern: {w: :majority}).
+          use(spec.use!('databaseName'))[spec.use!('collectionName')]
         collection.drop
         docs = spec.use!('documents')
         if docs.any?
@@ -268,7 +280,7 @@ module Unified
         end
         if expected_error = op.use('expectError')
           begin
-            send(method_name, op)
+            public_send(method_name, op)
           rescue Mongo::Error, BSON::String::IllegalKey => e
             if expected_error.use('isClientError')
               # isClientError doesn't actually mean a client error.