ione 1.2.0.pre1 → 1.2.0.pre2

data/spec/ione/io/acceptor_spec.rb

@@ -63,6 +63,7 @@ module Ione
         socket_impl.stub(:new)
           .with('FAMILY2', 'TYPE2', 0)
           .and_return(socket)
+        socket.stub(:close)
         socket.stub(:bind)
         socket.stub(:listen)
       end
@@ -100,6 +101,12 @@ module Ione
           expect { f.value }.to raise_error(Errno::EADDRNOTAVAIL)
         end
 
+        it 'closes the socket when none of the addresses worked' do
+          socket.stub(:bind).and_raise(Errno::EADDRNOTAVAIL)
+          acceptor.bind.value rescue nil
+          socket.should have_received(:close)
+        end
+
         it 'returns a future that resolves to itself when the socket has been bound' do
           f = acceptor.bind
           f.should be_resolved

data/spec/ione/io/connection_common.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-shared_examples_for 'a connection' do
+shared_examples_for 'a connection' do |options|
   describe '#close' do
     it 'closes the socket' do
       socket.should_receive(:close)
@@ -219,36 +219,38 @@ shared_examples_for 'a connection' do
     end
   end
 
-  describe '#read/#on_data' do
-    it 'reads a chunk from the socket' do
-      socket.should_receive(:read_nonblock).with(instance_of(Fixnum)).and_return('foo bar')
-      handler.read
-    end
-
-    it 'calls the data listener with the new data' do
-      socket.should_receive(:read_nonblock).with(instance_of(Fixnum)).and_return('foo bar')
-      data = nil
-      handler.on_data { |d| data = d }
-      handler.read
-      data.should == 'foo bar'
-    end
-
-    context 'when #read_nonblock raises an error' do
-      before do
-        socket.stub(:close)
-        socket.stub(:read_nonblock).and_raise('Bork!')
+  if options.nil? || options.fetch(:skip_read, false) == false
+    describe '#read/#on_data' do
+      it 'reads a chunk from the socket' do
+        socket.should_receive(:read_nonblock).with(instance_of(Fixnum)).and_return('foo bar')
+        handler.read
       end
 
-      it 'closes the socket' do
-        socket.should_receive(:close)
+      it 'calls the data listener with the new data' do
+        socket.should_receive(:read_nonblock).with(instance_of(Fixnum)).and_return('foo bar')
+        data = nil
+        handler.on_data { |d| data = d }
         handler.read
+        data.should == 'foo bar'
       end
 
-      it 'passes the error to the close handler' do
-        error = nil
-        handler.on_closed { |e| error = e }
-        handler.read
-        error.should be_a(Exception)
+      context 'when #read_nonblock raises an error' do
+        before do
+          socket.stub(:close)
+          socket.stub(:read_nonblock).and_raise('Bork!')
+        end
+
+        it 'closes the socket' do
+          socket.should_receive(:close)
+          handler.read
+        end
+
+        it 'passes the error to the close handler' do
+          error = nil
+          handler.on_closed { |e| error = e }
+          handler.read
+          error.should be_a(Exception)
+        end
       end
     end
   end

data/spec/ione/io/io_reactor_spec.rb

@@ -29,7 +29,11 @@ module Ione
         end
 
         def fake_connected(connection)
-          connection.to_io.stub(:connect_nonblock)
+          if connection.is_a?(SslConnection)
+            connection.instance_variable_get(:@io).stub(:connect_nonblock)
+          else
+            connection.to_io.stub(:connect_nonblock)
+          end
         end
 
         after do
@@ -159,6 +163,18 @@ module Ione
           x.should == :foo
         end
 
+        it 'defaults to 5 as the connection timeout' do
+          reactor.start.value
+          connection = reactor.connect('example.com', 9999).value
+          connection.connection_timeout.should == 5
+        end
+
+        it 'takes the connection timeout from the :timeout option' do
+          reactor.start.value
+          connection = reactor.connect('example.com', 9999, timeout: 9).value
+          connection.connection_timeout.should == 9
+        end
+
         it 'returns the connection when no block is given' do
           reactor.start.value
           reactor.connect('example.com', 9999, 5).value.should be_a(Connection)
@@ -170,6 +186,19 @@ module Ione
           await { selector.last_arguments[0].length > 1 }
           selector.last_arguments[0].should include(connection)
         end
+
+        it 'upgrades the connection to SSL' do
+          reactor.start.value
+          connection = reactor.connect('example.com', 9999, ssl: true).value
+          connection.should be_a(SslConnection)
+        end
+
+        it 'passes an SSL context to the SSL connection' do
+          ssl_context = double(:ssl_context)
+          reactor.start.value
+          f = reactor.connect('example.com', 9999, ssl: ssl_context)
+          expect { f.value }.to raise_error
+        end
       end
 
       describe '#bind' do
@@ -192,6 +221,18 @@ module Ione
           x.should == :foo
         end
 
