mongo 1.12.5 → 2.0.0.beta

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

@@ -0,0 +1,116 @@
+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
+
+      context 'write concern' do
+
+        context 'w == 0' do
+
+          pending 'no response is returned'
+        end
+
+        context 'w > 0' do
+
+          pending 'returns a response'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+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
+
+      context 'write concern' do
+
+        context 'w == 0' do
+
+          pending 'no response is returned'
+        end
+
+        context 'w > 0' do
+
+          pending 'returns a response'
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::Command::Update do
+  include_context 'operation'
+
+  let(:updates) { [{:q => { :foo => 1 },
+                    :u => { :$set => { :bar => 1 } },
+                    :multi => true,
+                    :upsert => false }] }
+  let(:spec) do
+    { :updates       => updates,
+      :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_updates) { [{:q => { :bar => 1 },
+                          :u => { :$set => { :bar => 2 } },
+                          :multi => true,
+                          :upsert => false }] }
+        let(:other_spec) do
+          { :updates       => other_updates,
+            :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
+          { :updates       => updates,
+            :update        => 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
+
+      context 'write concern' do
+
+        context 'w == 0' do
+
+          pending 'no response is returned'
+        end
+
+        context 'w > 0' do
+
+          pending 'returns a response'
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::CreateUser do
+
+  describe '#execute' do
+
+    let(:user) do
+      Mongo::Auth::User.new(
+        user: 'durran',
+        password: 'password',
+        roles: [ Mongo::Auth::Roles::READ_WRITE ]
+      )
+    end
+
+    let(:operation) do
+      described_class.new(user: user, db_name: TEST_DB)
+    end
+
+    after do
+      root_authorized_client.database.users.remove('durran')
+    end
+
+    context 'when user creation was successful' do
+
+      let!(:response) do
+        operation.execute(root_authorized_primary.context)
+      end
+
+      it 'saves the user in the database' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when creation was not successful' do
+
+      it 'raises an exception' do
+        expect {
+          operation.execute(root_authorized_primary.context)
+          operation.execute(root_authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::Delete do
+  include_context 'operation'
+
+  let(:document) { { :q => { :foo => 1 }, :limit => 1 } }
+  let(:spec) do
+    { :delete        => document,
+      :db_name       => db_name,
+      :coll_name     => coll_name,
+      :write_concern => write_concern,
+      :ordered       => true
+    }
+  end
+
+  let(:delete_write_cmd) do
+    double('delete_write_cmd').tap do |d|
+      allow(d).to receive(:execute) { [] }
+    end
+  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_doc) { { :q => { :bar => 1 }, :limit => 1 } }
+        let(:other_spec) do
+          { :delete        => other_doc,
+            :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 '#execute' do
+
+    before do
+      authorized_collection.insert_many([
+        { name: 'test', field: 'test' },
+        { name: 'testing', field: 'test' }
+      ])
+    end
+
+    after do
+      authorized_collection.find.remove_many
+    end
+
+    context 'when deleting a single document' do
+
+      let(:delete) do
+        described_class.new({
+          delete: document,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          write_concern: Mongo::WriteConcern.get(:w => 1)
+        })
+      end
+
+      context 'when the delete succeeds' do
+
+        let(:document) do
+          { q: { field: 'test' }, limit: 1 }
+        end
+
+        let(:result) do
+          delete.execute(authorized_primary.context)
+        end
+
+        it 'deletes the documents from the database' do
+          expect(result.written_count).to eq(1)
+        end
+      end
+
+      context 'when the delete fails' do
+
+        let(:document) do
+          { que: { field: 'test' } }
+        end
+
+        it 'raises an exception' do
+          expect {
+            delete.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+    end
+
+    context 'when deleting multiple documents' do
+
+      let(:delete) do
+        described_class.new({
+          delete: document,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          write_concern: Mongo::WriteConcern.get(:w => 1)
+        })
+      end
+
+      context 'when the deletes succeed' do
+
+        let(:document) do
+          { q: { field: 'test' }, limit: 0 }
+        end
+
+        let(:result) do
+          delete.execute(authorized_primary.context)
+        end
+
+        it 'deletes the documents from the database' do
+          expect(result.written_count).to eq(2)
+        end
+      end
+
+      context 'when a delete fails' do
+
+        let(:document) do
+          failing_delete_doc
+        end
+
+        let(:result) do
+          delete.execute(authorized_primary.context)
+        end
+
+        it 'does not delete any documents' do
+
+          expect {
+            op.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+
+          expect(authorized_collection.find.count).to eq(2)
+        end
+      end
+
+      context 'when a document exceeds max bson size' do
+
+        let(:document) do
+          { q: { field: 't'*17000000 }, limit: 0 }
+        end
+
+        it 'raises an error' do
+          expect {
+            op.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::MaxBSONSize)
+        end
+      end
+    end
+  end
+end