mongo 2.0.6 → 2.1.0

data/spec/support/sdam/single/direct_connection_standalone.yml

@@ -1,6 +1,6 @@
 description: "Connect to standalone"
 
-uri: "mongodb://a/?connect=direct"
+uri: "mongodb://a"
 
 phases: [
 

data/spec/support/sdam/single/not_ok_response.yml

@@ -26,7 +26,6 @@ phases: [
 
                 "a:27017": {
 
-                    address: "a",
                     type: "Unknown",
                     setName:
                 }

data/spec/support/server_discovery_and_monitoring.rb

@@ -45,6 +45,15 @@ module Mongo
       client.cluster.instance_variable_get(:@servers).detect{ |s| s.address.to_s == uri }
     end
 
+    # Helper to convert an extended JSON ObjectId electionId to BSON::ObjectId.
+    #
+    # @since 2.1.0
+    def self.convert_election_ids(docs)
+      docs.each do |doc |
+        doc['electionId'] = BSON::ObjectId.from_string(doc['electionId']['$oid']) if doc['electionId']
+      end
+    end
+
     # Represents a specification.
     #
     # @since 2.0.0
@@ -71,7 +80,9 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(file)
-        @test = YAML.load(ERB.new(File.new(file).read).result)
+        file = File.new(file)
+        @test = YAML.load(ERB.new(file.read).result)
+        file.close
         @description = @test['description']
         @uri_string = @test['uri']
         @uri = URI.new(uri_string)
@@ -102,7 +113,7 @@ module Mongo
       # @since 2.0.0
       def initialize(phase, uri)
         @phase = phase
-        @responses = @phase['responses'].map{ |response| Response.new(response, uri) }
+        @responses = @phase['responses'].map{ |response| Response.new(SDAM::convert_election_ids(response), uri) }
         @outcome = Outcome.new(@phase['outcome'])
       end
     end
@@ -158,10 +169,18 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(outcome)
-        @servers = outcome['servers']
+        @servers = process_servers(outcome['servers'])
         @set_name = outcome['setName']
         @topology_type = outcome['topologyType']
       end
+
+      private
+
+      def process_servers(servers)
+        servers.each do |s|
+          SDAM::convert_election_ids([ s[1] ])
+        end
+      end
     end
   end
 end

data/spec/support/server_selection.rb

@@ -70,7 +70,9 @@ module Mongo
         #
         # @since 2.0.0
         def initialize(file)
-          @test = YAML.load(ERB.new(File.new(file).read).result)
+          file = File.new(file)
+          @test = YAML.load(ERB.new(file.read).result)
+          file.close
           @description = "#{@test['topology_description']['type']}: #{File.basename(file)}"
           @read_preference = @test['read_preference']
           @read_preference['mode'] = READ_PREFERENCES[@read_preference['mode']]

data/spec/support/shared/bulk_write.rb

@@ -28,6 +28,19 @@ shared_examples 'a bulk write object' do
 
   context 'when an insert_one operation is provided' do
 
+    context 'when there is a write failure' do
+
+      let(:operations) do
+        [{ insert_one: { _id: 1 }}, { insert_one: { _id: 1 }}]
+      end
+
+      it 'raises a BulkWriteError' do
+        expect {
+          bulk.execute
+        }.to raise_error(Mongo::Error::BulkWriteError)
+      end
+    end
+
     context 'when a document is provided' do
 
       let(:operations) do
@@ -35,13 +48,34 @@ shared_examples 'a bulk write object' do
       end
 
       it 'returns n_inserted of 1' do
-        expect(bulk.execute[:n_inserted]).to eq(1)
+        expect(bulk.execute.inserted_count).to eq(1)
       end
 
       it 'only inserts that document' do
         bulk.execute
         expect(authorized_collection.find.first['name']).to eq('test')
       end
+
+      context 'when there is a write concern error' do
+
+        context 'when the server version is < 2.6' do
+
+          it 'raises a BulkWriteError', if: !write_command_enabled?  && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+        end
+
+        context 'when the server version has write commands enabled' do
+
+          it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::OperationFailure)
+          end
+        end
+      end
     end
 
     context 'when an invalid object is provided' do
@@ -94,13 +128,34 @@ shared_examples 'a bulk write object' do
     context 'when multiple documents match delete selector' do
 
       it 'reports n_removed correctly' do
-        expect(bulk.execute[:n_removed]).to eq(1)
+        expect(bulk.execute.deleted_count).to eq(1)
       end
 
       it 'deletes only matching documents' do
         bulk.execute
         expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
       end
+
+      context 'when there is a write concern error' do
+
+        context 'when the server version is < 2.6' do
+
+          it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+        end
+
+        context 'when the server version has write commands enabled' do
+
+          it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::OperationFailure)
+          end
+        end
+      end
     end
   end
 
