mongo 2.5.0.beta → 2.5.0

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

@@ -179,6 +179,24 @@ describe Mongo::Collection::View::Readable do
       it_behaves_like 'a read concern aware operation'
     end
 
+    context 'when a session supporting causal consistency is used' do
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, selector, session: session)
+      end
+
+      let(:operation) do
+        begin; view.map_reduce(map, reduce).to_a; rescue; end
+      end
+
+      let(:command) do
+        operation
+        subscriber.started_events.find { |cmd| cmd.command_name == 'mapreduce' }.command
+      end
+
+      it_behaves_like 'an operation supporting causally consistent reads'
+    end
+
     context 'when not iterating the map/reduce' do
 
       it 'returns the map/reduce object' do
@@ -305,7 +323,7 @@ describe Mongo::Collection::View::Readable do
       end
     end
 
-    it 'takes a read preference option' do
+    it 'takes a read preference option', unless: sharded? do
       expect(view.count(read: { mode: :secondary })).to eq(10)
     end
 
@@ -460,13 +478,13 @@ describe Mongo::Collection::View::Readable do
       end
     end
 
-    it 'takes a max_time_ms option', if: write_command_enabled? do
+    it 'takes a max_time_ms option' do
       expect {
         view.count(max_time_ms: 0.1)
       }.to raise_error(Mongo::Error::OperationFailure)
     end
 
-    it 'sets the max_time_ms option on the command', if: write_command_enabled? do
+    it 'sets the max_time_ms option on the command' do
       expect(view.count(max_time_ms: 100)).to eq(10)
     end
 
@@ -830,7 +848,7 @@ describe Mongo::Collection::View::Readable do
       end
     end
 
-    context 'when a max_time_ms is specified', if: write_command_enabled? do
+    context 'when a max_time_ms is specified' do
 
       let(:documents) do
         (1..3).map{ |i| { field: "test" }}
@@ -960,7 +978,7 @@ describe Mongo::Collection::View::Readable do
       end
 
       it 'does not apply the collation to the distinct' do
-        expect(result).to eq(['bang', 'BANG'])
+        expect(result).to match_array(['bang', 'BANG'])
       end
     end
   end

data/spec/mongo/collection_spec.rb

@@ -14,6 +14,10 @@ describe Mongo::Collection do
     authorized_client[:validating]
   end
 
+  let(:client) do
+    authorized_client
+  end
+
   describe '#==' do
 
     let(:database) do
@@ -648,7 +652,6 @@ describe Mongo::Collection do
     end
   end
 
-
   describe '#drop' do
 
     let(:database) do
@@ -763,8 +766,12 @@ describe Mongo::Collection do
         client[TEST_COLL].find.first
       end
 
+      let(:operation_with_session) do
+        client[TEST_COLL].find({}, session: session).first
+      end
+
       let(:second_operation) do
-        client[TEST_COLL].find.first
+        client[TEST_COLL].find({}, session: session).first
       end
 
       it_behaves_like 'an operation updating cluster time'
@@ -864,10 +871,6 @@ describe Mongo::Collection do
 
     context 'when provided options' do
 
-      let(:view) do
-        authorized_collection.find({}, options)
-      end
-
       context 'when a session is provided' do
 
         let(:operation) do
@@ -879,7 +882,7 @@ describe Mongo::Collection do
         end
 
         let(:failed_operation) do
-          authorized_collection.find({ '$._id' => 1 }, session: session).to_a
+          client[authorized_collection.name].find({ '$._id' => 1 }, session: session).to_a
         end
 
         let(:client) do
@@ -890,6 +893,58 @@ describe Mongo::Collection do
         it_behaves_like 'a failed operation using a session'
       end
 
