mongo 2.11.2 → 2.13.0.beta1

data/spec/mongo/write_concern_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::WriteConcern do
 
@@ -194,6 +194,18 @@ describe Mongo::WriteConcern do
           expect(wc).to be_a(Mongo::WriteConcern::Unacknowledged)
           expect(wc.options[:w]).to eq(0)
         end
+
+        context 'and j is true' do
+          let(:options) do
+            { 'w' => 0, j: true }
+          end
+
+          it 'raises an exception' do
+            expect do
+              wc
+            end.to raise_error(Mongo::Error::InvalidWriteConcern, /:j cannot be true when :w is 0/)
+          end
+        end
       end
     end
 

data/spec/{support → runners}/auth.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,7 +13,20 @@
 # limitations under the License.
 RSpec::Matchers.define :have_blank_credentials do
   match do |client|
-    %i(auth_mech auth_mech_properties auth_source password user).all? do |key|
+    # The "null credential" definition in auth spec tests readme at
+    # https://github.com/mongodb/specifications/blob/master/source/auth/tests/README.rst
+    # is as follows:
+    #
+    # credential: If null, the credential must not be considered configured
+    # for the the purpose of deciding if the driver should authenticate to the
+    # topology.
+    #
+    # Ruby driver authenticates if :user or :auth_mech client options are set.
+    #
+    # Note that this is a different test from "no auth-related options are
+    # set on the client". Options like password or auth source are preserved
+    # by the client if set, but do not trigger authentication.
+    %i(auth_mech user).all? do |key|
       client.options[key].nil?
     end
   end
@@ -78,7 +91,10 @@ module Mongo
         end
 
         if credential['mechanism_properties']
-          expected_credential['auth_mech_properties'] = expected_auth_mech_properties
+          props = Hash[credential['mechanism_properties'].map do |k, v|
+            [k.downcase, v]
+          end]
+          expected_credential['auth_mech_properties'] = props
         end
 
         expected_credential
@@ -95,10 +111,6 @@ module Mongo
       def expected_auth_mech
         Mongo::URI::AUTH_MECH_MAP[credential['mechanism']]
       end
-
-      def expected_auth_mech_properties
-        credential['mechanism_properties'].keys.map(&:downcase)
-      end
     end
   end
 end

data/spec/runners/change_streams/outcome.rb

@@ -0,0 +1,42 @@
+# Copyright (C) 2014-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  module ChangeStreams
+    class Outcome
+      def initialize(spec)
+        if spec.nil?
+          raise ArgumentError, 'Outcome specification cannot be nil'
+        end
+        if spec.keys.length != 1
+          raise ArgumentError, 'Outcome must have exactly one key: success or error'
+        end
+        if spec['success']
+          @documents = spec['success']
+        elsif spec['error']
+          @error = spec['error']
+        else
+          raise ArgumentError, 'Outcome must have exactly one key: success or error'
+        end
+      end
+
+      attr_reader :documents
+      attr_reader :error
+
+      def error?
+        !!error
+      end
+    end
+  end
+end

data/spec/runners/change_streams/spec.rb

@@ -0,0 +1,57 @@
+# Copyright (C) 2014-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'runners/change_streams/test'
+
+module Mongo
+  module ChangeStreams
+    class Spec
+
+      # @return [ String ] description The spec description.
+      #
+      # @since 2.6.0
+      attr_reader :description
+
+      # Instantiate the new spec.
+      #
+      # @param [ String ] test_path The path to the file.
+      #
+      # @since 2.6.0
+      def initialize(test_path)
+        @spec = YAML.load(File.read(test_path))
+        @description = File.basename(test_path)
+        @spec_tests = @spec['tests']
+        @collection_name = @spec['collection_name']
+        @collection2_name = @spec['collection2_name']
+        @database_name = @spec['database_name']
+        @database2_name = @spec['database2_name']
+      end
+
+      # Get a list of ChangeStreamsTests for each test definition.
+      #
+      # @example Get the list of ChangeStreamsTests.
+      #   spec.tests
+      #
+      # @return [ Array<ChangeStreamsTest> ] The list of ChangeStreamsTests.
+      #
+      # @since 2.0.0
+      def tests
+        @spec_tests.map do |test|
+          ChangeStreamsTest.new(self, test,
+            @collection_name, @collection2_name, @database_name, @database2_name)
+        end
+      end
+    end
+  end
+end