@@ -136,13 +191,34 @@ shared_examples 'a bulk write object' do
       context 'when multiple documents match delete selector' do
 
         it 'reports n_removed correctly' do
-          expect(bulk.execute[:n_removed]).to eq(2)
+          expect(bulk.execute.deleted_count).to eq(2)
         end
 
         it 'deletes all matching documents' do
           bulk.execute
           expect(authorized_collection.find.to_a).to be_empty
         end
+
+        context 'when there is a write concern error' do
+
+          context 'when the server version is < 2.6' do
+
+            it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+              expect {
+                bulk_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::BulkWriteError)
+            end
+          end
+
+          context 'when the server version has write commands enabled' do
+
+            it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+              expect {
+                bulk_invalid_write_concern.execute
+              }.to raise_error(Mongo::Error::OperationFailure)
+            end
+          end
+        end
       end
 
       context 'when only one document matches delete selector' do
@@ -156,7 +232,7 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_removed correctly' do
-          expect(bulk.execute[:n_removed]).to eq(1)
+          expect(bulk.execute.deleted_count).to eq(1)
         end
 
         it 'deletes all matching documents' do
@@ -233,7 +309,7 @@ shared_examples 'a bulk write object' do
       end
 
       it 'reports n_matched correctly' do
-        expect(bulk.execute[:n_matched]).to eq(1)
+        expect(bulk.execute.matched_count).to eq(1)
       end
 
       it 'only applies the replacement to one matching document' do
@@ -241,6 +317,27 @@ shared_examples 'a bulk write object' do
         expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
       end
 
+      context 'when there is a write concern error' do
+
+        context 'when the server version is < 2.6' do
+
+          it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+        end
+
+        context 'when the server version has write commands enabled' do
+
+          it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::OperationFailure)
+          end
+        end
+      end
+
       context 'when upsert is true' do
 
         let(:operations) do
@@ -260,7 +357,7 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_matched correctly' do
-          expect(bulk.execute[:n_matched]).to eq(0)
+          expect(bulk.execute.matched_count).to eq(0)
         end
 
         it 'does not replace any documents' do
@@ -296,6 +393,22 @@ shared_examples 'a bulk write object' do
       [{ 'a' => 2 },  { 'a' => 1 }]
     end
 
+    context 'when there is a write failure' do
+
+      let(:operations) do
+        [{ update_one: { find: { a: 1 },
+                         update: { '$st' => { field: 'blah' } },
+                         upsert: false }
+         }]
+      end
+
+      it 'raises a BulkWriteError' do
+        expect {
+          bulk.execute
+        }.to raise_error(Mongo::Error::BulkWriteError)
+      end
+    end
+
     context 'when an update document is not specified' do
 
       let(:operations) do
@@ -331,19 +444,19 @@ shared_examples 'a bulk write object' do
     context 'when a valid update document is specified' do
 
       it 'reports n_modified correctly', if: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(1)
+        expect(bulk.execute.modified_count).to eq(1)
       end
 
       it 'reports n_modified correctly', unless: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(nil)
+        expect(bulk.execute.modified_count).to eq(nil)
       end
 
       it 'reports n_upserted correctly' do
-        expect(bulk.execute[:n_upserted]).to eq(0)
+        expect(bulk.execute.upserted_count).to eq(0)
       end
 
       it 'reports n_matched correctly' do
-        expect(bulk.execute[:n_matched]).to eq(1)
+        expect(bulk.execute.matched_count).to eq(1)
       end
 
       it 'applies the correct writes' do
@@ -351,6 +464,27 @@ shared_examples 'a bulk write object' do
         expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
       end
 
+      context 'when there is a write concern error' do
+
+        context 'when the server version is < 2.6' do
+
+          it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+        end
+
+        context 'when the server version has write commands enabled' do
+
+          it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::OperationFailure)
+          end
+        end
+      end
+
       context 'when upsert is true' do
 
         let(:operations) do