+        it 'defaults to a backlog of 5' do
+          reactor.start.value
+          acceptor = reactor.bind(ENV['SERVER_HOST'], port).value
+          acceptor.backlog.should == 5
+        end
+
+        it 'takes the backlog from the :backlog option' do
+          reactor.start.value
+          acceptor = reactor.bind(ENV['SERVER_HOST'], port, backlog: 9).value
+          acceptor.backlog.should == 9
+        end
+
         it 'returns the acceptor when no block is given' do
           reactor.start.value
           acceptor = reactor.bind(ENV['SERVER_HOST'], port, 5).value
@@ -201,9 +242,16 @@ module Ione
         it 'creates an acceptor and passes it to the selector as a readable' do
           reactor.start.value
           acceptor = reactor.bind(ENV['SERVER_HOST'], port, 5).value
-          await { selector.last_arguments[0].length > 1 }
+          await { selector.last_arguments && selector.last_arguments[0].length > 1 }
           selector.last_arguments[0].should include(acceptor)
         end
+
+        it 'creates an SSL acceptor' do
+          ssl_context = double(:ssl_context)
+          reactor.start.value
+          acceptor = reactor.bind(ENV['SERVER_HOST'], port, ssl: ssl_context).value
+          acceptor.should be_an(SslAcceptor)
+        end
       end
 
       describe '#schedule_timer' do

