mongo 1.12.5 → 2.0.0.beta

data/spec/mongo/protocol/reply_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::Reply do
+
+  let(:length)      { 78 }
+  let(:request_id)  { 0 }
+  let(:response_to) { 0 }
+  let(:op_code)     { 1 }
+  let(:flags)       { 0 }
+  let(:start)       { 0 }
+  let(:n_returned)  { 2 }
+  let(:cursor_id)   { 999_999 }
+  let(:doc)         { { 'name' => 'Tyler' } }
+  let(:documents)   { [doc] * 2 }
+
+  let(:header) do
+    [length, request_id, response_to, op_code].pack('l<l<l<l<')
+  end
+
+  let(:data) do
+    data =  [flags].pack('l<')
+    data << [cursor_id].pack('q<')
+    data << [start].pack('l<')
+    data << [n_returned].pack('l<')
+    data << documents.map(&:to_bson).join
+  end
+
+  let(:io)    { StringIO.new(header + data) }
+  let(:reply) { described_class.deserialize(io) }
+
+  describe '#==' do
+
+    context 'when the other is a reply' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          other = described_class.allocate
+          other.instance_variable_set(:@flags, [])
+          other.instance_variable_set(:@number_returned, n_returned)
+          other.instance_variable_set(:@cursor_id, cursor_id)
+          other.instance_variable_set(:@documents, documents)
+          other.instance_variable_set(:@starting_from, start)
+          other
+        end
+
+        it 'returns true' do
+          expect(reply).to eq(other)
+        end
+      end
+
+      context 'when fields are not equal' do
+        let(:other) do
+          other = described_class.allocate
+          other.instance_variable_set(:@flags, [:await_capable])
+          other.instance_variable_set(:@number_returned, n_returned)
+          other.instance_variable_set(:@cursor_id, cursor_id)
+          other.instance_variable_set(:@documents, documents)
+          other.instance_variable_set(:@starting_from, start)
+          other
+        end
+
+        it 'returns false' do
+          expect(reply).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a reply' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      reply.send(:fields).map do |field|
+        reply.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(reply.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#deserialize' do
+
+    describe 'response flags' do
+
+      context 'no flags' do
+        it 'sets no flags' do
+          expect(reply.flags).to be_empty
+        end
+      end
+
+      context 'cursor not found' do
+        let(:flags) { 1 }
+        it 'sets the cursor not found flag' do
+          expect(reply.flags).to eq([:cursor_not_found])
+        end
+      end
+
+      context 'query failure' do
+        let(:flags) { 2 }
+        it 'sets the query failure flag' do
+          expect(reply.flags).to eq([:query_failure])
+        end
+      end
+
+      context 'shard config stale' do
+        let(:flags) { 4 }
+        it 'sets the shard config stale flag' do
+          expect(reply.flags).to eq([:shard_config_stale])
+        end
+      end
+
+      context 'await capable' do
+        let(:flags) { 8 }
+        it 'sets the await capable flag' do
+          expect(reply.flags).to eq([:await_capable])
+        end
+      end
+
+      context 'multiple flags' do
+        let(:flags) { 10 }
+        it 'sets multiple flags' do
+          expect(reply.flags).to include(:query_failure, :await_capable)
+        end
+      end
+    end
+
+    describe 'cursor id' do
+      it 'sets the cursor id attribute' do
+        expect(reply.cursor_id).to eq(cursor_id)
+      end
+    end
+
+    describe 'starting from' do
+      it 'sets the starting from attribute' do
+        expect(reply.starting_from).to eq(start)
+      end
+    end
+
+    describe 'number returned' do
+      it 'sets the number returned attribute' do
+        expect(reply.number_returned).to eq(n_returned)
+      end
+    end
+
+    describe 'documents' do
+      it 'sets the documents attribute' do
+        expect(reply.documents).to eq(documents)
+      end
+    end
+  end
+end

data/spec/mongo/protocol/update_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::Update do
+
+  let(:opcode)   { 2001 }
+  let(:db)       { TEST_DB }
+  let(:coll)     { TEST_COLL }
+  let(:ns)       { "#{db}.#{coll}" }
+  let(:selector) { { :name => 'Tyler' } }
+  let(:update_doc) { { :name => 'Bob' } }
+  let(:options)       { Hash.new }
+
+  let(:message) do
+    described_class.new(db, coll, selector, update_doc, options)
+  end
+
+  describe '#initialize' do
+
+    it 'sets the namespace' do
+      expect(message.namespace).to eq(ns)
+    end
+
+    it 'sets the selector' do
+      expect(message.selector).to eq(selector)
+    end
+
+    it 'sets the update document' do
+      expect(message.update).to eq(update_doc)
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the other is an update' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          described_class.new(db, coll, selector, update_doc, 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, update_doc, 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, update_doc, 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 }, update_doc, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the update document is not equal' do
+        let(:other) do
+          described_class.new(db, coll, selector, { :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, update_doc,
+                              :flags => :upsert)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a query' 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 'upsert flag' do
+          let(:flags) { [:upsert] }
+          it 'sets the first bit' do
+            expect(field).to be_int32(1)
+          end
+        end
+
+        context 'multi update' do
+          let(:flags) { [:multi_update] }
+          it 'sets the second bit' do
+            expect(field).to be_int32(2)
+          end
+        end
+      end
+    end
+
+    describe 'selector' do
+      let(:field) { bytes[41..61] }
+      it 'serializes the selector' do
+        expect(field).to be_bson(selector)
+      end
+    end
+
+    describe 'update' do
+      let(:field) { bytes[62..80] }
+      it 'serializes the update' do
+        expect(field).to be_bson(update_doc)
+      end
+    end
+  end
+end

data/spec/mongo/server/connection_pool/queue_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Mongo::Server::ConnectionPool::Queue do
+
+  describe '#dequeue' do
+
+    let(:connection) do
+      double('connection')
+    end
+
+    let(:queue) do
+      described_class.new(:max_pool_size => 1) { connection }
+    end
+
+    context 'when the queue is empty' do
+
+      context 'when the max size is reached' do
+
+        it 'raises a timeout error' do
+          expect {
+            queue.dequeue
+            queue.dequeue
+          }.to raise_error(Timeout::Error)
+        end
+      end
+
+      context 'when the max size is not reached' do
+
+        it 'creates a new connecection' do
+          expect(queue.dequeue).to eq(connection)
+        end
+      end
+    end
+
+    context 'when waiting for a connection to be enqueued' do
+
+      before do
+        Thread.new do
+          sleep(0.5)
+          queue.enqueue(connection)
+        end.join
+      end
+
+      it 'returns the enqueued connection' do
+        expect(queue.dequeue).to eq(connection)
+      end
+    end
+  end
+
+  describe '#enqueue' do
+
+    let(:connection) do
+      double('connection')
+    end
+
+    let(:queue) do
+      described_class.new { connection }
+    end
+
+    before do
+      queue.enqueue(connection)
+    end
+
+    it 'adds the connection to the queue' do
+      expect(queue.dequeue).to eq(connection)
+    end
+  end
+
+  describe '#initialize' do
+
+    context 'when a min size is provided' do
+
+      let(:queue) do
+        described_class.new(:min_pool_size => 2) { double('connection') }
+      end
+
+      it 'creates the queue with the minimum connections' do
+        expect(queue.size).to eq(2)
+      end
+    end
+
+    context 'when no min size is provided' do
+
+      let(:queue) do
+        described_class.new { double('connection') }
+      end
+
+      it 'creates the queue with the default connections' do
+        expect(queue.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#inspect' do
+
+    let(:queue) do
+      described_class.new(:min_pool_size => 2) { double('connection') }
+    end
+
+    it 'includes the object id' do
+      expect(queue.inspect).to include(queue.object_id.to_s)
+    end
+
+    it 'includes the min size' do
+      expect(queue.inspect).to include('min_size=2')
+    end
+
+    it 'includes the max size' do
+      expect(queue.inspect).to include('max_size=5')
+    end
+
+    it 'includes the wait timeout' do
+      expect(queue.inspect).to include('wait_timeout=1')
+    end
+
+    it 'includes the current size' do
+      expect(queue.inspect).to include('current_size=2')
+    end
+  end
+
+  describe '#max_size' do
+
+    context 'when a max pool size option is provided' do
+
+      let(:queue) do
+        described_class.new(:max_pool_size => 3) { double('connection') }
+      end
+
+      it 'returns the max size' do
+        expect(queue.max_size).to eq(3)
+      end
+    end
+
+    context 'when no pool size option is provided' do
+
+      let(:queue) do
+        described_class.new { double('connection') }
+      end
+
+      it 'returns the default size' do
+        expect(queue.max_size).to eq(5)
+      end
+    end
+  end
+
+  describe '#wait_timeout' do
+
+    context 'when the wait timeout option is provided' do
+
+      let(:queue) do
+        described_class.new(:wait_queue_timeout => 3) { double('connection') }
+      end
+
+      it 'returns the wait timeout' do
+        expect(queue.wait_timeout).to eq(3)
+      end
+    end
+
+    context 'when the wait timeout option is not provided' do
+
+      let(:queue) do
+        described_class.new { double('connection') }
+      end
+
+      it 'returns the default wait timeout' do
+        expect(queue.wait_timeout).to eq(1)
+      end
+    end
+  end
+end