mongo 2.4.3 → 2.5.0.beta

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

@@ -68,11 +68,11 @@ describe Mongo::Grid::FSBucket::Stream::Read do
         end
 
         it 'sets the read preference' do
-          expect(stream.read_preference).to eq(Mongo::ServerSelector.get(options[:read]))
+          expect(stream.read_preference).to eq(options[:read])
         end
 
         it 'sets the read preference on the view' do
-          expect(stream.send(:view).read).to eq(Mongo::ServerSelector.get(options[:read]))
+          expect(stream.send(:view).read).to eq(BSON::Document.new(options[:read]))
         end
       end
 

data/spec/mongo/index/view_spec.rb

@@ -3,7 +3,11 @@ require 'spec_helper'
 describe Mongo::Index::View do
 
   let(:view) do
-    described_class.new(authorized_collection)
+    described_class.new(authorized_collection, options)
+  end
+
+  let(:options) do
+    {}
   end
 
   describe '#drop_one' do
@@ -12,12 +16,34 @@ describe Mongo::Index::View do
       { another: -1 }
     end
 
+    after do
+      begin; view.drop_one('another_-1'); rescue; end
+    end
+
     before do
       view.create_one(spec, unique: true)
     end
 
-    after do
-      begin; view.drop_one('another_-1'); rescue; end
+    context 'when provided a session' do
+
+      let(:view_with_session) do
+        described_class.new(authorized_collection, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      let(:operation) do
+        view_with_session.drop_one('another_-1')
+      end
+
+      let(:failed_operation) do
+        view_with_session.drop_one('_another_-1')
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
     end
 
     context 'when the index exists' do
@@ -123,6 +149,23 @@ describe Mongo::Index::View do
         expect(result).to be_successful
       end
 
+      context 'when provided a session' do
+
+        let(:view_with_session) do
+          described_class.new(authorized_collection, session: session)
+        end
+
+        let(:operation) do
+          view_with_session.drop_all
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+      end
+
       context 'when the collection has a write concern' do
 
         let(:collection) do
@@ -183,6 +226,33 @@ describe Mongo::Index::View do
           it 'returns ok' do
             expect(result).to be_successful
           end
+
+          context 'when provided a session' do
+
+            let(:view_with_session) do
+              described_class.new(authorized_collection, session: session)
+            end
+
+            let(:operation) do
+              view_with_session.create_many(
+                  { key: { random: 1 }, unique: true },
+                  { key: { testing: -1 }, unique: true }
+              )
+            end
+
+            let(:client) do
+              authorized_client
+            end
+
+            let(:failed_operation) do
+              view_with_session.create_many(
+                  { key: { random: 1 }, invalid: true }
+              )
+            end
+
+            it_behaves_like 'an operation using a session'
+            it_behaves_like 'a failed operation using a session'
+          end
         end
 
         context 'when collation is specified', if: collation_enabled? do
@@ -313,6 +383,31 @@ describe Mongo::Index::View do
           it 'returns ok' do
             expect(result).to be_successful
           end
+
+          context 'when provided a session' do
+
+            let(:view_with_session) do
+              described_class.new(authorized_collection, session: session)
+            end
+
+            let(:operation) do
+              view_with_session.create_many([
+                                             { key: { random: 1 }, unique: true },
+                                             { key: { testing: -1 }, unique: true }
+                                            ])
+            end
+
+            let(:failed_operation) do
+              view_with_session.create_many([ { key: { random: 1 }, invalid: true }])
+            end
+
+            let(:client) do
+              authorized_client
+            end
+
+            it_behaves_like 'an operation using a session'
+            it_behaves_like 'a failed operation using a session'
+          end
         end
 
         context 'when collation is specified' do
@@ -463,16 +558,38 @@ describe Mongo::Index::View do
         view.create_one(spec, unique: true)
       end
 
-      after do
-        begin; view.drop_one('random_1'); rescue; end
-      end
-
       it 'returns ok' do
         expect(result).to be_successful
       end
 
+      context 'when provided a session' do
+
+        let(:view_with_session) do
+          described_class.new(authorized_collection, session: session)
+        end
+
+        let(:operation) do
+          view_with_session.create_one(spec, unique: true)
+        end
+
+        let(:failed_operation) do
+          view_with_session.create_one(spec, invalid: true)
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
       context 'when the collection has a write concern' do
 
+        after do
+          begin; view.drop_one('random_1'); rescue; end
+        end
+
         let(:collection) do
           authorized_collection.with(write: INVALID_WRITE_CONCERN)
         end
@@ -514,6 +631,10 @@ describe Mongo::Index::View do
 
       context 'when the index is created on an subdocument field' do
 
+        after do
+          begin; view.drop_one('random_1'); rescue; end
+        end
+
         let(:spec) do
           { 'sub_document.random' => 1 }
         end
@@ -632,7 +753,7 @@ describe Mongo::Index::View do
     end
 
     after do
-      view.drop_one('random_name')
+      begin; view.drop_one('random_name'); rescue; end
     end
 
     context 'when providing a name' do
@@ -657,6 +778,23 @@ describe Mongo::Index::View do
       end
     end
 
+    context 'when provided a session' do
+
+      let(:view_with_session) do
+        described_class.new(authorized_collection, session: session)
+      end
+
+      let(:operation) do
+        view_with_session.get(random: 1)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+    end
+
     context 'when the index does not exist' do
 
       it 'returns nil' do

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

@@ -54,4 +54,46 @@ describe Mongo::Monitoring::Event::Secure do
       end
     end
   end
+
+  describe '#compression_allowed?' do
+
+    context 'when the selector represents a command for which compression is not allowed' do
+
+      let(:secure) do
+        klass.new
+      end
+
+      Mongo::Monitoring::Event::Secure::REDACTED_COMMANDS.each do |command|
+
+        let(:selector) do
+          { command => 1 }
+        end
+
+        context "when the command is #{command}" do
+
+          it 'does not allow compression for the command' do
+           expect(secure.compression_allowed?(selector.keys.first)).to be(false)
+          end
+        end
+      end
+    end
+
+    context 'when the selector represents a command for which compression is allowed' do
+
+      let(:selector) do
+        { ping: 1 }
+      end
+
+      let(:secure) do
+        klass.new
+      end
+
+      context 'when the command is :ping' do
+
+        it 'does not allow compression for the command' do
+          expect(secure.compression_allowed?(selector.keys.first)).to be(true)
+        end
+      end
+    end
+  end
 end

data/spec/mongo/operation/read/query_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mongo::Operation::Read::Query do
+describe Mongo::Operation::Read::Query, unless: op_msg_enabled? do
   
   let(:selector) { { foo: 1 } }
   let(:query_options) { {} }
@@ -71,6 +71,7 @@ describe Mongo::Operation::Read::Query do
         double('secondary_server').tap do |server|
           allow(server).to receive(:mongos?) { false }
           allow(server).to receive(:cluster) { cluster_single }
+          allow(server).to receive(:features) { authorized_primary.features }
         end
       end
 

data/spec/mongo/operation/specifiable_spec.rb

@@ -76,8 +76,8 @@ describe Mongo::Operation::Specifiable do
 
     context 'when read is not specified' do
 
-      it 'returns a Primary ServerSelector object' do
-        expect(specifiable.read).to eq(Mongo::ServerSelector.get(Mongo::ServerSelector::PRIMARY))
+      it 'returns nil' do
+        expect(specifiable.read).to be_nil
       end
     end
   end

data/spec/mongo/operation/write/command/delete_spec.rb

@@ -86,21 +86,104 @@ describe Mongo::Operation::Write::Command::Delete do
 
   describe '#message' do
 
-    let(:expected_selector) do
-      {
-        :delete        => authorized_collection.name,
-        :deletes       => deletes,
-        :writeConcern => write_concern.options,
-        :ordered       => true
-      }
+    context 'when the server supports OP_MSG' do
+
+      let(:global_args) do
+        {
+            delete: TEST_COLL,
+            ordered: true,
+            writeConcern: write_concern.options,
+            '$db' => TEST_DB
+        }
+      end
+
+      let(:expected_payload_1) do
+        {
+            type: 1,
+            payload: { identifier: 'deletes',
+                       sequence: deletes
+            }
+        }
+      end
+
+      context 'when the topology is sharded', if: sharded? && op_msg_enabled? do
+
+        let(:expected_global_args) do
+          global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+        end
+
+        it 'creates the correct OP_MSG message' do
+          authorized_client.command(ping:1)
+          expect(Mongo::Protocol::Msg).to receive(:new).with([:none], {}, expected_global_args, expected_payload_1)
+          op.send(:message, authorized_primary)
+        end
+      end
+
+      context 'when the topology is not sharded', if: !sharded? && op_msg_enabled? do
+
+        let(:expected_global_args) do
+          global_args
+        end
+
+        it 'creates the correct OP_MSG message' do
+          authorized_client.command(ping:1)
+          expect(Mongo::Protocol::Msg).to receive(:new).with([:none], {}, expected_global_args, expected_payload_1)
+          op.send(:message, authorized_primary)
+        end
+      end
+
+      context 'when the write concern is 0' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 0)
+        end
+
+        context 'when the topology is sharded', if: sharded? && op_msg_enabled? do
+
+          let(:expected_global_args) do
+            global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+          end
+
+          it 'creates the correct OP_MSG message' do
+            authorized_client.command(ping:1)
+            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
+            op.send(:message, authorized_primary)
+          end
+        end
+
+        context 'when the topology is not sharded', if: !sharded? && op_msg_enabled? do
+
+          let(:expected_global_args) do
+            global_args
+          end
+
+          it 'creates the correct OP_MSG message' do
+            authorized_client.command(ping:1)
+            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
+            op.send(:message, authorized_primary)
+          end
+        end
+      end
     end
 
