mongo 2.5.3 → 2.6.0

data/spec/mongo/error/parser_spec.rb

@@ -95,4 +95,131 @@ describe Mongo::Error::Parser do
       end
     end
   end
+  
+  describe '#code' do
+    let(:parser) do
+      described_class.new(document)
+    end
+
+    context 'when document contains code' do
+      let(:document) do
+        { 'ok' => 0, 'errmsg' => 'not master', 'code' => 10107, 'codeName' => 'NotMaster' }
+      end
+      
+      it 'returns the code' do
+        expect(parser.code).to eq(10107)
+      end
+    end
+
+    context 'when document does not contain code' do
+      let(:document) do
+        { 'ok' => 0, 'errmsg' => 'not master' }
+      end
+      
+      it 'returns nil' do
+        expect(parser.code).to eq(nil)
+      end
+    end
+
+    context 'when the document contains a writeConcernError with a code' do
+
+      let(:document) do
+        { 'writeConcernError' => { 'code' => 100, 'errmsg' => 'Not enough data-bearing nodes' } }
+      end
+
+      it 'returns the code' do
+        expect(parser.code).to eq(100)
+      end
+    end
+
+    context 'when the document contains a writeConcernError without a code' do
+
+      let(:document) do
+        { 'writeConcernError' => { 'errmsg' => 'Not enough data-bearing nodes' } }
+      end
+
+      it 'returns nil' do
+        expect(parser.code).to be nil
+      end
+    end
+  end
+  
+  describe '#code_name' do
+    let(:parser) do
+      described_class.new(document)
+    end
+
+    context 'when document contains code name' do
+      let(:document) do
+        { 'ok' => 0, 'errmsg' => 'not master', 'code' => 10107, 'codeName' => 'NotMaster' }
+      end
+      
+      it 'returns the code name' do
+        expect(parser.code_name).to eq('NotMaster')
+      end
+    end
+
+    context 'when document does not contain code name' do
+      let(:document) do
+        { 'ok' => 0, 'errmsg' => 'not master' }
+      end
+      
+      it 'returns nil' do
+        expect(parser.code_name).to eq(nil)
+      end
+    end
+
+    context 'when the document contains a writeConcernError with a code' do
+
+      let(:document) do
+        { 'writeConcernError' => { 'code' => 100, 'codeName' => 'CannotSatisfyWriteConcern',
+          'errmsg' => 'Not enough data-bearing nodes' } }
+      end
+
+      it 'returns the code name' do
+        expect(parser.code_name).to eq('CannotSatisfyWriteConcern')
+      end
+    end
+
+    context 'when the document contains a writeConcernError without a code' do
+
+      let(:document) do
+        { 'writeConcernError' => { 'code' => 100, 'errmsg' => 'Not enough data-bearing nodes' } }
+      end
+
+      it 'returns nil' do
+        expect(parser.code_name).to be nil
+      end
+    end
+  end
+  
+  describe '#document' do
+    let(:parser) do
+      described_class.new(document)
+    end
+
+    let(:document) do
+      { 'ok' => 0, 'errmsg' => 'not master', 'code' => 10107, 'codeName' => 'NotMaster' }
+    end
+    
+    it 'returns the document' do
+      expect(parser.document).to eq(document)
+    end
+  end
+  
+  describe '#replies' do
+    let(:parser) do
+      described_class.new(document)
+    end
+
+    context 'when there are no replies' do
+      let(:document) do
+        { 'ok' => 0, 'errmsg' => 'not master', 'code' => 10107, 'codeName' => 'NotMaster' }
+      end
+      
+      it 'returns nil' do
+        expect(parser.replies).to eq(nil)
+      end
+    end
+  end
 end

data/spec/mongo/grid/fs_bucket_spec.rb

@@ -98,6 +98,38 @@ describe Mongo::Grid::FSBucket do
             expect(stream.write_concern.options).to eq(Mongo::WriteConcern.get(options[:write]).options)
           end
         end
+
+        context 'when disable_md5 is not specified' do
+
+          it 'does not set the option on the write stream' do
+            expect(stream.options[:disable_md5]).to be_nil
+          end
+        end
+
+        context 'when disable_md5 is specified' do
+
+          context 'when disable_md5 is true' do
+
+            let(:options) do
+              { disable_md5: true }
+            end
+
+            it 'passes the option to the write stream' do
+              expect(stream.options[:disable_md5]).to be(true)
+            end
+          end
+
+          context 'when disable_md5 is false' do
+
+            let(:options) do
+              { disable_md5: false }
+            end
+
+            it 'passes the option to the write stream' do
+              expect(stream.options[:disable_md5]).to be(false)
+            end
+          end
+        end
       end
     end
   end

