mongo 1.12.5 → 2.0.0

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

data/spec/mongo/server/connection_pool_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Mongo::Server::ConnectionPool do
+
+  let(:address) do
+    Mongo::Address.new('127.0.0.1:27017')
+  end
+
+  describe '#checkin' do
+
+    let(:server) do
+      Mongo::Server.new(address, Mongo::Event::Listeners.new)
+    end
+
+    let(:pool) do
+      described_class.get(server)
+    end
+
+    context 'when a connection is checked out on the thread' do
+
+      let!(:connection) do
+        pool.checkout
+      end
+
+      before do
+        pool.checkin(connection)
+      end
+
+      let(:queue) do
+        pool.send(:queue).queue
+      end
+
+      it 'returns the connection to the queue' do
+        expect(queue.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#checkout' do
+
+    let(:server) do
+      Mongo::Server.new(address, Mongo::Event::Listeners.new)
+    end
+
+    let(:pool) do
+      described_class.get(server)
+    end
+
+    context 'when no connection is checked out on the same thread' do
+
+      let!(:connection) do
+        pool.checkout
+      end
+
+      it 'returns a new connection' do
+        expect(connection.address).to eq(server.address)
+      end
+    end
+
+    context 'when a connection is checked out on the same thread' do
+
+      before do
+        pool.checkout
+      end
+
+      it 'returns the threads connection' do
+        expect(pool.checkout.address).to eq(server.address)
+      end
+    end
+
+    context 'when a connection is checked out on a different thread' do
+
+      let!(:connection) do
+        Thread.new { pool.checkout }.value
+      end
+
+      it 'returns a new connection' do
+        expect(pool.checkout.address).to eq(server.address)
+      end
+
+      it 'does not return the same connection instance' do
+        expect(pool.checkout).to_not eql(connection)
+      end
+    end
+  end
+
+  describe '.get' do
+
+    let(:server) do
+      Mongo::Server.new(address, Mongo::Event::Listeners.new)
+    end
+
+    let(:pool) do
+      described_class.get(server)
+    end
+
+    it 'returns the pool for the server' do
+      expect(pool).to eql(described_class.get(server))
+    end
+  end
+
+  describe '#inspect' do
+
+    let(:server) do
+      Mongo::Server.new(address, Mongo::Event::Listeners.new)
+    end
+
+    let(:pool) do
+      described_class.get(server)
+    end
+
+    it 'includes the object id' do
+      expect(pool.inspect).to include(pool.object_id.to_s)
+    end
+
+    it 'includes the queue inspection' do
+      expect(pool.inspect).to include(pool.__send__(:queue).inspect)
+    end
+  end
+end