mongo 2.13.0.beta1 → 2.14.0

data/spec/mongo/collection/view/change_stream_resume_spec.rb

@@ -183,7 +183,7 @@ describe Mongo::Collection::View::ChangeStream do
 
   context 'when a killCursors command is issued for the cursor' do
     context 'using Enumerable' do
-      only_mri
+      require_mri
 
       before do
         change_stream
@@ -196,7 +196,7 @@ describe Mongo::Collection::View::ChangeStream do
         change_stream.to_enum
       end
 
-      it 'propagates cursor not found error' do
+      it 'resumes on a cursor not found error' do
         original_cursor_id = cursor.id
 
         client.use(:admin).command({
@@ -204,9 +204,9 @@ describe Mongo::Collection::View::ChangeStream do
           cursors: [cursor.id]
         })
 
-        lambda do
+        expect do
           enum.next
-        end.should raise_error(Mongo::Error::OperationFailure, /cursor.*not found/)
+        end.not_to raise_error
       end
     end
 
@@ -218,7 +218,7 @@ describe Mongo::Collection::View::ChangeStream do
         collection.insert_one(a:2)
       end
 
-      it 'propagates cursor not found error' do
+      it 'resumes on a cursor not found error' do
         original_cursor_id = cursor.id
 
         client.use(:admin).command({
@@ -226,9 +226,9 @@ describe Mongo::Collection::View::ChangeStream do
           cursors: [cursor.id]
         })
 
-        lambda do
+        expect do
           change_stream.try_next
-        end.should raise_error(Mongo::Error::OperationFailure, /cursor.*not found/)
+        end.not_to raise_error
       end
     end
   end

data/spec/mongo/collection/view/explainable_spec.rb

@@ -20,12 +20,95 @@ describe Mongo::Collection::View::Explainable do
 
   describe '#explain' do
 
-    let(:explain) do
-      view.explain
+    shared_examples 'executes the explain' do
+      context '3.0+ server' do
+        min_server_fcv '3.0'
+
+        context 'not sharded' do
+          require_topology :single, :replica_set
+
+          it 'executes the explain' do
+            explain[:queryPlanner][:namespace].should == authorized_collection.namespace
+          end
+        end
+
+        context 'sharded' do
+          require_topology :sharded
+
+          context 'pre-3.2 server' do
+            max_server_version '3.0'
+
+            it 'executes the explain' do
+              explain[:queryPlanner][:parsedQuery].should be_a(Hash)
+            end
+          end
+
+          context '3.2+ server' do
+            min_server_fcv '3.2'
+
+            it 'executes the explain' do
+              explain[:queryPlanner][:mongosPlannerVersion].should == 1
+            end
+          end
+        end
+      end
+
+      context '2.6 server' do
+        max_server_version '2.6'
+
+        it 'executes the explain' do
+          explain[:cursor].should == 'BasicCursor'
+        end
+      end
+    end
+
+    context 'without arguments' do
+      let(:explain) do
+        view.explain
+      end
+
+      include_examples 'executes the explain'
     end
 
-    it 'executes an explain' do
-      expect(explain[:cursor] == 'BasicCursor' || explain[:queryPlanner]).to be_truthy
+    context 'with verbosity argument' do
+      let(:explain) do
+        view.explain(verbosity: verbosity)
+      end
+
+      shared_examples 'triggers server error' do
+        # 3.0 does not produce the error.
+        min_server_fcv '3.2'
+
+        it 'triggers server error' do
+          lambda do
+            explain
+          end.should raise_error(Mongo::Error::OperationFailure, /verbosity string must be/)
+        end
+      end
+
+      context 'valid symbol value' do
+        let(:verbosity) { :query_planner }
+
+        include_examples 'executes the explain'
+      end
+
+      context 'valid string value' do
+        let(:verbosity) { 'executionStats' }
+
+        include_examples 'executes the explain'
+      end
+
+      context 'invalid symbol value' do
+        let(:verbosity) { :bogus }
+
+        include_examples 'triggers server error'
+      end
+
+      context 'invalid string value' do
+        let(:verbosity) { 'bogus' }
+
+        include_examples 'triggers server error'
+      end
     end
   end
 end

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -581,6 +581,7 @@ describe Mongo::Collection::View::MapReduce do
 
       context 'when the server is not valid for writing' do
         clean_slate