data/spec/mongo/grid/stream/write_spec.rb

@@ -27,7 +27,7 @@ describe Mongo::Grid::FSBucket::Stream::Write do
   end
 
   let(:options) do
-    { filename: filename }.merge(extra_options)
+    { filename: filename }.merge(extra_options).merge(fs.options)
   end
 
   after do
@@ -53,6 +53,45 @@ describe Mongo::Grid::FSBucket::Stream::Write do
       expect(stream.close).to be_a(BSON::ObjectId)
     end
 
+    context 'when the fs does not have disable_md5 specified' do
+
+      it 'sets an md5 for the file' do
+        stream.send(:file_info).to_bson
+        expect(stream.send(:file_info).document[:md5].size).to eq(32)
+      end
+    end
+
+    context 'when the fs has disable_md5 specified' do
+
+      before do
+        stream.send(:file_info).to_bson
+      end
+
+      context 'when disable_md5 is true' do
+
+        let(:fs_options) do
+          { disable_md5: true }
+        end
+
+        it 'does not set an md5 for the file' do
+          expect(stream.send(:file_info).document.has_key?(:md5)). to be(false)
+          expect(stream.send(:file_info).document[:md5]). to be_nil
+        end
+      end
+
+      context 'when disabled_md5 is false' do
+
+        let(:fs_options) do
+          { disable_md5: false }
+        end
+
+        it 'sets an md5 for the file' do
+          stream.send(:file_info).to_bson
+          expect(stream.send(:file_info).document[:md5].size).to eq(32)
+        end
+      end
+    end
+
     context 'when the fs has a write concern', if: standalone? do
 
       let(:fs_options) do

data/spec/mongo/monitoring/event/command_failed_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Mongo::Monitoring::Event::CommandFailed do
+
+  let(:address) do
+    Mongo::Address.new('127.0.0.1:27017')
+  end
+
+  describe '#command_name' do
+    context 'when command_name is given as a string' do
+      let(:event) do
+        described_class.new('find', 'admin', address, 1, 2, 'Uh oh', nil, 0.5)
+      end
+
+      it 'is a string' do
+        expect(event.command_name).to eql('find')
+      end
+    end
+
+    context 'when command_name is given as a symbol' do
+      let(:event) do
+        described_class.new(:find, 'admin', address, 1, 2, 'Uh oh', nil, 0.5)
+      end
+
+      it 'is a string' do
+        expect(event.command_name).to eql('find')
+      end
+    end
+  end
+end

data/spec/mongo/monitoring/event/command_started_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Mongo::Monitoring::Event::CommandStarted do
 
-  describe '#initialize' do
+  let(:address) do
+    Mongo::Address.new('127.0.0.1:27017')
+  end
 
-    let(:address) do
-      Mongo::Address.new('127.0.0.1:27017')
-    end
+  describe '#initialize' do
 
     let(:command) do
       BSON::Document.new(test: 'value')
@@ -23,4 +23,26 @@ describe Mongo::Monitoring::Event::CommandStarted do
       end
     end
   end
+
+  describe '#command_name' do
+    context 'when command_name is given as a string' do
+      let(:event) do
+        described_class.new('find', 'admin', address, 1, 2, {})
+      end
+
+      it 'is a string' do
+        expect(event.command_name).to eql('find')
+      end
+    end
+
+    context 'when command_name is given as a symbol' do
+      let(:event) do
+        described_class.new(:find, 'admin', address, 1, 2, {})
+      end
+
+      it 'is a string' do
+        expect(event.command_name).to eql('find')
+      end
+    end
+  end
 end

data/spec/mongo/monitoring/event/command_succeeded_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe Mongo::Monitoring::Event::CommandSucceeded do
 
-  describe '#initialize' do
+  let(:address) do
+    Mongo::Address.new('127.0.0.1:27017')
+  end
 
-    let(:address) do
-      Mongo::Address.new('127.0.0.1:27017')
-    end
+  let(:reply) do
+    BSON::Document.new(test: 'value')
+  end
 
-    let(:reply) do
-      BSON::Document.new(test: 'value')
-    end
+  describe '#initialize' do
 
     context 'when the reply should be redacted' do
 
@@ -23,4 +23,26 @@ describe Mongo::Monitoring::Event::CommandSucceeded do
       end
     end
   end
