mongo 2.17.4 → 2.18.0.beta1

data/spec/mongo/error/operation_failure_heavy_spec.rb

@@ -40,6 +40,9 @@ describe Mongo::Error::OperationFailure do
       begin
         authorized_client['foo'].insert_one(test: 1)
       rescue Mongo::Error::OperationFailure => exc
+        expect(exc.details).to eq(exc.document['writeConcernError']['errInfo'])
+        expect(exc.server_message).to eq(exc.document['writeConcernError']['errmsg'])
+        expect(exc.code).to eq(exc.document['writeConcernError']['code'])
       else
         fail 'Expected an OperationFailure'
       end
@@ -58,4 +61,50 @@ describe Mongo::Error::OperationFailure do
       }
     end
   end
+
+  describe 'WriteError details' do
+    min_server_fcv '5.0'
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:subscribed_client) do
+      authorized_client.tap do |client|
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      end
+    end
+
+    let(:collection_name) { 'write_error_prose_spec' }
+
+    let(:collection) do
+      subscribed_client[:collection_name].drop
+      subscribed_client[:collection_name,
+      {
+        'validator' => {
+          'x' => { '$type' => 'string' },
+        }
+      }].create
+      subscribed_client[:collection_name]
+    end
+
+    context 'when there is a write error' do
+      it 'succeeds and prints the error' do
+        begin
+          collection.insert_one({x: 1})
+        rescue Mongo::Error::OperationFailure => e
+          insert_events = subscriber.succeeded_events.select { |e| e.command_name == "insert" }
+          expect(insert_events.length).to eq 1
+          expect(e.message).to match(/\[#{e.code}(:.*)?\].+ -- .+/)
+
+          expect(e.details).to eq(e.document['writeErrors'][0]['errInfo'])
+          expect(e.server_message).to eq(e.document['writeErrors'][0]['errmsg'])
+          expect(e.code).to eq(e.document['writeErrors'][0]['code'])
+
+          expect(e.code).to eq 121
+          expect(e.details).to eq(insert_events[0].reply['writeErrors'][0]['errInfo'])
+        else
+          fail 'Expected an OperationFailure'
+        end
+      end
+    end
+  end
 end

data/spec/mongo/index/view_spec.rb

@@ -5,6 +5,18 @@ require 'spec_helper'
 
 describe Mongo::Index::View do
 
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:authorized_collection) do
+    client[TEST_COLL]
+  end
+
   let(:view) do
     described_class.new(authorized_collection, options)
   end
@@ -140,6 +152,17 @@ describe Mongo::Index::View do
         end
       end
     end
+
+    context 'with a comment' do
+      min_server_version '4.4'
+
+      it 'drops the index' do
+        expect(view.drop_one('another_-1', comment: "comment")).to be_successful
+        command = subscriber.command_started_events("dropIndexes").last&.command
+        expect(command).not_to be_nil
+        expect(command["comment"]).to eq("comment")
+      end
+    end
   end
 
   describe '#drop_all' do
@@ -211,6 +234,17 @@ describe Mongo::Index::View do
           end
         end
       end
+
+      context 'with a comment' do
+        min_server_version '4.4'
+
+        it 'drops indexes' do
+          expect(view.drop_all(comment: "comment")).to be_successful
+          command = subscriber.command_started_events("dropIndexes").last&.command
+          expect(command).not_to be_nil
+          expect(command["comment"]).to eq("comment")
+        end
+      end
     end
   end
 
@@ -672,6 +706,25 @@ describe Mongo::Index::View do
         end
       end
     end
+
+    context 'with a comment' do
+      min_server_version '4.4'
+
+      it 'creates indexes' do
+        expect(
+          view.create_many(
+            [
+              { key: { random: 1 }, unique: true },
+              { key: { testing: -1 }, unique: true }
+            ],
+            comment: "comment"
+          )
+        ).to be_successful
+        command = subscriber.single_command_started_event("createIndexes")&.command
+        expect(command).not_to be_nil
+        expect(command["comment"]).to eq("comment")
+      end
+    end
   end
 
   describe '#create_one' do
@@ -988,6 +1041,22 @@ describe Mongo::Index::View do
         end
       end
     end
+
+    context 'with a comment' do
+      min_server_version '4.4'
+
+      it 'creates index' do
+        expect(
+          view.create_one(
+            { 'x' => 1 },
+            comment: "comment"
+          )
+        ).to be_successful
+        command = subscriber.single_command_started_event("createIndexes")&.command
+        expect(command).not_to be_nil
+        expect(command["comment"]).to eq("comment")
+      end
+    end
   end
 
   describe '#get' do

data/spec/mongo/operation/create/op_msg_spec.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Operation::Create::OpMsg do
+
+  let(:write_concern) do
+    Mongo::WriteConcern.get(w: :majority)
+  end
+
+  let(:session) { nil }
+  let(:spec) do
+    { :selector       => { :create => authorized_collection.name },
+      :db_name       => authorized_collection.database.name,
+      :write_concern => write_concern,
+      :session       => session
+    }
+  end
+
+  let(:op) { described_class.new(spec) }
+
+  let(:connection) do
+    double('connection').tap do |connection|
+      allow(connection).to receive(:server).and_return(authorized_primary)
+      allow(connection).to receive(:features).and_return(authorized_primary.features)
+      allow(connection).to receive(:description).and_return(authorized_primary.description)
+      allow(connection).to receive(:cluster_time).and_return(authorized_primary.cluster_time)
+    end
+  end
+
+  describe '#initialize' do
+
+    context 'spec' do
+
+      it 'sets the spec' do
+        expect(op.spec).to eq(spec)
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context 'spec' do
+
+      context 'when two ops have the same specs' do
+        let(:other) { described_class.new(spec) }
+
+        it 'returns true' do
+          expect(op).to eq(other)
+        end
+      end
+
+      context 'when two ops have different specs' do
+        let(:other_selector) do
+           { :create => "other_collection_name" }
+        end
+
+        let(:other_spec) do
+          { :selector       => other_selector,
+            :db_name       => authorized_collection.database.name,
+            :write_concern => write_concern,
+            :ordered       => true
+          }
+        end
+        let(:other) { described_class.new(other_spec) }
+
+        it 'returns false' do
+          expect(op).not_to eq(other)
+        end
+      end
+    end
+  end
+
+  describe '#selector' do
+    min_server_fcv '3.6'
+
+    it 'does not mutate user input' do
+      user_input = IceNine.deep_freeze(spec.dup)
+      expect do
+        described_class.new(user_input).send(:selector, connection)
+      end.not_to raise_error
+    end
+
+    context 'with encryptedFields' do
+      let(:spec) do
+        {
+          :selector       => { :create => authorized_collection.name },
+          :db_name       => authorized_collection.database.name,
+          :write_concern => write_concern,
+          :session       => session,
+          :encrypted_fields => {
+            'fields' => [
+              {
+                'path' => "name",
+                'bsonType' => "string",
+                'queries' => {
+                  'queryType' => "equality",
+                  'contention' => 10
+                }
+              }
+            ]
+          }
+        }
+      end
+
+      it 'converts contention values to BSON::Int64' do
+        selector = op.send(:selector, connection)
+        expect(selector).to eq({
+          :create => authorized_collection.name,
+          :encryptedFields => {
+            'fields' => [
+              {
+                'path' => "name",
+                'bsonType' => "string",
+                'queries' => {
+                  'queryType' => "equality",
+                  'contention' => BSON::Int64.new(10)
+                }
+              }
+            ]
+          }
+        })
+      end
+    end
+  end
+
+  describe '#message' do
+    # https://jira.mongodb.org/browse/RUBY-2224
+    require_no_linting
+
+    context 'when the server supports OP_MSG' do
+
+      let(:global_args) do
+        {
+            create: TEST_COLL,
+            writeConcern: write_concern.options,
+            '$db' => SpecConfig.instance.test_db,
+            lsid: session.session_id
+        }
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      context 'when the topology is replica set or sharded' do
+        min_server_fcv '3.6'
+        require_topology :replica_set, :sharded
+
+        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([], {}, expected_global_args)
+          op.send(:message, connection)
+        end
+      end
+
+      context 'when the topology is standalone' do
+        min_server_fcv '3.6'
+        require_topology :single
+
+        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([], {}, expected_global_args)
+          op.send(:message, connection)
+        end
+
+        context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
+          # Mocks on features are incompatible with linting
+          require_no_linting
+
+          let(:expected_global_args) do
+            global_args.dup.tap do |args|
+              args.delete(:lsid)
+            end
+          end
+
+          let(:session) do
+            Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+              allow(session).to receive(:session_id).and_return(42)
+              session.should be_implicit
+            end
+          end
+
+          it 'creates the correct OP_MSG message' do
+            RSpec::Mocks.with_temporary_scope do
+              expect(connection.features).to receive(:sessions_enabled?).and_return(false)
+
+              expect(expected_global_args[:session]).to be nil
+              expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
+              op.send(:message, connection)
+            end
+          end
+        end
+      end
+
+      context 'when the write concern is 0' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 0)
+        end
+
+        context 'when the session is implicit' do
+
+          let(:session) do
+            Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+              allow(session).to receive(:session_id).and_return(42)
+              session.should be_implicit
+            end
+          end
+
+          context 'when the topology is replica set or sharded' do
+            min_server_fcv '3.6'
+            require_topology :replica_set, :sharded
+
+            let(:expected_global_args) do
+              global_args.dup.tap do |args|
+                args.delete(:lsid)
+                args.merge!(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+              end
+            end
+
+            it 'does not send a session id in the command' do
+              authorized_client.command(ping:1)
+              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args)
+              op.send(:message, connection)
+            end
+          end
+
+          context 'when the topology is standalone' do
+            min_server_fcv '3.6'
+            require_topology :single
+
+            let(:expected_global_args) do
+              global_args.dup.tap do |args|
+                args.delete(:lsid)
+              end
+            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)
+              op.send(:message, connection)
+            end
+          end
+        end
+
+        context 'when the session is explicit' do
+          min_server_fcv '3.6'
+          require_topology :replica_set, :sharded
+
+          let(:session) do
+            authorized_client.start_session
+          end
+
+          before do
+            session.should_not be_implicit
+          end
+
+          let(:expected_global_args) do
+            global_args.dup.tap do |args|
+              args.delete(:lsid)
+              args.merge!(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+            end
+          end
+
+          it 'does not send a session id in the command' do
+            authorized_client.command(ping:1)
+            RSpec::Mocks.with_temporary_scope do
+              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args)
+              op.send(:message, connection)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/operation/delete/op_msg_spec.rb