@@ -365,19 +499,23 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_modified correctly', if: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(0)
+          expect(bulk.execute.modified_count).to eq(0)
         end
 
         it 'reports n_modified correctly', unless: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(nil)
+          expect(bulk.execute.modified_count).to eq(nil)
         end
 
         it 'reports n_upserted correctly' do
-          expect(bulk.execute[:n_upserted]).to eq(1)
+          expect(bulk.execute.upserted_count).to eq(1)
+        end
+
+        it 'returns the upserted ids', if: write_command_enabled? do
+          expect(bulk.execute.upserted_ids.size).to eq(1)
         end
 
         it 'reports n_matched correctly' do
-          expect(bulk.execute[:n_matched]).to eq(0)
+          expect(bulk.execute.matched_count).to eq(0)
         end
 
         it 'applies the correct writes' do
@@ -413,6 +551,22 @@ shared_examples 'a bulk write object' do
       authorized_collection.insert_many(docs)
     end
 
+    context 'when there is a write failure' do
+
+      let(:operations) do
+        [{ update_many: { find: { a: 1 },
+                          update: { '$st' => { field: 'blah' } },
+                          upsert: false }
+         }]
+      end
+
+      it 'raises an BulkWriteError' do
+        expect {
+          bulk.execute
+        }.to raise_error(Mongo::Error::BulkWriteError)
+      end
+    end
+
     context 'when an update document is not specified' do
 
       let(:operations) do
@@ -444,19 +598,19 @@ shared_examples 'a bulk write object' do
     context 'when a valid update document is specified' do
 
       it 'reports n_modified correctly', if: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(2)
+        expect(bulk.execute.modified_count).to eq(2)
       end
 
       it 'reports n_modified correctly', unless: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(nil)
+        expect(bulk.execute.modified_count).to eq(nil)
       end
 
       it 'reports n_upserted correctly' do
-        expect(bulk.execute[:n_upserted]).to eq(0)
+        expect(bulk.execute.upserted_count).to eq(0)
       end
 
       it 'reports n_matched correctly' do
-        expect(bulk.execute[:n_matched]).to eq(2)
+        expect(bulk.execute.matched_count).to eq(2)
       end
 
       it 'applies the correct writes' do
@@ -464,6 +618,27 @@ shared_examples 'a bulk write object' do
         expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
       end
 
+      context 'when there is a write concern error' do
+
+        context 'when the server version is < 2.6' do
+
+          it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+        end
+
+        context 'when the server version has write commands enabled' do
+
+          it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+            expect {
+              bulk_invalid_write_concern.execute
+            }.to raise_error(Mongo::Error::OperationFailure)
+          end
+        end
+      end
+
       context 'when upsert is true' do
 
         let(:operations) do
@@ -478,19 +653,19 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_modified correctly', if: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(0)
+          expect(bulk.execute.modified_count).to eq(0)
         end
 
         it 'reports n_modified correctly', unless: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(nil)
+          expect(bulk.execute.modified_count).to eq(nil)
         end
 
         it 'reports n_upserted correctly' do
-          expect(bulk.execute[:n_upserted]).to eq(1)
+          expect(bulk.execute.upserted_count).to eq(1)
         end
 
         it 'reports n_matched correctly' do
-          expect(bulk.execute[:n_matched]).to eq(0)
+          expect(bulk.execute.matched_count).to eq(0)
         end
 
         it 'applies the correct writes' do
@@ -531,5 +706,26 @@ shared_examples 'a bulk write object' do
       bulk.execute
       expect(authorized_collection.find(x: { '$lte' => 3000 }).to_a.size).to eq(3000)
     end
+
+    context 'when there is a write concern error' do
+
+      context 'when the server version is < 2.6' do
+
+        it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+          expect {
+            bulk_invalid_write_concern.execute
+          }.to raise_error(Mongo::Error::BulkWriteError)
+        end
+      end
+
+      context 'when the server version has write commands enabled' do
+
+        it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+          expect {
+            bulk_invalid_write_concern.execute
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+    end
   end
 end

data/spec/support/shared/server_selector.rb

@@ -11,9 +11,10 @@ def server(mode, options = {})
               }
 
   listeners = Mongo::Event::Listeners.new
-  address = Mongo::Address.new('127.0.0.1:27017')
+  monitoring = Mongo::Monitoring.new
+  address = Mongo::Address.new(DEFAULT_ADDRESS)
 
