mongo 2.1.0.beta → 2.2.0

data/spec/mongo/server_selector_spec.rb

@@ -6,66 +6,125 @@ describe Mongo::ServerSelector do
 
   describe '.get' do
 
-    let(:read_pref) do
-      described_class.get({ :mode => name })
+    let(:selector) do
+      described_class.get(:mode => name, :tag_sets => tag_sets)
     end
 
-    let(:name) { :secondary }
-    let(:tag_sets) { [{ 'test' => 'tag' }] }
-
     context 'when the mode is primary' do
-      let(:name) { :primary }
+
+      let(:name) do
+        :primary
+      end
 
       it 'returns a read preference of class Primary' do
-        expect(read_pref).to be_a(Mongo::ServerSelector::Primary)
+        expect(selector).to be_a(Mongo::ServerSelector::Primary)
       end
     end
 
     context 'when the mode is primary_preferred' do
-      let(:name) { :primary_preferred }
+      let(:name) do
+        :primary_preferred
+      end
 
       it 'returns a read preference of class PrimaryPreferred' do
-        expect(read_pref).to be_a(Mongo::ServerSelector::PrimaryPreferred)
+        expect(selector).to be_a(Mongo::ServerSelector::PrimaryPreferred)
       end
     end
 
     context 'when the mode is secondary' do
-      let(:name) { :secondary }
+      let(:name) do
+        :secondary
+      end
 
       it 'returns a read preference of class Secondary' do
-        expect(read_pref).to be_a(Mongo::ServerSelector::Secondary)
+        expect(selector).to be_a(Mongo::ServerSelector::Secondary)
       end
     end
 
     context 'when the mode is secondary_preferred' do
-      let(:name) { :secondary_preferred }
+      let(:name) do
+        :secondary_preferred
+      end
 
       it 'returns a read preference of class SecondaryPreferred' do
-        expect(read_pref).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+        expect(selector).to be_a(Mongo::ServerSelector::SecondaryPreferred)
       end
     end
 
     context 'when the mode is nearest' do
-      let(:name) { :nearest }
+      let(:name) do
+        :nearest
+      end
 
       it 'returns a read preference of class Nearest' do
-        expect(read_pref).to be_a(Mongo::ServerSelector::Nearest)
+        expect(selector).to be_a(Mongo::ServerSelector::Nearest)
       end
     end
 
     context 'when a mode is not provided' do
-      let(:read_pref) { described_class.get }
+      let(:selector) { described_class.get }
 
       it 'returns a read preference of class Primary' do
-        expect(read_pref).to be_a(Mongo::ServerSelector::Primary)
+        expect(selector).to be_a(Mongo::ServerSelector::Primary)
       end
     end
 
-    context 'when tag sets provided' do
-      let(:read_pref) { described_class.get(:mode => name, :tag_sets => tag_sets) }
+    context 'when tag sets are provided' do
+
+      let(:selector) do
+        described_class.get(:mode => :secondary, :tag_sets => tag_sets)
+      end
+
+      let(:tag_sets) do
+        [{ 'test' => 'tag' }]
+      end
 
       it 'sets tag sets on the read preference object' do
-        expect(read_pref.tag_sets).to eq(tag_sets)
+        expect(selector.tag_sets).to eq(tag_sets)
+      end
+    end
+
+    context 'when server_selection_timeout is specified' do
+
+      let(:selector) do
+        described_class.get(:mode => :secondary, :server_selection_timeout => 1)
+      end
+
+      it 'sets server selection timeout on the read preference object' do
+        expect(selector.server_selection_timeout).to eq(1)
+      end
+    end
+
+    context 'when server_selection_timeout is not specified' do
+
+      let(:selector) do
+        described_class.get(:mode => :secondary)
+      end
+
+      it 'sets server selection timeout to the default' do
+        expect(selector.server_selection_timeout).to eq(Mongo::ServerSelector::SERVER_SELECTION_TIMEOUT)
+      end
+    end
+
+    context 'when local_threshold is specified' do
+
+      let(:selector) do
+        described_class.get(:mode => :secondary, :local_threshold => 0.010)
+      end
+
+      it 'sets local_threshold on the read preference object' do
+        expect(selector.local_threshold).to eq(0.010)
+      end
+    end
+
+    context 'when local_threshold is not specified' do
+
+      let(:selector) do
+        described_class.get(:mode => :secondary)
+      end
+
+      it 'sets local threshold to the default' do
+        expect(selector.local_threshold).to eq(Mongo::ServerSelector::LOCAL_THRESHOLD)
       end
     end
   end
@@ -74,7 +133,9 @@ describe Mongo::ServerSelector do
 
     context 'when #select returns a list of nils' do
 
-      let(:servers) { [ server(:primary) ] }
+      let(:servers) do
+        [ server(:primary) ]
+      end
 
       let(:cluster) do
         double('cluster').tap do |c|
@@ -86,7 +147,7 @@ describe Mongo::ServerSelector do
       end
 
       let(:read_pref) do