@@ -163,8 +163,11 @@ describe Mongo::Operation::Delete::OpMsg do
             end
           end
 
-          before do
-            session.instance_variable_set(:@options, { implicit: true })
+          let(:session) do
+            Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+              allow(session).to receive(:session_id).and_return(42)
+              session.should be_implicit
+            end
           end
 
           it 'creates the correct OP_MSG message' do
@@ -188,8 +191,10 @@ describe Mongo::Operation::Delete::OpMsg do
         context 'when the session is implicit' do
 
           let(:session) do
-            # Use client#get_session so the session is implicit
-            authorized_client.send(:get_session)
+            Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+              allow(session).to receive(:session_id).and_return(42)
+              session.should be_implicit
+            end
           end
 
           context 'when the topology is replica set or sharded' do
@@ -236,6 +241,10 @@ describe Mongo::Operation::Delete::OpMsg do
             authorized_client.start_session
           end
 
+          before do
+            session.should_not be_implicit
+          end
+
           let(:expected_global_args) do
             global_args.dup.tap do |args|
               args.delete(:lsid)

data/spec/mongo/operation/delete_spec.rb

@@ -199,35 +199,5 @@ describe Mongo::Operation::Delete do
         end
       end
     end
-
-    context 'when write concern { w: 0 } is used' do
-      max_server_version '3.4'
-
-      let(:delete) do
-        described_class.new({
-                              deletes: [ document ],
-                              db_name: SpecConfig.instance.test_db,
-                              coll_name: TEST_COLL,
-                              write_concern: Mongo::WriteConcern.get(:w => 0)
-                            })
-      end
-
-
-      let(:document) do
-        { 'q' => { field: 'test' }, 'limit' => 1 }
-      end
-
-      let(:result) do
-        delete.execute(authorized_primary, context: context)
-      end
-
-      before do
-        expect(Mongo::Operation::Delete::Legacy).to receive(:new).and_call_original
-      end
-
-      it 'uses op codes instead of write commands' do
-        expect(result.written_count).to eq(0)
-      end
-    end
   end
 end

