ione 1.0.0 → 1.1.0.pre0

data/spec/ione/io/acceptor_spec.rb

@@ -0,0 +1,223 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Ione
+  module Io
+    describe Acceptor do
+      let :acceptor do
+        described_class.new('example.com', 4321, backlog, unblocker, reactor, socket_impl)
+      end
+
+      let :backlog do
+        3
+      end
+
+      let :unblocker do
+        double(:unblocker)
+      end
+
+      let :reactor do
+        double(:reactor)
+      end
+
+      let :socket_impl do
+        double(:socket_impl)
+      end
+
+      let :socket do
+        double(:socket)
+      end
+
+      shared_context 'accepting_connections' do
+        let :client_socket do
+          double(:client_socket)
+        end
+
+        let :accepted_handlers do
+          []
+        end
+
+        before do
+          socket_impl.stub(:unpack_sockaddr_in).with('SOCKADDRX').and_return([3333, 'example.com'])
+          socket.stub(:bind)
+          socket.stub(:accept_nonblock).and_return([client_socket, 'SOCKADDRX'])
+          reactor.stub(:accept) { |h| accepted_handlers << h }
+        end
+      end
+
+      before do
+        socket_impl.stub(:getaddrinfo)
+          .with('example.com', 4321, nil, Socket::SOCK_STREAM)
+          .and_return([[nil, 'PORT', nil, 'IP1', 'FAMILY1', 'TYPE1'], [nil, 'PORT', nil, 'IP2', 'FAMILY2', 'TYPE2']])
+        socket_impl.stub(:sockaddr_in)
+          .with('PORT', 'IP1')
+          .and_return('SOCKADDR1')
+        socket_impl.stub(:sockaddr_in)
+          .with('PORT', 'IP2')
+          .and_return('SOCKADDR2')
+        socket_impl.stub(:new)
+          .with('FAMILY1', 'TYPE1', 0)
+          .and_return(socket)
+        socket_impl.stub(:new)
+          .with('FAMILY2', 'TYPE2', 0)
+          .and_return(socket)
+        socket.stub(:bind)
+        socket.stub(:listen)
+      end
+
+      describe '#bind' do
+        if RUBY_ENGINE == 'jruby'
+          it 'creates a new socket and binds it to all interfaces' do
+            acceptor.bind
+            socket.should have_received(:bind).with('SOCKADDR1', backlog)
+          end
+
+          it 'tries the next address when the first one raises EADDRNOTAVAIL' do
+            socket.stub(:bind).with('SOCKADDR1', anything).and_raise(Errno::EADDRNOTAVAIL)
+            acceptor.bind
+            socket.should have_received(:bind).with('SOCKADDR2', backlog)
+          end
+        else
+          it 'creates a new socket and binds it to all interfaces' do
+            acceptor.bind
+            socket.should have_received(:bind).with('SOCKADDR1')
+            socket.should have_received(:listen).with(backlog)
+          end
+
+          it 'tries the next address when the first one raises EADDRNOTAVAIL' do
+            socket.stub(:bind).with('SOCKADDR1').and_raise(Errno::EADDRNOTAVAIL)
+            acceptor.bind
+            socket.should have_received(:bind).with('SOCKADDR2')
+            socket.should have_received(:listen).with(backlog)
+          end
+        end
+
+        it 'returns a failed future when none of the addresses worked' do
+          socket.stub(:bind).and_raise(Errno::EADDRNOTAVAIL)
+          f = acceptor.bind
+          expect { f.value }.to raise_error(Errno::EADDRNOTAVAIL)
+        end
+
+        it 'returns a future that resolves to itself when the socket has been bound' do
+          f = acceptor.bind
+          f.should be_resolved
+          f.value.should equal(acceptor)
+        end
+      end
+
+      describe '#close' do
+        before do
+          socket.stub(:close)
+        end
+
+        it 'closes the socket' do
+          acceptor.bind
+          acceptor.close
+          socket.should have_received(:close)
+        end
+
+        it 'does nothing when called before #bind' do
+          acceptor.close
+        end
+
+        it 'does nothing when called again' do
+          acceptor.bind
+          acceptor.close
+          acceptor.close
+          acceptor.close
+        end
+
+        it 'ignores IOError' do
+          socket.stub(:close).and_raise(IOError)
+          acceptor.bind
+          expect { acceptor.close }.to_not raise_error
+        end
+
+        it 'ignores Errno::*' do
+          socket.stub(:close).and_raise(Errno::EINVAL)
+          acceptor.bind
+          expect { acceptor.close }.to_not raise_error
+        end
+
+        it 'is closed afterwards' do
+          acceptor.bind
+          acceptor.close
+          acceptor.should be_closed
+        end
+
+        it 'is is not connected afterwards' do
+          acceptor.bind
+          acceptor.close
+          acceptor.should_not be_connected
+        end
+      end
+
+      describe '#read' do
+        include_context 'accepting_connections'
+
+        it 'accepts a new connection' do
+          acceptor.bind
+          acceptor.read
+          socket.should have_received(:accept_nonblock)
+        end
+
+        it 'creates a new connection handler and registers 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 'passes the unblocker along to the connection handler' do
+          unblocker.stub(:unblock!)
+          acceptor.bind
+          acceptor.read
+          accepted_handlers.first.write('foo')
+          unblocker.should have_received(:unblock!)
+        end
+      end
+
+      describe '#on_accept' do
+        include_context 'accepting_connections'
+
+        it 'calls accept listeners with new connections' do
+          received_connection1 = nil
+          received_connection2 = nil
+          acceptor.on_accept { |c| received_connection1 = c }
+          acceptor.on_accept { |c| received_connection2 = c }
+          acceptor.bind
+          acceptor.read
+          received_connection1.host.should == 'example.com'
+          received_connection2.host.should == 'example.com'
+          received_connection2.port.should == 3333
+        end
+
+        it 'ignores exceptions raised by the connection callback' do
+          called = false
+          acceptor.on_accept { |c| raise 'bork!' }
+          acceptor.on_accept { |c| called = true }
+          acceptor.bind
+          acceptor.read
+          called.should be_true
+        end
+      end
+
+      describe '#to_io' do
+        it 'returns the socket' do
+          acceptor.bind
+          acceptor.to_io.should equal(socket)
+        end
+
+        it 'returns nil when the socket has been closed' do
+          socket.stub(:close)
+          acceptor.bind
+          acceptor.close
+          acceptor.to_io.should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/ione/io/connection_common.rb