-        described_class.get({ mode: :primary }, server_selection_timeout: 1).tap do |pref|
+        described_class.get(mode: :primary, server_selection_timeout: 0.1).tap do |pref|
           allow(pref).to receive(:select).and_return([ nil, nil ])
         end
       end
@@ -103,7 +164,9 @@ describe Mongo::ServerSelector do
 
     context 'when cluster#servers is empty' do
 
-      let(:servers) { [] }
+      let(:servers) do
+        []
+      end
 
       let(:cluster) do
         double('cluster').tap do |c|
@@ -115,7 +178,7 @@ describe Mongo::ServerSelector do
       end
 
       let(:read_pref) do
-        described_class.get({ mode: :primary }, server_selection_timeout: 1)
+        described_class.get(mode: :primary, server_selection_timeout: 0.1)
       end
 
       it 'raises a NoServerAvailable error' do

data/spec/mongo/server_spec.rb

@@ -18,12 +18,21 @@ describe Mongo::Server do
     Mongo::Address.new('127.0.0.1:27017')
   end
 
+  let(:pool) do
+    Mongo::Server::ConnectionPool.get(server)
+  end
+
   describe '#==' do
 
     let(:server) do
       described_class.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
     end
 
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
+    end
+
     context 'when the other is not a server' do
 
       let(:other) do
@@ -65,6 +74,48 @@ describe Mongo::Server do
     end
   end
 
+  describe '#connectable?' do
+
+    context 'when the server is connectable' do
+
+      let(:server) do
+        described_class.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+      end
+
+      after do
+        server.disconnect!
+      end
+
+      before do
+        expect(cluster).to receive(:pool).with(server).and_return(pool)
+      end
+
+      it 'returns true' do
+        expect(server).to be_connectable
+      end
+    end
+
+    context 'when the server is not connectable' do
+
+      let(:bad_address) do
+        Mongo::Address.new('127.0.0.1:666')
+      end
+
+      let(:server) do
+        described_class.new(bad_address, cluster, monitoring, listeners, TEST_OPTIONS)
+      end
+
+      before do
+        expect(cluster).to receive(:pool).with(server).and_return(pool)
+        server.disconnect!
+      end
+
+      it 'returns false' do
+        expect(server).to_not be_connectable
+      end
+    end
+  end
+
   describe '#context' do
 
     let(:server) do
@@ -75,6 +126,11 @@ describe Mongo::Server do
       server.context
     end
 
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
+    end
+
     it 'returns a new server context' do
       expect(context.server).to eq(server)
     end
@@ -88,6 +144,7 @@ describe Mongo::Server do
 
     it 'stops the monitor instance' do
       expect(server.instance_variable_get(:@monitor)).to receive(:stop!).and_return(true)
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
       server.disconnect!
     end
   end
@@ -95,7 +152,18 @@ describe Mongo::Server do
   describe '#initialize' do
 
     let(:server) do
-      described_class.new(address, cluster, monitoring, listeners, TEST_OPTIONS.merge(:heartbeat_frequency => 5))
+      described_class.new(
+        address,
+        cluster,
+        monitoring,
+        listeners,
+        TEST_OPTIONS.merge(:heartbeat_frequency => 5)
+      )
+    end
+
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
     end
 
     it 'sets the address host' do
@@ -111,25 +179,15 @@ describe Mongo::Server do
     end
   end
 
-  describe '#pool' do
+  describe '#scan!' do
 
     let(:server) do
       described_class.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
     end
 
-    let(:pool) do
-      server.pool
-    end
-
-    it 'returns the connection pool for the server' do
-      expect(pool).to be_a(Mongo::Server::ConnectionPool)
-    end
-  end
-
-  describe '#scan!' do
-
-    let(:server) do
-      described_class.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
     end
 
     it 'forces a scan on the monitor' do
@@ -147,6 +205,11 @@ describe Mongo::Server do
       expect(server.monitor).to receive(:restart!).and_call_original
     end
 
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
+    end
+
     it 'restarts the monitor and returns true' do
       expect(server.reconnect!).to be(true)
     end

data/spec/mongo/socket/ssl_spec.rb

@@ -1,61 +1,78 @@
 require 'spec_helper'
 
-describe Mongo::Socket::SSL do
+describe Mongo::Socket::SSL, if: running_ssl? do
 
-  describe '#connect!', if: running_ssl? do
+  let(:socket) do
+    described_class.new(*DEFAULT_ADDRESS.split(":"), DEFAULT_ADDRESS.split(":")[0], 5, Socket::PF_INET, options)
+  end
 
-    let(:socket) do
-      described_class.new(*DEFAULT_ADDRESS.split(":"), DEFAULT_ADDRESS.split(":")[0], 5, Socket::PF_INET, options)
-    end
+  let(:options) do
+    {
+      :ssl => true,
+      :ssl_cert => CLIENT_PEM,
+      :ssl_key => CLIENT_PEM,
+      :ssl_verify => false
+    }
+  end
+
+  describe '#connect!' do
 
     context 'when a certificate is provided' do
 
-      let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CLIENT_PEM,
-            :ssl_verify => false
-        }
-      end
+      context 'when connecting the tcp socket is successful' do
 