data/spec/mongo/operation/insert/op_msg_spec.rb

@@ -126,7 +126,9 @@ describe Mongo::Operation::Insert::OpMsg do
       end
 
       let(:session) do
-        authorized_client.start_session
+        Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+          allow(session).to receive(:session_id).and_return(42)
+        end
       end
 
       context 'when the topology is replica set or sharded' do
@@ -141,7 +143,7 @@ describe Mongo::Operation::Insert::OpMsg do
           authorized_client.command(ping:1)
           RSpec::Mocks.with_temporary_scope do
             expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                               { validating_keys: true },
+                                                               {},
                                                                expected_global_args,
                                                                expected_payload_1)
             op.send(:message, connection)
@@ -161,7 +163,7 @@ describe Mongo::Operation::Insert::OpMsg do
           RSpec::Mocks.with_temporary_scope do
             authorized_client.command(ping:1)
             expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                               { validating_keys: true },
+                                                               {},
                                                                expected_global_args,
                                                                expected_payload_1)
             op.send(:message, connection)
@@ -179,7 +181,7 @@ describe Mongo::Operation::Insert::OpMsg do
           end
 
           before do
-            session.instance_variable_set(:@options, { implicit: true })
+            session.implicit?.should be true
           end
 
           it 'creates the correct OP_MSG message' do
