mongo 2.17.2 → 2.18.1

data/spec/runners/connection_string.rb

@@ -182,6 +182,14 @@ module Mongo
       def write_concern_expectation
         @spec['writeConcern']
       end
+
+      def num_seeds
+        @spec['numSeeds']
+      end
+
+      def num_hosts
+        @spec['numHosts']
+      end
     end
 
     class Host

data/spec/runners/crud/operation.rb

@@ -274,7 +274,14 @@ module Mongo
 
       def create_collection(database, context)
         opts = transformed_options(context)
-        database[arguments.fetch('collection')].create(session: opts[:session])
+        database[arguments.fetch('collection')]
+          .create(
+            {
+              session: opts[:session],
+              encrypted_fields: opts[:encrypted_fields],
+              validator: opts[:validator],
+            }.compact
+          )
       end
 
       def rename(collection, context)
@@ -285,11 +292,13 @@ module Mongo
       end
 
       def drop(collection, context)
-        collection.drop
+        opts = transformed_options(context)
+        collection.drop(encrypted_fields: opts[:encrypted_fields])
       end
 
       def drop_collection(database, context)
-        database[arguments.fetch('collection')].drop
+        opts = transformed_options(context)
+        database[arguments.fetch('collection')].drop(encrypted_fields: opts[:encrypted_fields])
       end
 
       def create_index(collection, context)

data/spec/runners/crud/requirement.rb

@@ -4,7 +4,7 @@
 module Mongo
   module CRUD
     class Requirement
-      YAML_KEYS = %w(auth minServerVersion maxServerVersion topology topologies serverParameters serverless).freeze
+      YAML_KEYS = %w(auth minServerVersion maxServerVersion topology topologies serverParameters serverless csfle).freeze
 
       def initialize(spec)
         spec = spec.dup
@@ -49,6 +49,7 @@ module Mongo
           nil
         end
         @auth = spec['auth']
+        @csfle = !!spec['csfle'] if spec['csfle']
       end
 
       attr_reader :min_server_version
@@ -75,11 +76,11 @@ module Mongo
       def satisfied?
         cc = ClusterConfig.instance
         ok = true
-        if short_min_server_version
-          ok &&= cc.fcv_ish >= short_min_server_version
+        if min_server_version
+          ok &&= Gem::Version.new(cc.fcv_ish) >= Gem::Version.new(min_server_version)
         end
         if max_server_version
-          ok &&= cc.short_server_version <= max_server_version
+          ok &&= Gem::Version.new(cc.server_version) <= Gem::Version.new(max_server_version)
         end
         if topologies
           ok &&= topologies.include?(cc.topology)
@@ -112,6 +113,10 @@ module Mongo
         elsif @auth == false
           ok &&= !cc.auth_enabled?
         end
+        if @csfle
+          ok &&= !!(ENV['LIBMONGOCRYPT_PATH'] || ENV['FLE'])
+          ok &&= Gem::Version.new(cc.fcv_ish) >= Gem::Version.new('4.2.0')
+        end
         ok
       end
 

data/spec/runners/crud/spec.rb

@@ -20,6 +20,7 @@ module Mongo
         # Introduced with Client-Side Encryption tests
         @json_schema = BSON::ExtJSON.parse_obj(@spec['json_schema'])
         @key_vault_data = BSON::ExtJSON.parse_obj(@spec['key_vault_data'])
+        @encrypted_fields = BSON::ExtJSON.parse_obj(@spec['encrypted_fields'])
 
         @requirements = if run_on = @spec['runOn']
           run_on.map do |spec|
@@ -46,6 +47,10 @@ module Mongo
       #   running each test.
       attr_reader :key_vault_data
 
+      # @return [ Hash ]  An encryptedFields option that should be set on the
+      #   collection (using createCollection) before each test run.
+      attr_reader :encrypted_fields
+
       def collection_name
         # Older spec tests do not specify a collection name, thus
         # we provide a default here

data/spec/runners/crud/test.rb

@@ -96,7 +96,7 @@ module Mongo
         elsif @data.is_a?(Array)
           collection = client[spec.collection_name, write_concern: {w: :majority}]
           collection.delete_many
-          collection.insert_many(@data)
+          collection.insert_many(@data) unless @data.empty?
         elsif @data.is_a?(Hash)
           converter = DataConverter.new
           @data.each do |collection_name, data|

data/spec/runners/crud/verifier.rb

@@ -159,6 +159,12 @@ EOT
               verify_hash_items_equal(expected, actual, k)
             end
           end