+      context 'session id', if: test_sessions? do
+
+        let(:options) do
+          { session: session }
+        end
+
+        let(:client) do
+          authorized_client.with(heartbeat_frequency: 100).tap do |cl|
+            cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+          end
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:subscriber) do
+          EventSubscriber.new
+        end
+
+        let(:view) do
+          Mongo::Collection::View.new(client[TEST_COLL], selector, view_options)
+        end
+
+        let(:command) do
+          client[TEST_COLL].find({}, session: session).explain
+          subscriber.started_events.find { |c| c.command_name == :explain }.command
+        end
+
+        it 'sends the session id' do
+          expect(command['lsid']).to eq(session.session_id)
+        end
+      end
+      
+      context 'when a session supporting causal consistency is used' do
+
+        let(:operation) do
+          collection.find({}, session: session).to_a
+        end
+
+        let(:command) do
+          operation
+          subscriber.started_events.find { |cmd| cmd.command_name == 'find' }.command
+        end
+
+        it_behaves_like 'an operation supporting causally consistent reads'
+      end
+
+      let(:view) do
+        authorized_collection.find({}, options)
+      end
+
       context 'when provided :allow_partial_results' do
 
         let(:options) do
@@ -1064,6 +1119,19 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.insert_many([{ name: 'test1' }, { name: 'test2' }], session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
+
     context 'when a document contains invalid keys' do
 
       let(:docs) do
@@ -1218,6 +1286,21 @@ describe Mongo::Collection do
         end
       end
     end
+
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:result) do
+        collection_with_unacknowledged_write_concern.insert_many([{ _id: 1 }, { _id: 1 }])
+      end
+
+      it 'does not raise an exception' do
+        expect(result.inserted_count).to be(0)
+      end
+    end
   end
 
   describe '#insert_one' do
@@ -1228,8 +1311,12 @@ describe Mongo::Collection do
         client[TEST_COLL].insert_one({ name: 'testing' })
       end
 
+      let(:operation_with_session) do
+        client[TEST_COLL].insert_one({ name: 'testing' }, session: session)
+      end
+
       let(:second_operation) do
-        client[TEST_COLL].insert_one({ name: 'testing' })
+        client[TEST_COLL].insert_one({ name: 'testing' }, session: session)
       end
 
       it_behaves_like 'an operation updating cluster time'
@@ -1239,14 +1326,10 @@ describe Mongo::Collection do
       authorized_collection.insert_one({ name: 'testing' })
     end
 
-    it 'inserts the document into the collection', if: write_command_enabled? do
+    it 'inserts the document into the collection'do
       expect(result.written_count).to eq(1)
     end
 
-    it 'inserts the document into the collection', unless: write_command_enabled? do
-      expect(result.written_count).to eq(0)
-    end
-
     it 'contains the id in the result' do
       expect(result.inserted_id).to_not be_nil
     end
