mongo 2.1.2 → 2.2.0.rc0

data/lib/mongo/server/description/features.rb

@@ -25,6 +25,7 @@ module Mongo
         #
         # @since 2.0.0
         MAPPINGS = {
+          :find_command => 4,
           :list_collections => 3,
           :list_indexes => 3,
           :scram_sha_1 => 3,
@@ -35,7 +36,7 @@ module Mongo
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (0..3).freeze
+        DRIVER_WIRE_VERSIONS = (0..4).freeze
 
         # Create the methods for each mapping to tell if they are supported.
         #

data/lib/mongo/server/monitor.rb

@@ -35,16 +35,6 @@ module Mongo
       # @since 2.0.0
       MIN_SCAN_FREQUENCY = 0.5.freeze
 
-      # The command used for determining server status.
-      #
-      # @since 2.0.0
-      STATUS = { :ismaster => 1 }.freeze
-
-      # The constant for the ismaster command.
-      #
-      # @since 2.0.0
-      ISMASTER = Protocol::Query.new(Database::ADMIN, Database::COMMAND, STATUS, :limit => -1)
-
       # The weighting factor (alpha) for calculating the average moving round trip time.
       #
       # @since 2.0.0
@@ -170,8 +160,7 @@ module Mongo
         @mutex.synchronize do
           start = Time.now
           begin
-            result = connection.dispatch([ ISMASTER ]).documents[0]
-            return result, calculate_average_round_trip_time(start)
+            return connection.ismaster, calculate_average_round_trip_time(start)
           rescue Exception => e
             log_debug(e.message)
             return {}, calculate_average_round_trip_time(start)

data/lib/mongo/server/monitor/connection.rb

@@ -22,11 +22,41 @@ module Mongo
       class Connection
         include Connectable
 
+        # The command used for determining server status.
+        #
+        # @since 2.2.0
+        ISMASTER = { :ismaster => 1 }.freeze
+
+        # The constant for the ismaster command.
+        #
+        # @since 2.2.0
+        ISMASTER_MESSAGE = Protocol::Query.new(Database::ADMIN, Database::COMMAND, ISMASTER, :limit => -1)
+
+        # The raw bytes for the ismaster message.
+        #
+        # @since 2.2.0
+        ISMASTER_BYTES = ISMASTER_MESSAGE.serialize.to_s.freeze
+
         # The default time in seconds to timeout a connection attempt.
         #
         # @since 2.1.2
         CONNECT_TIMEOUT = 10.freeze
 
+        # Send the preserialized ismaster call.
+        #
+        # @example Send a preserialized ismaster message.
+        #   connection.ismaster
+        #
+        # @return [ BSON::Document ] The ismaster result.
+        #
+        # @since 2.2.0
+        def ismaster
+          ensure_connected do |socket|
+            socket.write(ISMASTER_BYTES)
+            Protocol::Reply.deserialize(socket).documents[0]
+          end
+        end
+
         # Get the connection timeout.
         #
         # @example Get the connection timeout.
@@ -77,25 +107,6 @@ module Mongo
           true
         end
 
-        # Dispatch the provided messages to the connection. If the last message
-        # requires a response a reply will be returned.
-        #
-        # @example Dispatch the messages.
-        #   connection.dispatch([ insert, command ])
-        #
-        # @note This method is named dispatch since 'send' is a core Ruby method on
-        #   all objects.
-        #
-        # @param [ Array<Message> ] messages The messages to dispatch.
-        #
-        # @return [ Protocol::Reply ] The reply if needed.
-        #
-        # @since 2.0.0
-        def dispatch(messages)
-          write(messages)
-          messages.last.replyable? ? read : nil
-        end
-
         # Initialize a new socket connection from the client to the server.
         #
         # @api private
@@ -117,13 +128,6 @@ module Mongo
           @socket = nil
           @pid = Process.pid
         end
-
-        private
-
-        def write(messages, buffer = '')
-          messages.each{ |message| message.serialize(buffer) }
-          ensure_connected{ |socket| socket.write(buffer) }
-        end
       end
     end
   end

data/lib/mongo/server_selector/selectable.rb

@@ -67,6 +67,19 @@ module Mongo
         @tag_sets = tag_sets.freeze
       end
 
+      # Inspect the server selector.
+      #
+      # @example Inspect the server selector.
+      #   selector.inspect
+      #
+      # @return [ String ] The inspection.
+      #
+      # @since 2.2.0
+      def inspect
+        "#<#{self.class.name}:0x#{object_id} tag_sets=#{tag_sets.inspect} " +
+        "server_selection_timeout=#{server_selection_timeout} local_threshold=#{local_threshold}>"
+      end
+
       # Select a server from eligible candidates.
       #
       # @example Select a server from the cluster.
@@ -77,13 +90,19 @@ module Mongo
       # @return [ Mongo::Server ] A server matching the server preference.
       #
       # @since 2.0.0
-      def select_server(cluster)
+      def select_server(cluster, ping = true)
         deadline = Time.now + server_selection_timeout
         while (deadline - Time.now) > 0
           servers = candidates(cluster)
           if servers && !servers.compact.empty?
             server = servers.first
-            return server if server.connectable?
+            # There is no point pinging a standalone as the subsequent scan is
+            # not going to change anything about the cluster.
+            if ping && !cluster.single?
+              return server if server.connectable?
+            else
+              return server
+            end
           end
           cluster.scan!
         end
@@ -188,8 +207,6 @@ module Mongo
         matches || []
       end
 
-      private
-
       def validate_tag_sets!(tag_sets)
         if !tag_sets.all? { |set| set.empty? } && !tags_allowed?
           raise Error::InvalidServerPreference.new(name)

data/lib/mongo/uri.rb

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'uri'
+
 module Mongo
 
   # The URI class provides a way for users to parse the MongoDB uri as

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.1.2'.freeze
+  VERSION = '2.2.0.rc0'.freeze
 end

data/lib/mongo/write_concern.rb

@@ -52,7 +52,7 @@ module Mongo
     # The default write concern is to acknowledge on a single server.
     #
     # @since 2.0.0
-    DEFAULT = { W => 1 }.freeze
+    DEFAULT = { }.freeze
 
     # Get a write concern mode for the provided options.
     #
@@ -72,17 +72,32 @@ module Mongo
     #
     # @return [ Unacknowledged, Acknowledged ] The appropriate concern.
     #
+    # @raise [ Error::InvalidWriteConcern ] If the write concern is invalid.
+    #
     # @since 2.0.0
     def get(options)
-      if unacknowledged?(options)
-        Unacknowledged.new(options)
-      else
-        Acknowledged.new(options || DEFAULT)
+      if options
+        validate!(options)
+        if unacknowledged?(options)
+          Unacknowledged.new(options)
+        else
+          Acknowledged.new(options)
+        end
       end
     end
 
     private
 
+    def validate!(options)
+      if options[W]
+        if options[W] == 0 && (options[J] || options[FSYNC])
+          raise Mongo::Error::InvalidWriteConcern.new
+        elsif options[W].is_a?(Integer) && options[W] < 0
+          raise Mongo::Error::InvalidWriteConcern.new
+        end
+      end
+    end
+
     # Determine if the options are for an unacknowledged write concern.
     #
     # @api private
@@ -93,7 +108,7 @@ module Mongo
     #
     # @since 2.0.0
     def unacknowledged?(options)
-      options && (options[W] == 0 || options[W] == -1)
+      options[W] == 0
     end
   end
 end

data/mongo.gemspec

@@ -4,7 +4,6 @@ require 'mongo/version'
 
 Gem::Specification.new do |s|
   s.name              = 'mongo'
-  s.rubyforge_project = 'mongo'
   s.version           = Mongo::VERSION
   s.platform          = Gem::Platform::RUBY
 
@@ -30,5 +29,5 @@ Gem::Specification.new do |s|
   s.has_rdoc          = 'yard'
   s.bindir            = 'bin'
 
-  s.add_dependency 'bson', '~> 3.0'
+  s.add_dependency 'bson', '~> 4.0.0.rc0'
 end

data/spec/mongo/bulk_write/ordered_combiner_spec.rb

@@ -94,6 +94,19 @@ describe Mongo::BulkWrite::OrderedCombiner do
 
     context 'when provided a series of insert one' do
 
+      context 'when providing only one operation' do
+
+        let(:requests) do
+          [{ insert_one: { _id: 0 }}]
+        end
+
+        it 'returns a single insert one' do
+          expect(combiner.combine).to eq(
+            [{ insert_one: [{ _id: 0 }]}]
+          )
+        end
+      end
+
       context 'when the documents are valid' do
 
         let(:requests) do

data/spec/mongo/bulk_write_spec.rb

@@ -8,6 +8,14 @@ describe Mongo::BulkWrite do
 
   after do
     authorized_collection.delete_many
+    collection_with_validator.drop()
+  end
+
+  let(:collection_with_validator) do
+    authorized_client[:validating,
+                      :validator => { :a => { '$exists' => true } }].tap do |c|
+      c.create
+    end
   end
 
   describe '#execute' do
@@ -425,4 +433,54 @@ describe Mongo::BulkWrite do
       end
     end
   end
+
+  describe 'when the collection has a validator', if: find_command_enabled? do
+
+    before do
+      collection_with_validator.insert_many([{ :a => 1 }, { :a => 2 }])
+    end
+
+    after do
+      collection_with_validator.delete_many
+    end
+
+    context 'when the documents are invalid' do
+
+      let(:ops) do
+        [
+            { insert_one: { :x => 1 } },
+            { update_one: { filter: { :a => 1 },
+                            update: { '$unset' => { :a => '' } } } },
+            { replace_one: { filter: { :a => 2 },
+                             replacement: { :x => 2 } } }
+        ]
+      end
+
+      context 'when bypass_document_validation is not set' do
+
+        let(:result) do
+          collection_with_validator.bulk_write(ops)
+        end
+
+        it 'raises BulkWriteError' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::BulkWriteError)
+        end
+      end
+
+      context 'when bypass_document_validation is true' do
+
+        let(:result2) do
+          collection_with_validator.bulk_write(
+              ops, :bypass_document_validation => true)
+        end
+
+        it 'executes successfully' do
+          expect(result2.modified_count).to eq(2)
+          expect(result2.inserted_count).to eq(1)
+        end
+      end
+    end
+  end
 end

