mongo 2.15.1 → 2.16.0.alpha1

data/spec/mongo/uri_option_parsing_spec.rb

@@ -267,19 +267,52 @@ describe Mongo::URI do
 
   context 'connect' do
 
-    let(:string) { 'mongodb://example.com/?connect=sharded' }
+    let(:client) { new_local_client_nmio(string) }
 
-    it_behaves_like 'parses successfully'
+    shared_examples 'raises an error when client is created' do
+      it 'raises an error when client is created' do
+        lambda do
+          client
+        end.should raise_error(ArgumentError, /Invalid :connect option value/)
+      end
+    end
 
-    it 'is a symbol' do
-      expect(uri.uri_options[:connect]).to eq(:sharded)
+    %i(direct sharded replica_set load_balanced).each do |value|
+      context "#{value}" do
+        let(:string) { "mongodb://example.com/?connect=#{value}" }
+
+        it_behaves_like 'parses successfully'
+
+        it 'is a symbol' do
+          expect(uri.uri_options[:connect]).to eq(value)
+        end
+      end
+    end
+
+    %i(replica-set load-balanced).each do |value|
+      context "#{value}" do
+        let(:string) { "mongodb://example.com/?connect=#{value}" }
+
+        it_behaves_like 'parses successfully'
+
+        it 'is a symbol' do
+          expect(uri.uri_options[:connect]).to eq(value)
+        end
+
+        include_examples 'raises an error when client is created'
+      end
     end
 
     context 'invalid value' do
       let(:string) { 'mongodb://example.com/?connect=bogus' }
 
-      # should raise an error
       it_behaves_like 'parses successfully'
+
+      it 'is a symbol' do
+        expect(uri.uri_options[:connect]).to eq(:bogus)
+      end
+
+      include_examples 'raises an error when client is created'
     end
   end
 

data/spec/runners/change_streams/test.rb

@@ -89,7 +89,7 @@ module Mongo
 
         setup_fail_point(client)
 
-        @subscriber = EventSubscriber.new
+        @subscriber = Mrss::EventSubscriber.new
         client.subscribe(Mongo::Monitoring::COMMAND, @subscriber)
 
         @target = case @target_type

data/spec/runners/cmap.rb

@@ -33,7 +33,7 @@ module Mongo
       # @return [ Mongo::ConnectionPool ] pool The connection pool to use for operations.
       attr_reader :pool
 
-      # @return [ EventSubscriber ] subscriber The subscriber receiving the CMAP events.
+      # @return [ Mrss::EventSubscriber ] subscriber The subscriber receiving the CMAP events.
       attr_reader :subscriber
 
       # Instantiate the new spec.

data/spec/runners/connection_string.rb

@@ -147,10 +147,14 @@ module Mongo
         end
       end
 
-      def options
+      def expected_options
         @spec['options']
       end
 
+      def non_uri_options
+        @spec['parsed_options']
+      end
+
       def client
         @client ||= ClientRegistry.instance.new_local_client(@spec['uri'], monitoring_io: false)
       rescue Mongo::Error::LintError => e
@@ -307,14 +311,14 @@ def define_connection_string_spec_tests(test_paths, spec_cls = Mongo::Connection
               expect(test.client).to match_auth(test)
             end
 
-            if test.options
+            if test.expected_options
               it 'creates a client with the correct options' do
                 mapped = Mongo::URI::OptionsMapper.new.ruby_to_smc(test.client.options)
                 # Connection string spec tests do not use canonical URI option names
                 actual = Utils.downcase_keys(mapped)
                 actual.delete('authsource')
                 expected = Mongo::ConnectionString.adjust_expected_mongo_client_options(
-                  test.options,
+                  test.expected_options,
                 )
                 actual.should == expected
               end

data/spec/runners/crud/operation.rb

@@ -376,9 +376,11 @@ module Mongo
         arguments.merge(arguments['options'] || {}).each do |spec_k, v|
           ruby_k = ::Utils.underscore(spec_k).to_sym
 
-          if v.is_a?(Hash) && v['$numberLong']
-            v = v['$numberLong'].to_i
-          end
+          ruby_k = {
+            min: :min_value,
+            max: :max_value,
+            show_record_id: :show_disk_loc
+          }[ruby_k] || ruby_k
 
           if respond_to?("transform_#{ruby_k}", true)
             v = send("transform_#{ruby_k}", v)

data/spec/runners/crud/requirement.rb

@@ -27,6 +27,7 @@ module Mongo
               'single' => :single,
               'sharded' => :sharded,
               'sharded-replicaset' => :sharded,
+              'load-balanced' => :load_balanced,
             }[topology].tap do |v|
               unless v
                 raise "Unknown topology #{topology}"

