mongo 2.0.0.beta → 2.0.0.rc

data/lib/mongo/server.rb

@@ -79,7 +79,7 @@ module Mongo
     # @example Get the server context.
     #   server.context
     #
-    # @return [ Mongo::Server::Context ] The server context.
+    # @return [ Mongo::Server::Context ] context The server context.
     #
     # @since 2.0.0
     def context
@@ -149,7 +149,7 @@ module Mongo
     # @example Are the provided tags a subset of the server's tags.
     #   server.matches_tag_set?({ 'rack' => 'a', 'dc' => 'nyc' })
     #
-    # @param [ Hash ] The tag set to compare to the server's tags.
+    # @param [ Hash ] tag_set The tag set to compare to the server's tags.
     #
     # @return [ true, false ] If the provided tags are a subset of the server's tags.
     #

data/lib/mongo/server/connection_pool/queue.rb

@@ -84,7 +84,7 @@ module Mongo
         # @example Create the queue.
         #   Mongo::Pool::Queue.new(max_pool_size: 5) { Connection.new }
         #
-        # @param [ Integer ] size The initial size of the queue.
+        # @param [ Hash ] options The options.
         #
         # @option options [ Integer ] :max_pool_size The maximum size.
         # @option options [ Integer ] :min_pool_size The minimum size.

data/lib/mongo/server/description.rb

@@ -202,7 +202,7 @@ module Mongo
       # @example Instantiate the new description.
       #   Description.new(address, { 'ismaster' => true }, 0.5)
       #
-      # @param [ Address ] addressThe server address.
+      # @param [ Address ] address The server address.
       # @param [ Hash ] config The result of the ismaster command.
       # @param [ Float ] average_round_trip_time The moving average time (ms) the ismaster
       #   call took to complete.

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

@@ -45,7 +45,7 @@ module Mongo
         # @example Create the new inspector.
         #   Inspector.new(listeners)
         #
-        # @param [ Event::Listeners ] The event listeners.
+        # @param [ Event::Listeners ] listeners The event listeners.
         #
         # @since 2.0.0
         def initialize(listeners)

data/lib/mongo/server_selector.rb

@@ -69,7 +69,7 @@ module Mongo
       # @example Instantiate the exception.
       #   Mongo::ServerSelector::NoServerAvailable.new(server_selector)
       #
-      # @params [ Hash ] server_selector The server preference that could not be
+      # @param [ Hash ] server_selector The server preference that could not be
       #   satisfied.
       #
       # @since 2.0.0

data/lib/mongo/socket/unix.rb

@@ -47,11 +47,9 @@ module Mongo
       # Initializes a new Unix socket.
       #
       # @example Create the Unix socket.
-      #   Unix.new('::1', 27017, 30)
-      #   Unix.new('127.0.0.1', 27017, 30)
+      #   Unix.new('/path/to.sock', 27017, 30)
       #
-      # @param [ String ] host The hostname or IP address.
-      # @param [ Integer ] port The port number.
+      # @param [ String ] path The path.
       # @param [ Float ] timeout The socket timeout value.
       # @param [ Integer ] family The socket family.
       #

data/lib/mongo/version.rb

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

data/lib/mongo/write_concern/acknowledged.rb

@@ -31,7 +31,21 @@ module Mongo
       #
       # @since 2.0.0
       def get_last_error
-        @get_last_error ||= { GET_LAST_ERROR => 1 }.merge(normalize(options))
+        @get_last_error ||= { GET_LAST_ERROR => 1 }.merge(
+          Options::Mapper.transform_values_to_strings(options)
+        )
+      end
+
+      # Get a human-readable string representation of an acknowledged write concern.
+      #
+      # @example Inspect the write concern.
+      #   write_concern.inspect
+      #
+      # @return [ String ] A string representation of an acknowledged write concern.
+      #
+      # @since 2.0.0
+      def inspect
+        "<Mongo::WriteConcern::Acknowledged:0x#{object_id} options=#{options}>"
       end
     end
   end

data/lib/mongo/write_concern/normalizable.rb

@@ -46,28 +46,6 @@ module Mongo
       def initialize(options)
         @options = options.freeze
       end