-      before do
-        socket.connect!
+        before do
+          socket.connect!
+        end
+
+        it 'connects to the server' do
+          expect(socket).to be_alive
+        end
       end
 
-      it 'connects to the server' do
-        expect(socket).to be_alive
+      context 'when connecting the tcp socket raises an exception' do
+
+        before do
+          tcp_socket = socket.instance_variable_get(:@tcp_socket)
+          allow(tcp_socket).to receive(:connect).and_raise(Mongo::Error::SocketTimeoutError)
+        end
+
+        let!(:result) do
+          begin
+            socket.connect!
+          rescue => e
+            e
+          end
+        end
+
+        it 'raises an exception' do
+          expect(result).to be_a(Mongo::Error::SocketTimeoutError)
+        end
       end
     end
 
     context 'when a bad certificate is provided' do
 
       let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CRL_PEM,
-            :ssl_verify => false
-        }
+        super().merge({
+          :ssl_key => CRL_PEM
+        })
       end
 
       it 'raises an exception' do
         expect {
           socket.connect!
-        }.to raise_error
+        }.to raise_exception(OpenSSL::PKey::RSAError)
       end
     end
 
     context 'when a CA certificate is provided', if: testing_ssl_locally? do
 
       let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CLIENT_PEM,
-            :ssl_ca_cert => CA_PEM,
-            :ssl_verify => true
-        }
+        super().merge({
+          :ssl_ca_cert => CA_PEM,
+          :ssl_verify => true
+        })
       end
 
       before do
@@ -70,12 +87,9 @@ describe Mongo::Socket::SSL do
     context 'when a CA certificate is not provided', if: testing_ssl_locally? do
 
       let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CLIENT_PEM,
-            :ssl_verify => true
-        }
+        super().merge({
+          :ssl_verify => true
+        })
       end
 
       before do
@@ -91,12 +105,9 @@ describe Mongo::Socket::SSL do
     context 'when ssl_verify is not specified', if: testing_ssl_locally? do
 
       let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CLIENT_PEM,
-            :ssl_ca_cert => CA_PEM
-        }
+        super().merge({
+          :ssl_ca_cert => CA_PEM
+        }).tap { |options| options.delete(:ssl_verify) }
       end
 
       before do
@@ -111,13 +122,10 @@ describe Mongo::Socket::SSL do
     context 'when ssl_verify is true', if: testing_ssl_locally? do
 
       let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CLIENT_PEM,
-            :ssl_ca_cert => CA_PEM,
-            :ssl_verify => true
-        }
+        super().merge({
+          :ssl_ca_cert => CA_PEM,
+          :ssl_verify => true
+        })
       end
 
       before do
@@ -132,13 +140,10 @@ describe Mongo::Socket::SSL do
     context 'when ssl_verify is false' do
 
       let(:options) do
-        {
-            :ssl => true,
-            :ssl_cert => CLIENT_PEM,
-            :ssl_key => CLIENT_PEM,
-            :ssl_ca_cert => 'invalid',
-            :ssl_verify => false
-        }
+        super().merge({
+          :ssl_ca_cert => 'invalid',
+          :ssl_verify => false
+        })
       end
 
       before do
@@ -150,4 +155,43 @@ describe Mongo::Socket::SSL do
       end
     end
   end
+
+  describe '#readbyte' do
+
+    before do
+      allow_message_expectations_on_nil
+
+      allow(socket.socket).to receive(:read) do |length|
+        socket_content[0, length]
+      end
+    end
+
+    context 'with the socket providing "abc"' do
+
+      let(:socket_content) { "abc" }
+
+      it 'should return 97 (the byte for "a")' do
+        expect(socket.readbyte).to eq(97)
+      end
+    end
+
+    context 'with the socket providing "\x00" (NULL_BYTE)' do
+
+      let(:socket_content) { "\x00" }
+
+      it 'should return 0' do
+        expect(socket.readbyte).to eq(0)
+      end
+    end
+
+    context 'with the socket providing no data' do
+
+      let(:socket_content) { "" }
+
+      it 'should raise EOFError' do
+        expect { socket.readbyte }
+          .to raise_error(Mongo::Error::SocketError).with_message("EOFError")
+      end
+    end
+  end
 end

data/spec/mongo/socket/unix_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Mongo::Socket::Unix do
+
+  let(:socket) do
+    described_class.new("/tmp/mongodb-27017.sock", 5)
+  end
+
+  describe '#connect!' do
+
+    before do
+      socket.connect!
+    end
+
+    after do
+      socket.close
+    end
+
+    it 'connects to the server' do
+      expect(socket).to be_alive
+    end
+  end
+
+  describe '#alive?' do
+
+    context 'when the socket is connected' do
+
+      before do
+        socket.connect!
+      end
+
+      after do
+        socket.close
+      end
+
+      it 'returns true' do
+        expect(socket).to be_alive
+      end
+    end
+
+    context 'when the socket is not connected' do
+
+      before do
+        socket.close
+      end
+
+      it 'raises error' do
+        expect { socket.alive? }.to raise_error(IOError)
+      end
+    end
+  end
+end