+        when Array
+          expect(actual).to be_a(Array)
+          expect(actual.size).to eq(expected.size)
+          expected.zip(actual).each do |pair|
+            verify_result(pair.first, pair.last)
+          end
         else
           expect(actual).to eq(expected)
         end

data/spec/runners/transactions/spec.rb

@@ -19,9 +19,9 @@ module Mongo
   module Transactions
 
     class Spec < Mongo::CRUD::Spec
-      def tests
+      def tests(expectations_bson_types: true)
         @tests.map do |test|
-          Mongo::Transactions::TransactionsTest.new(self, @data, test)
+          Mongo::Transactions::TransactionsTest.new(self, @data, test, expectations_bson_types: expectations_bson_types)
         end
       end
     end

data/spec/runners/transactions/test.rb

@@ -22,6 +22,7 @@ module Mongo
     #
     # @since 2.6.0
     class TransactionsTest < CRUD::CRUDTestBase
+      include MongosMacros
 
       attr_reader :expected_results
       attr_reader :skip_reason
@@ -39,10 +40,10 @@ module Mongo
       # @param [ Hash ] test The test specification.
       #
       # @since 2.6.0
-      def initialize(crud_spec, data, test)
+      def initialize(crud_spec, data, test, expectations_bson_types: true)
         test = IceNine.deep_freeze(test)
         @spec = crud_spec