@@ -188,7 +190,7 @@ describe Mongo::Operation::Insert::OpMsg do
 
               expect(expected_global_args).not_to have_key(:lsid)
               expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                                 { validating_keys: true },
+                                                                 {},
                                                                  expected_global_args,
                                                                  expected_payload_1)
               op.send(:message, connection)
@@ -206,8 +208,10 @@ describe Mongo::Operation::Insert::OpMsg do
         context 'when the session is implicit' do
 
           let(:session) do
-            # Use client#get_session so the session is implicit
-            authorized_client.send(:get_session)
+            Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+              allow(session).to receive(:session_id).and_return(42)
+              session.should be_implicit
+            end
           end
 
           context 'when the topology is replica set or sharded' do
@@ -225,7 +229,7 @@ describe Mongo::Operation::Insert::OpMsg do
               authorized_client.command(ping:1)
               RSpec::Mocks.with_temporary_scope do
                 expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
-                                                                   { validating_keys: true },
+                                                                   {},
                                                                    expected_global_args,
                                                                    expected_payload_1)
                 op.send(:message, connection)
@@ -247,7 +251,7 @@ describe Mongo::Operation::Insert::OpMsg do
               authorized_client.command(ping:1)
               RSpec::Mocks.with_temporary_scope do
                 expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
-                                                                   { validating_keys: true },
+                                                                   {},
                                                                    expected_global_args,
                                                                    expected_payload_1)
                 op.send(:message, connection)
@@ -264,6 +268,10 @@ describe Mongo::Operation::Insert::OpMsg do
             authorized_client.start_session
           end
 
+          before do
+            session.should_not be_implicit
+          end
+
           let(:expected_global_args) do
             global_args.dup.tap do |args|
               args.delete(:lsid)
@@ -275,7 +283,7 @@ describe Mongo::Operation::Insert::OpMsg do
             authorized_client.command(ping:1)
             RSpec::Mocks.with_temporary_scope do
               expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
-                                                                 { validating_keys: true },
+                                                                 {},
                                                                  expected_global_args,
                                                                  expected_payload_1)
               op.send(:message, connection)

data/spec/mongo/operation/insert_spec.rb

@@ -254,37 +254,5 @@ describe Mongo::Operation::Insert do
         end
       end
     end
-
-    context 'when write concern { w: 0 } is used' do
-      max_server_version '3.4'
-
-      let(:spec) do
-        { :documents     => documents,
-          :db_name       => SpecConfig.instance.test_db,
-          :coll_name     => TEST_COLL,
-          :write_concern => Mongo::WriteConcern.get(:w => 0)
-        }
-      end
-
-      let(:documents) do
-        [{ '_id' => 1 }]
-      end
-
-      let(:op) do
-        described_class.new(spec)
-      end
-
-      before do
-        expect(Mongo::Operation::Insert::Legacy).to receive(:new).and_call_original
-      end
-
-      let(:response) do
-        op.execute(authorized_primary, context: context)
-      end
-
-      it 'uses op codes instead of write commands' do
-        expect(response.written_count).to eq(0)
-      end
-    end
   end
 end

data/spec/mongo/operation/result_spec.rb

@@ -89,6 +89,26 @@ describe Mongo::Operation::Result do
     end
   end
 
+  describe '#has_cursor_id?' do
+    context 'when the reply exists' do
+
+      let(:cursor_id) { 5 }
+
+      it 'returns true' do
+        expect(result).to have_cursor_id
+      end
+    end
+
+    context 'when the reply does not exist' do
+
+      let(:reply) { nil }
+
+      it 'returns false' do
+        expect(result).not_to have_cursor_id
+      end
+    end
+  end
+
   describe '#documents' do
 
     context 'when the result is for a command' do