mongo 2.10.5 → 2.11.0.rc0

data/spec/support/cluster_tools.rb

@@ -349,6 +349,8 @@ class ClusterTools
     end
   end
 
+  private
+
   def each_server(&block)
     admin_client.cluster.servers_list.each(&block)
   end
@@ -359,8 +361,6 @@ class ClusterTools
     end
   end
 
-  private
-
   def reset_server_states
     each_server do |server|
       server.unknown!

data/spec/support/cmap.rb

@@ -53,21 +53,17 @@ module Mongo
         preprocess
       end
 
-      def setup(cluster)
-        @subscriber = EventSubscriber.new
-
-        monitoring = Mongo::Monitoring.new(monitoring: false)
-        monitoring.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
-
-        server = Mongo::Server.new(
-            Address.new(SpecConfig.instance.addresses.first),
-            cluster,
-            monitoring,
-            Mongo::Event::Listeners.new,
-            pool_options.merge(monitoring_io: false))
-
+      def setup(server, subscriber)
+        @subscriber = subscriber
         @pool = server.pool
-        @pool.populate
+
+        # let pool populate
+        ([0.1, 0.15, 0.15] + [0.2] * 20).each do |t|
+          if @pool.size >= @pool.min_size
+            break
+          end
+          sleep t
+        end
       end
 
       def run
@@ -170,6 +166,9 @@ module Mongo
       end
 
       # Converts the options given by the spec to the Ruby driver format.
+      #
+      # This method only handles options used by spec tests at the time when
+      # this method was written. Other options are silently dropped.
       def process_options(options)
         (options || {}).reduce({}) do |opts, kv|
           case kv.first

data/spec/support/cmap/verifier.rb

@@ -27,14 +27,13 @@ module Mongo
         expect(expected).to be_a(Hash)
         expect(actual).to be_a(Hash)
 
-        actual = actual.dup
+        actual_modified = actual.dup
         if actual['reason']
-          actual['reason'] = actual['reason'].to_s.gsub(/_[a-z]/) { |m| m[1].upcase }
+          actual_modified['reason'] = actual['reason'].to_s.gsub(/_[a-z]/) { |m| m[1].upcase }
         end
 
-        actual_modified = actual.dup
-        actual_modified.each do |k, v|
-          if expected.key?(k) && expected[k] == 42
+        actual.each do |k, v|
+          if expected.key?(k) && expected[k] == 42 && v
             actual_modified[k] = 42
           end
         end

data/spec/support/command_monitoring.rb

@@ -134,11 +134,6 @@ module Mongo
         end
         if expected.keys.first == '$numberLong'
           converted = expected.values.first.to_i
-          if actual.is_a?(BSON::Int64)
-            actual = Utils.int64_value(actual)
-          elsif actual.is_a?(BSON::Int32)
-            return false
-          end
           (actual == converted) || actual >= 0
         else
           expected.each do |key, value|

data/spec/support/common_shortcuts.rb

@@ -16,6 +16,7 @@ module CommonShortcuts
     def clean_slate
       before do
         ClientRegistry.instance.close_all_clients
+        BackgroundThreadRegistry.instance.verify_empty!
       end
     end
 
@@ -25,6 +26,7 @@ module CommonShortcuts
     def clean_slate_for_all
       before(:all) do
         ClientRegistry.instance.close_all_clients
+        BackgroundThreadRegistry.instance.verify_empty!
       end
     end
 
@@ -107,7 +109,13 @@ module CommonShortcuts
       allow(cluster).to receive(:topology).and_return(topology)
       allow(cluster).to receive(:app_metadata)
       allow(cluster).to receive(:options).and_return({})
-      server = Mongo::Server.new(address, cluster, monitoring, listeners, SpecConfig.instance.test_options)
+      allow(cluster).to receive(:run_sdam_flow)
+      allow(cluster).to receive(:heartbeat_interval).and_return(10)
+      server = Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false))
+      # Since the server references a double for the cluster, the server
+      # must be closed in the scope of the example.
+      register_server(server)
       description = Mongo::Server::Description.new(address, ismaster, average_round_trip_time)
       server.tap do |s|
         allow(s).to receive(:description).and_return(description)
