mongo 1.12.5 → 2.0.0

data/spec/support/shared/bulk_write.rb

@@ -0,0 +1,535 @@
+shared_examples 'a bulk write object' do
+
+  context 'when no operations are provided' do
+
+    let(:operations) do
+      []
+    end
+
+    it 'raises an error' do
+      expect {
+        bulk.execute
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when invalid operations are provided' do
+
+    let(:operations) do
+      [{ :not_an_op => {}}]
+    end
+
+    it 'raises an error' do
+      expect {
+        bulk.execute
+      }.to raise_error(Mongo::Error::InvalidBulkOperationType)
+    end
+  end
+
+  context 'when an insert_one operation is provided' do
+
+    context 'when a document is provided' do
+
+      let(:operations) do
+        [{ insert_one: { name: 'test' }}]
+      end
+
+      it 'returns n_inserted of 1' do
+        expect(bulk.execute[:n_inserted]).to eq(1)
+      end
+
+      it 'only inserts that document' do
+        bulk.execute
+        expect(authorized_collection.find.first['name']).to eq('test')
+      end
+    end
+
+    context 'when an invalid object is provided' do
+
+      let(:operations) do
+        [{ insert_one: [] }]
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_error(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+  end
+
+  context 'delete_one' do
+
+    let(:docs) do
+      [ { a: 1 }, { a: 1 } ]
+    end
+
+    let(:expected) do
+      [{ 'a' => 1 }]
+    end
+
+    before do
+      authorized_collection.insert_many(docs)
+    end
+
+    let(:operations) do
+      [ { delete_one: { a: 1 }},
+        { delete_one: { a: 2 }}
+      ]
+    end
+
+    context 'when no selector is specified' do
+
+      let(:operations) do
+        [{ delete_one: nil }]
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when multiple documents match delete selector' do
+
+      it 'reports n_removed correctly' do
+        expect(bulk.execute[:n_removed]).to eq(1)
+      end
+
+      it 'deletes only matching documents' do
+        bulk.execute
+        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+      end
+    end
+  end
+
+  context 'when a delete_many operation is provided' do
+
+    let(:docs) do
+      [{ a: 1 }, { a: 1 }]
+    end
+
+    before do
+      authorized_collection.insert_many(docs)
+    end
+
+    let(:operations) do
+      [{ delete_many: { a: 1 }}]
+    end
+
+    context 'when no selector is specified' do
+
+      let(:operations) do
+        [{ delete_many: nil }]
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when a selector is specified' do
+
+      context 'when multiple documents match delete selector' do
+
+        it 'reports n_removed correctly' do
+          expect(bulk.execute[:n_removed]).to eq(2)
+        end
+
+        it 'deletes all matching documents' do
+          bulk.execute
+          expect(authorized_collection.find.to_a).to be_empty
+        end
+      end
+
+      context 'when only one document matches delete selector' do
+
+        let(:docs) do
+          [{ a: 1 }, { a: 2 }]
+        end
+
+        let(:expected) do
+          [{ 'a' => 2 }]
+        end
+
+        it 'reports n_removed correctly' do
+          expect(bulk.execute[:n_removed]).to eq(1)
+        end
+
+        it 'deletes all matching documents' do
+          bulk.execute
+          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+        end
+      end
+    end
+  end
+
+  context 'when a replace_one operation is provided' do
+
+    let(:docs) do
+      [{ a: 1 }, { a: 1 }]
+    end
+
+    let(:expected) do
+      [{ 'a' => 2 }, { 'a' => 1 }]
+    end
+
+    before do
+      authorized_collection.insert_many(docs)
+    end
+
+    let(:replacement) do
+      { a: 2 }
+    end
+
+    let(:operations) do
+      [{ replace_one: { find: { a: 1 },
+                        replacement: replacement,
+                        upsert: false }
+      }]
+    end
+
+    context 'when a replace document is not specified' do
+
+      let(:operations) do
+        [{ replace_one: { find: { a: 1 },
+                          replacement: nil,
+                          upsert: false }
+        }]
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when there are $-operator top-level keys' do
+
+      let(:operations) do
+        [{ replace_one: { find: { a: 1 },
+                          replacement: { :$set => { a: 3 }},
+                          upsert: false }
+        }]
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+
+    end
+
+    context 'when a replace document is specified' do
+
+      it 'applies the replacement to only one matching document' do
+        bulk.execute
+        expect(authorized_collection.find(replacement).count).to eq(1)
+      end
+
+      it 'reports n_matched correctly' do
+        expect(bulk.execute[:n_matched]).to eq(1)
+      end
+
+      it 'only applies the replacement to one matching document' do
+        bulk.execute
+        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+      end
+
+      context 'when upsert is true' do
+
+        let(:operations) do
+          [{ replace_one: { find: { a: 4 },
+                            replacement: replacement,
+                            upsert: true }
+          }]
+        end
+
+        let(:expected) do
+          [{ 'a' => 1 }, { 'a' => 1 }, { 'a' => 2 }]
+        end
+
+        it 'upserts the replacement document' do
+          bulk.execute
+          expect(authorized_collection.find(replacement).count).to eq(1)
+        end
+
+        it 'reports n_matched correctly' do
+          expect(bulk.execute[:n_matched]).to eq(0)
+        end
+
+        it 'does not replace any documents' do
+          bulk.execute
+          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+        end
+      end
+    end
+  end
+
+  context 'when an update_one operation is provided' do
+
+    let(:docs) do
+      [{ a: 1 }, { a: 1 }]
+    end
+
+    let(:update) do
+      { :$set => { a: 2 }}
+    end
+
+    let(:operations) do
+      [{ update_one: { find: { a: 1 },
+                       update: update,
+                       upsert: false }
+      }]
+    end
+
+    before do
+      authorized_collection.insert_many(docs)
+    end
+
+    let(:expected) do
+      [{ 'a' => 2 },  { 'a' => 1 }]
+    end
+
+    context 'when an update document is not specified' do
+
+      let(:operations) do
+        [{ update_one: [{ a: 1 }]}]
+      end
+
+      let(:operations) do
+        [{ update_one: { find: { a: 1 },
+                         upsert: false }
+        }]
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when an invalid update document is specified' do
+
+      let(:update) do
+        { a: 2 }
+      end
+
+      it 'raises an exception' do
+        expect {
+          bulk.execute
+        }.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when a valid update document is specified' do
+
+      it 'reports n_modified correctly', if: write_command_enabled?  do
+        expect(bulk.execute[:n_modified]).to eq(1)
+      end
+
+      it 'reports n_modified correctly', unless: write_command_enabled?  do
+        expect(bulk.execute[:n_modified]).to eq(nil)
+      end
+
+      it 'reports n_upserted correctly' do
+        expect(bulk.execute[:n_upserted]).to eq(0)
+      end
+
+      it 'reports n_matched correctly' do
+        expect(bulk.execute[:n_matched]).to eq(1)
+      end
+
+      it 'applies the correct writes' do
+        bulk.execute
+        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+      end
+
+      context 'when upsert is true' do
+
+        let(:operations) do
+          [{ update_one: { find: { a: 3 },
+                           update: update,
+                           upsert: true }
+          }]
+        end
+
+        let(:expected) do
+          [{ 'a' => 1 },  { 'a' => 1 }, { 'a' => 2 }]
+        end
+
+        it 'reports n_modified correctly', if: write_command_enabled?  do
+          expect(bulk.execute[:n_modified]).to eq(0)
+        end
+
+        it 'reports n_modified correctly', unless: write_command_enabled?  do
+          expect(bulk.execute[:n_modified]).to eq(nil)
+        end
+
+        it 'reports n_upserted correctly' do
+          expect(bulk.execute[:n_upserted]).to eq(1)
+        end
+
+        it 'reports n_matched correctly' do
+          expect(bulk.execute[:n_matched]).to eq(0)
+        end
+
+        it 'applies the correct writes' do
+          bulk.execute
+          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+        end
+      end
+    end
+  end
+
+  context 'when an update_many operation is provided' do
+
+    let(:docs) do
+      [{ a: 1 }, { a: 1 }]
+    end
+
+    let(:update) do
+      { :$set => { a: 2 }}
+    end
+
+    let(:operations) do
+      [{ update_many: { find: { a: 1 },
+                        update: update,
+                        upsert: false }
+      }]
+    end
+
+    let(:expected) do
+      [{ 'a' => 2 },  { 'a' => 2 }]
+    end
+
+    before do
+      authorized_collection.insert_many(docs)
+    end
+
+    context 'when an update document is not specified' do
+
+      let(:operations) do
+        [{ update_many: { find: { a: 1 },
+                          upsert: false }
+        }]
+      end
+
+      it 'raises an exception' do
+        expect do
+          bulk.execute
+        end.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when an invalid update document is specified' do
+
+      let(:update) do
+        { a: 2 }
+      end
+
+      it 'raises an exception' do
+        expect do
+          bulk.execute
+        end.to raise_exception(Mongo::Error::InvalidBulkOperation)
+      end
+    end
+
+    context 'when a valid update document is specified' do
+
+      it 'reports n_modified correctly', if: write_command_enabled?  do
+        expect(bulk.execute[:n_modified]).to eq(2)
+      end
+
+      it 'reports n_modified correctly', unless: write_command_enabled?  do
+        expect(bulk.execute[:n_modified]).to eq(nil)
+      end
+
+      it 'reports n_upserted correctly' do
+        expect(bulk.execute[:n_upserted]).to eq(0)
+      end
+
+      it 'reports n_matched correctly' do
+        expect(bulk.execute[:n_matched]).to eq(2)
+      end
+
+      it 'applies the correct writes' do
+        bulk.execute
+        expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+      end
+
+      context 'when upsert is true' do
+
+        let(:operations) do
+          [{ update_many: { find: { a: 3 },
+                            update: update,
+                            upsert: true }
+          }]
+        end
+
+        let(:expected) do
+          [ { 'a' => 1 },  { 'a' => 1 }, { 'a' => 2 } ]
+        end
+
+        it 'reports n_modified correctly', if: write_command_enabled?  do
+          expect(bulk.execute[:n_modified]).to eq(0)
+        end
+
+        it 'reports n_modified correctly', unless: write_command_enabled?  do
+          expect(bulk.execute[:n_modified]).to eq(nil)
+        end
+
+        it 'reports n_upserted correctly' do
+          expect(bulk.execute[:n_upserted]).to eq(1)
+        end
+
+        it 'reports n_matched correctly' do
+          expect(bulk.execute[:n_matched]).to eq(0)
+        end
+
+        it 'applies the correct writes' do
+          bulk.execute
+          expect(authorized_collection.find.projection(_id: 0).to_a).to eq(expected)
+        end
+      end
+    end
+  end
+
+  context 'when the operations need to be split' do
+
+    before do
+      6000.times do |i|
+        authorized_collection.insert_one(x: i)
+      end
+    end
+
+    let(:operations) do
+      [].tap do |ops|
+        3000.times do |i|
+          ops << { update_one: { find: { x: i },
+                                 update: { '$set' => { x: 6000-i } },
+                                 upsert: false }
+                 }
+        end
+        ops << { :insert_one => { test: 'emily' } }
+        3000.times do |i|
+          ops << { update_one: { find:  { x: 3000+i },
+                                 update: { '$set' => { x: 3000-i } },
+                                 upsert: false }
+                 }
+        end
+      end
+    end
+
+    it 'completes all operations' do
+      bulk.execute
+      expect(authorized_collection.find(x: { '$lte' => 3000 }).to_a.size).to eq(3000)
+    end
+  end
+end

data/spec/support/shared/cursor.rb

@@ -0,0 +1,38 @@
+shared_context 'shared cursor' do
+
+  let(:client) do
+    double('client').tap do |client|
+      allow(client).to receive(:mongos?).and_return(false)
+      allow(client).to receive(:execute).and_return(*get_mores)
+    end
+  end
+
+  let(:db) { Mongo::Database.new(client, TEST_DB) }
+  let(:collection) do
+    db[TEST_COLL].tap do |collection|
+      allow(collection).to receive(:full_namespace) do
+        "#{db.name}.#{collection.name}"
+      end
+      allow(collection).to receive(:client) { client }
+    end
+  end
+
+  let(:view_options) { {} }
+  let(:view) { Mongo::View::Collection.new(collection, {}, view_options) }
+
+  let(:nonzero) { 1 }
+  let(:b) { proc { |d| d } }
+
+  let(:response) { make_response(1, 3) }
+
+  def make_response(cursor_id = 0, nreturned = 5)
+    double('response').tap do |response|
+      allow(response).to receive(:documents) { (0...nreturned).to_a }
+      allow(response).to receive(:cursor_id) { cursor_id }
+    end
+  end
+
+  def get_mores
+    [ make_response ]
+  end
+end

data/spec/support/shared/operation.rb

@@ -0,0 +1,77 @@
+shared_context 'operation' do
+
+  let(:db_name) { TEST_DB }
+  let(:coll_name) { TEST_COLL }
+  let(:write_concern) { Mongo::WriteConcern.get(:w => 1) }
+  let(:options) { {} }
+
+  # Server doubles
+  let(:secondary_server) do
+    double('secondary_server').tap do |s|
+      allow(s).to receive(:secondary?) { true }
+      allow(s).to receive(:primary?) { false }
+      allow(s).to receive(:standalone?) { false }
+    end
+  end
+  let(:primary_server) do
+    double('primary_server').tap do |s|
+      allow(s).to receive(:primary?) { true }
+      allow(s).to receive(:secondary?) { false }
+      allow(s).to receive(:standalone?) { false }
+    end
+  end
+
+  let(:features_2_4) do
+    double('features').tap do |cxt|
+      allow(cxt).to receive(:write_command_enabled?) { false }
+    end
+  end
+
+  let(:features_2_6) do
+    double('features').tap do |cxt|
+      allow(cxt).to receive(:write_command_enabled?) { true }
+    end
+  end
+
+  # Context doubles
+  let(:primary_context) do
+    double('primary_context').tap do |cxt|
+      allow(cxt).to receive(:with_connection).and_yield(connection)
+      allow(cxt).to receive(:server) { primary_server }
+      allow(cxt).to receive(:features) { features_2_6 }
+      allow(cxt).to receive(:mongos?) { false }
+      allow(cxt).to receive(:primary?) { true }
+      allow(cxt).to receive(:secondary?) { false }
+      allow(cxt).to receive(:standalone?) { false }
+    end
+  end
+  let(:secondary_context) do
+    double('secondary_context').tap do |cxt|
+      allow(cxt).to receive(:with_connection).and_yield(connection)
+      allow(cxt).to receive(:server) { secondary_server }
+      allow(cxt).to receive(:mongos?) { false }
+      allow(cxt).to receive(:features) { features_2_6 }
+      allow(cxt).to receive(:secondary?) { true }
+      allow(cxt).to receive(:primary?) { false }
+      allow(cxt).to receive(:standalone?) { false }
+    end
+  end
+  let(:primary_context_2_4_version) do
+    double('primary_context').tap do |cxt|
+      allow(cxt).to receive(:with_connection).and_yield(connection)
+      allow(cxt).to receive(:server) { primary_server }
+      allow(cxt).to receive(:mongos?) { false }
+      allow(cxt).to receive(:primary?) { true }
+      allow(cxt).to receive(:secondary?) { false }
+      allow(cxt).to receive(:standalone?) { false }
+      allow(cxt).to receive(:features) { features_2_4 }
+    end
+  end
+
+  let(:connection) do
+    double('connection').tap do |conn|
+      allow(conn).to receive(:dispatch) { [] }
+    end
+  end
+end
+

data/spec/support/shared/protocol.rb

@@ -0,0 +1,31 @@
+shared_examples 'message with a header' do
+  describe 'header' do
+    describe 'length' do
+      let(:field) { bytes[0..3] }
+      it 'serializes the length' do
+        expect(field).to be_int32(bytes.size)
+      end
+    end
+
+    describe 'request id' do
+      let(:field) { bytes[4..7] }
+      it 'serializes the request id' do
+        expect(field).to be_int32(message.request_id)
+      end
+    end
+
+    describe 'response to' do
+      let(:field) { bytes[8..11] }
+      it 'serializes the response to' do
+        expect(field).to be_int32(0)
+      end
+    end
+
+    describe 'op code' do
+      let(:field) { bytes[12..15] }
+      it 'serializes the op code' do
+        expect(field).to be_int32(opcode)
+      end
+    end
+  end
+end