-  server = Mongo::Server.new(address, double('cluster'), listeners, TEST_OPTIONS)
+  server = Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
   description = Mongo::Server::Description.new(address, ismaster, average_round_trip_time)
   server.tap do |s|
     allow(s).to receive(:description).and_return(description)
@@ -21,7 +22,7 @@ def server(mode, options = {})
 end
 
 shared_context 'server selector' do
-  let(:read_pref) { described_class.new(tag_sets) }
+
   let(:tag_sets) { [] }
   let(:tag_set) do
     { 'test' => 'tag' }
@@ -31,37 +32,82 @@ shared_context 'server selector' do
   end
   let(:primary) { server(:primary) }
   let(:secondary) { server(:secondary) }
+  let(:options) { { :mode => name, :tag_sets => tag_sets } }
+  let(:selector) { described_class.new(options) }
+
+  before(:all) do
+    module Mongo
+      # We monkey-patch the server here, so the monitors do not run and no
+      # real TCP connection is attempted.
+      #
+      # @since 2.1.0
+      class Server
+
+        alias :original_initialize :initialize
+        def initialize(address, cluster, monitoring, event_listeners, options = {})
+          @address = address
+          @cluster = cluster
+          @monitoring = monitoring
+          @options = options.freeze
+          @monitor = Monitor.new(address, event_listeners, options)
+        end
+
+        alias :original_disconnect! :disconnect!
+        def disconnect!; true; end
+      end
+    end
+  end
+
+  after(:all) do
+
+    # Return the server implementation to its original for the other
+    # tests in the suite.
+    module Mongo
+      class Server
+        alias :initialize :original_initialize
+        remove_method(:original_initialize)
+
+        alias :disconnect! :original_disconnect!
+        remove_method(:original_disconnect!)
+      end
+    end
+  end
 end
 
-shared_examples 'a read preference mode' do
+shared_examples 'a server selector mode' do
 
   describe '#name' do
 
     it 'returns the name' do
-      expect(read_pref.name).to eq(name)
+      expect(selector.name).to eq(name)
     end
   end
 
   describe '#slave_ok?' do
 
     it 'returns whether the slave_ok bit should be set' do
-      expect(read_pref.slave_ok?).to eq(slave_ok)
+      expect(selector.slave_ok?).to eq(slave_ok)
     end
   end
 
   describe '#==' do
 
     context 'when mode is the same' do
-      let(:other) { described_class.new }
+
+      let(:other) do
+        described_class.new
+      end
 
       context 'tag sets are the same' do
+
         it 'returns true' do
-          expect(read_pref).to eq(other)
+          expect(selector).to eq(other)
         end
       end
     end
 
     context 'mode is different' do
+
       let(:other) do
         double('selectable').tap do |mode|
           allow(mode).to receive(:name).and_return(:other)
@@ -69,28 +115,31 @@ shared_examples 'a read preference mode' do
       end
 
       it 'returns false' do
-        expect(read_pref).not_to eq(other)
+        expect(selector).not_to eq(other)
       end
     end
   end
 end
 
-shared_examples 'a read preference mode accepting tag sets' do
+shared_examples 'a server selector accepting tag sets' do
 
   describe '#tag_sets' do
 
     context 'tags not provided' do
 
       it 'returns an empty array' do
-        expect(read_pref.tag_sets).to be_empty
+        expect(selector.tag_sets).to be_empty
       end
     end
 
     context 'tag sets provided' do
-      let(:tag_sets) { [tag_set] }
+
+      let(:tag_sets) do
+        [ tag_set ]
+      end
 
       it 'returns the tag sets' do
-        expect(read_pref.tag_sets).to eq(tag_sets)
+        expect(selector.tag_sets).to eq(tag_sets)
       end
     end
   end
@@ -103,9 +152,26 @@ shared_examples 'a read preference mode accepting tag sets' do
         let(:tag_sets) { { 'other' => 'tag'  } }
 
         it 'returns false' do
-          expect(read_pref).not_to eq(other)
+          expect(selector).not_to eq(other)
         end
       end
     end
   end
 end
+
+shared_examples 'a server selector with sensitive data in its options' do
+
+  describe '#inspect' do
+
+    context 'when there is sensitive data in the options' do
+
+      let(:options) do
+        Mongo::Options::Redacted.new(:mode => name, :password => 'sensitive_data')
+      end
+
+      it 'does not print out sensitive data' do
+        expect(selector.inspect).not_to match(options[:password])
+      end
+    end
+  end
+end