+        require_warning_clean
 
         before do
           stop_monitoring(authorized_client)
@@ -661,6 +662,7 @@ describe Mongo::Collection::View::MapReduce do
 
       context 'when the server is a valid for writing' do
         clean_slate
+        require_warning_clean
 
         before do
           stop_monitoring(authorized_client)

data/spec/mongo/collection/view/readable_spec.rb

@@ -602,6 +602,42 @@ describe Mongo::Collection::View::Readable do
     end
   end
 
+  describe "#estimated_document_count" do
+
+   let(:documents) do
+      (1..10).map{ |i| { field: "test#{i}" }}
+   end
+
+   before do
+    authorized_collection.delete_many
+    authorized_collection.insert_many(documents)
+   end
+
+    let(:result) do
+      view.estimated_document_count(options)
+    end
+
+    context 'when a selector is provided' do
+
+      let(:selector) do
+        { field: 'test1' }
+      end
+
+      it 'raises an error' do
+        expect {
+          result
+        }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with a filter")
+      end
+    end
+
+    context 'when no selector is provided' do
+
+      it 'returns the estimated count of matching documents' do
+        expect(view.estimated_document_count).to eq(10)
+      end
+    end
+  end
+
   describe '#distinct' do
 
     context 'when incorporating read concern' do

data/spec/mongo/collection_spec.rb

@@ -821,6 +821,38 @@ describe Mongo::Collection do
           end
         end
 
+        context 'when write concern passed in as an option' do
+          min_server_fcv '3.4'
+          require_topology :replica_set
+
+          before do
+            database['collection_spec'].drop
+          end
+
+          let(:events) do
+            subscriber.command_started_events('create')
+          end
+
+          let(:options) do
+            { write_concern: {w: 1} }
+          end
+
+          let!(:collection) do
+            authorized_collection.with(options)
+          end
+
+          let!(:command) do
+            Utils.get_command_event(authorized_client, 'create') do |client|
+              collection.create({ write_concern: {w: 2} })
+            end.command
+          end
+
+          it 'applies the write concern passed in as an option' do
+            expect(events.length).to eq(1)
+            expect(command[:writeConcern][:w]).to eq(2)
+          end
+        end
+
         context 'when the server does not support write concern on the create command' do
           max_server_version '3.2'
 
@@ -941,6 +973,30 @@ describe Mongo::Collection do
         it_behaves_like 'a failed operation using a session'
       end
     end
+
+    context 'when collation has a strength' do
+      min_server_fcv '3.4'
+
+      let(:band_collection) do
+        described_class.new(database, :bands)
+      end
+
+      before do
+        band_collection.delete_many
+        band_collection.insert_many([{ name: "Depeche Mode" }, { name: "New Order" }])
+      end
+
+      let(:options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+      let(:band_result) do
+        band_collection.find({ name: 'DEPECHE MODE' }, options)
+      end
+
+      it 'finds Capitalize from UPPER CASE' do
+        expect(band_result.count_documents).to eq(1)
+      end
+    end
   end
 
   describe '#drop' do
@@ -1035,6 +1091,34 @@ describe Mongo::Collection do
           end
         end
 
+        context 'when write concern passed in as an option' do
+          min_server_fcv '3.4'
+          require_set_write_concern
+
+          let(:events) do
+            subscriber.command_started_events('drop')
+          end
+
+          let(:options) do
+            { write_concern: {w: 1} }
+          end
+
+          let!(:collection) do
+            authorized_collection.with(options)
+          end
+
+          let!(:command) do
+            Utils.get_command_event(authorized_client, 'drop') do |client|
+              collection.drop({ write_concern: {w: 0} })
+            end.command
+          end
+
+          it 'applies the write concern passed in as an option' do
+            expect(events.length).to eq(1)
+            expect(command[:writeConcern][:w]).to eq(0)
+          end
+        end
+
         context 'when the server does not support write concern on the drop command' do
           max_server_version '3.2'
 
@@ -1601,6 +1685,40 @@ describe Mongo::Collection do
         expect(result.inserted_count).to be(0)
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('insert')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'insert') do |client|
+          collection.insert_many([{ name: 'test1' }, { name: 'test2' }], session: session,
+            write_concern: {w: 1}, bypass_document_validation: true)
+        end.command
+      end
+
+      it 'inserts many successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to be(true)
+      end
+    end
   end
 
   describe '#insert_one' do