@@ -138,5 +146,97 @@ module CommonShortcuts
         'ok' => 0, 'code' => 91, 'errmsg' => 'shutdown in progress'
       )
     end
+
+    def register_cluster(cluster)
+      finalizer = lambda do |cluster|
+        cluster.disconnect!
+      end
+      LocalResourceRegistry.instance.register(cluster, finalizer)
+    end
+
+    def register_server(server)
+      finalizer = lambda do |server|
+        if server.connected?
+          server.disconnect!
+        end
+      end
+      LocalResourceRegistry.instance.register(server, finalizer)
+    end
+
+    def register_background_thread_object(bgt_object)
+      finalizer = lambda do |bgt_object|
+        bgt_object.stop!
+      end
+      LocalResourceRegistry.instance.register(bgt_object, finalizer)
+    end
+
+    def register_pool(pool)
+      finalizer = lambda do |pool|
+        if !pool.closed?
+          pool.close(wait: true)
+        end
+      end
+      LocalResourceRegistry.instance.register(pool, finalizer)
+    end
+
+    # Stop monitoring threads on the specified clients, after ensuring
+    # each client has a writable server. Used for tests which assert on
+    # global side effects like log messages being generated, to prevent
+    # background threads from interfering with assertions.
+    def stop_monitoring(*clients)
+      clients.each do |client|
+        client.cluster.next_primary
+        client.cluster.disconnect!
+      end
+    end
+
+    DNS_INTERFACES = [
+      [:udp, "0.0.0.0", 5300],
+      [:tcp, "0.0.0.0", 5300],
+    ]
+
+    def mock_dns(config)
+      semaphore = Mongo::Semaphore.new
+
+      thread = Thread.new do
+        RubyDNS::run_server(DNS_INTERFACES) do
+          config.each do |(query, type, *answers)|
+
+            resource_cls = Resolv::DNS::Resource::IN.const_get(type.to_s.upcase)
+            resources = answers.map do |answer|
+              resource_cls.new(*answer)
+            end
+            match(query, resource_cls) do |req|
+              req.add(resources)
+            end
+          end
+
+          semaphore.signal
+        end
+      end
+
+      semaphore.wait
+
+      begin
+        yield
+      ensure
+        10.times do
+          if $last_async_task
+            break
+          end
+          sleep 0.5
+        end
+
+        # Hack to stop the server - https://github.com/socketry/rubydns/issues/75
+        if $last_async_task.nil?
+          STDERR.puts "No async task - server never started?"
+        else
+          $last_async_task.stop
+        end
+
+        thread.kill
+        thread.join
+      end
+    end
   end
 end

data/spec/support/constraints.rb

@@ -158,6 +158,14 @@ module Constraints
     end
   end
 
+  def require_multi_shard
+    before do
+      if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length == 1
+        skip 'Test requires a minimum of two shards if run in sharded topology'
+      end
+    end
+  end
+
   def require_no_multi_shard
     before do
       if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length > 1
@@ -191,4 +199,21 @@ module Constraints
       end
     end
   end
+
+  # Integration tests for SRV polling require internet connectivity to
+  # look up SRV records and a sharded cluster configured on default port on
+  # localhost (localhost:27017, localhost:27018).
+  def require_default_port_deployment
+    # Because the DNS records at test1.test.build.10gen.cc point to
+    # localhost:27017 & localhost:27018, the test suite must have been
+    # configured to use these addresses
+    before(:all) do
+      have_default_port = SpecConfig.instance.addresses.any? do |address|
+        %w(127.0.0.1 127.0.0.1:27017 localhost localhost:27017).include?(address)
+      end
+      unless have_default_port
+        skip 'This test requires the test suite to be configured for localhost:27017'
+      end
+    end
+  end
 end

data/spec/support/dns.rb

