mongo 2.14.0 → 2.15.0.alpha

data/spec/mongo/server/monitor_spec.rb

@@ -17,6 +17,12 @@ describe Mongo::Server::Monitor 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)
@@ -32,7 +38,9 @@ describe Mongo::Server::Monitor do
   let(:monitor) do
     register_background_thread_object(
       described_class.new(server, listeners, Mongo::Monitoring.new,
-        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options))
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
     )
   end
 

data/spec/mongo/server_spec.rb

@@ -40,12 +40,20 @@ describe Mongo::Server do
     )
   end
 
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
   shared_context 'with monitoring io' do
     let(:server_options) do
       {monitoring_io: true}
     end
 
     before do
+      allow(cluster).to receive(:monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:push_monitor_app_metadata).and_return(monitor_app_metadata)
       allow(cluster).to receive(:heartbeat_interval).and_return(1000)
     end
   end
@@ -144,8 +152,13 @@ describe Mongo::Server do
       expect(server.options[:monitoring_io]).to be true
     end
 
-    it 'creates monitor with monitoring app metadata' do
-      expect(server.monitor.options[:app_metadata]).to be_a(Mongo::Server::Monitor::AppMetadata)
+    context 'with monitoring app metadata option' do
+      require_no_required_api_version
+
+      it 'creates monitor with monitoring app metadata' do
+        server.monitor.scan!
+        expect(server.monitor.connection.options[:app_metadata]).to be monitor_app_metadata
+      end
     end
 
     context 'monitoring_io: false' do

data/spec/mongo/socket/ssl_spec.rb

@@ -50,6 +50,46 @@ describe Mongo::Socket::SSL, retry: 3 do
   end
 
   describe '#connect!' do
+    context 'when TLS context hooks are provided' do
+      # https://github.com/jruby/jruby-openssl/issues/221
+      fails_on_jruby
+
+      let(:proc) do
+        Proc.new do |context|
+          if BSON::Environment.jruby?
+            context.ciphers = ["AES256-SHA256"]
+          else
+            context.ciphers = ["AES256-SHA"]
+          end
+        end
+      end
+
+      before do
+        Mongo.tls_context_hooks = [ proc ]
+      end
+
+      after do
+        Mongo.tls_context_hooks.clear
+      end
+
+      it 'runs the TLS context hook before connecting' do
+        if ENV['OCSP_ALGORITHM']
+          skip "OCSP configurations use different certificates which this test does not handle"
+        end
+
+        expect(proc).to receive(:call).and_call_original
+        socket
+        # Even though we are requesting a single cipher in the hook,
+        # there may be multiple ciphers available in the context.
+        # All of the ciphers should match the requested one (using
+        # OpenSSL's idea of what "match" means).
+        socket.context.ciphers.each do |cipher|
+          unless cipher.first =~ /SHA256/ || cipher.last == 256
+            raise "Unexpected cipher #{cipher} after requesting SHA-256"
+          end
+        end
+      end
+    end
 
     context 'when a certificate is provided' do
 

data/spec/mongo/socket_spec.rb

@@ -48,7 +48,7 @@ describe Mongo::Socket do
         socket.send(:map_exceptions) do
           raise OpenSSL::SSL::SSLError.new('Test error')
         end
-      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with TLS support)')
+      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address)')
     end
   end
 
@@ -86,7 +86,7 @@ describe Mongo::Socket do
 
           expect do
             socket.read(10)