-
-      private
-
-      # Normalizes symbol option values into strings, since symbol will raise
-      # an error on the server side with the gle.
-      #
-      # @api private
-      #
-      # @example Normalize the options.
-      #   mode.normalize(:w => :majority)
-      #
-      # @param [ Hash ] options The options to normalize.
-      #
-      # @return [ Hash ] The hash with normalized values.
-      #
-      # @since 2.0.0
-      def normalize(options)
-        options.reduce({}) do |options, (key, value)|
-          options[key] = value.is_a?(Symbol) ? value.to_s : value
-          options
-        end
-      end
     end
   end
 end

data/lib/mongo/write_concern/unacknowledged.rb

@@ -38,6 +38,18 @@ module Mongo
       def get_last_error
         NOOP
       end
+
+      # Get a human-readable string representation of an unacknowledged write concern.
+      #
+      # @example Inspect the write concern.
+      #   write_concern.inspect
+      #
+      # @return [ String ] A string representation of an unacknowledged write concern.
+      #
+      # @since 2.0.0
+      def inspect
+        "<Mongo::WriteConcern::Unacknowledged:0x#{object_id} options=#{options}>"
+      end
     end
   end
 end

data/spec/mongo/bulk/bulk_write_spec.rb

@@ -3,138 +3,229 @@ require 'spec_helper'
 describe Mongo::BulkWrite do
 
   before do
-    authorized_collection.find.remove_many
+    authorized_collection.find.delete_many
   end
 
-  describe '#execute' do
+  after do
+    authorized_collection.find.delete_many
+  end
+
+  let(:bulk) do
+    described_class.get(authorized_collection, operations, options)
+  end
+
+  describe '#get' do
 
-    let(:bulk) do
-      described_class.new(operations, options, authorized_collection)
+    let(:operations) do
+      [{ insert_one: { _id: 0 } }]
     end
 
-    context 'when the operations are ordered' do
+    context 'When an ordered bulk write object is created' do
 
       let(:options) do
         { ordered: true }
       end
 
-      it_behaves_like 'a bulk write object'
+      it 'returns an OrderedBulkWrite object' do
+        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
+      end
+    end
 
-      context 'when the insert batch requires splitting' do
+    context 'When an unordered bulk write object is created' do
 
-        context 'when the operations exceed the max batch size' do
+      let(:options) do
+        { ordered: false }
+      end
 
-          let(:error) do
-            begin
-              bulk.execute
-            rescue => ex
-              ex
-            end
-          end
+      it 'returns an UnorderedBulkWrite object' do
+        expect(bulk).to be_a(Mongo::BulkWrite::UnorderedBulkWrite)
+      end
+    end
 
-          let(:operations) do
-            [].tap do |ops|
-              3000.times do |i|
-                ops << { insert_one: { _id: i } }
-              end
-              ops << { insert_one: { _id: 0 } }
-              ops << { insert_one: { _id: 3001 } }
-            end
-          end
+    context 'When ordered is not specified in options' do
 
-          it 'raises an error' do
-            expect(error).to be_a(Mongo::Error::BulkWriteFailure)
-          end
+      let(:options) do
+        { }
+      end
+
+      it 'returns an OrderedBulkWrite object' do
+        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
+      end
+    end
+  end
+
+  describe 'Ordered bulk write' do
 
-          it 'halts execution after first error and reports correct index' do
-            expect(error.result['writeErrors'].first['index']).to eq(3000)
-            expect(authorized_collection.find.count).to eq(3000)
+    let(:options) do
+       { ordered: true }
+    end
+     
+    it_behaves_like 'a bulk write object'
+    
+    context 'when the batch requires splitting' do
+    
+      context 'when the operations are the same type' do
+    
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+    
+        let(:operations) do
+          [].tap do |ops|
+            3000.times do |i|
+              ops << { insert_one: { _id: i } }
+            end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 3001 } }
           end
         end
+    
+        it 'raises a BulkWriteError' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
 
-        context 'when the operations exceed the max bson size' do
+        it 'halts execution after first error and reports correct index' do
+          expect(error.result[:write_errors].first['index']).to eq(3000)
+          expect(authorized_collection.find.count).to eq(3000)
+        end
+      end
 