data/spec/runners/change_streams/test.rb

@@ -0,0 +1,229 @@
+# Copyright (C) 2014-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'runners/crud/operation'
+require 'runners/crud/test_base'
+require 'runners/change_streams/outcome'
+
+module Mongo
+  module ChangeStreams
+
+    class ChangeStreamsTest < Mongo::CRUD::CRUDTestBase
+
+      def initialize(crud_spec, test, collection_name, collection2_name, database_name, database2_name)
+        @spec = crud_spec
+        @description = test['description']
+
+        @fail_point_command = test['failPoint']
+
+        @min_server_version = test['minServerVersion']
+        @max_server_version = test['maxServerVersion']
+        @target_type = test['target']
+        @topologies = test['topology'].map do |topology|
+          {'single' => :single, 'replicaset' => :replica_set, 'sharded' => :sharded}[topology]
+        end
+        @pipeline = test['changeStreamPipeline'] || []
+        @options = test['changeStreamOptions'] || {}
+
+        @operations = test['operations'].map do |op|
+          Mongo::CRUD::Operation.new(self, op)
+        end
+
+        @expectations = test['expectations'] &&
+          BSON::ExtJSON.parse_obj(test['expectations'], mode: :bson)
+
+        @result = BSON::ExtJSON.parse_obj(test['result'], mode: :bson)
+        @collection_name = collection_name
+        @collection2_name = collection2_name
+        @database_name = database_name
+        @database2_name = database2_name
+
+        @outcome = Outcome.new(test.fetch('result'))
+      end
+
+      attr_reader :topologies
+
+      attr_reader :outcome
+
+      attr_reader :result
+
+      def setup_test
+        clear_fail_point(global_client)
+
+        @database = global_client.use(@database_name).database.tap(&:drop)
+        if @database2_name
+          @database2 = global_client.use(@database2_name).database.tap(&:drop)
+        end
+
+        # Work around https://jira.mongodb.org/browse/SERVER-17397
+        if ClusterConfig.instance.server_version < '4.3' &&
+          global_client.cluster.servers.length > 1
+        then
+          mongos_each_direct_client do |client|
+            client.database.command(flushRouterConfig: 1)
+          end
+        end
+
+        @database[@collection_name].create
+        if @collection2_name
+          @database2[@collection2_name].create
+        end
+
+        client = ClientRegistry.instance.global_client('root_authorized').with(
+          database: @database_name,
+          app_name: 'this is used solely to force the new client to create its own cluster')
+
+        setup_fail_point(client)
+
+        @subscriber = EventSubscriber.new
+        client.subscribe(Mongo::Monitoring::COMMAND, @subscriber)
+
+        @target = case @target_type
+                 when 'client'
+                   client
+                 when 'database'
+                   client.database
+                 when 'collection'
+                   client[@collection_name]
+                 end
+      end
+
+      def teardown_test
+        if @fail_point_command
+          clear_fail_point(global_client)
+        end
+      end
+
+      def run
+        change_stream = begin
+          @target.watch(@pipeline, Utils.snakeize_hash(@options))
+        rescue Mongo::Error::OperationFailure => e
+          return {
+            result: {
+              error: {
+                code: e.code,
+                labels: e.labels,
+              },
+            },
+            events: events,
+          }
+        end
+
+        # JRuby must iterate the same object, not switch from
+        # enum to change stream
+        enum = change_stream.to_enum
+
+        @operations.each do |op|
+          db = case op.spec['database']
+            when @database_name
+              @database
+            when @database2_name
+              @database2
+            else
+              raise "Unknown database name #{op.spec['database']}"
+            end
+          collection = db[op.spec['collection']]
+          op.execute(collection)
+        end
+
+        changes = []
+
+        # attempt first next call (catch NonResumableChangeStreamError errors)
+        begin
+          change = enum.next
+          changes << change
+        rescue Mongo::Error::OperationFailure => e
+          return {
+            result: {
+              error: {
+                code: e.code,
+                labels: e.labels,
+              },
+            },
+            events: events,
+          }
+        end
+
+        # continue until changeStream has received as many changes as there
+        # are in result.success
+        if @result['success'] && changes.length < @result['success'].length
+          while changes.length < @result['success'].length
+            changes << enum.next
+          end
+        end
+
+        change_stream.close
+
+        {
+          result: { 'success' => changes },
+          events: events,
+        }
+      end
+
+      def server_version_satisfied?(client)
+        lower_bound_satisfied?(client) && upper_bound_satisfied?(client)
+      end
+
+      private
+
+      IGNORE_COMMANDS = %w(saslStart saslContinue killCursors)
+
+      def global_client
+        @global_client ||= ClientRegistry.instance.global_client('root_authorized').use('admin')
+      end
+
+      def events
+        @subscriber.started_events.reduce([]) do |evs, e|
+          next evs if IGNORE_COMMANDS.include?(e.command_name)
+
+          command = e.command.dup
+          if command['aggregate'] && command['pipeline']
+            command['pipeline'] = command['pipeline'].map do |stage|
+              if stage['$changeStream']
+                cs = stage['$changeStream'].dup
+                cs.delete('resumeAfter')
+                stage.merge('$changeStream' => cs)
+              else
+                stage
+              end
+            end
+          end
+
+          evs << {
+            'command_started_event' => {
+              'command' => command,
+              'command_name' => e.command_name.to_s,
+              'database_name' => e.database_name,
+            }
+          }
+        end
+      end
+
+      def server_version(client)
+        @server_version ||= client.database.command(buildInfo: 1).first['version']
+      end
+
+      def upper_bound_satisfied?(client)
+        return true unless @max_server_version
+        ClusterConfig.instance.server_version <= @max_server_version
+      end
+
+      def lower_bound_satisfied?(client)
+        return true unless @min_server_version
+        #@min_server_version <= server_version(client)
+        @min_server_version <= ClusterConfig.instance.fcv_ish
+      end
+    end
+  end
+end