@@ -0,0 +1,13 @@
+require 'rubydns'
+
+# Hack to stop the server - https://github.com/socketry/rubydns/issues/75
+module Async
+  class Task
+    alias :run_without_record :run
+    def run(*args)
+      run_without_record.tap do
+        $last_async_task = self
+      end
+    end
+  end
+end

data/spec/support/event_subscriber.rb

@@ -44,13 +44,6 @@ class EventSubscriber
       end
     end
 
-    # Filters command started events for the specified command name.
-    def command_started_events(command_name)
-      started_events.select do |event|
-        event.command[command_name]
-      end
-    end
-
     # Locates command stated events for the specified command name,
     # asserts that there is exactly one such event, and returns it.
     def single_command_started_event(command_name)

data/spec/support/json_ext_formatter.rb

@@ -1,8 +1,12 @@
 class JsonExtFormatter < RSpec::Core::Formatters::JsonFormatter
-  RSpec::Core::Formatters.register self, :message, :dump_summary, :dump_profile, :stop, :seed, :close
+  RSpec::Core::Formatters.register self, :message,
+    :dump_summary, :dump_profile, :stop, :seed, :close
 
   def format_example(example)
     super.tap do |hash|
+      # Time format is chosen to be the same as driver's log entries
+      hash[:started_at] = example.execution_result.started_at.strftime('%Y-%m-%d %H:%M:%S.%L %z')
+      hash[:finished_at] = example.execution_result.finished_at.strftime('%Y-%m-%d %H:%M:%S.%L %z')
       hash[:sdam_log_entries] = SdamFormatterIntegration.example_log_entries(example.id)
     end
   end

data/spec/support/lite_constraints.rb

@@ -1,7 +1,7 @@
 module LiteConstraints
   # Constrain tests that use TimeoutInterrupt to MRI (and Unix)
   def only_mri
-    before do
+    before(:all) do
       unless SpecConfig.instance.mri?
         skip "MRI required, we have #{SpecConfig.instance.platform}"
       end
@@ -12,22 +12,38 @@ module LiteConstraints
   # in principle work (as opposed to being fundamentally incompatible
   # with jruby).
   # Often times these failures happen only in Evergreen.
-  def fails_on_jruby
-    before do
-      unless SpecConfig.instance.mri?
-        skip "Fails on jruby"
+  def fails_on_jruby(version=nil)
+    before(:all) do
+      if BSON::Environment.jruby?
+        if version
+          min_parts = version.split('.').map(&:to_i)
+          actual_parts = JRUBY_VERSION.split('.').map(&:to_i)[0...min_parts.length]
+          actual = actual_parts.join('.')
+          if actual <= version
+            skip "Fails on jruby through #{version}"
+          end
+        else
+          skip "Fails on jruby"
+        end
       end
     end
   end
 
   def require_external_connectivity
-    before do
+    before(:all) do
       if ENV['EXTERNAL_DISABLED']
         skip "Test requires external connectivity"
       end
     end
   end
 
+  def require_mongo_kerberos
+    before(:all) do
+      skip 'KERBEROS_REQUIRED env var not specified' unless ENV['KERBEROS_REQUIRED']
+      require 'mongo_kerberos'
+    end
+  end
+
   def require_linting
     before do
       unless Mongo::Lint.enabled?

data/spec/support/local_resource_registry.rb

@@ -0,0 +1,34 @@
+require 'singleton'
+
+class LocalResourceRegistry
+  include Singleton
+
+  def initialize
+    @resources = []
+  end
+
+  def register(resource, finalizer)
+    @resources << [resource, finalizer]
+    # Return resource for chaining
+    resource
+  end
+
+  def unregister(resource)
+    @resources.delete_if do |_resource, finalizer|
+      _resource == resource
+    end
+  end
+
+  def close_all
+    @resources.each do |resource, finalizer|
+      if finalizer.is_a?(Symbol)
+        resource.send(finalizer)
+      elsif finalizer.is_a?(Proc)
+        finalizer.call(resource)
+      else
+        raise "Unknown finalizer: #{finalizer}"
+      end
+    end
+    @resources = []
+  end
+end

data/spec/support/sdam_monitoring.rb

