mongo 1.12.5 → 2.0.0

data/spec/mongo/operation/write/bulk_insert_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::BulkInsert do
+  include_context 'operation'
+
+  let(:documents) do
+    [{ :name => 'test' }]
+  end
+
+  let(:spec) do
+    { documents: documents,
+      db_name: db_name,
+      coll_name: coll_name,
+      write_concern: write_concern
+    }
+  end
+
+  let(:op) do
+    described_class.new(spec)
+  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 inserts have the same specs' do
+
+        let(:other) do
+          described_class.new(spec)
+        end
+
+        it 'returns true' do
+          expect(op).to eq(other)
+        end
+      end
+
+      context 'when two inserts have different specs' do
+
+        let(:other_docs) do
+          [{ :bar => 1 }]
+        end
+
+        let(:other_spec) do
+          { :documents     => other_docs,
+            :db_name       => 'test',
+            :coll_name     => 'coll_name',
+            :write_concern => { 'w' => 1 },
+            :ordered       => true
+          }
+        end
+
+        let(:other) do
+          described_class.new(other_spec)
+        end
+
+        it 'returns false' do
+          expect(op).not_to eq(other)
+        end
+      end
+    end
+  end
+
+  describe '#dup' do
+
+    context 'deep copy' do
+
+      it 'copies the list of documents' do
+        copy = op.dup
+        expect(copy.spec[:documents]).to_not be(op.spec[:documents])
+      end
+    end
+  end
+
+  describe '#execute' do
+
+    before do
+      authorized_collection.indexes.create_one({ name: 1 }, { unique: true })
+    end
+
+    after do
+      authorized_collection.find.delete_many
+      authorized_collection.indexes.drop_one('name_1')
+    end
+
+    context 'when inserting a single document' do
+
+      context 'when the insert succeeds' do
+
+        let(:response) do
+          op.execute(authorized_primary.context)
+        end
+
+        it 'inserts the documents into the database', if: write_command_enabled? do
+          expect(response.written_count).to eq(1)
+        end
+
+        it 'inserts the documents into the database', unless: write_command_enabled? do
+          expect(response.written_count).to eq(0)
+        end
+      end
+    end
+
+    context 'when inserting multiple documents' do
+
+      context 'when the insert succeeds' do
+
+        let(:documents) do
+          [{ name: 'test1' }, { name: 'test2' }]
+        end
+
+        let(:response) do
+          op.execute(authorized_primary.context)
+        end
+
+        it 'inserts the documents into the database', if: write_command_enabled? do
+          expect(response.written_count).to eq(2)
+        end
+
+        it 'inserts the documents into the database', unless: write_command_enabled? do
+          expect(response.written_count).to eq(0)
+        end
+      end
+    end
+
+    context 'when the inserts are ordered' do
+
+      let(:documents) do
+        [{ name: 'test' }, { name: 'test' }, { name: 'test1' }]
+      end
+
+      let(:spec) do
+        { documents: documents,
+          db_name: db_name,
+          coll_name: coll_name,
+          write_concern: write_concern,
+          ordered: true
+        }
+      end
+
+      let(:failing_insert) do
+        described_class.new(spec)
+      end
+
+      context 'when write concern is acknowledged' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 1)
+        end
+
+        context 'when the insert fails' do
+    
+          it 'aborts after first error' do
+            failing_insert.execute(authorized_primary.context)
+            expect(authorized_collection.find.count).to eq(1)
+          end
+        end
+      end
+
+      context 'when write concern is unacknowledged' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 0)
+        end
+
+        context 'when the insert fails' do
+
+          it 'aborts after first error' do
+            failing_insert.execute(authorized_primary.context)
+            expect(authorized_collection.find.count).to eq(1)
+          end
+        end
+      end
+    end
+
+    context 'when the inserts are unordered' do
+
+      let(:documents) do
+        [{ name: 'test' }, { name: 'test' }, { name: 'test1' }]
+      end
+
+      let(:spec) do
+        { documents: documents,
+          db_name: db_name,
+          coll_name: coll_name,
+          write_concern: write_concern,
+          ordered: false
+        }
+      end
+
+      let(:failing_insert) do
+        described_class.new(spec)
+      end
+
+      context 'when write concern is acknowledged' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 1)
+        end
+
+        context 'when the insert fails' do
+    
+          it 'does not abort after first error' do
+            failing_insert.execute(authorized_primary.context)
+            expect(authorized_collection.find.count).to eq(2)
+          end
+        end
+      end
+
+      context 'when write concern is unacknowledged' do
+
+        let(:write_concern) do
+          Mongo::WriteConcern.get(w: 0)
+        end
+
+        context 'when the insert fails' do
+
+          it 'does not after first error' do
+            failing_insert.execute(authorized_primary.context)
+            expect(authorized_collection.find.count).to eq(2)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/operation/write/bulk_update_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::BulkUpdate do
+  include_context 'operation'
+
+  let(:documents) do
+    [{ :q => { :foo => 1 },
+       :u => { :$set => { :bar => 1 } },
+       :multi => true,
+       :upsert => false }]
+  end
+
+  let(:spec) do
+    { updates: documents,
+      db_name: db_name,
+      coll_name: coll_name,
+      write_concern: write_concern,
+      ordered: true
+    }
+  end
+
+  let(:op) do
+    described_class.new(spec)
+  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_docs) do 
+          [ {:q => { :foo => 1 },
+             :u => { :$set => { :bar => 1 } },
+             :multi => true,
+             :upsert => true } ]
+        end
+
+        let(:other_spec) do
+          { updates: other_docs,
+            db_name: db_name,
+            coll_name: coll_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 '#dup' do
+
+    context 'deep copy' do
+
+      it 'copies the list of updates' do
+        copy = op.dup
+        expect(copy.spec[:updates]).not_to be(op.spec[:updates])
+      end
+    end
+  end
+
+  describe '#execute' do
+
+    before do
+      authorized_collection.insert_many([
+        { name: 'test', field: 'test', other: 'test' },
+        { name: 'testing', field: 'test', other: 'test' }
+      ])
+    end
+
+    after do
+      authorized_collection.find.delete_many
+    end
+
+    context 'when updating a single document' do
+
+      context 'when the update passes' do
+
+        let(:documents) do
+          [{ q: { other: 'test' }, u: { '$set' => { field: 'blah' }}, multi: false }]
+        end
+
+        it 'updates the document' do
+          op.execute(authorized_primary.context)
+          expect(authorized_collection.find(field: 'blah').count).to eq(1)
+        end
+      end
+    end
+
+    context 'when updating multiple documents' do
+
+      let(:update) do
+        described_class.new({
+          updates: documents,
+          db_name: db_name,
+          coll_name: coll_name,
+          write_concern: write_concern
+        })
+      end
+
+      context 'when the updates succeed' do
+
+        let(:documents) do
+          [{ q: { other: 'test' }, u: { '$set' => { field: 'blah' }}, multi: true }]
+        end
+
+        it 'updates the documents' do
+          op.execute(authorized_primary.context)
+          expect(authorized_collection.find(field: 'blah').count).to eq(2)
+        end
+      end
+    end
+
+    context 'when the updates are ordered' do
+
+      let(:documents) do
+        [ { q: { name: 'test' }, u: { '$st' => { field: 'blah' }}, multi: true},
+          { q: { field: 'test' }, u: { '$set' => { other: 'blah' }}, multi: true }
+        ]
+      end
+
+      let(:spec) do
+        { updates: documents,
+          db_name: db_name,
+          coll_name: coll_name,
+          write_concern: write_concern,
+          ordered: true
+        }
+      end
+
+      let(:failing_update) do
+        described_class.new(spec)
+      end
+
+      context 'when the update fails' do
+
+        context 'when write concern is acknowledged' do
+
+          let(:write_concern) do
+            Mongo::WriteConcern.get(w: 1)
+          end
+
+          it 'aborts after first error' do
+            failing_update.execute(authorized_primary.context)
+            expect(authorized_collection.find(other: 'blah').count).to eq(0)
+          end
+        end
+
+        context 'when write concern is unacknowledged' do
+
+          let(:write_concern) do
+            Mongo::WriteConcern.get(w: 0)
+          end
+
+          it 'aborts after first error' do
+            failing_update.execute(authorized_primary.context)
+            expect(authorized_collection.find(other: 'blah').count).to eq(0)
+          end
+        end
+      end
+    end
+
+    context 'when the updates are unordered' do
+
+      let(:documents) do
+        [ { q: { name: 'test' }, u: { '$st' => { field: 'blah' }}, multi: true},
+          { q: { field: 'test' }, u: { '$set' => { other: 'blah' }}, multi: false }
+        ]
+      end
+
+      let(:spec) do
+        { updates: documents,
+          db_name: db_name,
+          coll_name: coll_name,
+          write_concern: write_concern,
+          ordered: false
+        }
+      end
+
+      let(:failing_update) do
+        described_class.new(spec)
+      end
+
+      context 'when the update fails' do
+
+        context 'when write concern is acknowledged' do
+
+          let(:write_concern) do
+            Mongo::WriteConcern.get(w: 1)
+          end
+
+          it 'does not abort after first error' do
+            failing_update.execute(authorized_primary.context)
+            expect(authorized_collection.find(other: 'blah').count).to eq(1)
+          end
+        end
+
+        context 'when write concern is unacknowledged' do
+
+          let(:write_concern) do
+            Mongo::WriteConcern.get(w: 0)
+          end
+
+          it 'does not abort after first error' do
+            failing_update.execute(authorized_primary.context)
+            expect(authorized_collection.find(other: 'blah').count).to eq(1)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::Command::Delete do
+  include_context 'operation'
+
+  let(:deletes) { [{:q => { :foo => 1 }, :limit => 1}] }
+  let(:spec) do
+    { :deletes       => deletes,
+      :db_name       => db_name,
+      :coll_name     => coll_name,
+      :write_concern => write_concern,
+      :ordered       => true
+    }
+  end
+
+  let(:op) { described_class.new(spec) }
+
+  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_deletes) { [{:q => { :bar => 1 }, :limit => 1}] }
+        let(:other_spec) do
+          { :deletes       => other_deletes,
+            :db_name       => db_name,
+            :coll_name     => coll_name,
+            :write_concern => write_concern.options,
+            :ordered       => true
+          }
+        end
+        let(:other) { described_class.new(other_spec) }
+
+        it 'returns false' do
+          expect(op).not_to eq(other)
+        end
+      end
+    end
+  end
+
+  context '#merge' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge(other_op) }.to raise_exception
+    end
+  end
+
+  context '#merge!' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge!(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#execute' do
+
+    context 'server' do
+
+      context 'message' do
+        let(:expected_selector) do
+          { :deletes       => deletes,
+            :delete        => coll_name,
+            :writeConcern => write_concern.options,
+            :ordered       => true
+          }
+        end
+
+        it 'creates a query wire protocol message with correct specs' do
+          allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
+            primary_server
+          end
+
+          expect(Mongo::Protocol::Query).to receive(:new) do |db, coll, sel, options|
+            expect(db).to eq(db_name)
+            expect(coll).to eq(Mongo::Database::COMMAND)
+            expect(sel).to eq(expected_selector)
+          end
+          op.execute(primary_context)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::Command::Insert do
+  include_context 'operation'
+
+  let(:documents) { [{ :foo => 1 }] }
+  let(:spec) do
+    { :documents     => documents,
+      :db_name       => db_name,
+      :coll_name     => coll_name,
+      :write_concern => write_concern,
+      :ordered       => true
+    }
+  end
+
+  let(:op) { described_class.new(spec) }
+
+  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_documents) { [{ :bar => 1 }] }
+        let(:other_spec) do
+          { :documents     => other_documents,
+            :db_name       => db_name,
+            :insert        => coll_name,
+            :write_concern => write_concern.options,
+            :ordered       => true
+          }
+        end
+        let(:other) { described_class.new(other_spec) }
+
+        it 'returns false' do
+          expect(op).not_to eq(other)
+        end
+      end
+    end
+  end
+
+  context '#merge' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge(other_op) }.to raise_exception
+    end
+  end
+
+  context '#merge!' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge!(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#execute' do
+
+    context 'server' do
+
+      context 'message' do
+        let(:expected_selector) do
+          { :documents     => documents,
+            :insert        => coll_name,
+            :writeConcern => write_concern.options,
+            :ordered       => true
+          }
+        end
+
+        it 'creates a query wire protocol message with correct specs' do
+          allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
+            primary_server
+          end
+
+          expect(Mongo::Protocol::Query).to receive(:new) do |db, coll, sel, options|
+            expect(db).to eq(db_name)
+            expect(coll).to eq(Mongo::Database::COMMAND)
+            expect(sel).to eq(expected_selector)
+          end
+          op.execute(primary_context)
+        end
+      end
+    end
+  end
+end