data/spec/runners/crud.rb

@@ -96,7 +96,7 @@ def define_crud_spec_test_examples(spec, req = nil, &block)
       end
 
       let(:event_subscriber) do
-        EventSubscriber.new
+        Mrss::EventSubscriber.new
       end
 
       let(:verifier) { Mongo::CRUD::Verifier.new(test) }

data/spec/runners/sdam.rb

@@ -37,6 +37,7 @@ module Mongo
           when 'PossiblePrimary' then server.unknown?
           when 'RSGhost' then server.ghost?
           when 'RSOther' then server.other?
+          when 'LoadBalancer' then server.load_balancer?
           else
             raise "Unknown type #{type}"
         end
@@ -252,7 +253,7 @@ module Mongo
         'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
         'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
         'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening
-      }
+      }.freeze
 
       attr_reader :name
       attr_reader :data

data/spec/runners/transactions/test.rb

@@ -141,11 +141,11 @@ module Mongo
       end
 
       def command_subscriber
-        @command_subscriber ||= EventSubscriber.new
+        @command_subscriber ||= Mrss::EventSubscriber.new
       end
 
       def sdam_subscriber
-        @sdam_subscriber ||= EventSubscriber.new(name: 'sdam subscriber')
+        @sdam_subscriber ||= Mrss::EventSubscriber.new(name: 'sdam subscriber')
       end
 
       # Run the test.

data/spec/runners/unified/assertions.rb

@@ -4,6 +4,7 @@
 module Unified
 
   module Assertions
+    include RSpec::Matchers
 
     def assert_result_matches(actual, expected)
       if Hash === expected
@@ -86,8 +87,6 @@ module Unified
 
     def assert_document_matches(actual, expected, msg)
       unless actual == expected
-    p actual
-    p expected
         raise Error::ResultMismatch, "#{msg} does not match"
       end
     end
@@ -130,7 +129,7 @@ module Unified
       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
+        actual.service_id.should_not be nil
       end
       if db_name = spec.use('databaseName')
         assert_eq(actual.database_name, db_name, 'Database names differ')

data/spec/runners/unified/event_subscriber.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-require 'support/event_subscriber'
+require 'mrss/event_subscriber'
 
 module Unified
 
-  class EventSubscriber < ::EventSubscriber
+  class EventSubscriber < Mrss::EventSubscriber
     def ignore_commands(command_names)
       @ignore_commands = command_names
     end

data/spec/runners/unified/test.rb

@@ -165,6 +165,9 @@ module Unified
           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)
+          end
           database[spec.use!('collectionName'), opts]
         when 'bucket'
           database = entities.get(:database, spec.use!('database'))

data/spec/runners/unified.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
+require 'support/using_hash'
 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|

data/spec/shared/lib/mrss/constraints.rb

@@ -257,10 +257,14 @@ module Mrss
       end
     end
 
-    def require_multi_shard
+    def require_multi_mongos
       before(:all) do
         if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length == 1
-          skip 'Test requires a minimum of two shards if run in sharded topology'
+          skip 'Test requires a minimum of two mongoses if run in sharded topology'
+        end
+
+        if ClusterConfig.instance.topology == :load_balanced && SpecConfig.instance.single_mongos?
+          skip 'Test requires a minimum of two mongoses if run in load-balanced topology'
         end
       end
     end
