ione 1.2.0 → 1.2.1

data/spec/ione/future_spec.rb

@@ -822,6 +822,17 @@ module Ione
         future.value.should == {'foo' => 'bar', 'qux' => 'baz', 'hello' => 'world'}
       end
 
+      it 'accepts boolean accumulators' do
+        futures = [
+          Future.resolved([:foo]),
+          Future.resolved([]),
+        ]
+        future = Future.reduce(futures, false) do |accumulator, value|
+          accumulator || value.empty?
+        end
+        future.value.should == true
+      end
+
       it 'calls the block with the values in the order of the source futures' do
         promises = [Promise.new, Promise.new, Promise.new, Promise.new, Promise.new]
         futures = promises.map(&:future)
@@ -868,6 +879,18 @@ module Ione
         future.should be_failed
       end
 
+      it 'allows invocations to return nil' do
+        futures = [Future.resolved(1), Future.resolved(2), Future.resolved(3)]
+        future = Future.reduce(futures, []) do |accumulator, value|
+          if value == 2
+            nil
+          else
+            value
+          end
+        end
+        future.value.should eq(3)
+      end
+
       context 'when the list of futures is empty' do
         it 'returns a future that resolves to the initial value' do
           Future.reduce([], :foo).value.should == :foo
@@ -938,6 +961,95 @@ module Ione
       end
     end
 
+    describe '.after' do
+      context 'returns a new future which' do
+        it 'is resolved when the source futures are resolved' do
+          p1 = Promise.new
+          p2 = Promise.new
+          f = Future.after(p1.future, p2.future)
+          p1.fulfill
+          f.should_not be_resolved
+          p2.fulfill
+          f.should be_resolved
+        end
+
+        it 'returns no value' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.after(p1.future, p2.future, p3.future)
+          p2.fulfill(2)
+          p1.fulfill(1)
+          p3.fulfill(3)
+          f.value.should be_nil
+        end
+
+        it 'fails if any of the source futures fail' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          p4 = Promise.new
+          f = Future.after(p1.future, p2.future, p3.future, p4.future)
+          p2.fulfill
+          p1.fail(StandardError.new('hurgh'))
+          p3.fail(StandardError.new('murgasd'))
+          p4.fulfill
+          expect { f.value }.to raise_error(/hurgh|murgasd/)
+          f.should be_failed
+        end
+
+        it 'completes with nil when no futures are given' do
+          Future.after.value.should be_nil
+        end
+
+        it 'completes with nil when an empty list is given' do
+          Future.after([]).value.should be_nil
+        end
+
+        it 'completes with nil when an empty enumerable is given' do
+          Future.after([].to_enum).value.should be_nil
+        end
+
+        it 'completes with nil when a single future is given' do
+          f = Future.resolved(1)
+          Future.after(f).value.should be_nil
+        end
+
+        it 'accepts a list of futures' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future)
+          f = Future.after(futures)
+          promises.each(&:fulfill)
+          f.value.should be_nil
+        end
+
+        it 'accepts an enumerable of futures' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future).to_enum
+          f = Future.after(futures)
+          promises.each(&:fulfill)
+          f.value.should be_nil
+        end
+
+        it 'accepts an enumerable of one future' do
+          promises = [Promise.new]
+          futures = promises.map(&:future).to_enum
+          f = Future.after(futures)
+          promises.each(&:fulfill)
+          f.value.should be_nil
+        end
+
+        it 'accepts anything that implements #on_complete as futures' do
+          ff1, ff2, ff3 = double, double, double
+          ff1.stub(:on_complete) { |&listener| listener.call(1, nil) }
+          ff2.stub(:on_complete) { |&listener| listener.call(2, nil) }
+          ff3.stub(:on_complete) { |&listener| listener.call(3, nil) }
+          future = Future.after(ff1, ff2, ff3)
+          future.value.should be_nil
+        end
+      end
+    end
+
     describe '.all' do
       context 'returns a new future which' do
         it 'is resolved when the source futures are resolved' do

data/spec/ione/io/connection_spec.rb

@@ -312,15 +312,15 @@ module Ione
           end
 
           it 'includes the connection state' do
