mongo 1.12.5 → 2.0.0.beta

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

@@ -0,0 +1,177 @@
+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.remove_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 passes' 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
+      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
+      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
+    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