mongo 2.12.4 → 2.13.0.beta1

data/spec/mongo/timeout_spec.rb

@@ -6,79 +6,33 @@ describe Mongo::Timeout do
     let(:custom_error_class) { Mongo::Error::SocketTimeoutError }
     let(:custom_error_message) { 'socket timed out' }
 
-    context 'Ruby version older than 2.4.0' do
-      before do
-        unless RUBY_VERSION < '2.4.0'
-          skip 'This test requires a Ruby version older than 2.4.0'
-        end
-      end
-
-      context 'with time argument' do
-        it 'raises StandardError' do
-          expect do
-            Mongo::Timeout.timeout(0.1) do
-              sleep 1
-            end
-          end.to raise_error(::Timeout::Error, default_error_message)
-        end
-      end
-
-      context 'with time and class arguments' do
-        it 'raises the specified error class' do
-          expect do
-            Mongo::Timeout.timeout(0.1, custom_error_class) do
-              sleep 1
-            end
-          end.to raise_error(custom_error_class, default_error_message)
-        end
-      end
-
-      context 'with time, class, and message arguments' do
-        it 'raises the specified error class but ignores the message' do
-          expect do
-            Mongo::Timeout.timeout(0.1, custom_error_class, custom_error_message) do
-              sleep 1
-            end
-          end.to raise_error(custom_error_class, default_error_message)
-        end
+    context 'with time argument' do
+      it 'raises StandardError' do
+        expect do
+          Mongo::Timeout.timeout(0.1) do
+            sleep 1
+          end
+        end.to raise_error(::Timeout::Error, default_error_message)
       end
     end
 
-    context 'Ruby 2.4.0 or newer' do
-      before do
-        unless RUBY_VERSION >= '2.4.0'
-          skip 'This test requires a Ruby 2.4.0 or newer'
-        end
-      end
-
-      context 'with time argument' do
-        it 'raises StandardError' do
-          expect do
-            Mongo::Timeout.timeout(0.1) do
-              sleep 1
-            end
-          end.to raise_error(::Timeout::Error, default_error_message)
-        end
-      end
-
-      context 'with time and class arguments' do
-        it 'raises the specified error class' do
-          expect do
-            Mongo::Timeout.timeout(0.1, custom_error_class) do
-              sleep 1
-            end
-          end.to raise_error(custom_error_class, default_error_message)
-        end
+    context 'with time and class arguments' do
+      it 'raises the specified error class' do
+        expect do
+          Mongo::Timeout.timeout(0.1, custom_error_class) do
+            sleep 1
+          end
+        end.to raise_error(custom_error_class, default_error_message)
       end
+    end
 
-      context 'with time, class, and message arguments' do
-        it 'raises the specified error class with message' do
-          expect do
-            Mongo::Timeout.timeout(0.1, custom_error_class, custom_error_message) do
-              sleep 1
-            end
-          end.to raise_error(custom_error_class, custom_error_message)
-        end
+    context 'with time, class, and message arguments' do
+      it 'raises the specified error class with message' do
+        expect do
+          Mongo::Timeout.timeout(0.1, custom_error_class, custom_error_message) do
+            sleep 1
+          end
+        end.to raise_error(custom_error_class, custom_error_message)
       end
     end
   end

data/spec/mongo/uri_spec.rb

@@ -275,10 +275,10 @@ describe Mongo::URI do
 
     context 'equal sign in option value' do
 
-      let(:string) { 'mongodb://example.com/?w=a=b' }
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=foo:a=b&appname=test' }
 
-      it 'raises an error' do
-        expect { uri }.to raise_error(Mongo::Error::InvalidURI, %r,Value for option w contains the key/value delimiter \(=\): a=b,)
+      it 'is allowed' do
+        expect(uri.uri_options[:auth_mech_properties]).to eq('foo' => 'a=b')
       end
     end
 
@@ -819,13 +819,13 @@ describe Mongo::URI do
 
         let(:mechanism) { 'GSSAPI' }
         let(:expected) { :gssapi }
+        let(:client) { new_local_client_nmio(string) }
 
         it 'sets the auth mechanism to :gssapi' do
           expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
 
         it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
           expect(client.options[:auth_mech]).to eq(expected)
         end
 
@@ -839,7 +839,7 @@ describe Mongo::URI do
 
           it 'does not allow a client to be created' do
             expect {
-              new_local_client_nmio(string)
+              client
             }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
           end
         end
@@ -848,9 +848,24 @@ describe Mongo::URI do
           let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:other,CANONICALIZE_HOST_NAME:true" }
 
           it 'sets the options on a client created with the uri' do
-            client = new_local_client_nmio(string)
             expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => true, 'service_name' => 'other' })
           end
+
+          context 'when a mapping value is missing' do
+            let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:,CANONICALIZE_HOST_NAME:" }
+
+            it 'sets the options on a client created with the uri' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => nil, 'service_name' => nil })
+            end
+          end
+
+          context 'when a mapping value is missing but another is present' do
+            let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:foo,CANONICALIZE_HOST_NAME:" }
+
+            it 'sets the options on a client created with the uri' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => nil, 'service_name' => 'foo' })
+            end
+          end
         end
       end
 

data/spec/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.
@@ -91,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
@@ -108,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