ione 1.2.4 → 1.3.0.pre0

data/spec/ione/heap_spec.rb

@@ -17,9 +17,9 @@ module Ione
       it 'returns the number of items in the heap' do
         heap.push(13)
         heap.push(100)
-        heap.size.should eq(2)
+        heap.size.should == 2
         heap.push(101)
-        heap.size.should eq(3)
+        heap.size.should == 3
       end
     end
 
@@ -40,7 +40,7 @@ module Ione
         heap.push(3)
         heap.push(6)
         heap.push(5)
-        heap.size.should eq(4)
+        heap.size.should == 4
       end
 
       it 'is aliased as #<<' do
@@ -48,14 +48,14 @@ module Ione
         heap << 3
         heap << 6
         heap << 5
-        heap.size.should eq(4)
+        heap.size.should == 4
       end
 
       it 'does not add duplicates' do
         heap << 3
         heap << 3
         heap << 3
-        heap.size.should eq(1)
+        heap.size.should == 1
       end
     end
 
@@ -66,21 +66,21 @@ module Ione
 
       it 'returns the only item when there is only one' do
         heap.push(3)
-        heap.peek.should eq(3)
+        heap.peek.should == 3
       end
 
       it 'returns the smallest item' do
         heap.push(10)
         heap.push(3)
         heap.push(7)
-        heap.peek.should eq(3)
+        heap.peek.should == 3
       end
 
       it 'does not remove the item from the heap' do
         heap.push(3)
-        heap.peek.should eq(3)
-        heap.peek.should eq(3)
-        heap.peek.should eq(3)
+        heap.peek.should == 3
+        heap.peek.should == 3
+        heap.peek.should == 3
       end
     end
 
@@ -91,7 +91,7 @@ module Ione
 
       it 'returns and removes the only item when there is only one' do
         heap.push(3)
-        heap.pop.should eq(3)
+        heap.pop.should == 3
         heap.should be_empty
       end
 
@@ -99,14 +99,14 @@ module Ione
         heap.push(10)
         heap.push(3)
         heap.push(7)
-        heap.pop.should eq(3)
-        heap.pop.should eq(7)
-        heap.size.should eq(1)
+        heap.pop.should == 3
+        heap.pop.should == 7
+        heap.size.should == 1
       end
 
       it 'removes the item from the heap' do
         heap.push(3)
-        heap.pop.should eq(3)
+        heap.pop.should == 3
         heap.pop.should be_nil
       end
     end
@@ -125,8 +125,8 @@ module Ione
         heap.push(101)
         heap.delete(4)
         heap.pop
-        heap.peek.should eq(100)
-        heap.size.should eq(2)
+        heap.peek.should == 100
+        heap.size.should == 2
       end
 
       it 'removes the last item from the heap' do
@@ -155,7 +155,7 @@ module Ione
         heap.push(3)
         heap.push(4)
         heap.push(5)
-        heap.delete(4).should eq(4)
+        heap.delete(4).should == 4
       end
 
       it 'returns nil when the item is not found' do

data/spec/ione/io/acceptor_spec.rb

@@ -174,8 +174,8 @@ module Ione
           acceptor.bind
           acceptor.read
           accepted_handlers.should have(1).item
-          accepted_handlers.first.host.should eq('example.com')
-          accepted_handlers.first.port.should eq(3333)
+          accepted_handlers.first.host.should == 'example.com'
+          accepted_handlers.first.port.should == 3333
         end
 
         it 'passes the unblocker along to the connection handler' do
@@ -197,9 +197,9 @@ module Ione
           acceptor.on_accept { |c| received_connection2 = c }
           acceptor.bind
           acceptor.read
-          received_connection1.host.should eq('example.com')
-          received_connection2.host.should eq('example.com')
-          received_connection2.port.should eq(3333)
+          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

data/spec/ione/io/connection_common.rb