@@ -273,17 +277,19 @@ module Mrss
     #
     # In load-balanced topology, the same problem can happen when there is
     # more than one mongos behind the load balancer.
-    def require_no_multi_shard
+    def require_no_multi_mongos
       before(:all) do
         if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length > 1
-          skip 'Test requires a single shard if run in sharded topology'
+          skip 'Test requires a single mongos if run in sharded topology'
         end
         if ClusterConfig.instance.topology == :load_balanced && !SpecConfig.instance.single_mongos?
-          skip 'Test requires a minimum of two shards if run in sharded topology'
+          skip 'Test requires a single mongos, as indicated by SINGLE_MONGOS=1 environment variable, if run in load-balanced topology'
         end
       end
     end
 
+    alias :require_no_multi_shard :require_no_multi_mongos
+
     def require_wired_tiger
       before(:all) do
         # Storage detection fails for serverless instances. However, it is safe to

data/spec/shared/lib/mrss/event_subscriber.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Mrss
+  # Test event subscriber.
+  class EventSubscriber
+
+    # The mappings of event names to types.
+    MAPPINGS = {
+      'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening,
+      'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
+      'topology_closed_event' => Mongo::Monitoring::Event::TopologyClosed,
+      'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
+      'server_description_changed_event' => Mongo::Monitoring::Event::ServerDescriptionChanged,
+      'server_closed_event' => Mongo::Monitoring::Event::ServerClosed
+    }.freeze
+
+    attr_reader :all_events
+
+    attr_reader :started_events
+
+    attr_reader :succeeded_events
+
+    attr_reader :failed_events
+
+    attr_reader :published_events
+
+    # @param [ String ] name Optional name for the event subscriber.
+    def initialize(name: nil)
+      @mutex = Mutex.new
+      clear_events!
+      @name = name
+    end
+
+    def to_s
+      %Q`#<EventSubscriber:#{@name ? "\"#{@name}\"" : '%x' % object_id} \
+  started=#{started_events.length} \
+  succeeded=#{succeeded_events.length} \
+  failed=#{failed_events.length} \
+  published=#{published_events.length}>`
+    end
+
+    alias :inspect :to_s
+
+    # Event retrieval
+
+    def select_started_events(cls)
+      started_events.select do |event|
+        event.is_a?(cls)
+      end
+    end
+
+    def select_succeeded_events(cls)
+      succeeded_events.select do |event|
+        event.is_a?(cls)
+      end
+    end
+
+    def select_completed_events(*classes)
+      (succeeded_events + failed_events).select do |event|
+        classes.any? { |c| c === event }
+      end
+    end
+
+    def select_published_events(cls)
+      published_events.select do |event|
+        event.is_a?(cls)
+      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
+
+    def non_auth_command_started_events
+      started_events.reject do |event|
+        %w(authenticate getnonce saslSstart saslContinue).any? do |cmd|
+          event.command[cmd]
+        end
+      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, include_auth: false)
+      events = if include_auth
+                 started_events
+               else
+                 non_auth_command_started_events
+               end
+      events.select! do |event|
+        event.command[command_name]
+      end
+      if events.length != 1
+        raise "Expected a single #{command_name} event but we have #{events.length}"
+      end
+      events.first
+    end
+
+
+    # Get the first succeeded event published for the name, and then delete it.
+    #
+    # @param [ String ] name The event name.
+    #
+    # @return [ Event ] The matching event.
+    def first_event(name)
+      cls = MAPPINGS[name]
+      if cls.nil?
+        raise ArgumentError, "Bogus event name #{name}"
+      end
+      matching = succeeded_events.find do |event|
+        cls === event
+      end
+      succeeded_events.delete(matching)
+      matching
+    end
+
+    # Event recording
+
+    # Cache the started event.
+    #
+    # @param [ Event ] event The event.
+    def started(event)
+      @mutex.synchronize do
+        started_events << event
+        all_events << event
+      end
+    end
+
+    # Cache the succeeded event.
+    #
+    # @param [ Event ] event The event.
+    def succeeded(event)
+      @mutex.synchronize do
+        succeeded_events << event
+        all_events << event
+      end
+    end
+
+    # Cache the failed event.
+    #
+    # @param [ Event ] event The event.
+    def failed(event)
+      @mutex.synchronize do
+        failed_events << event
+        all_events << event
+      end
+    end
+
+    def published(event)
+      @mutex.synchronize do
+        published_events << event
+        all_events << event
+      end
+    end
+
+    # Clear all cached events.
+    def clear_events!
+      @all_events = []
+      @started_events = []
+      @succeeded_events = []
+      @failed_events = []
+      @published_events = []
+      self
+    end
+  end
+  # Only handles succeeded events correctly.
+  class PhasedEventSubscriber < EventSubscriber
+    def initialize
+      super
+      @phase_events = {}
+    end
+
+    def phase_finished(phase_index)
+      @phase_events[phase_index] = succeeded_events
+      @succeeded_events = []
+    end
+
+    def phase_events(phase_index)
+      @phase_events[phase_index]
+    end
+
+    def event_count
+      @phase_events.inject(0) do |sum, event|
+        sum + event.length
+      end
+    end
+  end
+
+  class VerboseEventSubscriber < EventSubscriber
+    %w(started succeeded failed published).each do |meth|
+      define_method(meth) do |event|
+        puts event.summary
+        super(event)
+      end
+    end
+  end
+end

