mongo 2.14.0.rc1 → 2.15.1

data/spec/runners/crud/operation.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/crud/outcome.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/crud/requirement.rb

@@ -1,23 +1,59 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module CRUD
     class Requirement
-      YAML_KEYS = %w(minServerVersion maxServerVersion topology).freeze
+      YAML_KEYS = %w(auth minServerVersion maxServerVersion topology topologies serverParameters serverless).freeze
 
       def initialize(spec)
+        spec = spec.dup
+        # Legacy tests have the requirements mixed with other test fields
+        spec.delete('data')
+        spec.delete('tests')
+
+        unless (unhandled_keys = spec.keys - YAML_KEYS).empty?
+          raise "Unhandled requirement specification keys: #{unhandled_keys}"
+        end
+
         @min_server_version = spec['minServerVersion']
         @max_server_version = spec['maxServerVersion']
-        @topologies = if topologies = spec['topology']
+        # topologies is for unified test format.
+        # topology is for legacy tests.
+        @topologies = if topologies = spec['topology'] || spec['topologies']
           topologies.map do |topology|
-            {'replicaset' => :replica_set, 'single' => :single, 'sharded' => :sharded}[topology]
+            {
+              'replicaset' => :replica_set,
+              'single' => :single,
+              'sharded' => :sharded,
+              'sharded-replicaset' => :sharded,
+            }[topology].tap do |v|
+              unless v
+                raise "Unknown topology #{topology}"
+              end
+            end
           end
         else
           nil
         end
+        @server_parameters = spec['serverParameters']
+        @serverless = if serverless = spec['serverless']
+          case spec['serverless']
+          when 'require' then :require
+          when 'forbid' then :forbid
+          when 'allow' then :allow
+          else raise "Unknown serverless requirement: #{serverless}"
+          end
+        else
+          nil
+        end
+        @auth = spec['auth']
       end
 
       attr_reader :min_server_version
       attr_reader :max_server_version
       attr_reader :topologies
+      attr_reader :serverless
 
       def short_min_server_version
         if min_server_version
@@ -47,6 +83,34 @@ module Mongo
         if topologies
           ok &&= topologies.include?(cc.topology)
         end
+        if @server_parameters
+          @server_parameters.each do |k, required_v|
+            actual_v = cc.server_parameters[k]
+            if actual_v.nil? && !required_v.nil?
+              ok = false
+            elsif actual_v != required_v
+              if Numeric === actual_v && Numeric === required_v
+                if actual_v.to_f != required_v.to_f
+                  ok = false
+                end
+              else
+                ok = false
+              end
+            end
+          end
+        end
+        if @serverless
+          if SpecConfig.instance.serverless?
+            ok = ok && [:allow, :require].include?(serverless)
+          else
+            ok = ok && [:allow, :forbid].include?(serverless)
+          end
+        end
+        if @auth == true
+          ok &&= cc.auth_enabled?
+        elsif @auth == false
+          ok &&= !cc.auth_enabled?
+        end
         ok
       end
 

data/spec/runners/crud/spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module CRUD
     # Represents a CRUD specification test.

data/spec/runners/crud/test.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module CRUD
 

data/spec/runners/crud/test_base.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module CRUD
 
@@ -45,25 +48,6 @@ module Mongo
           raise "Unknown target #{operation.object}"
         end
       end
-
-      # If the deployment is a sharded cluster, creates a direct client
-      # to each of the mongos nodes and yields each in turn to the
-      # provided block. Does nothing in other topologies.
-      def mongos_each_direct_client
-        if ClusterConfig.instance.topology == :sharded
-          client = ClientRegistry.instance.global_client('basic')
-          client.cluster.next_primary
-          client.cluster.servers.each do |server|
-            direct_client = ClientRegistry.instance.new_local_client(
-              [server.address.to_s],
-              SpecConfig.instance.test_options.merge(
-                connect: :sharded
-              ).merge(SpecConfig.instance.auth_options))
-            yield direct_client
-            direct_client.close
-          end
-        end
-      end
     end
   end
 end

data/spec/runners/crud/verifier.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -193,6 +196,14 @@ EOT
           return
         end
 
+        if k == 'updateDescription'
+          # Change stream result - verify subset, not exact match
+          expected.fetch(k).each do |sub_k, sub_v|
+            {sub_k => sub_v}.should == {sub_k => actual.fetch(k).fetch(sub_k)}
+          end
+          return
+        end
+
         if expected[k].is_a?(Time)
           expect(k => actual[k].utc.to_s).to eq(k => expected[k].utc.to_s)
         else