@@ -40,7 +40,7 @@ shared_examples_for 'a connection' do |options|
       handler.on_closed { calls += 1 }
       handler.close
       handler.close
-      calls.should eq(1)
+      calls.should == 1
     end
 
     it 'returns false if it did nothing' do
@@ -83,6 +83,19 @@ shared_examples_for 'a connection' do |options|
       handler.should be_closed
     end
 
+    it 'closes the socket for reading if possible' do
+      socket.stub(:close_read)
+      handler.write('hello world')
+      handler.drain
+      socket.should have_received(:close_read)
+    end
+
+    it 'ignores IO errors when closing for reading' do
+      socket.stub(:close_read).and_raise(IOError, 'Boork')
+      handler.write('hello world')
+      expect { handler.drain }.to_not raise_error
+    end
+
     it 'returns a future that completes when the socket has closed' do
       handler.write('hello world')
       f = handler.drain
@@ -238,7 +251,7 @@ shared_examples_for 'a connection' do |options|
         data = nil
         handler.on_data { |d| data = d }
         handler.read
-        data.should eq('foo bar')
+        data.should == 'foo bar'
       end
 
       context 'when #read_nonblock raises an error' do

data/spec/ione/io/io_reactor_spec.rb

@@ -7,7 +7,11 @@ module Ione
   module Io
     describe IoReactor do
       let :reactor do
-        described_class.new(selector: selector, clock: clock)
+        described_class.new(options)
+      end
+
+      let :options do
+        {selector: selector, clock: clock, drain_timeout: 3}
       end
 
       let! :selector do
@@ -37,7 +41,7 @@ module Ione
         end
 
         after do
-          reactor.stop if reactor.running?
+          reactor.stop.value if reactor.running?
         end
       end
 
@@ -77,15 +81,16 @@ module Ione
             end
             reactor.start.value
             stopped_future = reactor.stop
-            restarted_future = reactor.start
             sequence = []
             stopped_future.on_complete { sequence << :stopped }
+            restarted_future = reactor.start
             restarted_future.on_complete { sequence << :restarted }
             barrier.push(nil)
             stopped_future.value
             restarted_future.value
+            await { sequence.size >= 2 }
             begin
-              sequence.should eq([:stopped, :restarted])
+              sequence.should == [:stopped, :restarted]
             ensure
               reactor.stop
               barrier.push(nil) while reactor.running?
@@ -93,7 +98,6 @@ module Ione
           end
 
           it 'restarts the reactor even when restarted before a failed stop' do
-            pending 'This test is broken in JRuby' if RUBY_ENGINE == 'jruby'
             barrier = Queue.new
             selector.handler do
               if barrier.pop == :fail
@@ -112,6 +116,7 @@ module Ione
             barrier.push(:fail)
             stopped_future.value rescue nil
             restarted_future.value
+            await { crashed && restarted }
             begin
               crashed.should be_true
               restarted.should be_true
@@ -136,6 +141,8 @@ module Ione
 
         context 'when already started' do
           it 'is not started again' do
+            calls = 0
+            lock = Mutex.new
             ticks = Queue.new
             barrier = Queue.new
             selector.handler do
@@ -176,7 +183,7 @@ module Ione
           reactor.should_not be_running
         end
 
-        it 'keeps running until stop completed' do
+        it 'keeps running until stop completes' do
           running_barrier = Queue.new
           stop_barrier = Queue.new
           selector.handler do
@@ -191,11 +198,125 @@ module Ione
           stop_barrier.push(nil) until future.completed?
         end
 
-        it 'closes all sockets' do
+        it 'unblocks the reactor' do
+          running_barrier = Queue.new
+          selector.handler do |readables, writables, _, _|
+            running_barrier.push(nil)
+            IO.select(readables, writables, nil, 5)
+          end
           reactor.start.value