@@ -1683,6 +1801,37 @@ describe Mongo::Collection do
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
 
+    context 'when various options passed in' do
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('insert')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 3})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'insert') do |client|
+          collection.insert_one({name: 'test1'}, session: session, write_concern: {w: 1},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      it 'inserts one successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to be(true)
+      end
+    end
+
     context 'when the document contains invalid keys' do
 
       let(:doc) do
@@ -1696,6 +1845,18 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when the document is nil' do
+      let(:result) do
+        authorized_collection.insert_one(nil)
+      end
+
+      it 'raises an ArgumentError' do
+       expect {
+         result
+       }.to raise_error(ArgumentError, "Document to be inserted cannot be nil")
+     end
+    end
+
     context 'when the insert fails' do
 
       let(:result) do
@@ -1791,6 +1952,52 @@ describe Mongo::Collection do
     end
   end
 
+  describe '#bulk_write' do
+
+    context 'when various options passed in' do
+      min_server_fcv '3.2'
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:requests) do
+        [
+          { insert_one: { name: "anne" }},
+          { insert_one: { name: "bob" }},
+          { insert_one: { name: "charlie" }}
+        ]
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'insert') do |client|
+          collection.bulk_write(requests, session: session, write_concern: {w: 1},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      let(:events) do
+        subscriber.command_started_events('insert')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      it 'inserts successfully with correct options sent to server' do
+        expect(collection.count).to eq(3)
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to eq(true)
+      end
+    end
+  end
+
   describe '#inspect' do
 
     it 'includes the object id' do
@@ -2000,6 +2207,39 @@ describe Mongo::Collection do
   end
 
   describe '#count_documents' do
+
+    before do
+      authorized_collection.delete_many
+    end
+
+    context 'no argument provided' do
+
+      context 'when collection is empty' do
+        it 'returns 0 matching documents' do
+          expect(authorized_collection.count_documents).to eq(0)
+        end
+      end
+
+      context 'when collection is not empty' do
+
+        let(:documents) do
+          documents = []
+          1.upto(10) do |index|
+            documents << { key: 'a', _id: "in#{index}" }
+          end
+          documents
+        end
+
+        before do
+          authorized_collection.insert_many(documents)
+        end
+
+        it 'returns 10 matching documents' do
+          expect(authorized_collection.count_documents).to eq(10)
+        end
+      end
+    end
+
     context 'when transactions are enabled' do
       require_wired_tiger
       require_transaction_support
@@ -2478,6 +2718,48 @@ describe Mongo::Collection do
         expect(authorized_collection.find(name: 'bang').count).to eq(1)
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.insert_many([{ name: 'test1' }, { name: 'test2' }])
+      end
+
+      let(:selector) do
+        {name: 'test2'}
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('delete')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'delete') do |client|
+          collection.delete_one(selector, session: session, write_concern: {w: 1},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      it 'deletes one successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to eq(true)
+      end
+    end
   end
 
   describe '#delete_many' do
@@ -2668,6 +2950,48 @@ describe Mongo::Collection do
         expect(authorized_collection.find(name: 'bang').count).to eq(2)
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        collection.insert_many([{ name: 'test1' }, { name: 'test2' }, { name: 'test3'}])
+      end
+
+      let(:selector) do
+        {name: 'test1'}
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('delete')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 1})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'delete') do |client|
+          collection.delete_many(selector, session: session, write_concern: {w: 2},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      it 'deletes many successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to be(true)
+      end
+    end
   end
 
   describe '#parallel_scan' do
@@ -3174,6 +3498,51 @@ describe Mongo::Collection do
 
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.insert_one({field: 'test1'})
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('update')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 3})
+      end
+
+      let(:updated) do
+        collection.find(field: 'test4').first
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'update') do |client|
+          collection.replace_one(selector, { field: 'test4'},
+            session: session, :return_document => :after, write_concern: {w: 2},
+            upsert: true, bypass_document_validation: true)
+       end.command
+      end
+
+      it 'replaced one successfully with correct options sent to server' do
+        expect(updated[:field]).to eq('test4')
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:updates][0][:upsert]).to be(true)
+      end
+    end
   end
 
   describe '#update_many' do
