mongo 2.4.1 → 2.14.0

data/spec/mongo/utils_spec.rb

@@ -0,0 +1,39 @@
+require 'lite_spec_helper'
+
+describe Mongo::Utils do
+  describe '#shallow_symbolize_keys' do
+    it 'symbolizes' do
+      described_class.shallow_symbolize_keys(
+        'foo' => 'bar',
+        'aKey' => 'aValue',
+        'a_key' => 'a_value',
+        key: :value,
+      ).should == {
+        foo: 'bar',
+        aKey: 'aValue',
+        a_key: 'a_value',
+        key: :value,
+      }
+    end
+  end
+
+  describe '#shallow_camelize_keys' do
+    it 'camelizes' do
+      described_class.shallow_camelize_keys(
+        'foo' => 'bar',
+        'aKey' => 'aValue',
+        'aa_key' => 'a_value',
+        key: :value,
+        sKey: :sValue,
+        us_key: :us_value,
+      ).should == {
+        'foo' => 'bar',
+        'aKey' => 'aValue',
+        'aaKey' => 'a_value',
+        'key' => :value,
+        'sKey' => :sValue,
+        'usKey' => :us_value,
+      }
+    end
+  end
+end

data/spec/mongo/write_concern/acknowledged_spec.rb

@@ -2,6 +2,17 @@ require 'spec_helper'
 
 describe Mongo::WriteConcern::Acknowledged do
 
+  describe '#acknowledged?' do
+
+    let(:concern) do
+      described_class.new(:w => :majority)
+    end
+
+    it 'returns true' do
+      expect(concern.acknowledged?).to be(true)
+    end
+  end
+
   describe '#get_last_error' do
 
     let(:get_last_error) do

data/spec/mongo/write_concern/unacknowledged_spec.rb

@@ -12,4 +12,15 @@ describe Mongo::WriteConcern::Unacknowledged do
       expect(concern.get_last_error).to be_nil
     end
   end
+
+  describe '#acknowledged?' do
+
+    let(:concern) do
+      described_class.new(:w => 0)
+    end
+
+    it 'returns false' do
+      expect(concern.acknowledged?).to be(false)
+    end
+  end
 end

data/spec/mongo/write_concern_spec.rb

@@ -1,9 +1,11 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::WriteConcern do
 
   describe '#get' do
 
+    let(:wc) { Mongo::WriteConcern.get(options) }
+
     context 'when no options are set' do
 
       let(:options) do
@@ -70,6 +72,19 @@ describe Mongo::WriteConcern do
               Mongo::WriteConcern.get(options)
             }.to raise_error(Mongo::Error::InvalidWriteConcern)
           end
+
+          context 'when j is given as a string' do
+
+            let(:options) do
+              { w: 0, 'j' => true }
+            end
+
+            it 'raises an exception' do
+              expect {
+                Mongo::WriteConcern.get(options)
+              }.to raise_error(Mongo::Error::InvalidWriteConcern)
+            end
+          end
         end
 
         context 'when fsync is true' do
@@ -114,7 +129,7 @@ describe Mongo::WriteConcern do
     context 'when w is greater than 0' do
 
       let(:options) do
-        { w: 2, journal: true }
+        { w: 2, j: true }
       end
 
       it 'returns an Acknowledged write concern object' do
@@ -129,7 +144,7 @@ describe Mongo::WriteConcern do
     context 'when w is a string' do
 
       let(:options) do
-        { w: 'majority', journal: true }
+        { w: 'majority', j: true }
       end
 
       it 'returns an Acknowledged write concern object' do
@@ -144,7 +159,7 @@ describe Mongo::WriteConcern do
     context 'when w is a symbol' do
 
       let(:options) do
-        { w: :majority, journal: true }
+        { w: :majority, j: true }
       end
 
       it 'returns an Acknowledged write concern object' do
@@ -155,5 +170,55 @@ describe Mongo::WriteConcern do
         expect(Mongo::WriteConcern.get(options).options[:w]).to eq('majority')
       end
     end
+
+    context 'when options are provided with string keys' do
+
+      context 'acknowledged write concern' do
+        let(:options) do
+          { 'w' => 2, 'j' => true }
+        end
+
+        it 'converts keys to symbols' do
+          expect(wc).to be_a(Mongo::WriteConcern::Acknowledged)
+          expect(wc.options[:w]).to eq(2)
+          expect(wc.options[:j]).to be true
+        end
+      end
+
+      context 'unacknowledged write concern' do
+        let(:options) do
+          { 'w' => 0 }
+        end
+
+        it 'converts keys to symbols' 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
+
+    context 'when :journal option is given' do
+      let(:options) do
+        { 'w' => 1, journal: true }
+      end
+
+      it 'raises an exception' do
+        expect do
+          wc
+        end.to raise_error(Mongo::Error::InvalidWriteConcern, /use :j for journal/)
+      end
+    end
   end
 end

data/spec/runners/auth.rb

@@ -0,0 +1,119 @@
+# 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_blank_credentials do
+  match do |client|
+    # 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
+
+  failure_message do |client|
+    "Expected client to have blank credentials, but got the following credentials: \n\n" +
+      client.options.inspect
+  end
+end
+
+module Mongo
+  module Auth
+    class Spec
+
+      attr_reader :description
+      attr_reader :tests
+
+      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
+      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 credential
+        @spec['credential']
+      end
+
+      def client
+        @client ||= ClientRegistry.instance.new_local_client(@spec['uri'], monitoring_io: false)
+      end
+
+      def expected_credential
+        expected_credential = { 'auth_source' => credential['source'] }
+
+        if credential['username']
+          expected_credential['user'] = credential['username']
+        end
+
+        if credential['password']
+          expected_credential['password'] = credential['password']
+        end
+
+        if credential['mechanism']
+          expected_credential['auth_mech'] = expected_auth_mech
+        end
+
+        if credential['mechanism_properties']
+          props = Hash[credential['mechanism_properties'].map do |k, v|
+            [k.downcase, v]
+          end]
+          expected_credential['auth_mech_properties'] = props
+        end
+
+        expected_credential
+      end
+
+      def received_credential
+        client.options.select do |k, _|
+          %w(auth_mech auth_mech_properties auth_source password user).include?(k)
+        end
+      end
+
+      private
+
+      def expected_auth_mech
+        Mongo::URI::AUTH_MECH_MAP[credential['mechanism']]
+      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.4' &&
+          global_client.cluster.servers.length > 1
+        then
+          ::Utils.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/runners/cmap/verifier.rb

@@ -0,0 +1,45 @@
+# 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.
+# 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 Cmap
+    class Verifier
+      include RSpec::Matchers
+
+      def initialize(test_instance)
+        @test_instance = test_instance
+      end
+
+      attr_reader :test_instance
+
+      def verify_hashes(actual, expected)
+        expect(expected).to be_a(Hash)
+        expect(actual).to be_a(Hash)
+
+        actual_modified = actual.dup
+        if actual['reason']
+          actual_modified['reason'] = actual['reason'].to_s.gsub(/_[a-z]/) { |m| m[1].upcase }
+        end
+
+        actual.each do |k, v|
+          if expected.key?(k) && expected[k] == 42 && v
+            actual_modified[k] = 42
+          end
+        end
+
+        expect(actual_modified).to eq(expected)
+      end
+    end
+  end
+end