-          let(:error) do
-            begin
-              bulk.execute
-            rescue => ex
-              ex
-            end
+      context 'when operations are mixed types' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
           end
+        end
 
-          let(:operations) do
-            [].tap do |ops|
-              6.times do |i|
-                ops << { insert_one: { _id: i, x: 'y'*4000000 } }
-              end
-              ops << { insert_one: { _id: 0 } }
-              ops << { insert_one: { _id: 100 } }
+        let(:operations) do
+          [].tap do |ops|
+            2000.times do |i|
+              ops << { insert_one: { _id: i } }
             end
+            ops << { delete_one: { _id: 0 } }
+            ops << { insert_one: { _id: 1 } }
+            ops << { insert_one: { _id: 2000 } }
           end
+        end
 
-          it 'raises an error' do
-            expect(error).to be_a(Mongo::Error::BulkWriteFailure)
-          end
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
 
-          it 'splits messages into multiple messages' do
-            error
-            expect(authorized_collection.find.count).to eq(6)
-          end
+        it 'halts execution after first error and reports correct index' do
+          expect(error.result[:write_errors].first['index']).to eq(2001)
+          expect(authorized_collection.find.count).to eq(1999)
         end
       end
-    end
 
-    context 'when the operations are unordered' do
+      context 'when the operations exceed the max bson size' do
 
-      before do
-        authorized_collection.find.remove_many
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+    
+        let(:operations) do
+          [].tap do |ops|
+            6.times do |i|
+              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
+            end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 100 } }
+          end
+        end
+    
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+    
+        it 'splits messages into multiple messages' do
+          error
+          expect(authorized_collection.find.count).to eq(6)
+        end
       end
+    end
+  end
 
-      let(:options) do
-        { ordered: false }
-      end
+  describe 'Unordered bulk write' do
 
-      let(:bulk) do
-        described_class.new(operations, options, authorized_collection)
-      end
+    let(:options) do
+       { ordered: false }
+    end
 
-      it_behaves_like 'a bulk write object'
+    it_behaves_like 'a bulk write object'
 
-      context 'when the insert batch requires splitting' do
+    context 'when the operations exceed the max batch size' do
 
-        context 'when the operations exceed the max batch size' do
+      context 'when operations are all the same type' do
 
-          let(:error) do
-            begin
-              bulk.execute
-            rescue => ex
-              ex
-            end
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
           end
+        end
 
-          let(:operations) do
-            [].tap do |ops|
-              3000.times do |i|
-                ops << { insert_one: { _id: i } }
-              end
-              ops << { insert_one: { _id: 0 } }
-              ops << { insert_one: { _id: 3001 } }
+        let(:operations) do
+          [].tap do |ops|
+            3000.times do |i|
+              ops << { insert_one: { _id: i } }
             end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 3001 } }
           end
+        end
 
-          after do
-            authorized_collection.find.remove_many
-          end
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
 
-          it 'raises an error' do
-            expect(error).to be_a(Mongo::Error::BulkWriteFailure)
+        it 'does not halt execution after first error' do
+          expect(error.result[:write_errors].first['index']).to eq(3000)
+          expect(authorized_collection.find.count).to eq(3001)
+        end
+      end
+
+      context 'when operations are mixed types' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
           end
+        end
 
-          it 'does not halt execution after first error' do
-            expect(error.result['writeErrors'].first['index']).to eq(3000)
-            expect(authorized_collection.find.count).to eq(3001)
+        let(:operations) do
+          [].tap do |ops|
+            2000.times do |i|
+              ops << { insert_one: { _id: i } }
+            end
+            ops << { delete_one: { _id: 0 } }
+            ops << { insert_one: { _id: 1 } }
+            ops << { insert_one: { _id: 2000 } }
           end
         end
+
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+
+        it 'does not halt execution after first error' do
+          expect(error.result[:write_errors].first['index']).to eq(2001)
+          expect(authorized_collection.find.count).to eq(2000)
+        end
       end
 
       context 'when the operations exceed the max bson size' do
@@ -157,12 +248,8 @@ describe Mongo::BulkWrite do
           end
         end
 
-        after do
-          authorized_collection.find.remove_many
-        end
-
-        it 'raises an error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteFailure)
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
         end
 
         it 'splits messages into multiple messages' do