-          connection = reactor.connect('example.com', 9999, 5).value
-          reactor.stop.value
-          connection.should be_closed
+          running_barrier.pop
+          stopped_future = reactor.stop
+          await { stopped_future.completed? }
+          stopped_future.should be_completed
+          stopped_future.value
+        end
+
+        it 'drains all sockets' do
+          reactor.start.value
+          TCPServer.open(0) do |server|
+            lazy_socket = Thread.start { server.accept }
+            connection = reactor.connect(server.addr[3], server.addr[1], 5).value
+            writable = false
+            connection.stub(:stub_writable?) { writable }
+            class <<connection; alias_method :writable?, :stub_writable?; end
+            connection.write('12345678')
+            release_barrier = barrier = Queue.new
+            selector.handler do |readables, writables, _, _|
+              barrier.pop
+              [[], writables, []]
+            end
+            await { barrier.num_waiting > 0 }
+            barrier = []
+            release_barrier.push(nil)
+            connection.stub(:flush) do
+              writable = false
+            end
+            writable = true
+            reactor.stop.value
+            connection.should have_received(:flush)
+          end
+        end
+
+        it 'waits on drain to complete upto the specified drain timeout' do
+          time = time_increment = next_increment = 0
+          mutex = Mutex.new
+          clock.stub(:now) { mutex.synchronize { time } }
+          selector.handler do |_, writables, _, _|
+            mutex.synchronize do
+              time += time_increment
+              time_increment = next_increment
+            end
+            [[], writables, []]
+          end
+          reactor.start.value
+          TCPServer.open(0) do |server|
+            lazy_socket = Thread.start { server.accept }
+            connection = reactor.connect(server.addr[3], server.addr[1], 5).value
+            stopped_future = nil
+            mutex.synchronize do
+              connection.stub(:writable?).and_return(true)
+              connection.stub(:flush)
+              next_increment = 1
+              stopped_future = reactor.stop
+            end
+            expect { stopped_future.value }.to raise_error(ReactorError, /timeout/)
+            (time).should eq(3)
+          end
+        end
+
+        it 'waits on drain to complete upto five seconds by default' do
+          with_server do |host, port|
+            options.delete(:drain_timeout)
+            time = time_increment = next_increment = 0
+            mutex = Mutex.new
+            clock.stub(:now) { mutex.synchronize { time } }
+            selector.handler do |_, writables, _, _|
+              mutex.synchronize do
+                time += time_increment
+                time_increment = next_increment
+              end
+              [[], writables, []]
+            end
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            stopped_future = nil
+            mutex.synchronize do
+              connection.stub(:writable?).and_return(true)
+              connection.stub(:flush)
+              next_increment = 1
+              stopped_future = reactor.stop
+            end
+            expect { stopped_future.value }.to raise_error(ReactorError, /timeout/)
+            time.should eq(5)
+          end
+        end
+
+        it 'closes all sockets' do
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            reactor.stop.value
+            connection.should be_closed
+          end
+        end
+
+        it 'closes all sockets even if drain fails' do
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            Thread.pass
+            writable = false
+            connection.stub(:stub_writable?) { writable }
+            class <<connection; alias_method :writable?, :stub_writable?; end
+            connection.write('12345678')
+            Thread.pass
+            connection.stub(:flush).and_raise(StandardError, 'Boork')
+            writable = true
+            f = reactor.stop
+            expect { f.value }.to raise_error(StandardError, 'Boork')
+            connection.should be_closed
+          end
         end
 
         it 'cancels all active timers' do
@@ -237,7 +358,7 @@ module Ione
           reactor.on_error { |e| error = e }
           reactor.start
           await { error }
-          error.message.should eq('Blurgh')
+          error.message.should == 'Blurgh'
         end
 
         it 'calls the listener immediately when the reactor has already crashed' do
@@ -266,17 +387,18 @@ module Ione
           reactor.on_error { calls << :post_started }
           barrier.push(nil)
           await { !reactor.running? }
+          await { calls.size >= 2 }
           reactor.on_error { calls << :pre_restarted }