+
+  describe '#command_name' do
+    context 'when command_name is given as a string' do
+      let(:event) do
+        described_class.new('find', 'admin', address, 1, 2, reply, 0.5)
+      end
+
+      it 'is a string' do
+        expect(event.command_name).to eql('find')
+      end
+    end
+
+    context 'when command_name is given as a symbol' do
+      let(:event) do
+        described_class.new(:find, 'admin', address, 1, 2, reply, 0.5)
+      end
+
+      it 'is a string' do
+        expect(event.command_name).to eql('find')
+      end
+    end
+  end
 end

data/spec/mongo/monitoring_spec.rb

@@ -85,12 +85,37 @@ describe Mongo::Monitoring do
       double('subscriber')
     end
 
-    before do
+    it 'subscribes to the topic' do
       monitoring.subscribe('topic', subscriber)
+      expect(monitoring.subscribers['topic']).to eq([ subscriber ])
     end
 
-    it 'subscribes to the topic' do
-      expect(monitoring.subscribers['topic']).to eq([ subscriber ])
+    it 'subscribes to the topic twice' do
+      monitoring.subscribe('topic', subscriber)
+      monitoring.subscribe('topic', subscriber)
+      expect(monitoring.subscribers['topic']).to eq([ subscriber, subscriber ])
+    end
+  end
+
+  describe '#unsubscribe' do
+
+    let(:monitoring) do
+      described_class.new(monitoring: false)
+    end
+
+    let(:subscriber) do
+      double('subscriber')
+    end
+
+    it 'unsubscribes from the topic' do
+      monitoring.subscribe('topic', subscriber)
+      monitoring.unsubscribe('topic', subscriber)
+      expect(monitoring.subscribers['topic']).to eq([ ])
+    end
+
+    it 'unsubscribes from the topic when not subscribed' do
+      monitoring.unsubscribe('topic', subscriber)
+      expect(monitoring.subscribers['topic']).to eq([ ])
     end
   end
 

data/spec/mongo/protocol/get_more_spec.rb

@@ -30,7 +30,7 @@ describe Mongo::Protocol::GetMore do
 
   describe '#==' do
 
-    context 'when the other is a getmore' do
+    context 'when the other is a getMore' do
 
       context 'when the fields are equal' do
         let(:other) do
@@ -83,7 +83,7 @@ describe Mongo::Protocol::GetMore do
       end
     end
 
-    context 'when the other is not a getmore' do
+    context 'when the other is not a getMore' do
       let(:other) do
         expect(message).not_to eq('test')
       end

data/spec/mongo/retryable_spec.rb

@@ -1,41 +1,74 @@
 require 'spec_helper'
 
-describe Mongo::Retryable do
+class RetryableTestConsumer
+  include Mongo::Retryable
 
-  let(:klass) do
-    Class.new do
-      include Mongo::Retryable
+  attr_reader :cluster
+  attr_reader :operation
 
-      attr_reader :cluster
-      attr_reader :operation
+  def initialize(operation, cluster)
+    @operation = operation
+    @cluster = cluster
+  end
 
-      def initialize(operation, cluster)
-        @operation = operation
-        @cluster = cluster
-      end
+  def max_read_retries
+    cluster.max_read_retries
+  end
 
-      def max_read_retries
-        cluster.max_read_retries
-      end
+  def read_retry_interval
+    cluster.read_retry_interval
+  end
 
-      def read_retry_interval
-        cluster.read_retry_interval
-      end
+  def read
+    read_with_retry do
+      operation.execute
+    end
+  end
 
-      def read
-        read_with_retry do
-          operation.execute
-        end
-      end
+  def write
+    # This passes a nil session and therefore triggers
+    # legacy_write_with_retry code path
+    write_with_retry(session, write_concern) do
+      operation.execute
+    end
+  end
 
-      def write
-        write_with_retry(nil, nil) do
-          operation.execute
-        end
-      end
+  def retry_write_allowed_as_configured?
+    retry_write_allowed?(session, write_concern)
+  end
+end
+
+class LegacyRetryableTestConsumer < RetryableTestConsumer
+  def session
+    nil
+  end
+
+  def write_concern
+    nil
+  end
+end
+
+class ModernRetryableTestConsumer < LegacyRetryableTestConsumer
+  include RSpec::Mocks::ExampleMethods
+
+  def session
+    double('session').tap do |session|
+      expect(session).to receive(:retry_writes?).and_return(true)
+
+      # mock everything else that is in the way
+      i = 1
+      allow(session).to receive(:next_txn_num) { i += 1 }
+      allow(session).to receive(:in_transaction?).and_return(false)
     end
   end
 
+  def write_concern
+    nil
+  end
+end
+
+describe Mongo::Retryable do
+
   let(:operation) do
     double('operation')
   end