@@ -0,0 +1,255 @@
+# encoding: utf-8
+
+shared_examples_for 'a connection' do
+  describe '#close' do
+    it 'closes the socket' do
+      socket.should_receive(:close)
+      handler.close
+    end
+
+    it 'returns true' do
+      handler.close.should be_true
+    end
+
+    it 'does nothing when called again' do
+      handler.close
+      handler.close
+      handler.close
+    end
+
+    it 'swallows SystemCallErrors' do
+      socket.stub(:close).and_raise(SystemCallError.new('Bork!', 9999))
+      handler.close
+    end
+
+    it 'swallows IOErrors' do
+      socket.stub(:close).and_raise(IOError.new('Bork!'))
+      handler.close
+    end
+
+    it 'calls the closed listener' do
+      called = false
+      handler.on_closed { called = true }
+      handler.close
+      called.should be_true, 'expected the close listener to have been called'
+    end
+
+    it 'does nothing when closed a second time' do
+      socket.should_receive(:close).once
+      calls = 0
+      handler.on_closed { calls += 1 }
+      handler.close
+      handler.close
+      calls.should == 1
+    end
+
+    it 'returns false if it did nothing' do
+      handler.close
+      handler.close.should be_false
+    end
+
+    it 'is not writable when closed' do
+      handler.write('foo')
+      handler.close
+      handler.should_not be_writable
+    end
+
+    it 'is closed afterwards' do
+      handler.close
+      handler.should be_closed
+    end
+
+    it 'is is not connected afterwards' do
+      handler.close
+      handler.should_not be_connected
+    end
+  end
+
+  describe '#drain' do
+    before do
+      socket.stub(:write_nonblock) { |s| s.bytesize }
+    end
+
+    it 'waits for the buffer to drain and then closes the socket' do
+      handler.write('hello world')
+      handler.drain
+      handler.should_not be_closed
+      handler.flush
+      handler.should be_closed
+    end
+
+    it 'closes the socket immediately when the buffer is empty' do
+      handler.drain
+      handler.should be_closed
+    end
+
+    it 'returns a future that completes when the socket has closed' do
+      handler.write('hello world')
+      f = handler.drain
+      f.should_not be_completed
+      handler.flush
+      f.should be_completed
+    end
+  end
+
+  describe '#write/#flush' do
+    before do
+      socket.stub(:write_nonblock)
+      unblocker.stub(:unblock!)
+    end
+
+    it 'appends to its buffer when #write is called' do
+      handler.write('hello world')
+    end
+
+    it 'unblocks the reactor' do
+      unblocker.should_receive(:unblock!)
+      handler.write('hello world')
+    end
+
+    it 'is writable when there are bytes to write' do
+      handler.should_not be_writable
+      handler.write('hello world')
+      handler.should be_writable
+      socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+      handler.flush
+      handler.should_not be_writable
+    end
+
+    it 'writes to the socket from its buffer when #flush is called' do
+      handler.write('hello world')
+      socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+      handler.flush
+    end
+
+    it 'takes note of how much the #write_nonblock call consumed and writes the rest of the buffer on the next call to #flush' do
+      handler.write('hello world')
+      socket.should_receive(:write_nonblock).with('hello world').and_return(6)
+      handler.flush
+      socket.should_receive(:write_nonblock).with('world').and_return(5)
+      handler.flush
+    end
+
+    it 'does not call #write_nonblock if the buffer is empty' do
+      handler.flush
+      handler.write('hello world')
+      socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+      handler.flush
+      socket.should_not_receive(:write_nonblock)
+      handler.flush
+    end
+
+    context 'with a block' do
+      it 'yields a byte buffer to the block' do
+        socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+        handler.write do |buffer|
+          buffer << 'hello world'
+        end
+        handler.flush
+      end
+    end
+
+    context 'when #write_nonblock raises an error' do
+      before do
+        socket.stub(:close)
+        socket.stub(:write_nonblock).and_raise('Bork!')
+      end
+
+      it 'closes the socket' do
+        socket.should_receive(:close)
+        handler.write('hello world')
+        handler.flush
+      end
+
+      it 'passes the error to the close handler' do
+        error = nil
+        handler.on_closed { |e| error = e }
+        handler.write('hello world')
+        handler.flush
+        error.should be_a(Exception)
+      end
+    end
+
+    context 'when closed' do
+      it 'discards the bytes' do
+        handler.close
+        handler.write('hello world')
+        handler.flush
+        socket.should_not have_received(:write_nonblock)
+      end
+
+      it 'does not yield the buffer' do
+        called = false
+        handler.close
+        handler.write { called = true }
+        handler.flush
+        called.should be_false
+      end
+
+      it 'does not unblock the reactor' do
+        handler.close
+        handler.write('hello world')
+        handler.flush
+        unblocker.should_not have_received(:unblock!)
+      end
+    end
+
+    context 'when draining' do
+      it 'discards the bytes' do
+        handler.drain
+        handler.write('hello world')
+        handler.flush
+        socket.should_not have_received(:write_nonblock)
+      end
+
+      it 'does not yield the buffer' do
+        called = false
+        handler.drain
+        handler.write { called = true }
+        handler.flush
+        called.should be_false
+      end
+
+      it 'does not unblock the reactor' do
+        handler.drain
+        handler.write('hello world')
+        handler.flush
+        unblocker.should_not have_received(:unblock!)
+      end
+    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!')
+      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