@@ -3596,6 +3965,45 @@ describe Mongo::Collection do
 
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        collection.insert_many([{ field: 'test' }, { field: 'test2' }], session: session)
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 1})
+      end
+
+      let(:events) do
+        subscriber.command_started_events('update')
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'update') do |client|
+          collection.update_many(selector, {'$set'=> { field: 'testing' }}, session: session,
+            write_concern: {w: 2}, bypass_document_validation: true, upsert: true)
+        end.command
+      end
+
+      it 'updates many successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(collection.options[:write_concern]).to eq(w: 1)
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:updates][0][:upsert]).to be(true)
+      end
+    end
   end
 
   describe '#update_one' do
@@ -4014,6 +4422,47 @@ describe Mongo::Collection do
 
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        collection.insert_many([{ field: 'test1' }, { field: 'test2' }], session: session)
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 1})
+      end
+
+      let(:events) do
+        subscriber.command_started_events('update')
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'update') do |client|
+          collection.update_one(selector, { '$set'=> { field: 'testing' } }, session: session,
+            write_concern: {w: 2}, bypass_document_validation: true, :return_document => :after,
+            upsert: true)
+        end.command
+      end
+
+      it 'updates one successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(collection.options[:write_concern]).to eq(w:1)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:updates][0][:upsert]).to be(true)
+      end
+    end
   end
 
   describe '#find_one_and_delete' do
@@ -4231,6 +4680,46 @@ describe Mongo::Collection do
         expect(result).to be_nil
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.delete_many
+        authorized_collection.insert_many([{ name: 'test1' }, { name: 'test2' }])
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'findAndModify') do |client|
+          collection.find_one_and_delete(selector, session: session, write_concern: {w: 2},
+            bypass_document_validation: true, max_time_ms: 300)
+        end.command
+      end
+
+      let(:events) do
+        subscriber.command_started_events('findAndModify')
+      end
+
+      it 'finds and deletes successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to eq(true)
+        expect(command[:maxTimeMS]).to eq(300)
+      end
+    end
   end
 
   describe '#find_one_and_update' do
@@ -4652,6 +5141,51 @@ describe Mongo::Collection do
         end
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('findAndModify')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let(:selector) do
+        {field: 'test1'}
+      end
+
+      before do
+        collection.insert_one({field: 'test1'}, session: session)
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'findAndModify') do |client|
+          collection.find_one_and_update(selector, { '$set' => {field: 'testing'}},
+            :return_document => :after, write_concern: {w: 1}, upsert: true,
+            bypass_document_validation: true, max_time_ms: 100, session: session)
+        end.command
+      end
+
+      it 'find and updates successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:upsert]).to eq(true)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:maxTimeMS]).to eq(100)
+      end
+    end
   end
 
   describe '#find_one_and_replace' do
@@ -4965,6 +5499,44 @@ describe Mongo::Collection do
         expect(result).to be_nil
       end
     end
+
+    context 'when various options passed in' do
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.insert_one({field: 'test1'})
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('findAndModify')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: { w: 2 })
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'findAndModify') do |client|
+          collection.find_one_and_replace(selector, { '$set' => {field: 'test5'}},
+            :return_document => :after, write_concern: {w: 1}, session: session,
+            upsert: true, bypass_document_validation: false, max_time_ms: 200)
+        end.command
+      end
+
+      it 'find and replaces successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:upsert]).to be(true)
+        expect(command[:bypassDocumentValidation]).to be_nil
+        expect(command[:maxTimeMS]).to eq(200)
+      end
+    end
   end
 
   describe '#watch' do