mongo 1.12.5 → 2.0.0.beta

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::DropIndex do
+
+  describe '#execute' do
+
+    context 'when the index exists' do
+
+      let(:spec) do
+        { another: -1 }
+      end
+
+      before do
+        authorized_collection.indexes.create(spec, unique: true)
+      end
+
+      let(:operation) do
+        described_class.new(
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          index_name: 'another_-1'
+        )
+      end
+
+      let(:response) do
+        operation.execute(authorized_primary.context)
+      end
+
+      it 'removes the index' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when the index does not exist' do
+
+      let(:operation) do
+        described_class.new(
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          index_name: 'another_blah'
+        )
+      end
+
+      it 'raises an exception' do
+        expect {
+          operation.execute(authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::EnsureIndex do
+
+  describe '#execute' do
+
+    context 'when the index is created' do
+
+      let(:spec) do
+        { random: 1 }
+      end
+
+      let(:operation) do
+        described_class.new(
+          index: spec,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          index_name: 'random_1',
+          options: { unique: true }
+        )
+      end
+
+      let(:response) do
+        operation.execute(authorized_primary.context)
+      end
+
+      after do
+        authorized_collection.indexes.drop(spec)
+      end
+
+      it 'returns ok' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when index creation fails' do
+
+      let(:spec) do
+        { random: 1 }
+      end
+
+      let(:operation) do
+        described_class.new(
+          index: spec,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          index_name: 'random_1',
+          options: { unique: true }
+        )
+      end
+
+      let(:second_operation) do
+        described_class.new(
+          index: spec,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          index_name: 'random_1',
+          options: { unique: false }
+        )
+      end
+
+      before do
+        operation.execute(authorized_primary.context)
+      end
+
+      after do
+        authorized_collection.indexes.drop(spec)
+      end
+
+      it 'raises an exception', if: write_command_enabled? do
+        expect {
+          second_operation.execute(authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+
+      it 'does not raise an exception', unless: write_command_enabled? do
+        expect(second_operation.execute(authorized_primary.context)).to be_successful
+      end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::Insert do
+
+  let(:documents) do
+    [{ :name => 'test' }]
+  end
+
+  let(:spec) do
+    { :documents     => documents,
+      :db_name       => TEST_DB,
+      :coll_name     => TEST_COLL,
+      :write_concern => Mongo::WriteConcern.get(:w => 1)
+    }
+  end
+
+  let(:insert) do
+    described_class.new(spec)
+  end
+
+  describe '#initialize' do
+
+    context 'spec' do
+
+      it 'sets the spec' do
+        expect(insert.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(insert).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     => 'test_coll',
+            :write_concern => { 'w' => 1 }
+          }
+        end
+
+        let(:other) do
+          described_class.new(other_spec)
+        end
+
+        it 'returns false' do
+          expect(insert).not_to eq(other)
+        end
+      end
+    end
+  end
+
+  describe '#dup' do
+
+    context 'deep copy' do
+
+      it 'copies the list of documents' do
+        copy = insert.dup
+        expect(copy.spec[:documents]).to_not be(insert.spec[:documents])
+      end
+    end
+  end
+
+  describe '#execute' do
+
+    before do
+      authorized_collection.indexes.create({ name: 1 }, { unique: true })
+    end
+
+    after do
+      authorized_collection.find.remove_many
+      authorized_collection.indexes.drop({ name: 1 })
+    end
+
+    context 'when inserting a single document' do
+
+      context 'when the insert succeeds' do
+
+        let(:response) do
+          insert.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
+
+      context 'when the insert fails' do
+
+        let(:documents) do
+          [{ name: 'test' }]
+        end
+
+        let(:spec) do
+          { :documents     => documents,
+            :db_name       => TEST_DB,
+            :coll_name     => TEST_COLL,
+            :write_concern => Mongo::WriteConcern.get(:w => 1)
+          }
+        end
+
+        let(:failing_insert) do
+          described_class.new(spec)
+        end
+
+        it 'raises an error' do
+          expect {
+            failing_insert.execute(authorized_primary.context)
+            failing_insert.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+        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
+          insert.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
+
+      context 'when the insert fails on the last document' do
+
+        let(:documents) do
+          [{ name: 'test3' }, { name: 'test' }]
+        end
+
+        let(:spec) do
+          { :documents     => documents,
+            :db_name       => TEST_DB,
+            :coll_name     => TEST_COLL,
+            :write_concern => Mongo::WriteConcern.get(:w => 1)
+          }
+        end
+
+        let(:failing_insert) do
+          described_class.new(spec)
+        end
+
+        it 'raises an error' do
+          expect {
+            failing_insert.execute(authorized_primary.context)
+            failing_insert.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+
+      context 'when the insert fails on the first document' do
+
+        let(:documents) do
+          [{ name: 'test' }, { name: 'test4' }]
+        end
+
+        let(:spec) do
+          { :documents     => documents,
+            :db_name       => TEST_DB,
+            :coll_name     => TEST_COLL,
+            :write_concern => Mongo::WriteConcern.get(:w => 1)
+          }
+        end
+
+        let(:failing_insert) do
+          described_class.new(spec)
+        end
+
+        it 'raises an error' do
+          expect {
+            failing_insert.execute(authorized_primary.context)
+            failing_insert.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+
+      context 'when a document exceeds max bson size' do
+
+        let(:documents) do
+          [{ :x => 'y'* 17000000 }]
+        end
+
+        it 'raises an error' do
+          expect {
+            insert.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::MaxBSONSize)
+        end
+
+        it 'does not insert the document' do
+          expect {
+            insert.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::MaxBSONSize)
+          expect(authorized_collection.find.count).to eq(0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::RemoveUser do
+
+  describe '#execute' do
+
+    before do
+      root_authorized_client.database.users.create(
+        'durran',
+        password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+      )
+    end
+
+    let(:operation) do
+      described_class.new(user_name: 'durran', db_name: TEST_DB)
+    end
+
+    context 'when user removal was successful' do
+
+      let!(:response) do
+        operation.execute(root_authorized_primary.context)
+      end
+
+      it 'removes the user from the database' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when removal was not successful' do
+
+      before do
+        operation.execute(root_authorized_primary.context)
+      end
+
+      it 'raises an exception', if: write_command_enabled? do
+        expect {
+          operation.execute(root_authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+
+      it 'does not raise an exception', unless: write_command_enabled? do
+        expect(operation.execute(root_authorized_primary.context).written_count).to eq(0)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+# describe Mongo::Operation::Write::Response do
+
+  # describe '#initialize' do
+
+    # let(:response) do
+      # described_class.new(reply)
+    # end
+
+    # context 'when the reply is successful' do
+
+      # let(:reply) do
+        # Mongo::Protocol::Reply.new
+      # end
+
+      # let(:documents) do
+        # [{ 'ok' => 1.0, 'n' => 1 }]
+      # end
+
+      # before do
+        # reply.instance_variable_set(:@documents, documents)
+      # end
+
+      # it 'sets the documents on the response' do
+        # expect(response.documents).to eq(documents)
+      # end
+
+      # it 'sets the written count' do
+        # expect(response.n).to eq(1)
+      # end
+    # end
+
+    # context 'when the reply is not successful' do
+
+      # let(:reply) do
+        # Mongo::Protocol::Reply.new
+      # end
+
+      # let(:documents) do
+        # [{ 'ok' => 0.0, 'n' => 1 }]
+      # end
+
+      # before do
+        # reply.instance_variable_set(:@documents, documents)
+      # end
+
+      # it 'raises an exception' do
+        # expect { response }.to raise_error
+      # end
+    # end
+
+    # context 'when the reply is nil' do
+
+      # let(:reply) { nil }
+
+      # it 'does not raise an exception' do
+        # expect(response.documents).to be_empty
+      # end
+
+      # it 'does not set the written count' do
+        # expect(response.n).to be_nil
+      # end
+    # end
+
+    # context 'when providing a count' do
+
+      # let(:reply) do
+        # Mongo::Protocol::Reply.new
+      # end
+
+      # let(:response) do
+        # described_class.new(reply, 5)
+      # end
+
+      # before do
+        # reply.instance_variable_set(:@documents, [{ 'ok' => 1 }])
+      # end
+
+      # it 'sets the document count' do
+        # expect(response.n).to eq(5)
+      # end
+    # end
+  # end
+# end