data/spec/ione/io/ssl_acceptor_spec.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Ione
+  module Io
+    describe SslAcceptor do
+      let :acceptor do
+        described_class.new('example.com', 4321, backlog = 3, unblocker, reactor, ssl_context, socket_impl, ssl_socket_impl)
+      end
+
+      let :unblocker do
+        double(:unblocker)
+      end
+
+      let :reactor do
+        double(:reactor)
+      end
+
+      let :ssl_context do
+        double(:ssl_context)
+      end
+
+      let :socket_impl do
+        double(:socket_impl)
+      end
+
+      let :ssl_socket_impl do
+        double(:ssl_socket_impl)
+      end
+
+      let :socket do
+        double(:socket)
+      end
+
+      let :ssl_socket do
+        double(:ssl_socket)
+      end
+
+      let :client_socket do
+        double(:client_socket)
+      end
+
+      describe '#read' do
+        let :accepted_handlers do
+          []
+        end
+
+        before do
+          socket_impl.stub(:getaddrinfo).and_return([[nil, 'PORT', nil, 'IP1', 'FAMILY1', 'TYPE1']])
+          socket_impl.stub(:sockaddr_in).with('PORT', 'IP1').and_return('SOCKADDRX')
+          socket_impl.stub(:unpack_sockaddr_in).with('SOCKADDRX').and_return([3333, 'example.com'])
+          socket_impl.stub(:new).and_return(socket)
+          socket.stub(:bind)
+          socket.stub(:listen)
+          socket.stub(:accept_nonblock).and_return([client_socket, 'SOCKADDRX'])
+          reactor.stub(:accept) { |h| accepted_handlers << h }
+          ssl_socket_impl.stub(:new).with(client_socket, ssl_context).and_return(ssl_socket)
+          ssl_socket.stub(:accept_nonblock)
+        end
+
+        it 'accepts a new connection' do
+          acceptor.bind
+          acceptor.read
+          socket.should have_received(:accept_nonblock)
+        end
+
+        it 'notifies the accept handlers' do
+          connection = nil
+          acceptor.on_accept { |c| connection = c }
+          acceptor.bind
+          acceptor.read
+          accepted_handlers.first.read
+          connection.should equal(accepted_handlers.first)
+        end
+
+        context 'creates a new connection handler that' do
+          it 'is registered it with the reactor' do
+            acceptor.bind
+            acceptor.read
+            accepted_handlers.should have(1).item
+            accepted_handlers.first.host.should == 'example.com'
+            accepted_handlers.first.port.should == 3333
+          end
+
+          it 'returns the raw socket from #to_io' do
+            ssl_socket.stub(:to_io).and_return(client_socket)
+            acceptor.bind
+            acceptor.read
+            accepted_handlers.first.to_io.should equal(client_socket)
+          end
+
+          it 'has a reference to the unblocker' do
+            unblocker.stub(:unblock!)
+            acceptor.bind
+            acceptor.read
+            accepted_handlers.first.write('foo')
+            unblocker.should have_received(:unblock!)
+          end
+
+          it 'writes to the SSL socket' do
+            unblocker.stub(:unblock!)
+            ssl_socket.stub(:write_nonblock) { |b| b.bytesize }
+            acceptor.bind
+            acceptor.read
+            accepted_handlers.first.read
+            accepted_handlers.first.write('foo')
+            accepted_handlers.first.flush
+            ssl_socket.should have_received(:write_nonblock).with('foo')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ione/io/ssl_connection_spec.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ione/io/connection_common'
+
+
+module Ione
+  module Io
+    describe SslConnection do
+      let :handler do
+        described_class.new('example.com', 55555, raw_socket, unblocker, ssl_context, socket_impl)
+      end
+
+      let :socket_impl do
+        double(:socket_impl)
+      end
+
+      let :raw_socket do
+        double(:raw_socket)
+      end
+
+      let :ssl_socket do
+        double(:ssl_socket)
+      end
+
+      let :unblocker do
+        double(:unblocker, unblock!: nil)
+      end
+
+      let :ssl_context do
+        double(:ssl_context)
+      end
+
+      before do
+        socket_impl.stub(:new).with(raw_socket, ssl_context).and_return(ssl_socket)
+      end
+
+      before do
+        ssl_socket.stub(:connect_nonblock)
+        ssl_socket.stub(:close)
+      end
+
+      it_behaves_like 'a connection', skip_read: true do
+        let :socket do
+          ssl_socket
+        end
+
+        before do
+          handler.connect
+        end
+      end
+
+      describe '#connect' do
+        it 'creates an SSL socket and passes in the specified SSL context' do
+          handler.connect
+          socket_impl.should have_received(:new).with(raw_socket, ssl_context)
+        end
+
+        it 'does not pass the context parameter when the SSL context is nil' do
+          socket_impl.stub(:new).and_return(ssl_socket)
+          h = described_class.new('example.com', 55555, raw_socket, unblocker, nil, socket_impl)
+          h.connect
+          socket_impl.should have_received(:new).with(raw_socket)
+        end
+
+        it 'calls #connect_nonblock on the SSL socket' do
+          handler.connect
+          ssl_socket.should have_received(:connect_nonblock)
+        end
+
+        it 'does nothing when the socket raises a "would block" error' do
+          error = OpenSSL::SSL::SSLError.new('would block')
+          error.extend(IO::WaitReadable)
+          ssl_socket.stub(:connect_nonblock).and_raise(error)
+          expect { handler.connect }.to_not raise_error
+        end
+
+        it 'returns a future that resolves when the socket is connected' do
+          error = OpenSSL::SSL::SSLError.new('would block')
+          error.extend(IO::WaitReadable)
+          ssl_socket.stub(:connect_nonblock).and_raise(error)
+          f = handler.connect
+          f.should_not be_resolved
+          ssl_socket.stub(:connect_nonblock).and_return(nil)
+          handler.connect
+          f.should be_resolved
+        end
+
+        it 'is connected when #connect_nonblock does not raise' do
+          handler.connect
+          handler.should be_connected
+        end
+
+        it 'fails when #connect_nonblock raises an error that does not include the words "would block"' do
+          ssl_socket.stub(:connect_nonblock).and_raise(OpenSSL::SSL::SSLError.new('general bork'))
+          expect { handler.connect.value }.to raise_error(Ione::Io::ConnectionError)
+        end
+
+        it 'is closed when #connect_nonblock raises something that is not a "would block" error' do
+          ssl_socket.stub(:connect_nonblock).and_raise(OpenSSL::SSL::SSLError.new('general bork'))
+          handler.connect
+          handler.should be_closed
+        end
+      end
+
+      describe '#to_io' do
+        it 'returns the raw socket' do
+          handler.to_io.should equal(raw_socket)
+        end
+      end
+
+      describe '#read' do
+        if RUBY_ENGINE == 'jruby'
+          it 'reads chunks until #read_nonblock raises OpenSSL::SSL::SSLErrorWaitReadable' do
+            read_sizes = []
+            counter = 3
+            ssl_socket.stub(:read_nonblock) do |read_size|
+              read_sizes << read_size
+              if counter == 0
+                raise OpenSSL::SSL::SSLErrorWaitReadable, 'read would block'
+              end
+              counter -= 1
+              'bar'
+            end
+            handler.connect
+            handler.read
+            read_sizes.drop(1).should == [read_sizes.first] * 3
+          end
+        else
+          it 'reads and initial chunk of data' do
+            data = []
+            handler.on_data { |d| data << d }
+            ssl_socket.stub(:pending).and_return(0)
+            ssl_socket.stub(:read_nonblock).and_return('fooo')
+            handler.connect
+            handler.read
+            data.should == ['fooo']
+          end
+
+          it 'reads once, and then again with the value of #pending, until #pending returns zero' do
+            read_sizes = []
+            counter = 3
+            ssl_socket.stub(:pending).and_return(0)
+            ssl_socket.stub(:read_nonblock) do |read_size|
+              read_sizes << read_size
+              ssl_socket.stub(:pending).and_return(counter)
+              counter -= 1
+              'bar'
+            end
+            handler.connect
+            handler.read
+            read_sizes.drop(1).should == [3, 2, 1]
+          end
+        end
+
+        it 'closes the connection when an error occurs' do
+          ssl_socket.stub(:read_nonblock).and_raise('boork')
+          handler.connect
+          handler.read
+          handler.should be_closed
+        end
+      end
+    end
+  end
+end