data/spec/shared/lib/mrss/server_version_registry.rb

@@ -48,19 +48,24 @@ module Mrss
         url = dl['archive']['url']
       end
     rescue MissingDownloadUrl
-      if %w(4.7 4.7.0).include?(desired_version)
-        # 4.7.0 has no advertised downloads but it is downloadable and
-        # we do need it. Dirty hack below.
-        registry = self.class.new('4.4.3', arch)
-        registry.download_url.sub('4.4.3', '4.7.0').tap do |url|
-          # Sanity check - ensure the URL we hacked up is a valid one
-          io = uri_open(url)
-          begin
-            io.read(1)
-          ensure
-            io.close
-          end
+      if %w(2.6 3.0).include?(desired_version) && arch == 'ubuntu1604'
+        # 2.6 and 3.0 are only available for ubuntu1204 and ubuntu1404.
+        # Those ubuntus have ancient Pythons that don't work due to not
+        # implementing recent TLS protocols.
+        # Because of this we test on ubuntu1604 which has a newer Python.
+        # But we still need to retrieve ubuntu1404-targeting builds.
+        url = self.class.new('3.2', arch).download_url
+        unless url.include?('3.2.')
+          raise 'URL not in expected format'
         end
+        url = case desired_version
+        when '2.6'
+          url.sub(/\b3\.2\.\d+/, '2.6.12')
+        when '3.0'
+          url.sub(/\b3\.2\.\d+/, '3.0.15')
+        else
+          raise NotImplementedError
+        end.sub('ubuntu1604', 'ubuntu1404')
       else
         raise
       end

data/spec/shared/share/Dockerfile.erb

@@ -68,6 +68,7 @@ FROM <%= base_image %>
   # nokogiri: zlib1g-dev
   # Mongoid testing: tzdata shared-mime-info
   # Mongoid application testing: nodejs (8.x or newer)
+  # Test suite: procps for ps (to kill JRubies)
   #
   # We currently use Python 2-compatible version of mtools, which
   # is installable via pip (which uses Python 2). All of the MongoDB
@@ -75,7 +76,7 @@ FROM <%= base_image %>
   # therefore install python-pip in all configurations here.
 
   <% packages = %w(
-    lsb-release bzip2 curl zsh
+    procps lsb-release bzip2 curl zsh
     git make gcc libyaml-0-2 libgmp-dev zlib1g-dev libsnappy-dev
     krb5-user krb5-kdc krb5-admin-server libsasl2-dev libsasl2-modules-gssapi-mit
     haproxy