@@ -13,8 +13,123 @@
 # limitations under the License.
 #
 
+RSpec::Matchers.define :match_topology_opening_event do |expectation|
+
+  match do |event|
+    event.is_a?(Mongo::Monitoring::Event::TopologyOpening) &&
+      event.topology != nil
+  end
+end
+
+RSpec::Matchers.define :match_topology_description_changed_event do |expectation|
+  include Mongo::SDAMMonitoring::Matchable
+
+  match do |event|
+    event.is_a?(Mongo::Monitoring::Event::TopologyChanged) &&
+      topologies_match?(event, expectation)
+  end
+end
+
+RSpec::Matchers.define :match_server_opening_event do |expectation|
+
+  match do |event|
+    event.is_a?(Mongo::Monitoring::Event::ServerOpening) &&
+      event.address.to_s == expectation.data['address']
+  end
+end
+
+RSpec::Matchers.define :match_server_description_changed_event do |expectation|
+  include Mongo::SDAMMonitoring::Matchable
+
+  match do |event|
+    event.is_a?(Mongo::Monitoring::Event::ServerDescriptionChanged) &&
+      descriptions_match?(event, expectation)
+  end
+end
+
+RSpec::Matchers.define :match_server_closed_event do |expectation|
+
+  match do |event|
+    event.is_a?(Mongo::Monitoring::Event::ServerClosed) &&
+      event.address.to_s == expectation.data['address']
+  end
+end
+
+RSpec::Matchers.define :match_sdam_monitoring_event do |expectation|
+
+  match do |event|
+    expect(event).to send("match_#{expectation.name}", expectation)
+  end
+end
+
 module Mongo
   module SDAMMonitoring
+    module Matchable
+
+      def descriptions_match?(event, expectation)
+        description_matches?(event.previous_description, expectation.data['previousDescription']) &&
+          description_matches?(event.new_description, expectation.data['newDescription'])
+      end
+
+      def topologies_match?(event, expectation)
+        unless topology_matches?(event.previous_topology, expectation.data['previousDescription'])
+          if ENV['VERBOSE_MATCHERS']
+            $stderr.puts "Previous topology mismatch"
+          end
+          return false
+        end
+        unless topology_matches?(event.new_topology, expectation.data['newDescription'])
+          if ENV['VERBOSE_MATCHERS']
+            $stderr.puts "New topology mismatch:\nHave: #{event.new_topology}\nWant: #{expectation.data['newDescription']}"
+          end
+          return false
+        end
+        true
+      end
+
+      def description_matches?(actual, expected)
+        type_ok = case expected['type']
+          when 'Standalone' then actual.standalone?
+          when 'RSPrimary' then actual.primary?
+          when 'RSSecondary' then actual.secondary?
+          when 'RSArbiter' then actual.arbiter?
+          when 'Mongos' then actual.mongos?
+          when 'Unknown' then actual.unknown?
+          when 'PossiblePrimary' then actual.unknown?
+          when 'RSGhost' then actual.ghost?
+          when 'RSOther' then actual.other?
+        end
+        return false unless type_ok
+
+        return false if actual.address.to_s != expected['address']
+        return false if actual.arbiters != expected['arbiters']
+        return false if actual.hosts != expected['hosts']
+        return false if actual.passives != expected['passives']
+        return false if actual.primary_host != expected['primary']
+        return false if actual.replica_set_name != expected['setName']
+        true
+      end
+
+      def topology_matches?(actual, expected)
+        expected_type = ::Mongo::Cluster::Topology.const_get(expected['topologyType'])
+        return false unless actual.is_a?(expected_type)
+
+        return false unless actual.replica_set_name == expected['setName']
+
+        expected['servers'].each do |server|
+          desc = actual.server_descriptions[server['address'].to_s]
+          return false unless description_matches?(desc, server)
+        end
+
+        actual.server_descriptions.keys.each do |address_str|
+          unless expected['servers'].any? { |server| server['address'] == address_str }
+            return false
+          end
+        end
+
+        true
+      end
+    end
 
     # Test subscriber for SDAM monitoring.
     #