mongo 1.12.5 → 2.0.0

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

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

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Write::Update do
+
+  let(:document) do
+    { :q => { :foo => 1 },
+      :u => { :$set => { :bar => 1 } },
+      :multi => true,
+      :upsert => false }
+  end
+
+  let(:spec) do
+    { :update        => document,
+      :db_name       => TEST_DB,
+      :coll_name     => TEST_COLL,
+      :write_concern => Mongo::WriteConcern.get(:w => 1),
+      :ordered       => true
+    }
+  end
+
+  let(:update) do
+    described_class.new(spec)
+  end
+
+  describe '#initialize' do
+
+    context 'spec' do
+
+      it 'sets the spec' do
+        expect(update.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(update).to eq(other)
+        end
+      end
+
+      context 'when two ops have different specs' do
+        let(:other_doc) { {:q => { :foo => 1 },
+                           :u => { :$set => { :bar => 1 } },
+                           :multi => true,
+                           :upsert => true } }
+        let(:other_spec) do
+          { :update        => other_doc,
+            :db_name       => TEST_DB,
+            :coll_name     => TEST_COLL,
+            :write_concern => Mongo::WriteConcern.get(:w => 1),
+            :ordered       => true
+          }
+        end
+
+        let(:other) { described_class.new(other_spec) }
+
+        it 'returns false' do
+          expect(update).not_to eq(other)
+        end
+      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
+
+      let(:update) do
+        described_class.new({
+          update: document,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          write_concern: Mongo::WriteConcern.get(:w => 1)
+        })
+      end
+
+      context 'when the update succeeds' do
+
+        let(:document) do
+          { q: { name: 'test' }, u: { '$set' => { field: 'blah' }}, limit: 1 }
+        end
+
+        let(:result) do
+          update.execute(authorized_primary.context)
+        end
+
+        it 'updates the document' do
+          expect(result.written_count).to eq(1)
+        end
+
+        it 'reports the modified count' do
+          expect(result.modified_count).to eq(1)
+        end
+
+        it 'reports the matched count' do
+          expect(result.matched_count).to eq(1)
+        end
+
+        it 'reports the upserted id as nil' do
+          expect(result.upserted_id).to eq(nil)
+        end
+      end
+
+      context 'when the update fails' do
+
+        let(:document) do
+          { q: { name: 'test' }, u: { '$st' => { field: 'blah' } } }
+        end
+
+        it 'raises an exception' do
+          expect {
+            update.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+    end
+
+    context 'when updating multiple documents' do
+
+      let(:update) do
+        described_class.new({
+          update: document,
+          db_name: TEST_DB,
+          coll_name: TEST_COLL,
+          write_concern: Mongo::WriteConcern.get(:w => 1)
+        })
+      end
+
+      context 'when the updates succeed' do
+
+        let(:document) do
+          { q: { field: 'test' }, u: { '$set' => { other: 'blah' }}, multi: true }
+        end
+
+        let(:result) do
+          update.execute(authorized_primary.context)
+        end
+
+        it 'updates the documents' do
+          expect(result.written_count).to eq(2)
+        end
+
+        it 'reports the modified count' do
+          expect(result.modified_count).to eq(2)
+        end
+
+        it 'reports the matched count' do
+          expect(result.matched_count).to eq(2)
+        end
+
+        it 'reports the upserted id as nil' do
+          expect(result.upserted_id).to eq(nil)
+        end
+      end
+
+      context 'when an update fails' do
+
+        let(:document) do
+          { q: { name: 'test' }, u: { '$st' => { field: 'blah' } }, multi: true }
+        end
+
+        it 'raises an exception' do
+          expect {
+            update.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+
+      context 'when a document exceeds max bson size' do
+
+        let(:document) do
+          { q: { name: 't'*17000000}, u: { '$set' => { field: 'blah' } } }
+        end
+
+        it 'raises an error' do
+          expect {
+            update.execute(authorized_primary.context)
+          }.to raise_error(Mongo::Error::MaxBSONSize)
+        end
+      end
+
+      context 'when upsert is true' do
+
+        let(:document) do
+          { q: { field: 'non-existent' }, u: { '$set' => { other: 'blah' }}, upsert: true }
+        end
+
+        let(:result) do
+          update.execute(authorized_primary.context)
+        end
+
+        it 'inserts the document' do
+          expect(result.written_count).to eq(1)
+        end
+
+        it 'reports the modified count' do
+          expect(result.modified_count).to eq(0)
+        end
+
+        it 'reports the matched count' do
+          expect(result.matched_count).to eq(0)
+        end
+
+        it 'retruns the upserted id' do
+          expect(result.upserted_id).to be_a(BSON::ObjectId)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/protocol/delete_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::Delete do
+
+  let(:opcode)   { 2006 }
+  let(:db)       { TEST_DB }
+  let(:coll)     { TEST_COLL }
+  let(:ns)       { "#{db}.#{coll}" }
+  let(:selector) { { :name => 'Tyler' } }
+  let(:options)     { Hash.new }
+
+  let(:message) do
+    described_class.new(db, coll, selector, options)
+  end
+
+  describe '#initialize' do
+
+    it 'sets the namepsace' do
+      expect(message.namespace).to eq(ns)
+    end
+
+    it 'sets the selector' do
+      expect(message.selector).to eq(selector)
+    end
+
+    context 'when options are provided' do
+
+      context 'when flags are provided' do
+        let(:options) { { :flags => [:single_remove] } }
+
+        it 'sets the flags' do
+          expect(message.flags).to eq(options[:flags])
+        end
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the other is a delete' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          described_class.new(db, coll, selector, options)
+        end
+
+        it 'returns true' do
+          expect(message).to eq(other)
+        end
+      end
+
+      context 'when the database is not equal' do
+        let(:other) do
+          described_class.new('tyler', coll, selector, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the collection is not equal' do
+        let(:other) do
+          described_class.new(db, 'tyler', selector, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the selector is not equal' do
+        let(:other) do
+          described_class.new(db, coll, { :a => 1 }, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the options are not equal' do
+        let(:other) do
+          described_class.new(db, coll, selector, :flags => [:single_remove])
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a delete' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      message.send(:fields).map do |field|
+        message.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(message.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#replyable?' do
+
+    it 'returns false' do
+      expect(message).to_not be_replyable
+    end
+  end
+
+  describe '#serialize' do
+    let(:bytes) { message.serialize }
+
+    include_examples 'message with a header'
+
+    describe 'zero' do
+      let(:field) { bytes[16..19] }
+
+      it 'serializes a zero' do
+        expect(field).to be_int32(0)
+      end
+    end
+
+    describe 'namespace' do
+      let(:field) { bytes[20..36] }
+      it 'serializes the namespace' do
+        expect(field).to be_cstring(ns)
+      end
+    end
+
+    describe 'flags' do
+      let(:field) { bytes[37..40] }
+
+      context 'when no flags are provided' do
+        it 'does not set any bits' do
+          expect(field).to be_int32(0)
+        end
+      end
+
+      context 'when flags are provided' do
+        let(:options) { { :flags => flags } }
+
+        context 'single remove flag' do
+          let(:flags) { [:single_remove] }
+          it 'sets the first bit' do
+            expect(field).to be_int32(1)
+          end
+        end
+      end
+    end
+
+    describe 'selector' do
+      let(:field) { bytes[41..-1] }
+      it 'serializes the selector' do
+        expect(field).to be_bson(selector)
+      end
+    end
+  end
+end

data/spec/mongo/protocol/get_more_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::GetMore do
+
+  let(:opcode)    { 2005 }
+  let(:db)        { TEST_DB }
+  let(:coll)      { TEST_COLL }
+  let(:ns)        { "#{db}.#{coll}" }
+  let(:limit)     { 25 }
+  let(:cursor_id) { 12345 }
+
+  let(:message) do
+    described_class.new(db, coll, limit, cursor_id)
+  end
+
+  describe '#initialize' do
+
+    it 'sets the namepsace' do
+      expect(message.namespace).to eq(ns)
+    end
+
+    it 'sets the number to return' do
+      expect(message.number_to_return).to eq(limit)
+    end
+
+    it 'sets the cursor id' do
+      expect(message.cursor_id).to eq(cursor_id)
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the other is a getmore' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          described_class.new(db, coll, limit, cursor_id)
+        end
+
+        it 'returns true' do
+          expect(message).to eq(other)
+        end
+      end
+
+      context 'when the database is not equal' do
+        let(:other) do
+          described_class.new('tyler', coll, limit, cursor_id)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the collection is not equal' do
+        let(:other) do
+          described_class.new(db, 'tyler', limit, cursor_id)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the limit is not equal' do
+        let(:other) do
+          described_class.new(db, coll, 123, cursor_id)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the cursor id is not equal' do
+        let(:other) do
+          described_class.new(db, coll, limit, 7777)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a getmore' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      message.send(:fields).map do |field|
+        message.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(message.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#replyable?' do
+
+    it 'returns true' do
+      expect(message).to be_replyable
+    end
+  end
+
+  describe '#serialize' do
+    let(:bytes) { message.serialize }
+
+    include_examples 'message with a header'
+
+    describe 'zero' do
+      let(:field) { bytes[16..19] }
+
+      it 'does not set any bits' do
+        expect(field).to be_int32(0)
+      end
+    end
+
+    describe 'namespace' do
+      let(:field) { bytes[20..36] }
+      it 'serializes the namespace' do
+        expect(field).to be_cstring(ns)
+      end
+    end
+
+    describe 'number to return' do
+      let(:field) { bytes[37..40] }
+      it 'serializes the number to return' do
+        expect(field).to be_int32(limit)
+      end
+    end
+
+    describe 'cursor id' do
+      let(:field) { bytes[41..48] }
+      it 'serializes the cursor id' do
+        expect(field).to be_int64(cursor_id)
+      end
+    end
+  end
+end