data/spec/{support → runners}/cmap.rb

@@ -1,4 +1,4 @@
-require 'support/cmap/verifier'
+require 'runners/cmap/verifier'
 
 module Mongo
   module Cmap

data/spec/{support → runners}/cmap/verifier.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 MongoDB, Inc.
+# Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/spec/{support → runners}/command_monitoring.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -135,7 +135,7 @@ module Mongo
         if expected.keys.first == '$numberLong'
           converted = expected.values.first.to_i
           if actual.is_a?(BSON::Int64)
-            actual = actual.value
+            actual = Utils.int64_value(actual)
           elsif actual.is_a?(BSON::Int32)
             return false
           end

data/spec/runners/connection_string.rb

@@ -1,7 +1,362 @@
+# Copyright (C) 2014-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+RSpec::Matchers.define :have_hosts do |test, hosts|
+
+  match do |cl|
+
+    def find_server(client, host)
+      client.cluster.servers_list.detect do |s|
+        if host.port
+          s.address.host == host.host && s.address.port == host.port
+        else
+          s.address.host == host.host
+        end
+      end
+    end
+
+    def match_host?(server, host)
+      server.address.host == host.host
+    end
+
+    def match_port?(server, host)
+      server.address.port == host.port || !host.port
+    end
+
+    def match_address_family?(server, host)
+      address_family(server) == host.address_family
+    end
+
+    def address_family(server)
+      server.address.socket(2)
+      server.address.instance_variable_get(:@resolver).class
+    end
+
+    hosts.all? do |host|
+      server = find_server(cl, host)
+      server &&
+        match_host?(server, host) &&
+        match_port?(server, host) #&&
+        #match_address_family?(server, host)
+    end
+  end
+
+  failure_message do |client|
+    "With URI: #{test.uri_string}\n" +
+        "Expected client hosts: #{client.cluster.instance_variable_get(:@servers)} " +
+        "to match #{hosts}"
+  end
+end
+
+RSpec::Matchers.define :match_auth do |test|
+
+  def match_database?(client, auth)
+    client.options[:database] == auth.database || !auth.database
+  end
+
+  def match_password?(client, auth)
+    client.options[:password] == auth.password ||
+      client.options[:password].nil? && auth.password == ''
+  end
+
+  match do |client|
+    auth = test.auth
+    return true unless auth
+    client.options[:user] == auth.username &&
+      match_password?(client, auth) &&
+        match_database?(client, auth)
+  end
+
+  failure_message do |client|
+    "With URI: #{test.uri_string}\n" +
+        "Expected that test auth: #{test.auth} would match client auth: #{client.options}"
+  end
+end
+
+RSpec::Matchers.define :match_options do |test|
+
+  match do |client|
+    options = test.options
+    return true unless options
+    options.match?(client.options)
+  end
+
+  failure_message do |client|
+    "With URI: #{test.uri_string}\n" +
+      "Expected that test options: #{test.options.options} would match client options: #{client.options}"
+  end
+end
+
+module Mongo
+  module ConnectionString
+
+    class Spec
+
+      attr_reader :description
+
+      # Instantiate the new spec.
+      #
+      # @param [ String ] test_path The path to the file.
+      #
+      # @since 2.0.0
+      def initialize(test_path)
+        @spec = YAML.load(File.read(test_path))
+        @description = File.basename(test_path)
+      end
+
+      def tests
+        @tests ||= @spec['tests'].collect do |spec|
+          Test.new(spec)
+        end
+      end
+    end
+
+    class Test
+      include RSpec::Core::Pending
+
+      attr_reader :description
+      attr_reader :uri_string
+
+      def initialize(spec)
+        @spec = spec
+        @description = @spec['description']
+        @uri_string = @spec['uri']
+      end
+
+      def valid?
+        @spec['valid']
+      end
+
+      def warn?
+        @spec['warning']
+      end
+
+      def hosts
+        @hosts ||= (@spec['hosts'] || []).collect do |host|
+          Host.new(host)
+        end
+      end
+
+      def seeds
+        if @spec['seeds']
+          @seeds ||= (@spec['seeds'] || []).collect do |host|
+            Host.new(host)
+          end
+        else
+          nil
+        end
+      end
+
+      def options
+        @options ||= Options.new(@spec['options']) if @spec['options']
+      end
+
+      def client
+        @client ||= ClientRegistry.instance.new_local_client(@spec['uri'], monitoring_io: false)
+      rescue Mongo::Error::LintError => e
+        if e.message =~ /arbitraryButStillValid/
+          skip 'Test uses a read concern that fails linter'
+        end
+      end
+
+      def uri
+        @uri ||= Mongo::URI.get(@spec['uri'])
+      end
+
+      def auth
+        @auth ||= Auth.new(@spec['auth']) if @spec['auth']
+      end
+
+      def raise_error?
+        @spec['error']
+      end
+
+      def read_concern_expectation
+        @spec['readConcern']
+      end
+
+      def write_concern_expectation
+        @spec['writeConcern']
+      end
+    end
+
+    class Host
+
+      MAPPING = {
+          'ipv4' => Mongo::Address::IPv4,
+          'ipv6' => Mongo::Address::IPv6,
+          'unix' => Mongo::Address::Unix
+      }
+
+      attr_reader :host
+      attr_reader :port
+
+      def initialize(spec)
+        if spec.is_a?(Hash)
+          # Connection string spec tests
+          @spec = spec
+          @host = @spec['host']
+          @port = @spec['port']
+        else
+          # DNS seed list spec tests
+          address = Mongo::Address.new(spec)
+          @host = address.host
+          @port = address.port
+        end
+      end
+
+      def address_family
+        MAPPING[@spec['type']]
+      end
+    end
+
+    class Auth
+
+      attr_reader :username
+      attr_reader :password
+      attr_reader :database
+
+      def initialize(spec)
+        @spec = spec
+        @username = @spec['username']
+        @password = @spec['password']
+        @database = @spec['db']
+      end
+
+      def to_s
+        "username: #{username}, password: #{password}, database: #{database}"
+      end
+    end
+
+    class Options
+
+      MAPPINGS = {
+        # Connection and Replica Set Options
+        'replicaset' => :replica_set,
+        'directconnection' => :direct_connection,
+
+        # Timeout Options
+        'connecttimeoutms' => :connect_timeout,
+        'sockettimeoutms' => :socket_timeout,
+        'serverselectiontimeoutms' => :server_selection_timeout,
+        'localthresholdms' => :local_threshold,
+        'heartbeatfrequencyms' => :heartbeat_frequency,
+        'maxidletimems' => :max_idle_time,
+
+         # Write  Options
+        'journal' => [:write_concern, 'j'],
+        'w' => [:write_concern, 'w'],
+        'wtimeoutms' => [:write_concern, 'wtimeout'],
+
+        # Read Options
+        'readpreference' => ['read', 'mode'],
+        'readpreferencetags' => ['read', 'tag_sets'],
+        'maxstalenessseconds' => ['read', 'max_staleness'],
+
+        # Pool Options
+        'minpoolsize' => :min_pool_size,
+        'maxpoolsize' => :max_pool_size,
+
+        # Security Options
+        'tls' => :ssl,
+        'tlsallowinvalidcertificates' => :ssl_verify_certificate,
+        'tlsallowinvalidhostnames' => :ssl_verify_hostname,
+        'tlscafile' => :ssl_ca_cert,
+        'tlscertificatekeyfile' => :ssl_cert,
+        'tlscertificatekeyfilepassword' => :ssl_key_pass_phrase,
+        'tlsinsecure' => :ssl_verify,
+
+        # Auth Options
+        'authsource' => :auth_source,
+        'authmechanism' => :auth_mech,
+        'authmechanismproperties' => :auth_mech_properties,
+
+        # Client Options
+        'appname' => :app_name,
+        'readconcernlevel' => [:read_concern, 'level'],
+        'retrywrites' => :retry_writes,
+        'zlibcompressionlevel' => :zlib_compression_level,
+      }
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def match?(opts)
+        @options.all? do |k, v|
+          k = k.downcase
+
+          expected =
+            case k
+            when 'authmechanism'
+              Mongo::URI::AUTH_MECH_MAP[v].downcase.to_s
+            when 'authmechanismproperties'
+              v.reduce({}) do |new_v, prop|
+                prop_key = prop.first.downcase
+                prop_val = prop.last == 'true' ? true : prop.last
+                new_v[prop_key] = prop_val
+
+                new_v
+              end
+            when 'compressors'
+              v.dup.tap do |compressors|
+                # The Ruby driver doesn't support snappy
+                compressors.delete('snappy')
+              end
+            when 'readpreference'
+              Mongo::URI::READ_MODE_MAP[v.downcase].to_s
+            when 'tlsallowinvalidcertificates', 'tlsallowinvalidhostnames', 'tlsinsecure'
+              !v
+            else
+              if k.end_with?('ms') && k != 'wtimeoutms'
+                v / 1000.0
+              elsif v.is_a?(String)
+                v.downcase
+              else
+                v
+              end
+            end
+
+          actual =
+            case MAPPINGS[k]
+            when nil
+              opts[k]
+            when Array
+              opts[MAPPINGS[k].first][MAPPINGS[k].last]
+            else
+              opts[MAPPINGS[k]]
+            end
+
+          if actual.is_a?(Symbol)
+            actual = actual.to_s
+          end
+          if actual.is_a?(String)
+            actual = actual.downcase
+          end
+
+          expected == actual
+        end
+      end
+    end
+  end
+end
 
 def define_connection_string_spec_tests(test_paths, spec_cls = Mongo::ConnectionString::Spec, &block)
 
-  clean_slate_for_all
+  clean_slate_for_all_if_possible
 
   test_paths.each do |path|
 
@@ -20,9 +375,9 @@ def define_connection_string_spec_tests(test_paths, spec_cls = Mongo::Connection
           context 'when the uri is invalid', unless: test.valid? do
 
             it 'raises an error' do
-              expect{
+              expect do
                 test.uri
-              }.to raise_exception(Mongo::Error::InvalidURI)
+              end.to raise_exception(Mongo::Error::InvalidURI)
             end
           end
 
@@ -47,7 +402,7 @@ def define_connection_string_spec_tests(test_paths, spec_cls = Mongo::Connection
               expect(test.client).to have_hosts(test, test.hosts)
             end
 
-            it 'creates a client with the correct authentication properties' do
+            it 'creates a client with the correct authentication options' do
               expect(test.client).to match_auth(test)
             end