-            handler.to_s.should include('connecting')
+            handler.to_s.should include('CONNECTING')
             socket.stub(:connect_nonblock).and_raise(Errno::EINPROGRESS)
             handler.connect
-            handler.to_s.should include('connecting')
+            handler.to_s.should include('CONNECTING')
             socket.stub(:connect_nonblock)
             handler.connect
-            handler.to_s.should include('connected')
+            handler.to_s.should include('CONNECTED')
             handler.close
-            handler.to_s.should include('closed')
+            handler.to_s.should include('CLOSED')
           end
         end
       end

data/spec/ione/io/io_reactor_spec.rb

@@ -59,12 +59,6 @@ module Ione
           reactor.should be_running
         end
 
-        it 'cannot be started again once stopped' do
-          reactor.start.value
-          reactor.stop.value
-          expect { reactor.start }.to raise_error(ReactorError)
-        end
-
         it 'calls the selector' do
           called = false
           selector.handler { called = true; [[], [], []] }
@@ -73,6 +67,95 @@ module Ione
           reactor.stop.value
           called.should be_true, 'expected the selector to have been called'
         end
+
+        context 'when stopping' do
+          it 'waits for the reactor to stop, then starts it again' do
+            barrier = Queue.new
+            selector.handler do
+              barrier.pop
+              [[], [], []]
+            end
+            reactor.start.value
+            stopped_future = reactor.stop
+            restarted_future = reactor.start
+            sequence = []
+            stopped_future.on_complete { sequence << :stopped }
+            restarted_future.on_complete { sequence << :restarted }
+            barrier.push(nil)
+            stopped_future.value
+            restarted_future.value
+            begin
+              sequence.should == [:stopped, :restarted]
+            ensure
+              reactor.stop
+              barrier.push(nil) while reactor.running?
+            end
+          end
+
+          it 'restarts the reactor even when restarted before a failed stop' do
+            barrier = Queue.new
+            selector.handler do
+              if barrier.pop == :fail
+                raise 'Blurgh'
+              else
+                [[], [], []]
+              end
+            end
+            reactor.start.value
+            stopped_future = reactor.stop
+            restarted_future = reactor.start
+            crashed = false
+            restarted = false
+            stopped_future.on_failure { crashed = true }
+            restarted_future.on_complete { restarted = true }
+            barrier.push(:fail)
+            stopped_future.value rescue nil
+            restarted_future.value
+            begin
+              crashed.should be_true
+              restarted.should be_true
+            ensure
+              reactor.stop
+              barrier.push(nil) while reactor.running?
+            end
+          end
+        end
+
+        context 'when stopped' do
+          before do
+            reactor.start.value
+            reactor.stop.value
+          end
+
+          it 'starts the reactor again' do
+            reactor.start.value
+            reactor.should be_running
+          end
+        end
+
+        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
+              ticks.push(:tick)
+              barrier.pop
+              [[], [], []]
+            end
+            reactor.start.value
+            reactor.start.value
+            reactor.start.value
+            begin
+              ticks.pop.should_not be_nil
+              ticks.size.should be_zero
+            ensure
+              reactor.stop
+              barrier.push(nil) while reactor.running?
+            end
+          end
+        end
       end
 
       describe '#stop' do
@@ -114,6 +197,20 @@ module Ione
           active_timer1.should be_failed
           active_timer2.should be_failed
         end
+
+        context 'when not started' do
+          it 'does nothing' do
+            reactor = described_class.new(selector: selector, clock: clock)
+            expect { reactor.stop.value }.to_not raise_error
+          end
+        end
+
+        context 'when already stopped' do
+          it 'does nothing' do
+            reactor.stop.value
+            expect { reactor.stop.value }.to_not raise_error
+          end
+        end
       end
 
       describe '#on_error' do
@@ -145,6 +242,36 @@ module Ione
           await { called }
           called.should be_true, 'expected all close listeners to have been called'
         end