-    it 'creates the correct query wire protocol message' do
-      expect(Mongo::Protocol::Query).to receive(:new).with(authorized_collection.database.name,
-                                                           '$cmd',
-                                                           expected_selector,
-                                                           { limit: -1 } )
-      op.send(:message, double('server'))
+    context 'when the server does not support OP_MSG' do
+
+      let(:expected_selector) do
+        {
+            :delete        => authorized_collection.name,
+            :deletes       => deletes,
+            :writeConcern => write_concern.options,
+            :ordered       => true
+        }
+      end
+
+      it 'creates the correct query wire protocol message', unless: op_msg_enabled? do
+        expect(Mongo::Protocol::Query).to receive(:new).with(authorized_collection.database.name,
+                                                             '$cmd',
+                                                             expected_selector,
+                                                             { limit: -1 } )
+        op.send(:message, authorized_primary)
+      end
     end
   end
 end

data/spec/mongo/operation/write/command/insert_spec.rb

@@ -86,20 +86,119 @@ describe Mongo::Operation::Write::Command::Insert do
 
   describe '#message' do
 
-    let(:expected_selector) do
-      { :documents     => documents,
-        :insert        => authorized_collection.name,
-        :writeConcern => write_concern.options,
-        :ordered       => true
-      }
+    context 'when the server supports OP_MSG', if: op_msg_enabled? do
+
+      let(:documents) do
+        [ { foo: 1}, { bar: 2 }]
+      end
+
+      let(:global_args) do
+        {
+            insert: TEST_COLL,
+            ordered: true,
+            writeConcern: write_concern.options,
+            '$db' => TEST_DB
+        }
+      end
+
+      let(:expected_payload_1) do
+        {
+            type: 1,
+            payload: { identifier: 'documents',
+                       sequence: documents
+            }
+        }
+      end
+
+      context 'when the topology is sharded', if: sharded? && op_msg_enabled? do
+
+        let(:expected_global_args) do
+          global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+        end
+
+        it 'creates the correct OP_MSG message' do
+          authorized_client.command(ping:1)
+          expect(Mongo::Protocol::Msg).to receive(:new).with([:none],
+                                                             { validating_keys: true },
+                                                             expected_global_args,
+                                                             expected_payload_1)
+          op.send(:message, authorized_primary)
+        end
+      end
+
+      context 'when the topology is not sharded', if: !sharded? && op_msg_enabled? do
+
+        let(:expected_global_args) do
+          global_args
+        end
+
+        it 'creates the correct OP_MSG message' do
+          authorized_client.command(ping:1)
+          expect(Mongo::Protocol::Msg).to receive(:new).with([:none],
+                                                             { validating_keys: true },
+                                                             expected_global_args,
+                                                             expected_payload_1)
+          op.send(:message, authorized_primary)
+        end
+      end
+
+      context 'when the write concern is 0' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 0)
+        end
+
+        context 'when the topology is sharded', if: sharded? && op_msg_enabled? do
+
+          let(:expected_global_args) do
+            global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+          end
+
+          it 'creates the correct OP_MSG message' do
+            authorized_client.command(ping:1)
+            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
+                                                               { validating_keys: true },
+                                                               expected_global_args,
+                                                               expected_payload_1)
+            op.send(:message, authorized_primary)
+          end
+        end
+
+        context 'when the topology is not sharded', if: !sharded? && op_msg_enabled? do
+
+          let(:expected_global_args) do
+            global_args
+          end
+
+          it 'creates the correct OP_MSG message' do
+            authorized_client.command(ping:1)
+            expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
+                                                               { validating_keys: true },
+                                                               expected_global_args,
+                                                               expected_payload_1)
+            op.send(:message, authorized_primary)
+          end
+        end
+      end
     end
 
-    it 'creates a query wire protocol message with correct specs' do
-      expect(Mongo::Protocol::Query).to receive(:new).with(authorized_collection.database.name,
-                                                           '$cmd',
-                                                            expected_selector,
-                                                            { limit: -1, validating_keys: true })
-      op.send(:message, double('server'))
+    context 'when the server does not support OP_MSG' do
+
+      let(:expected_selector) do
+        { :documents     => documents,
+          :insert        => authorized_collection.name,
+          :writeConcern => write_concern.options,
+          :ordered       => true
+        }
+      end
+
+      it 'creates a query wire protocol message with correct specs', unless: op_msg_enabled? do
+        expect(Mongo::Protocol::Query).to receive(:new).with(authorized_collection.database.name,
+                                                             '$cmd',
+                                                             expected_selector,
+                                                             { limit: -1, validating_keys: true })
+        op.send(:message, authorized_primary)
+      end
     end
   end
 end