@@ -49,7 +82,7 @@ describe Mongo::Retryable do
   end
 
   let(:retryable) do
-    klass.new(operation, cluster)
+    LegacyRetryableTestConsumer.new(operation, cluster)
   end
 
   describe '#read_with_retry' do
@@ -132,7 +165,7 @@ describe Mongo::Retryable do
         context 'when the operation failure is retryable' do
 
           let(:error) do
-            Mongo::Error::OperationFailure.new('no master')
+            Mongo::Error::OperationFailure.new('not master')
           end
 
           context 'when the retry succeeds' do
@@ -173,7 +206,12 @@ describe Mongo::Retryable do
     end
   end
 
-  describe '#write_with_retry' do
+  describe '#write_with_retry - legacy' do
+
+    before do
+      # Quick sanity check that the expected code path is being exercised
+      expect(retryable.retry_write_allowed_as_configured?).to be false
+    end
 
     context 'when no exception occurs' do
 
@@ -186,32 +224,174 @@ describe Mongo::Retryable do
       end
     end
 
+    shared_examples 'executes the operation twice' do
+      it 'executes the operation twice' do
+        expect(retryable.write).to be true
+      end
+    end
+
     context 'when a not master error occurs' do
 
       before do
-        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure.new('not master')).ordered
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::OperationFailure.new('not master')).ordered
         expect(cluster).to receive(:scan!).and_return(true).ordered
         expect(operation).to receive(:execute).and_return(true).ordered
       end
 
-      it 'executes the operation twice' do
-        expect(retryable.write).to be true
+      it_behaves_like 'executes the operation twice'
+    end
+
+    context 'when a node is recovering error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::OperationFailure.new('node is recovering')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
       end
+
+      it_behaves_like 'executes the operation twice'
     end
 
-    context 'when a not primary error occurs' do
+    context 'when a retryable error occurs with a code' do
 
       before do
-        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure.new('Not primary')).ordered
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::OperationFailure.new('message missing', nil,
+            :code => 91, :code_name => 'ShutdownInProgress')).ordered
         expect(cluster).to receive(:scan!).and_return(true).ordered
         expect(operation).to receive(:execute).and_return(true).ordered
       end
 
+      it_behaves_like 'executes the operation twice'
+    end
+
+    context 'when a normal operation failure occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when a socket error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::SocketError.new('socket error')).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::SocketError)
+      end
+    end
+
+    context 'when a socket timeout occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::SocketTimeoutError.new('socket timeout')).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::SocketTimeoutError)
+      end
+    end
+
+    context 'when a non-retryable exception occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::UnsupportedCollation.new('unsupported collation')).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::UnsupportedCollation)
+      end
+    end
+
+  end
+
+  describe '#write_with_retry - modern' do
+
+    let(:retryable) do
+      ModernRetryableTestConsumer.new(operation, cluster)
+    end
+
+    before do
+      # Quick sanity check that the expected code path is being exercised
+      expect(retryable.retry_write_allowed_as_configured?).to be true
+
+      allow(server_selector).to receive(:retry_writes?).and_return(true)
+      allow(cluster).to receive(:scan!)
+    end
+
+    context 'when no exception occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_return(true)
+      end
+
+      it 'executes the operation once' do
+        expect(retryable.write).to be true
+      end
+    end
+
+    shared_examples 'executes the operation twice' do
       it 'executes the operation twice' do
         expect(retryable.write).to be true
       end
     end
 
+    context 'when a not master error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::OperationFailure.new('not master')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it_behaves_like 'executes the operation twice'
+    end
+
+    context 'when a node is recovering error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::OperationFailure.new('node is recovering')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it_behaves_like 'executes the operation twice'
+    end
+
+    context 'when a retryable error occurs with a code' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::OperationFailure.new('message missing', nil,
+            :code => 91, :code_name => 'ShutdownInProgress')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it_behaves_like 'executes the operation twice'
+    end
+
     context 'when a normal operation failure occurs' do
 
       before do
@@ -225,5 +405,43 @@ describe Mongo::Retryable do
       end
     end
 
+    context 'when a socket error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::SocketError.new('socket error')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it_behaves_like 'executes the operation twice'
+    end
+
+    context 'when a socket timeout occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::SocketTimeoutError.new('socket timeout')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it_behaves_like 'executes the operation twice'
+    end
+
+    context 'when a non-retryable exception occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(
+          Mongo::Error::UnsupportedCollation.new('unsupported collation')).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::UnsupportedCollation)
+      end
+    end
+
   end
 end