-        @data = data
+        @data = data || []
         @description = test['description']
         @client_options = {
           # Disable legacy read & write retries, so that when spec tests
@@ -70,7 +71,8 @@ module Mongo
           Operation.new(self, op)
         end
 
-        @expectations = BSON::ExtJSON.parse_obj(test['expectations'], mode: :bson)
+        mode = if expectations_bson_types then :bson else nil end
+        @expectations = BSON::ExtJSON.parse_obj(test['expectations'], mode: mode)
 
         if test['outcome']
           @outcome = Mongo::CRUD::Outcome.new(BSON::ExtJSON.parse_obj(test['outcome'], mode: :bson))
@@ -232,19 +234,20 @@ module Mongo
           end
         end
 
+        key_vault_coll = support_client
+        .use(:keyvault)[:datakeys]
+        .with(write: { w: :majority })
+
+        key_vault_coll.drop
         # Insert data into the key vault collection if required to do so by
         # the tests.
         if @spec.key_vault_data && !@spec.key_vault_data.empty?
-          key_vault_coll = support_client
-            .use(:admin)[:datakeys]
-            .with(write: { w: :majority })
-
-          key_vault_coll.drop
           key_vault_coll.insert_many(@spec.key_vault_data)
         end
 
+        encrypted_fields = @spec.encrypted_fields if @spec.encrypted_fields
         coll = support_client[@spec.collection_name].with(write: { w: :majority })
-        coll.drop
+        coll.drop(encrypted_fields: encrypted_fields)
 
         # Place a jsonSchema validator on the collection if required to do so
         # by the tests.
@@ -254,19 +257,19 @@ module Mongo
           {}
         end
 
-        support_client.command(
+        create_collection_spec = {
           create: @spec.collection_name,
           validator: collection_validator,
           writeConcern: { w: 'majority' }
-        )
+        }
+
+        create_collection_spec[:encryptedFields] = encrypted_fields if encrypted_fields
+        support_client.command(create_collection_spec)
 
         coll.insert_many(@data) unless @data.empty?
 
-        $distinct_ran ||= {}
-        $distinct_ran[@spec.database_name] ||= if description =~ /distinct/ || @operations.any? { |op| op.name == 'distinct' }
-          ::Utils.mongos_each_direct_client do |direct_client|
-            direct_client.use(@spec.database_name)['test'].distinct('foo').to_a
-          end
+        if description =~ /distinct/ || @operations.any? { |op| op.name == 'distinct' }
+          run_mongos_distincts(@spec.database_name, 'test')
         end
 
         admin_support_client.command(@fail_point_command) if @fail_point_command

data/spec/runners/transactions.rb

@@ -19,7 +19,8 @@ require 'runners/transactions/operation'
 require 'runners/transactions/spec'
 require 'runners/transactions/test'
 
-def define_transactions_spec_tests(test_paths)
+def define_transactions_spec_tests(test_paths, expectations_bson_types: true)
+  config_override :validate_update_replace, true
 
   test_paths.each do |file|
 
@@ -29,7 +30,7 @@ def define_transactions_spec_tests(test_paths)
 
       define_spec_tests_with_requirements(spec) do |req|
 
-        spec.tests.each do |test|
+        spec.tests(expectations_bson_types: expectations_bson_types).each do |test|
 
           context(test.description) do
 
@@ -51,16 +52,18 @@ def define_transactions_spec_tests(test_paths)
               end
             end
 
-            before(:all) do
-              if req.satisfied?
-                test.setup_test
+            unless req.satisfied?
+              before(:all) do
+                skip "Requirements not satisfied"
               end
             end
 
+            before(:all) do
+              test.setup_test
+            end
+
             after(:all) do
-              if req.satisfied?
-                test.teardown_test
-              end
+              test.teardown_test
             end
 
             let(:results) do

data/spec/runners/unified/assertions.rb

@@ -51,6 +51,57 @@ module Unified
             end
           end
 
+          %w(acknowledged).each do |k|
+            expected_v = expected.use(k)
+            next unless expected_v
+            actual_v = case actual
+            when Mongo::BulkWrite::Result, Mongo::Operation::Result
+              if Hash === expected_v && expected_v.keys == %w($$unsetOrMatches)
+                expected_v = expected_v.values.first
+              end
+              actual.send("#{k}?")
+            else
+              actual[k]
+            end
+            if expected_v
+              if expected_v.empty?
+                if actual_v && !actual_v.empty?
+                  raise Error::ResultMismatch, "Actual not empty"
+                end
+              else
+                if actual_v != expected_v
+                  raise Error::ResultMismatch, "Mismatch: actual #{actual_v}, expected #{expected_v}"
+                end
+              end
+            end
+          end
+
+          %w(bulkWriteResult).each do |k|
+            expected_v = expected.use(k)
+            next unless expected_v
+            actual_v = case actual
+            when Mongo::Crypt::RewrapManyDataKeyResult
+              actual.send(Utils.underscore(k))
+            else
+              raise Error::ResultMismatch, "Mismatch: actual #{actual_v}, expected #{expected_v}"
+            end
+            if expected_v
+              if expected_v.empty?
+                if actual_v && !actual_v.empty?
+                  raise Error::ResultMismatch, "Actual not empty"
+                end
+              else
+                %w(deleted inserted matched modified upserted).each do |k|
+                  if count = expected_v.use("#{k}Count")
+                    if Hash === count || count > 0
+                      actual_count = actual_v.send("#{k}_count")
+                      assert_value_matches(actual_count, count, "#{k} count")
+                    end
+                  end
+                end
+              end
+            end
+          end
           assert_matches(actual, expected, 'result')
           expected.clear
         end
@@ -99,6 +150,12 @@ module Unified
         client = entities.get(:client, client_id)
         subscriber = @subscribers.fetch(client)
         expected_events = spec.use!('events')
+        ignore_extra_events = if ignore = spec.use('ignoreExtraEvents')
+          # Ruby treats 0 as truthy, whereas the spec tests use it as falsy.
+          ignore == 0 ? false : ignore
+        else
+          false
+        end
         actual_events = subscriber.wanted_events(@observe_sensitive)
         case spec.use('eventType')
         when nil, 'command'
@@ -107,10 +164,12 @@ module Unified
           end
         when 'cmap'
           actual_events.select! do |event|
-            event.class.name.sub(/.*::/, '') =~ /^Pool/
+            event.class.name.sub(/.*::/, '') =~ /^(?:Pool|Connection)/
           end
         end
-        unless actual_events.length == expected_events.length
+
+        if (!ignore_extra_events && actual_events.length != expected_events.length) ||
+           (ignore_extra_events && actual_events.length < expected_events.length)
           raise Error::ResultMismatch, "Event count mismatch: expected #{expected_events.length}, actual #{actual_events.length}\nExpected: #{expected_events}\nActual: #{actual_events}"
         end
         expected_events.each_with_index do |event, i|
@@ -131,6 +190,9 @@ module Unified
       if spec.use('hasServiceId')
         actual.service_id.should_not be nil
       end
+      if spec.use('hasServerConnectionId')
+        actual.server_connection_id.should_not be nil
+      end
       if db_name = spec.use('databaseName')
         assert_eq(actual.database_name, db_name, 'Database names differ')
       end
@@ -155,8 +217,12 @@ module Unified
     end
 
     def assert_matches(actual, expected, msg)
-      if actual.nil? && !expected.nil?
-        raise Error::ResultMismatch, "#{msg}: expected #{expected} but got nil"
+      if actual.nil?
+        if expected.is_a?(Hash) && expected.keys == ["$$unsetOrMatches"]
+          return
+        elsif !expected.nil?
+          raise Error::ResultMismatch, "#{msg}: expected #{expected} but got nil"
+        end
       end
 
       case expected
@@ -179,7 +245,7 @@ module Unified
           if expected.empty?
             # This needs to be a match assertion. Check type only
             # and allow BulkWriteResult and generic operation result.
-            unless Hash === actual || Mongo::BulkWrite::Result === actual || Mongo::Operation::Result === actual
+            unless Hash === actual || Mongo::BulkWrite::Result === actual || Mongo::Operation::Result === actual || Mongo::Crypt::RewrapManyDataKeyResult === actual
               raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
             end
           else
@@ -208,10 +274,18 @@ module Unified
     end
 
     def assert_type(object, type)
+      ok = [*type].reduce(false) { |acc, x| acc || type_matches?(object, x) }
+
+      unless ok
+        raise Error::ResultMismatch, "Object #{object} is not of type #{type}"
+      end
+    end
+
+    def type_matches?(object, type)
       ok = case type
       when 'object'
         Hash === object
-      when %w(int long)
+      when 'int', 'long'
         Integer === object || BSON::Int32 === object || BSON::Int64 === object
       when 'objectId'
         BSON::ObjectId === object
@@ -219,12 +293,15 @@ module Unified
         Time === object
       when 'double'
         Float === object
+      when 'string'
+        String === object
+      when 'binData'
+        BSON::Binary === object
+      when 'array'
+        Array === object
       else
         raise NotImplementedError, "Unhandled type #{type}"
       end
-      unless ok
-        raise Error::ResultMismatch, "Object #{object} is not of type #{type}"
-      end
     end
 
     def assert_value_matches(actual, expected, msg)
@@ -235,8 +312,10 @@ module Unified
         case operator
         when '$$unsetOrMatches'
           if actual
-            unless actual == expected_v
-              raise Error::ResultMismatch, "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+            if Mongo::BulkWrite::Result === actual || Mongo::Operation::Result === actual
+              assert_result_matches(actual, UsingHash[expected_v])
+            else
+              assert_matches(actual, expected_v, msg)
             end
           end
         when '$$matchesHexBytes'

data/spec/runners/unified/change_stream_operations.rb

@@ -14,6 +14,18 @@ module Unified
         if batch_size = args.use('batchSize')
           opts[:batch_size] = batch_size
         end
+        if comment = args.use('comment')
+          opts[:comment] = comment
+        end
+        if full_document = args.use('fullDocument')
+          opts[:full_document] = full_document
+        end
+        if full_document_before_change = args.use('fullDocumentBeforeChange')
+          opts[:full_document_before_change] = full_document_before_change
+        end
+        if args.key?('showExpandedEvents')
+          opts[:show_expanded_events] = args.use!('showExpandedEvents')
+        end
         cs = object.watch(pipeline, **opts)
         name = op.use!('saveResultAsEntity')
         entities.set(:change_stream, name, cs)

data/spec/runners/unified/client_side_encryption_operations.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Unified
+  module ClientSideEncryptionOperations
+    def create_data_key(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = Utils.shallow_snakeize_hash(args.use('opts')) || {}
+        opts[:master_key] = Utils.shallow_snakeize_hash(opts[:master_key]) if opts[:master_key]
+        opts[:key_material] = opts[:key_material].data if opts[:key_material]
+        client_encryption.create_data_key(
+          args.use!('kmsProvider'),
+          opts,
+        )
+      end
+    end
+
+    def add_key_alt_name(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        client_encryption.add_key_alt_name(
+          args.use!('id'),
+          args.use!('keyAltName')
+        )
+      end
+    end
+
+    def delete_key(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        client_encryption.delete_key(
+          args.use!('id')
+        )
+      end
+    end
+
+    def get_key(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        client_encryption.get_key(
+          args.use!('id')
+        )
+      end
+    end
+
+    def get_key_by_alt_name(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        client_encryption.get_key_by_alt_name(
+          args.use!('keyAltName')
+        )
+      end
+    end
+
+    def get_keys(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      client_encryption.get_keys.to_a
+    end
+
+    def remove_key_alt_name(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        client_encryption.remove_key_alt_name(
+          args.use!('id'),
+          args.use!('keyAltName')
+        )
+      end
+    end
+
+    def rewrap_many_data_key(op)
+      client_encryption = entities.get(:clientEncryption, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = Utils.shallow_snakeize_hash(args.use('opts')) || {}
+        opts[:master_key] = Utils.shallow_snakeize_hash(opts[:master_key]) if opts[:master_key]
+        client_encryption.rewrap_many_data_key(
+          args.use!('filter'),
+          opts
+        )
+      end
+    end
+  end
+end