+
+        it 'calls all listeners when the reactor crashes after being restarted' do
+          calls = []
+          barrier = Queue.new
+          selector.handler { barrier.pop; raise 'Blurgh' }
+          reactor.on_error { calls << :pre_started }
+          reactor.start
+          reactor.on_error { calls << :post_started }
+          barrier.push(nil)
+          await { !reactor.running? }
+          reactor.on_error { calls << :pre_restarted }
+          calls.should == [
+            :pre_started,
+            :post_started,
+            :pre_restarted,
+          ]
+          reactor.start
+          reactor.on_error { calls << :post_restarted }
+          barrier.push(nil)
+          await { !reactor.running? }
+          calls.should == [
+            :pre_started,
+            :post_started,
+            :pre_restarted,
+            :pre_started,
+            :post_started,
+            :pre_restarted,
+            :post_restarted,
+          ]
+        end
       end
 
       describe '#connect' do
@@ -199,6 +326,24 @@ module Ione
           f = reactor.connect('example.com', 9999, ssl: ssl_context)
           expect { f.value }.to raise_error
         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
+          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
+          end
+        end
       end
 
       describe '#bind' do
@@ -252,22 +397,72 @@ module Ione
           acceptor = reactor.bind(ENV['SERVER_HOST'], port, ssl: ssl_context).value
           acceptor.should be_an(SslAcceptor)
         end
+
+        context 'when called before the reactor is started' do
+          it 'waits for the reactor to start' do
+            f = reactor.bind(ENV['SERVER_HOST'], port, 5)
+            reactor.start.value
+            f.value
+          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.bind(ENV['SERVER_HOST'], port, 5)
+            reactor.start.value
+            f.value
+          end
+        end
       end
 
       describe '#schedule_timer' do
-        before do
-          reactor.start.value
+        context 'when the reactor is running' do
+          before do
+            reactor.start.value
+          end
+
+          after do
+            reactor.stop.value
+          end
+
+          it 'returns a future that is resolved after the specified duration' do
+            clock.stub(:now).and_return(1)
+            f = reactor.schedule_timer(0.1)
+            clock.stub(:now).and_return(1.1)
+            await { f.resolved? }
+          end
         end
 
-        after do
-          reactor.stop.value
+        context 'when called before the reactor is started' do
+          after do
+            reactor.stop.value if reactor.running?
+          end
+
+          it 'waits for the reactor to start' do
+            clock.stub(:now).and_return(1)
+            f = reactor.schedule_timer(0.1)
+            clock.stub(:now).and_return(2)
+            reactor.start.value
+            f.value
+          end
         end
 
-        it 'returns a future that is resolved after the specified duration' do
-          clock.stub(:now).and_return(1)
-          f = reactor.schedule_timer(0.1)
-          clock.stub(:now).and_return(1.1)
-          await { f.resolved? }
+        context 'when called after the reactor has stopped' do
+          after do
+            reactor.stop.value if reactor.running?
+          end
+
+          it 'waits for the reactor to be restarted' do
+            reactor.start.value
+            reactor.stop.value
+            clock.stub(:now).and_return(1)
+            f = reactor.schedule_timer(0.1)
+            clock.stub(:now).and_return(2)
+            reactor.start.value
+            f.value
+          end
         end
       end
 
@@ -322,6 +517,29 @@ module Ione
         it 'does nothing when given nil' do
           reactor.cancel_timer(nil)
         end
+
+        context 'when called before the reactor is started' do
+          it 'removes the timer before the reactor starts' do
+            clock.stub(:now).and_return(1)
+            f = reactor.schedule_timer(0.1)
+            reactor.cancel_timer(f)
+            clock.stub(:now).and_return(2)
+            f.should be_failed
+            reactor.start.value
+          end
+        end
+
+        context 'when called after the reactor has stopped' do
+          it 'removes the timer before the reactor is started again' do
+            reactor.start.value
+            reactor.stop.value
+            clock.stub(:now).and_return(1)
+            f = reactor.schedule_timer(0.1)
+            reactor.cancel_timer(f)
+            f.should be_failed
+            reactor.start.value
+          end
+        end
       end
 
       describe '#to_s' do
@@ -330,9 +548,8 @@ module Ione
             reactor.to_s.should include('Ione::Io::IoReactor')
           end
 
-          it 'includes a list of its connections' do
-            reactor.to_s.should include('@connections=[')
-            reactor.to_s.should include('#<Ione::Io::Unblocker>')
+          it 'includes the state' do
+            reactor.to_s.should include('PENDING')
           end
         end
       end