-          end.to raise_error(Mongo::Error::SocketTimeoutError, /Took more than .* seconds to receive data \(for /)
+          end.to raise_error(Mongo::Error::SocketTimeoutError, /Took more than .* seconds to receive data.*\(for /)
         end
       end
 

data/spec/mongo/tls_context_hooks_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Mongo do
+  before do
+    Mongo.tls_context_hooks.clear
+  end
+
+  describe '#tls_context_hooks' do
+    it 'returns an array' do
+      expect(Mongo.tls_context_hooks).to eq([])
+    end
+  end
+
+  describe '#tls_context_hooks=' do
+    context 'when argument is not an array' do
+      it 'raises an ArgumentError' do
+        expect do
+          Mongo.tls_context_hooks = "Hello"
+        end.to raise_error(ArgumentError, /TLS context hooks must be an array of Procs/)
+      end
+    end
+
+    context 'when argument is an array not containing procs' do
+      it 'raises an ArgumentError' do
+        expect do
+          Mongo.tls_context_hooks = [1, 2, 3]
+        end.to raise_error(ArgumentError, /TLS context hooks must be an array of Procs/)
+      end
+    end
+
+    it 'saves the provided hooks' do
+      Mongo.tls_context_hooks = [ Proc.new { |x| x ** 2 } ]
+      expect(Mongo.tls_context_hooks.length).to eq(1)
+      expect(Mongo.tls_context_hooks.first).to be_a(Proc)
+    end
+  end
+end

data/spec/runners/connection_string.rb

@@ -235,10 +235,6 @@ module Mongo
           if k.downcase == 'authmechanismproperties'
             expected[k] = ::Utils.downcase_keys(v)
           end
-          # Ruby driver does not support snappy.
-          if k == 'compressors'
-            expected[k] = v.reject { |sub_v| sub_v == 'snappy' }
-          end
         end
         # We omit retryReads/retryWrites=true because some tests do not
         # provide those.

data/spec/runners/crud/requirement.rb

@@ -1,18 +1,39 @@
 module Mongo
   module CRUD
     class Requirement
-      YAML_KEYS = %w(minServerVersion maxServerVersion topology).freeze
+      YAML_KEYS = %w(minServerVersion maxServerVersion topology topologies serverParameters).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']
       end
 
       attr_reader :min_server_version
@@ -47,6 +68,22 @@ 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
         ok
       end
 

data/spec/runners/crud/verifier.rb

@@ -193,6 +193,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/transactions/operation.rb

@@ -191,8 +191,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/test.rb

@@ -289,6 +289,7 @@ module Mongo
             client.command(configureFailPoint: fail_point_command['configureFailPoint'],
               mode: 'off')
           end
+          $disable_fail_points = nil
         end
 
         if @test_client

data/spec/runners/unified.rb

@@ -0,0 +1,96 @@
+require 'runners/unified/error'
+require 'runners/unified/entity_map'
+require 'runners/unified/event_subscriber'
+require 'runners/unified/test'
+require 'runners/unified/test_group'
+require 'runners/unified/using_hash'
+
+def define_unified_spec_tests(base_path, paths, expect_failure: false)
+  paths.each do |path|
+    basename = path[base_path.length+1...path.length]
+    context basename do
+      group = Unified::TestGroup.new(path)
+
+      if basename =~ /retryable|transaction/
+        require_wired_tiger
+      end
+
+      group.tests.each do |test|
+        context test.description do
+
+          if test.skip?
+            before do
+              skip test.skip_reason
+            end
+          end
+
+          before(:all) do
+            if SpecConfig.instance.retry_reads == false
+              skip "Tests are not applicable when legacy read retries are used"
+            end
+            if SpecConfig.instance.retry_writes == false
+              skip "Tests are not applicable when legacy write retries are used"
+            end
+
+            if ClusterConfig.instance.topology == :sharded
+              if test.require_multiple_mongoses? && SpecConfig.instance.addresses.length == 1
+                skip "Test requires multiple mongoses"
+              elsif test.require_single_mongos? && SpecConfig.instance.addresses.length > 1
+                # Many transaction spec tests that do not specifically deal with
+                # sharded transactions fail when run against a multi-mongos cluster
+                skip "Test requires single mongos"
+              end
+            end
+          end
+
+          if expect_failure
+            it 'fails as expected' do
+              if test.group_reqs
+                unless test.group_reqs.any? { |r| r.satisfied? }
+                  skip "Group requirements not satisfied"
+                end
+              end
+              if test.reqs
+                unless test.reqs.any? { |r| r.satisfied? }
+                  skip "Requirements not satisfied"
+                end
+              end
+              begin
+                test.create_entities
+                test.set_initial_data
+                lambda do
+                  test.run
+                  test.assert_outcome
+                  test.assert_events
+                # HACK: other errors are possible and likely will need to
+                # be added here later as the tests evolve.
+                end.should raise_error(Mongo::Error::OperationFailure)
+              ensure
+                test.cleanup
+              end
+            end
+          else
+            it 'passes' do
+              if test.group_reqs
+                unless test.group_reqs.any? { |r| r.satisfied? }
+                  skip "Group requirements not satisfied"
+                end
+              end
+              if test.reqs
+                unless test.reqs.any? { |r| r.satisfied? }
+                  skip "Requirements not satisfied"
+                end
+              end
+              test.create_entities
+              test.set_initial_data
+              test.run
+              test.assert_outcome
+              test.assert_events
+              test.cleanup
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/runners/unified/assertions.rb

@@ -0,0 +1,249 @@
+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
+                  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
+        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
+      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 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
+    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
+          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
+      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