data/spec/mongo/client_spec.rb

@@ -674,8 +674,8 @@ describe Mongo::Client do
 
       let(:client) { described_class.new(['127.0.0.1:27017'], :database => TEST_DB) }
 
-      it 'returns a acknowledged write concern' do
-        expect(concern.get_last_error).to eq(:getlasterror => 1, :w => 1)
+      it 'does not set the write concern' do
+        expect(concern).to be_nil
       end
     end
 
@@ -711,8 +711,10 @@ describe Mongo::Client do
             described_class.new(['127.0.0.1:27017'], :write => { :w => -1 }, :database => TEST_DB)
           end
 
-          it 'returns an unacknowledged write concern' do
-            expect(concern.get_last_error).to be_nil
+          it 'raises an error' do
+            expect {
+              concern
+            }.to raise_error(Mongo::Error::InvalidWriteConcern)
           end
         end
       end

data/spec/mongo/collection/view/builder/find_command_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Builder::FindCommand do
+
+  describe '#specification' do
+
+    let(:view) do
+      Mongo::Collection::View.new(authorized_collection, filter, options)
+    end
+
+    let(:builder) do
+      described_class.new(view)
+    end
+
+    let(:specification) do
+      builder.specification
+    end
+
+    let(:selector) do
+      specification[:selector]
+    end
+
+    context 'when the options are standard' do
+
+      let(:filter) do
+        { 'name' => 'test' }
+      end
+
+      let(:options) do
+        {
+          sort: { _id: 1 },
+          projection: { name: 1 },
+          hint: { name: 1 },
+          skip: 10,
+          limit: 20,
+          batch_size: 5,
+          single_batch: false,
+          comment: "testing",
+          max_scan: 200,
+          max_time_ms: 40,
+          max_value: { name: 'joe' },
+          min_value: { name: 'albert' },
+          return_key: true,
+          show_disk_loc: true,
+          snapshot: true,
+          tailable: true,
+          oplog_replay: true,
+          no_cursor_timeout: true,
+          await_data: true,
+          allow_partial_results: true,
+          read_concern: { level: 'local' }
+        }
+      end
+
+      it 'maps the collection name' do
+        expect(selector['find']).to eq(authorized_collection.name)
+      end
+
+      it 'maps the filter' do
+        expect(selector['filter']).to eq(filter)
+      end
+
+      it 'maps sort' do
+        expect(selector['sort']).to eq('_id' => 1)
+      end
+
+      it 'maps projection' do
+        expect(selector['projection']).to eq('name' => 1)
+      end
+
+      it 'maps hint' do
+        expect(selector['hint']).to eq('name' => 1)
+      end
+
+      it 'maps skip' do
+        expect(selector['skip']).to eq(10)
+      end
+
+      it 'maps limit' do
+        expect(selector['limit']).to eq(20)
+      end
+
+      it 'maps batch size' do
+        expect(selector['batchSize']).to eq(5)
+      end
+
+      it 'maps single batch' do
+        expect(selector['singleBatch']).to be false
+      end
+
+      it 'maps comment' do
+        expect(selector['comment']).to eq('testing')
+      end
+
+      it 'maps max scan' do
+        expect(selector['maxScan']).to eq(200)
+      end
+
+      it 'maps max time ms' do
+        expect(selector['maxTimeMS']).to eq(40)
+      end
+
+      it 'maps max' do
+        expect(selector['max']).to eq('name' => 'joe')
+      end
+
+      it 'maps min' do
+        expect(selector['min']).to eq('name' => 'albert')
+      end
+
+      it 'maps read concern' do
+        expect(selector['readConcern']).to eq('level' => 'local')
+      end
+
+      it 'maps return key' do
+        expect(selector['returnKey']).to be true
+      end
+
+      it 'maps show record id' do
+        expect(selector['showRecordId']).to be true
+      end
+
+      it 'maps snapshot' do
+        expect(selector['snapshot']).to be true
+      end
+
+      it 'maps tailable' do
+        expect(selector['tailable']).to be true
+      end
+
+      it 'maps oplog replay' do
+        expect(selector['oplogReplay']).to be true
+      end
+
+      it 'maps no cursor timeout' do
+        expect(selector['noCursorTimeout']).to be true
+      end
+
+      it 'maps await data' do
+        expect(selector['awaitData']).to be true
+      end
+
+      it 'maps allow partial results' do
+        expect(selector['allowPartialResults']).to be true
+      end
+    end
+
+    context 'when limit is negative' do
+
+      let(:filter) do
+        { 'name' => 'test' }
+      end
+
+      let(:options) do
+        { limit: -1 }
+      end
+
+      it 'sets single batch to true' do
+        expect(selector['singleBatch']).to be true
+      end
+
+      it 'removes the limit from the command' do
+        expect(selector['limit']).to be_nil
+      end
+    end
+  end
+end