mongo 2.17.4 → 2.18.0.beta1

data/lib/mongo/operation/delete/legacy.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-# Copyright (C) 2018-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 Operation
-    class Delete
-
-      # A MongoDB delete operation sent as a legacy wire protocol message.
-      #
-      # @api private
-      #
-      # @since 2.5.2
-      class Legacy
-        include Specifiable
-        include Executable
-        include PolymorphicResult
-        include Validatable
-
-        private
-
-        def selector(connection)
-          # This returns the first delete.
-          # The driver only puts one delete into the list normally, so this
-          # doesn't discard operations.
-          send(IDENTIFIER).first.tap do |selector|
-            validate_find_options(connection, selector)
-          end
-        end
-
-        def message(connection)
-          selector = selector(connection)
-          opts = (selector[Operation::LIMIT] || 0) <= 0 ? {} : { :flags => [ :single_remove ] }
-          Protocol::Delete.new(db_name, coll_name, selector[Operation::Q], opts)
-        end
-
-        def gle
-          wc = write_concern ||  WriteConcern.get(WriteConcern::DEFAULT)
-          if gle_message = wc.get_last_error
-            Protocol::Query.new(
-                db_name,
-                Database::COMMAND,
-                gle_message,
-                options.merge(limit: -1)
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongo/operation/insert/legacy.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-# Copyright (C) 2015-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 'mongo/operation/update/legacy/result'
-
-module Mongo
-  module Operation
-    class Insert
-
-      # A MongoDB insert operation sent as a legacy wire protocol message.
-      #
-      # @api private
-      #
-      # @since 2.5.2
-      class Legacy
-        include Specifiable
-        include Executable
-        include Idable
-
-        private
-
-        def get_result(connection, context, options = {})
-          # This is a Mongo::Operation::Insert::Result
-          Result.new(*dispatch_message(connection, context), @ids)
-        end
-
-        def selector
-          send(IDENTIFIER).first
-        end
-
-        def message(connection)
-          opts = if options(connection)[:continue_on_error]
-            { :flags => [:continue_on_error] }
-          else
-            {}
-          end
-          Protocol::Insert.new(db_name, coll_name, documents, opts)
-        end
-
-        def gle
-          wc = write_concern ||  WriteConcern.get(WriteConcern::DEFAULT)
-          if gle_message = wc.get_last_error
-            Protocol::Query.new(
-                db_name,
-                Database::COMMAND,
-                gle_message,
-                options.merge(limit: -1)
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongo/operation/update/legacy/result.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-# Copyright (C) 2015-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 Operation
-    class Update
-      class Legacy
-
-        # Defines custom behavior of results for an update on server
-        # version <= 2.4.
-        #
-        # @since 2.0.0
-        # @api semiprivate
-        class Result < Operation::Result
-          include Operation::Result::UseLegacyErrorParser
-
-          # Whether an existing document was updated.
-          #
-          # @since 2.0.0
-          # @api private
-          UPDATED_EXISTING = 'updatedExisting'.freeze
-
-          # The upserted docs field in the result.
-          #
-          # @since 2.0.0
-          # @api private
-          UPSERTED = 'upserted'.freeze
-
-          # Get the number of documents matched.
-          #
-          # @example Get the matched count.
-          #   result.matched_count
-          #
-          # @return [ Integer ] The matched count.
-          #
-          # @since 2.0.0
-          # @api public
-          def matched_count
-            return 0 unless acknowledged?
-            if upsert?
-              0
-            else
-              n
-            end
-          end
-
-          # Get the number of documents modified.
-          #
-          # @example Get the modified count.
-          #   result.modified_count
-          #
-          # @return [ nil ] Always omitted for legacy versions.
-          #
-          # @since 2.0.0
-          # @api public
-          def modified_count; end
-
-          # The identifier of the inserted document if an upsert
-          #   took place.
-          #
-          # @example Get the upserted document's identifier.
-          #   result.upserted_id
-          #
-          # @return [ Object ] The upserted id.
-          #
-          # @since 2.0.0
-          # @api public
-          def upserted_id
-            first[UPSERTED] if upsert?
-          end
-
-          # Returns the number of documents upserted.
-          #
-          # @example Get the number of upserted documents.
-          #   result.upserted_count
-          #
-          # @return [ Integer ] The number upserted.
-          #
-          # @since 2.4.2
-          # @api public
-          def upserted_count
-            upsert? ? n : 0
-          end
-
-          private
-
-          def upsert?
-            !updated_existing? && n == 1
-          end
-
-          def updated_existing?
-            first[UPDATED_EXISTING]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongo/operation/update/legacy.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-# Copyright (C) 2018-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 'mongo/operation/update/legacy/result'
-
-module Mongo
-  module Operation
-    class Update
-
-      # A MongoDB update operation sent as a legacy wire protocol message.
-      #
-      # @api private
-      #
-      # @since 2.5.2
-      class Legacy
-        include Specifiable
-        include Executable
-        include PolymorphicResult
-        include Validatable
-
-        private
-
-        def selector(connection)
-          # This returns the first update.
-          # The driver only puts one update into the list normally, so this
-          # doesn't discard operations.
-          send(IDENTIFIER).first.tap do |selector|
-            validate_find_options(connection, selector)
-          end
-        end
-
-        def message(connection)
-          selector = selector(connection)
-
-          flags = []
-          flags << :multi_update if selector[Operation::MULTI]
-          flags << :upsert if selector[Operation::UPSERT]
-
-          Protocol::Update.new(
-            db_name,
-            coll_name,
-            selector[Operation::Q],
-            selector[Operation::U],
-            flags.empty? ? {} : { flags: flags },
-          )
-        end
-
-        def gle
-          wc = write_concern ||  WriteConcern.get(WriteConcern::DEFAULT)
-          if gle_message = wc.get_last_error
-            Protocol::Query.new(
-              db_name,
-              Database::COMMAND,
-              gle_message,
-              options.merge(limit: -1),
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/find_options_spec.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'Find operation options' do
-  require_mri
-  require_no_auth
-  min_server_fcv '4.4'
-
-  let(:subscriber) { Mrss::EventSubscriber.new }
-
-  let(:seeds) do
-    [ SpecConfig.instance.addresses.first ]
-  end
-
-  let(:client_options) do
-    {}
-  end
-
-  let(:collection_options) do
-    {}
-  end
-
-  let(:client) do
-    ClientRegistry.instance.new_local_client(
-      seeds,
-      SpecConfig.instance.test_options
-        .merge(database: SpecConfig.instance.test_db)
-        .merge(client_options)
-    ).tap do |client|
-      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-    end
-  end
-
-  let(:collection) do
-    client['find_options', collection_options]
-  end
-
-  let(:find_command) do
-    subscriber.started_events.find { |cmd| cmd.command_name == 'find' }
-  end
-
-  let(:should_create_collection) { true }
-
-  before do
-    client['find_options'].drop
-    collection.create if should_create_collection
-    collection.insert_many([ { a: 1 }, { a: 2 }, { a: 3 } ])
-  end
-
-  describe 'collation' do
-    let(:client_options) do
-      {}
-    end
-
-    let(:collation) do
-      { 'locale' => 'en_US' }
-    end
-
-    context 'when defined on the collection' do
-      let(:collection_options) do
-        { collation: collation }
-      end
-
-      it 'uses the collation defined on the collection' do
-        collection.find.to_a
-        expect(find_command.command['collation']).to be_nil
-      end
-    end
-
-    context 'when defined on the operation' do
-      let(:collection_options) do
-        {}
-      end
-
-      it 'uses the collation defined on the collection' do
-        collection.find({}, collation: collation).to_a
-        expect(find_command.command['collation']).to eq(collation)
-      end
-    end
-
-    context 'when defined on both collection and operation' do
-      let(:collection_options) do
-        { 'locale' => 'de_AT' }
-      end
-
-      let(:should_create_collection) { false }
-
-      it 'uses the collation defined on the collection' do
-        collection.find({}, collation: collation).to_a
-        expect(find_command.command['collation']).to eq(collation)
-      end
-    end
-  end
-
-  describe 'read concern' do
-    context 'when defined on the client' do
-      let(:client_options) do
-        { read_concern: { level: :local } }
-      end
-
-      let(:collection_options) do
-        {}
-      end
-
-      it 'uses the read concern defined on the client' do
-        collection.find.to_a
-        expect(find_command.command['readConcern']).to eq('level' => 'local')
-      end
-
-      context 'when defined on the collection' do
-        let(:collection_options) do
-          { read_concern: { level: :majority } }
-        end
-
-        it 'uses the read concern defined on the collection' do
-          collection.find.to_a
-          expect(find_command.command['readConcern']).to eq('level' => 'majority')
-        end
-
-        context 'when defined on the operation' do
-          let(:operation_read_concern) do
-            { level: :available }
-          end
-
-          it 'uses the read concern defined on the operation' do
-            collection.find({}, read_concern: operation_read_concern).to_a
-            expect(find_command.command['readConcern']).to eq('level' => 'available')
-          end
-        end
-      end
-
-      context 'when defined on the operation' do
-        let(:collection_options) do
-          {}
-        end
-
-        let(:operation_read_concern) do
-          { level: :available }
-        end
-
-        it 'uses the read concern defined on the operation' do
-          collection.find({}, read_concern: operation_read_concern).to_a
-          expect(find_command.command['readConcern']).to eq('level' => 'available')
-        end
-      end
-    end
-
-    context 'when defined on the collection' do
-      let(:client_options) do
-        {}
-      end
-
-      let(:collection_options) do
-        { read_concern: { level: :majority } }
-      end
-
-      it 'uses the read concern defined on the collection' do
-        collection.find.to_a
-        expect(find_command.command['readConcern']).to eq('level' => 'majority')
-      end
-
-      context 'when defined on the operation' do
-        let(:operation_read_concern) do
-          { level: :available }
-        end
-
-        it 'uses the read concern defined on the operation' do
-          collection.find({}, read_concern: operation_read_concern).to_a
-          expect(find_command.command['readConcern']).to eq('level' => 'available')
-        end
-      end
-    end
-  end
-
-  describe 'read preference' do
-    require_topology :replica_set
-
-    context 'when defined on the client' do
-      let(:client_options) do
-        { read: { mode: :secondary } }
-      end
-
-      let(:collection_options) do
-        {}
-      end
-
-      it 'uses the read preference defined on the client' do
-        collection.find.to_a
-        expect(find_command.command['$readPreference']).to eq('mode' => 'secondary')
-      end
-
-      context 'when defined on the collection' do
-        let(:collection_options) do
-          { read: { mode: :secondary_preferred } }
-        end
-
-        it 'uses the read concern defined on the collection' do
-          collection.find.to_a
-          expect(find_command.command['$readPreference']).to eq('mode' => 'secondaryPreferred')
-        end
-      end
-    end
-  end
-
-  describe 'cursor type' do
-    let(:collection_options) do
-      { capped: true, size: 1000 }
-    end
-
-    context 'when cursor type is :tailable' do
-      it 'sets the cursor type to tailable' do
-        collection.find({}, cursor_type: :tailable).first
-        expect(find_command.command['tailable']).to be true
-        expect(find_command.command['awaitData']).to be_falsey
-      end
-    end
-
-    context 'when cursor type is :tailable_await' do
-      it 'sets the cursor type to tailable' do
-        collection.find({}, cursor_type: :tailable_await).first
-        expect(find_command.command['tailable']).to be true
-        expect(find_command.command['awaitData']).to be true
-      end
-    end
-  end
-end

data/spec/mongo/dbref_spec.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-require 'json'
-
-describe Mongo::DBRef do
-
-  let(:object_id) do
-    BSON::ObjectId.new
-  end
-
-  describe '#as_json' do
-
-    context 'when the database is not provided' do
-
-      let(:dbref) do
-        described_class.new('users', object_id)
-      end
-
-      it 'returns the json document without database' do
-        expect(dbref.as_json).to eq({ '$ref' => 'users', '$id' => object_id })
-      end
-    end
-
-    context 'when the database is provided' do
-
-      let(:dbref) do
-        described_class.new('users', object_id, 'database')
-      end
-
-      it 'returns the json document with database' do
-        expect(dbref.as_json).to eq({
-          '$ref' => 'users',
-          '$id' => object_id,
-          '$db' => 'database'
-        })
-      end
-    end
-  end
-
-  describe '#initialize' do
-
-    let(:dbref) do
-      described_class.new('users', object_id)
-    end
-
-    it 'sets the collection' do
-      expect(dbref.collection).to eq('users')
-    end
-
-    it 'sets the id' do
-      expect(dbref.id).to eq(object_id)
-    end
-
-    context 'when a database is provided' do
-
-      let(:dbref) do
-        described_class.new('users', object_id, 'db')
-      end
-
-      it 'sets the database' do
-        expect(dbref.database).to eq('db')
-      end
-    end
-  end
-
-  describe '#to_bson' do
-
-    let(:dbref) do
-      described_class.new('users', object_id, 'database')
-    end
-
-    it 'converts the underlying document to bson' do
-      expect(dbref.to_bson.to_s).to eq(dbref.as_json.to_bson.to_s)
-    end
-  end
-
-  describe '#to_json' do
-
-    context 'when the database is not provided' do
-
-      let(:dbref) do
-        described_class.new('users', object_id)
-      end
-
-      it 'returns the json document without database' do
-        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json}}")
-      end
-    end
-
-    context 'when the database is provided' do
-
-      let(:dbref) do
-        described_class.new('users', object_id, 'database')
-      end
-
-      it 'returns the json document with database' do
-        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json},\"$db\":\"database\"}")
-      end
-    end
-  end
-
-  describe '#from_bson' do
-
-    let(:buffer) do
-      dbref.to_bson
-    end
-
-    let(:decoded) do
-      BSON::Document.from_bson(BSON::ByteBuffer.new(buffer.to_s))
-    end
-
-    context 'when a database exists' do
-
-      let(:dbref) do
-        described_class.new('users', object_id, 'database')
-      end
-
-      it 'decodes the ref' do
-        expect(decoded.collection).to eq('users')
-      end
-
-      it 'decodes the id' do
-        expect(decoded.id).to eq(object_id)
-      end
-
-      it 'decodes the database' do
-        expect(decoded.database).to eq('database')
-      end
-    end
-
-    context 'when no database exists' do
-
-      let(:dbref) do
-        described_class.new('users', object_id)
-      end
-
-      it 'decodes the ref' do
-        expect(decoded.collection).to eq('users')
-      end
-
-      it 'decodes the id' do
-        expect(decoded.id).to eq(object_id)
-      end
-
-      it 'sets the database to nil' do
-        expect(decoded.database).to be_nil
-      end
-    end
-  end
-end