data/spec/runners/crud.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -122,6 +125,15 @@ def define_crud_spec_test_examples(spec, req = nil, &block)
           if operation.outcome.error?
             it 'raises an error' do
               expect(result).to be_a(Mongo::Error)
+              if operation.outcome.result
+                verifier.verify_operation_result(
+                  operation.outcome.result,
+                  {
+                    'errorContains' => result.message,
+                    'errorLabels' => result.labels,
+                  }
+                )
+              end
             end
           else
             tested = false
@@ -212,6 +224,16 @@ def define_spec_tests_with_requirements(spec, &block)
         if req.topologies
           require_topology *req.topologies
         end
+        if SpecConfig.instance.serverless? && req.serverless == :forbid
+          before(:all) do
+            skip "Serverless forbidden"
+          end
+        end
+        if !SpecConfig.instance.serverless? && req.serverless == :require
+          before(:all) do
+            skip "Serverless required"
+          end
+        end
 
         instance_exec(req, &block)
       end

data/spec/runners/gridfs.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/read_write_concern_document.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module ReadWriteConcernDocument
 
   class Spec

data/spec/runners/sdam/verifier.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Sdam
   class Verifier
     include RSpec::Matchers

data/spec/runners/sdam.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Matcher for determining if the server is of the expected type according to
 # the test.
 #
@@ -120,8 +123,8 @@ module Mongo
       # @return [ String ] address The server address.
       attr_reader :address
 
-      # @return [ Hash ] ismaster The ismaster response.
-      attr_reader :ismaster
+      # @return [ Hash ] hello The hello response.
+      attr_reader :hello
 
       # Create the new response.
       #
@@ -135,7 +138,7 @@ module Mongo
       def initialize(response, uri)
         @uri = uri
         @address = response[0]
-        @ismaster = BSON::ExtJSON.parse_obj(response[1])
+        @hello = BSON::ExtJSON.parse_obj(response[1])
       end
     end
 

data/spec/runners/server_selection.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module ServerSelection
     module Read
@@ -123,7 +126,7 @@ end
 def define_server_selection_spec_tests(test_paths)
   # Linter insists that a server selection semaphore is present when
   # performing server selection.
-  skip_if_linting
+  require_no_linting
 
   test_paths.each do |file|
 

data/spec/runners/server_selection_rtt.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module ServerSelection
     module RTT
@@ -13,7 +16,7 @@ module Mongo
         # @return [ Float ] average_rtt The starting average round trip time, in seconds.
         attr_reader :average_rtt
 
-        # @return [ Float ] new_rtt The new round trip time for ismaster, in seconds.
+        # @return [ Float ] new_rtt The new round trip time for hello, in seconds.
         attr_reader :new_rtt
 
         # @return [ Float ] new_average_rtt The newly calculated moving average round trip time, in seconds.

data/spec/runners/transactions/operation.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -191,8 +194,19 @@ module Mongo
 
       def assert_event_count(client, context)
         events = _select_events(context)
-        unless events.length == arguments['count']
-          raise "Exppected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
+        if %w(ServerMarkedUnknownEvent PoolClearedEvent).include?(arguments['event'])
+          # We publish SDAM events from both regular and push monitors.
+          # This means sometimes there are two ServerMarkedUnknownEvent
+          # events published for the same server transition.
+          # Allow actual event count to be at least the expected event count
+          # in case there are multiple transitions in a single test.
+          unless events.length >= arguments['count']
+            raise "Expected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
+          end
+        else
+          unless events.length == arguments['count']
+            raise "Expected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
+          end
         end
       end
 

data/spec/runners/transactions/spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/transactions/test.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -224,7 +227,7 @@ module Mongo
         end
 
         if ClusterConfig.instance.fcv_ish >= '4.2'
-          mongos_each_direct_client do |direct_client|
+          ::Utils.mongos_each_direct_client do |direct_client|
             direct_client.command(configureFailPoint: 'failCommand', mode: 'off')
           end
         end
@@ -261,7 +264,7 @@ module Mongo
 
         $distinct_ran ||= {}
         $distinct_ran[@spec.database_name] ||= if description =~ /distinct/ || @operations.any? { |op| op.name == 'distinct' }