-          calls.should eq([
+          calls.should == [
             :pre_started,
             :post_started,
             :pre_restarted,
-          ])
+          ]
           reactor.start
           reactor.on_error { calls << :post_restarted }
           barrier.push(nil)
           await { !reactor.running? }
-          calls.should eq([
+          calls.should == [
             :pre_started,
             :post_started,
             :pre_restarted,
@@ -284,7 +406,7 @@ module Ione
             :post_started,
             :pre_restarted,
             :post_restarted,
-          ])
+          ]
         end
       end
 
@@ -292,70 +414,90 @@ module Ione
         include_context 'running_reactor'
 
         it 'calls the given block with a connection' do
-          connection = nil
-          reactor.start.value
-          reactor.connect('example.com', 9999, 5) { |c| connection = c }.value
-          connection.should_not be_nil
+          with_server do |host, port|
+            connection = nil
+            reactor.start.value
+            reactor.connect(host, port, 5) { |c| connection = c }.value
+            connection.should_not be_nil
+          end
         end
 
         it 'returns a future that resolves to what the given block returns' do
-          reactor.start.value
-          x = reactor.connect('example.com', 9999, 5) { :foo }.value
-          x.should eq(:foo)
+          with_server do |host, port|
+            reactor.start.value
+            x = reactor.connect(host, port, 5) { :foo }.value
+            x.should == :foo
+          end
         end
 
         it 'defaults to 5 as the connection timeout' do
-          reactor.start.value
-          connection = reactor.connect('example.com', 9999).value
-          connection.connection_timeout.should eq(5)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port).value
+            connection.connection_timeout.should == 5
+          end
         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 eq(9)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, timeout: 9).value
+            connection.connection_timeout.should == 9
+          end
         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)
+          with_server do |host, port|
+            reactor.start.value
+            reactor.connect(host, port, 5).value.should be_a(Connection)
+          end
         end
 
         it 'creates a connection and passes it to the selector as a readable' do
-          reactor.start.value
-          connection = reactor.connect('example.com', 9999, 5).value
-          await { selector.last_arguments[0].length > 1 }
-          selector.last_arguments[0].should include(connection)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, 5).value
+            await { selector.last_arguments[0].length > 1 }
+            selector.last_arguments[0].should include(connection)
+          end
         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)
+          with_server do |host, port|
+            reactor.start.value
+            connection = reactor.connect(host, port, ssl: true).value
+            connection.should be_a(SslConnection)
+          end
         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
+          with_server do |host, port|
+            ssl_context = double(:ssl_context)
+            reactor.start.value
+            f = reactor.connect(host, port, ssl: ssl_context)
+            expect { f.value }.to raise_error
+          end
         end
 
         context 'when called before the reactor is started' do
           it 'waits for the reactor to start' do
-            f = reactor.connect('example.com', 9999)
-            reactor.start.value
-            f.value
+            with_server do |host, port|
+              f = reactor.connect(host, port)
+              reactor.start.value
+              f.value
+            end
           end
         end
 
         context 'when called after the reactor has stopped' do
           it 'waits for the reactor to be restarted' do
-            reactor.start.value
-            reactor.stop.value
-            f = reactor.connect('example.com', 9999)
-            reactor.start.value
-            f.value
+            with_server do |host, port|
+              reactor.start.value
+              reactor.stop.value
+              f = reactor.connect(host, port)
+              reactor.start.value
+              f.value
+            end
           end
         end
       end
@@ -377,19 +519,19 @@ module Ione
         it 'returns a future that resolves to what the given block returns' do
           reactor.start.value
           x = reactor.bind(ENV['SERVER_HOST'], port, 5) { |acceptor| :foo }.value
-          x.should eq(:foo)
+          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 eq(5)
+          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 eq(9)
+          acceptor.backlog.should == 9
         end
 
         it 'returns the acceptor when no block is given' do