@@ -1274,6 +1357,19 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.insert_one({ name: 'testing' }, session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
+
     context 'when the document contains invalid keys' do
 
       let(:doc) do
@@ -1459,13 +1555,31 @@ describe Mongo::Collection do
         client[TEST_COLL].aggregate([]).first
       end
 
+      let(:operation_with_session) do
+        client[TEST_COLL].aggregate([], session: session).first
+      end
+
       let(:second_operation) do
-        client[TEST_COLL].aggregate([]).first
+        client[TEST_COLL].aggregate([], session: session).first
       end
 
       it_behaves_like 'an operation updating cluster time'
     end
 
+    context 'when a session supporting causal consistency is used' do
+
+      let(:operation) do
+        collection.aggregate([], session: session).first
+      end
+
+      let(:command) do
+        operation
+        subscriber.started_events.find { |cmd| cmd.command_name == 'aggregate' }.command
+      end
+
+      it_behaves_like 'an operation supporting causally consistent reads'
+    end
+
     it 'returns an Aggregation object' do
       expect(authorized_collection.aggregate([])).to be_a(Mongo::Collection::View::Aggregation)
     end
@@ -1480,6 +1594,17 @@ describe Mongo::Collection do
         expect(authorized_collection.aggregate([], options).options).to eq(BSON::Document.new(options))
       end
 
+      context 'when the :comment option is provided' do
+
+        let(:options) do
+          { :comment => 'testing' }
+        end
+
+        it 'sets the options on the Aggregation object' do
+          expect(authorized_collection.aggregate([], options).options).to eq(BSON::Document.new(options))
+        end
+      end
+
       context 'when a session is provided' do
 
         let(:session) do
@@ -1605,6 +1730,20 @@ describe Mongo::Collection do
         it_behaves_like 'a failed operation using a session'
       end
 
+      context 'when a session supporting causal consistency is used' do
+
+        let(:operation) do
+          collection.count({}, session: session)
+        end
+
+        let(:command) do
+          operation
+          subscriber.started_events.find { |cmd| cmd.command_name == :count }.command
+        end
+
+        it_behaves_like 'an operation supporting causally consistent reads'
+      end
+
       context 'when a collation is specified' do
 
         let(:selector) do
@@ -1705,6 +1844,20 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when a session supporting causal consistency is used' do
+
+      let(:operation) do
+        collection.distinct(:field, {}, session: session)
+      end
+
+      let(:command) do
+        operation
+        subscriber.started_events.find { |cmd| cmd.command_name == :distinct }.command
+      end
+
+      it_behaves_like 'an operation supporting causally consistent reads'
+    end
+
     context 'when a collation is specified' do
 
       let(:result) do
@@ -1762,7 +1915,7 @@ describe Mongo::Collection do
       end
 
       it 'does not apply the collation to the distinct' do
-        expect(result).to eq(['bang', 'BANG'])
+        expect(result).to match_array(['bang', 'BANG'])
       end
     end
   end
@@ -1842,6 +1995,19 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.delete_one({}, session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
+
     context 'when a collation is provided' do
 
       let(:selector) do
@@ -2001,6 +2167,19 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.delete_many({ '$._id' => 1}, session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
+
     context 'when a collation is specified' do
 
       let(:selector) do
@@ -2119,34 +2298,24 @@ describe Mongo::Collection do
       authorized_collection.parallel_scan(2)
     end
 
-    it 'returns an array of cursors', if: write_command_enabled? do
+    it 'returns an array of cursors' do
       cursors.each do |cursor|
         expect(cursor.class).to be(Mongo::Cursor)
       end
     end
 
-    it 'returns the correct number of documents', if: write_command_enabled? do
+    it 'returns the correct number of documents' do
       expect(
         cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
       ).to eq(200)
     end
 
-    it 'raises an error', unless: write_command_enabled? do
-      expect {
-        cursors
-      }.to raise_error(Mongo::Error::OperationFailure)
-    end
-
     context 'when a session is provided' do
 
       let(:cursors) do
         authorized_collection.parallel_scan(2, session: session)
       end
 
-      let(:session) do
-        authorized_client.start_session
-      end
-
       let(:operation) do
         cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
       end
@@ -2163,6 +2332,24 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when a session supporting causal consistency is used' do
+
+      let(:cursors) do
+        collection.parallel_scan(2, session: session)
+      end
+
+      let(:operation) do
+        cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
+      end
+
+      let(:command) do
+        operation
+        subscriber.started_events.find { |cmd| cmd.command_name == :parallelCollectionScan }.command
+      end
+
+      it_behaves_like 'an operation supporting causally consistent reads'
+    end
+
     context 'when a read concern is provided', if: find_command_enabled? do
 
       let(:result) do
@@ -2224,7 +2411,7 @@ describe Mongo::Collection do
       end
     end
 
-    context 'when a max time ms value is provided', if: (!sharded? && write_command_enabled?) do
+    context 'when a max time ms value is provided', if: !sharded? do
 
       let(:result) do
         authorized_collection.parallel_scan(2, options)
@@ -2276,14 +2463,10 @@ describe Mongo::Collection do
         authorized_collection.find(field: 'testing').first
       end
 
-      it 'updates the first matching document in the collection', if: write_command_enabled? do
+      it 'updates the first matching document in the collection' do
         expect(response.modified_count).to eq(1)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates the documents in the collection' do
         expect(updated[:field]).to eq('testing')
       end
@@ -2299,14 +2482,10 @@ describe Mongo::Collection do
         authorized_collection.find(field: 'test1').to_a
       end
 
-      it 'reports that no documents were written', if: write_command_enabled?  do
+      it 'reports that no documents were written'  do
         expect(response.modified_count).to eq(0)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'does not insert the document' do
         expect(updated).to be_empty
       end
@@ -2341,14 +2520,10 @@ describe Mongo::Collection do
         authorized_collection.find(field: 'test1').to_a
       end
 
-      it 'reports that no documents were written', if: write_command_enabled? do
+      it 'reports that no documents were written' do
         expect(response.modified_count).to eq(0)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'does not insert the document' do
         expect(updated).to be_empty
       end
@@ -2550,6 +2725,19 @@ describe Mongo::Collection do
       it_behaves_like 'an operation using a session'
       it_behaves_like 'a failed operation using a session'
     end
+
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.replace_one({ a: 1 }, { x: 5 }, session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
   end
 
   describe '#update_many' do
@@ -2572,14 +2760,10 @@ describe Mongo::Collection do
         authorized_collection.find(field: 'testing').to_a.last
       end
 
-      it 'returns the number updated', if: write_command_enabled? do
+      it 'returns the number updated' do
         expect(response.modified_count).to eq(2)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates the documents in the collection' do
         expect(updated[:field]).to eq('testing')
       end
@@ -2596,14 +2780,10 @@ describe Mongo::Collection do
         authorized_collection.find.to_a
       end
 
-      it 'reports that no documents were updated', if: write_command_enabled? do
+      it 'reports that no documents were updated' do
         expect(response.modified_count).to eq(0)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates no documents in the collection' do
         expect(updated).to be_empty
       end
@@ -2639,14 +2819,10 @@ describe Mongo::Collection do
         authorized_collection.find.to_a
       end
 
-      it 'reports that no documents were updated', if: write_command_enabled? do
+      it 'reports that no documents were updated' do
         expect(response.modified_count).to eq(0)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates no documents in the collection' do
         expect(updated).to be_empty
       end
@@ -2953,6 +3129,19 @@ describe Mongo::Collection do
       it_behaves_like 'an operation using a session'
       it_behaves_like 'a failed operation using a session'
     end
+
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.update_many({a: 1}, { '$set' => {x: 1} }, session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
   end
 
   describe '#update_one' do
@@ -2975,14 +3164,10 @@ describe Mongo::Collection do
         authorized_collection.find(field: 'testing').first
       end
 
-      it 'updates the first matching document in the collection', if: write_command_enabled? do
+      it 'updates the first matching document in the collection' do
         expect(response.modified_count).to eq(1)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates the documents in the collection' do
         expect(updated[:field]).to eq('testing')
       end
@@ -2999,14 +3184,10 @@ describe Mongo::Collection do
         authorized_collection.find.to_a
       end
 
-      it 'reports that no documents were updated', if: write_command_enabled? do
+      it 'reports that no documents were updated' do
         expect(response.modified_count).to eq(0)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates no documents in the collection' do
         expect(updated).to be_empty
       end
@@ -3042,14 +3223,10 @@ describe Mongo::Collection do
         authorized_collection.find.to_a
       end
 
-      it 'reports that no documents were updated', if: write_command_enabled? do
+      it 'reports that no documents were updated' do
         expect(response.modified_count).to eq(0)
       end
 
-      it 'does not return modified count', unless: write_command_enabled? do
-        expect(response.modified_count).to eq(nil)
-      end
-
       it 'updates no documents in the collection' do
         expect(updated).to be_empty
       end
@@ -3365,6 +3542,19 @@ describe Mongo::Collection do
       it_behaves_like 'an operation using a session'
       it_behaves_like 'a failed operation using a session'
     end
+
+    context 'when unacknowledged writes is used' do
+
+      let(:collection_with_unacknowledged_write_concern) do
+        authorized_collection.with(write: { w: 0 })
+      end
+
+      let(:operation) do
+        collection_with_unacknowledged_write_concern.update_one({a: 1}, { '$set' => {x: 1} }, session: session)
+      end
+
+      it_behaves_like 'a causally consistent client session with an unacknowledged write'
+    end
   end
 
   describe '#find_one_and_delete' do
@@ -3447,7 +3637,7 @@ describe Mongo::Collection do
         end
       end
 
-      context 'when max_time_ms is provided', if: write_command_enabled? do
+      context 'when max_time_ms is provided' do
 
         it 'includes the max_time_ms value in the command' do
           expect {
@@ -3472,7 +3662,7 @@ describe Mongo::Collection do
       end
     end
 
-    context 'when the operation fails', if: write_command_enabled? do
+    context 'when the operation fails' do
 
       let(:result) do
         authorized_collection.find_one_and_delete(selector, max_time_ms: 0.1)
@@ -3685,7 +3875,7 @@ describe Mongo::Collection do
 
     context 'when max_time_ms is provided' do
 
-      it 'includes the max_time_ms value in the command', if: write_command_enabled? do
+      it 'includes the max_time_ms value in the command' do
         expect {
           authorized_collection.find_one_and_update(selector, { '$set' => { field: 'testing' }}, max_time_ms: 0.1)
         }.to raise_error(Mongo::Error::OperationFailure)
@@ -3740,7 +3930,7 @@ describe Mongo::Collection do
       end
     end
 
-    context 'when the operation fails', if: write_command_enabled? do
+    context 'when the operation fails' do
 
       let(:result) do
         authorized_collection.find_one_and_update(selector, { '$set' => { field: 'testing' }}, max_time_ms: 0.1)
@@ -4116,7 +4306,7 @@ describe Mongo::Collection do
       end
     end
 
-    context 'when max_time_ms is provided', if: write_command_enabled? do
+    context 'when max_time_ms is provided' do
 
       it 'includes the max_time_ms value in the command' do
         expect {
@@ -4125,7 +4315,7 @@ describe Mongo::Collection do
       end
     end
 
-    context 'when the operation fails', if: write_command_enabled? do
+    context 'when the operation fails' do
 
       let(:result) do
         authorized_collection.find_one_and_replace(selector, { field: 'testing' }, max_time_ms: 0.1)
@@ -4364,8 +4554,11 @@ describe Mongo::Collection do
         context 'when batch_size is provided' do
 
           before do
-            authorized_collection.insert_one(a: 2)
-            authorized_collection.insert_one(a: 3)
+            Thread.new do
+              sleep 1
+              authorized_collection.insert_one(a: 2)
+              authorized_collection.insert_one(a: 3)
+            end
           end
 
           let(:change_stream) do
@@ -4375,31 +4568,28 @@ describe Mongo::Collection do
           it 'returns the documents in the batch size specified' do
             expect(change_stream.instance_variable_get(:@cursor)).to receive(:get_more).once.and_call_original
             enum.next
-            enum.next
           end
         end
 
         context 'when collation is provided' do
-          # pending 'server support for collation with the $changeStream operator'
-          #
-          # before do
-          #   authorized_collection.update_one({ a: 1 }, { '$set' => { a: 2 } })
-          # end
-          #
-          # let(:change_doc) do
-          #   change_stream.next
-          #   change_stream.next
-          # end
-          #
-          # let(:change_stream) do
-          #   authorized_collection.watch([ { '$match' => { operationType: 'UPDATE'}}],
-          #                               collation: { locale: 'en_US', strength: 2 } ).to_enum
-          # end
-          #
-          # it 'returns the change' do
-          #   expect(change_doc[:operationType]).to eq('update')
-          #   expect(change_doc[:fullDocument][:a]).to eq(2)
-          # end
+
+          before do
+            authorized_collection.update_one({ a: 1 }, { '$set' => { a: 2 } })
+          end
+
+          let(:change_doc) do
+            enum.next
+          end
+
+          let(:change_stream) do
+            authorized_collection.watch([ { '$match' => { operationType: 'UPDATE'}}],
+                                        collation: { locale: 'en_US', strength: 2 } ).to_enum
+          end
+
+          it 'returns the change' do
+            expect(change_doc['operationType']).to eq('update')
+            expect(change_doc['updateDescription']['updatedFields']['a']).to eq(2)
+          end
         end
       end
     end