-          mongos_each_direct_client do |direct_client|
+          ::Utils.mongos_each_direct_client do |direct_client|
             direct_client.use(@spec.database_name)['test'].distinct('foo').to_a
           end
         end
@@ -289,6 +292,7 @@ module Mongo
             client.command(configureFailPoint: fail_point_command['configureFailPoint'],
               mode: 'off')
           end
+          $disable_fail_points = nil
         end
 
         if @test_client

data/spec/runners/transactions.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/unified/assertions.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Unified
+
+  module Assertions
+
+    def assert_result_matches(actual, expected)
+      if Hash === expected
+        use_all(expected, 'expected result', expected) do |expected|
+          %w(deleted inserted matched modified upserted).each do |k|
+            if count = expected.use("#{k}Count")
+              if Hash === count || count > 0
+                actual_count = case actual
+                when Mongo::BulkWrite::Result, Mongo::Operation::Delete::Result, Mongo::Operation::Update::Result
+                  actual.send("#{k}_count")
+                else
+                  actual["n_#{k}"]
+                end
+                assert_value_matches(actual_count, count, "#{k} count")
+              end
+            end
+          end
+          %w(inserted upserted).each do |k|
+            expected_v = expected.use("#{k}Ids")
+            next unless expected_v
+            actual_v = case actual
+            when Mongo::BulkWrite::Result, Mongo::Operation::Update::Result
+              # Ruby driver returns inserted ids as an array of ids.
+              # The yaml file specifies them as a map from operation.
+              if Hash === expected_v && expected_v.keys == %w($$unsetOrMatches)
+                expected_v = expected_v.values.first.values
+              elsif Hash === expected_v
+                expected_v = expected_v.values
+              end
+              actual.send("#{k}_ids")
+            else
+              actual["#{k}_ids"]
+            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
+
+          assert_matches(actual, expected, 'result')
+          expected.clear
+        end
+      else
+        assert_matches(actual, expected, 'result')
+      end
+    end
+
+    def assert_outcome
+      return unless outcome
+
+      client = ClientRegistry.instance.global_client('authorized')
+      outcome.each do |spec|
+        spec = UsingHash[spec]
+        collection = client.use(spec.use!('databaseName'))[spec.use!('collectionName')]
+        expected_docs = spec.use!('documents')
+        actual_docs = collection.find({}, order: :_id).to_a
+        assert_documents_match(actual_docs, expected_docs)
+        unless spec.empty?
+          raise NotImplementedError, "Unhandled keys: #{spec}"
+        end
+      end
+    end
+
+    def assert_documents_match(actual, expected)
+      unless actual.length == expected.length
+        raise Error::ResultMismatch, "Unexpected number of documents: expected #{expected.length}, actual #{actual.length}"
+      end
+
+      actual.each_with_index do |document, index|
+        assert_matches(document, expected[index], "document ##{index}")
+      end
+    end
+
+    def assert_document_matches(actual, expected, msg)
+      unless actual == expected
+    p actual
+    p expected
+        raise Error::ResultMismatch, "#{msg} does not match"
+      end
+    end
+
+    def assert_events
+      return unless @expected_events
+      @expected_events.each do |spec|
+        spec = UsingHash[spec]
+        client_id = spec.use!('client')
+        client = entities.get(:client, client_id)
+        subscriber = @subscribers.fetch(client)
+        expected_events = spec.use!('events')
+        actual_events = subscriber.wanted_events(@observe_sensitive)
+        case spec.use('eventType')
+        when nil, 'command'
+          actual_events.select! do |event|
+            event.class.name.sub(/.*::/, '') =~ /^Command/
+          end
+        when 'cmap'
+          actual_events.select! do |event|
+            event.class.name.sub(/.*::/, '') =~ /^Pool/
+          end
+        end
+        unless 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|
+          assert_event_matches(actual_events[i], event)
+        end
+        unless spec.empty?
+          raise NotImplementedError, "Unhandled keys: #{spec}"
+        end
+      end
+    end
+
+    def assert_event_matches(actual, expected)
+      assert_eq(expected.keys.length, 1, "Expected event must have one key: #{expected}")
+      expected_name, spec = expected.first
+      spec = UsingHash[spec]
+      expected_name = expected_name.sub(/Event$/, '').sub(/^(.)/) { $1.upcase }
+      assert_eq(actual.class.name.sub(/.*::/, ''), expected_name, 'Event name does not match')
+      if spec.use('hasServiceId')
+        # TODO: RUBY-2654
+      end
+      if db_name = spec.use('databaseName')
+        assert_eq(actual.database_name, db_name, 'Database names differ')
+      end
+      if command_name = spec.use('commandName')
+        assert_eq(actual.command_name, command_name, 'Command names differ')
+      end
+      if command = spec.use('command')
+        assert_matches(actual.command, command, 'Commands differ')
+      end
+      if reply = spec.use('reply')
+        assert_matches(actual.reply, reply, 'Command reply does not match expectation')
+      end
+      unless spec.empty?
+        raise NotImplementedError, "Unhandled keys: #{spec}"
+      end
+    end
+
+    def assert_eq(actual, expected, msg)
+      unless expected == actual
+        raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
+      end
+    end
+
+    def assert_matches(actual, expected, msg)
+      if actual.nil? && !expected.nil?
+        raise Error::ResultMismatch, "#{msg}: expected #{expected} but got nil"
+      end
+
+      case expected
+      when Array
+        unless Array === actual
+          raise Error::ResultMismatch, "Expected an array, found #{actual}"
+        end
+        unless actual.length == expected.length
+          raise Error::ResultMismatch, "Expected array of length #{expected.length}, found array of length #{actual.length}: #{actual}"
+        end
+        expected.each_with_index do |v, i|
+          assert_matches(actual[i], v, "#{msg}: index #{i}")
+        end
+      when Hash
+        if expected.keys == %w($$unsetOrMatches) && expected.values.first.keys == %w(insertedId)
+          actual_v = actual.inserted_id
+          expected_v = expected.values.first.values.first
+          assert_value_matches(actual_v, expected_v, 'inserted_id')
+        else
+          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
+              raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
+            end
+          else
+            expected.each do |k, expected_v|
+              if k.start_with?('$$')
+                assert_value_matches(actual, expected, k)
+              else
+                actual_v = actual[k]
+                if Hash === expected_v && expected_v.length == 1 && expected_v.keys.first.start_with?('$$')
+                  assert_value_matches(actual_v, expected_v, k)
+                else
+                  assert_matches(actual_v, expected_v, "#{msg}: key #{k}")
+                end
+              end
+            end
+          end
+        end
+      else
+        if Integer === expected && BSON::Int64 === actual
+          actual = actual.value
+        end
+        unless actual == expected
+          raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
+        end
+      end
+    end
+
+    def assert_type(object, type)
+      ok = case type
+      when 'object'
+        Hash === object
+      when %w(int long)
+        Integer === object || BSON::Int32 === object || BSON::Int64 === object
+      when 'objectId'
+        BSON::ObjectId === object
+      when 'date'
+        Time === 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)
+      if Hash === expected && expected.keys.length == 1 &&
+        (operator = expected.keys.first).start_with?('$$')
+      then
+        expected_v = expected.values.first
+        case operator
+        when '$$unsetOrMatches'
+          if actual
+            unless actual == expected_v
+              raise Error::ResultMismatch, "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+            end
+          end
+        when '$$matchesHexBytes'
+          expected_data = decode_hex_bytes(expected_v)
+          unless actual == expected_data
+            raise Error::ResultMismatch, "Hex bytes do not match"
+          end
+        when '$$exists'
+          case expected_v
+          when true
+            if actual.nil?
+              raise Error::ResultMismatch, "#{msg}: wanted value to exist, but it did not"
+            end
+          when false
+            if actual
+              raise Error::ResultMismatch, "#{msg}: wanted value to not exist, but it did"
+            end
+          else
+            raise NotImplementedError, "Bogus value #{expected_v}"
+          end
+        when '$$sessionLsid'
+          expected_session = entities.get(:session, expected_v)
+          # TODO - sessions do not expose server sessions after being ended
+          #unless actual_v == {'id' => expected_session.server_session.session_id.to_bson}
+          #  raise Error::ResultMismatch, "Session does not match: wanted #{expected_session}, have #{actual_v}"
+          #end
+        when '$$type'
+          assert_type(actual, expected_v)
+        when '$$matchesEntity'
+          result = entities.get(:result, expected_v)
+          unless actual == result
+            raise Error::ResultMismatch, "Actual value #{actual} does not match entity #{expected_v} with value #{result}"
+          end
+        else
+          raise NotImplementedError, "Unknown operator #{operator}"
+        end
+      else
+        if actual != expected
+          raise Error::ResultMismatch, "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+        end
+      end
+    end
+  end
+end