cql-rb 1.1.0.pre3 → 1.1.0.pre6

data/spec/cql/client/connection_manager_spec.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe ConnectionManager do
+      let :manager do
+        described_class.new
+      end
+
+      let :connections do
+        [double(:connection1), double(:connection2), double(:connection3)]
+      end
+
+      before do
+        connections.each do |c|
+          c.stub(:on_closed) do |&listener|
+            c.stub(:closed_listener).and_return(listener)
+          end
+        end
+      end
+
+      describe '#add_connections' do
+        it 'registers as a close listener on each connection' do
+          manager.add_connections(connections)
+          connections.each { |c| c.should have_received(:on_closed) }
+        end
+
+        it 'stops managing the connection when the connection closes' do
+          manager.add_connections(connections)
+          connections.each { |c| c.closed_listener.call }
+          expect { manager.random_connection }.to raise_error(NotConnectedError)
+        end
+      end
+
+      describe '#connected?' do
+        it 'returns true when there are connections' do
+          manager.add_connections(connections)
+          manager.should be_connected
+        end
+
+        it 'returns false when there are no' do
+          manager.should_not be_connected
+        end
+      end
+
+      describe '#snapshot' do
+        it 'returns a copy of the list of connections' do
+          manager.add_connections(connections)
+          s = manager.snapshot
+          s.should == connections
+          s.should_not equal(connections)
+        end
+      end
+
+      describe '#random_connection' do
+        before do
+          connections.each { |c| c.stub(:on_closed) }
+        end
+
+        it 'returns one of the connections it is managing' do
+          manager.add_connections(connections)
+          connections.should include(manager.random_connection)
+        end
+
+        it 'raises a NotConnectedError when there are no connections' do
+          expect { manager.random_connection }.to raise_error(NotConnectedError)
+        end
+      end
+
+      describe '#each_connection' do
+        it 'yields each connection to the given block' do
+          manager.add_connections(connections)
+          yielded = []
+          manager.each_connection { |c| yielded << c }
+          yielded.should == connections
+        end
+
+        it 'is aliased as #each' do
+          manager.add_connections(connections)
+          yielded = []
+          manager.each { |c| yielded << c }
+          yielded.should == connections
+        end
+
+        it 'returns an Enumerable when no block is given' do
+          manager.each.should be_an(Enumerable)
+        end
+
+        it 'raises a NotConnectedError when there are no connections' do
+          expect { manager.each_connection { } }.to raise_error(NotConnectedError)
+        end
+      end
+
+      context 'as an Enumerable' do
+        before do
+          connections.each_with_index { |c, i| c.stub(:index).and_return(i) }
+        end
+
+        it 'can be mapped' do
+          manager.add_connections(connections)
+          manager.map { |c| c.index }.should == [0, 1, 2]
+        end
+
+        it 'can be filtered' do
+          manager.add_connections(connections)
+          manager.select { |c| c.index % 2 == 0 }.should == [connections[0], connections[2]]
+        end
+
+        it 'raises a NotConnectedError when there are no connections' do
+          expect { manager.select { } }.to raise_error(NotConnectedError)
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/keyspace_changer_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe KeyspaceChanger do
+      let :keyspace_changer do
+        described_class.new
+      end
+
+      let :connection do
+        double(:connection)
+      end
+
+      describe '#use_keyspace' do
+        it 'sends a query request with a USE statement' do
+          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one)).and_return(Future.resolved)
+          f = keyspace_changer.use_keyspace('important_stuff', connection)
+          connection.should have_received(:send_request)
+        end
+
+        it 'accepts quoted keyspace names' do
+          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE "ImportantStuff"', :one)).and_return(Future.resolved)
+          f = keyspace_changer.use_keyspace('"ImportantStuff"', connection)
+          connection.should have_received(:send_request)
+        end
+
+        context 'returns a future that' do
+          it 'immediately resolves to the given connection when the keyspace is nil' do
+            f = keyspace_changer.use_keyspace(nil, connection)
+            f.value.should equal(connection)
+          end
+
+          it 'fails with an InvalidKeyspaceNameError when the keyspace name is invalid' do
+            f = keyspace_changer.use_keyspace('TRUNCATE important_stuff', connection)
+            expect { f.value }.to raise_error(InvalidKeyspaceNameError)
+          end
+
+          it 'resolves to the given connection' do
+            connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one)).and_return(Future.resolved)
+            f = keyspace_changer.use_keyspace('important_stuff', connection)
+            f.value.should equal(connection)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/request_runner_spec.rb

@@ -11,11 +11,11 @@ module Cql
       end
 
       let :connection do
-        stub(:connection)
+        double(:connection)
       end
 
       let :request do
-        stub(:request)
+        double(:request)
       end
 
       let :metadata do
@@ -59,12 +59,12 @@ module Cql
         end
 
         def run(response, rq=request)
-          connection.stub(:send_request).and_return(Future.completed(response))
-          runner.execute(connection, rq).get
+          connection.stub(:send_request).and_return(Future.resolved(response))
+          runner.execute(connection, rq).value
         end
 
         it 'executes the request' do
-          connection.should_receive(:send_request).and_return(Future.completed(rows_response))
+          connection.should_receive(:send_request).and_return(Future.resolved(rows_response))
           runner.execute(connection, request)
         end
 
@@ -78,12 +78,6 @@ module Cql
           result.should be_nil
         end
 
-        it 'transforms a PreparedResultResponse to a prepared statement' do
-          result = run(prepared_response)
-          result.should be_a(AsynchronousPreparedStatement)
-          result.metadata['my_column'].should == ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :int)
-        end
-
         it 'transforms a AuthenticateResponse to an authentication required object' do
           result = run(authenticate_response)
           result.should be_a(AuthenticationRequired)
@@ -106,7 +100,7 @@ module Cql
           rescue QueryError => e
             e.cql.should == 'SELECT * FROM everything'
           else
-            fail!('No error was raised')
+            fail('No error was raised')
           end
         end
 
@@ -114,6 +108,12 @@ module Cql
           result = run('hibbly hobbly')
           result.should be_nil
         end
+
+        it 'allows the caller to transform unknown responses' do
+          connection.stub(:send_request).and_return(Future.resolved('hibbly hobbly'))
+          result = runner.execute(connection, request) { |response| response.reverse }.value
+          result.should == 'hibbly hobbly'.reverse
+        end
       end
     end
   end

data/spec/cql/client/synchronous_client_spec.rb

@@ -11,17 +11,17 @@ module Cql
       end
 
       let :async_client do
-        stub(:async_client)
+        double(:async_client)
       end
 
       let :future do
-        stub(:future, get: nil)
+        double(:future, value: nil)
       end
 
       describe '#connect' do
         it 'calls #connect on the async client and waits for the result' do
           async_client.should_receive(:connect).and_return(future)
-          future.should_receive(:get)
+          future.should_receive(:value)
           client.connect
         end
 
@@ -34,7 +34,7 @@ module Cql
       describe '#close' do
         it 'calls #close on the async client and waits for the result' do
           async_client.should_receive(:close).and_return(future)
-          future.should_receive(:get)
+          future.should_receive(:value)
           client.close
         end
 
@@ -63,31 +63,31 @@ module Cql
       describe '#use' do
         it 'calls #use on the async client and waits for the result' do
           async_client.should_receive(:use).with('foo').and_return(future)
-          future.should_receive(:get)
+          future.should_receive(:value)
           client.use('foo')
         end
       end
 
       describe '#execute' do
         it 'calls #execute on the async client and waits for, and returns the result' do
-          result = stub(:result)
+          result = double(:result)
           async_client.stub(:execute).with('SELECT * FROM something', :one).and_return(future)
-          future.stub(:get).and_return(result)
+          future.stub(:value).and_return(result)
           client.execute('SELECT * FROM something', :one).should equal(result)
         end
       end
 
       describe '#prepare' do
         it 'calls #prepare on the async client, waits for the result and returns a SynchronousFuture' do
-          result = stub(:result)
-          metadata = stub(:metadata)
-          async_statement = stub(:async_statement, metadata: metadata)
-          another_future = stub(:another_future)
+          result = double(:result)
+          metadata = double(:metadata)
+          async_statement = double(:async_statement, metadata: metadata)
+          another_future = double(:another_future)
           async_client.stub(:prepare).with('SELECT * FROM something').and_return(future)
-          future.stub(:get).and_return(async_statement)
+          future.stub(:value).and_return(async_statement)
           statement = client.prepare('SELECT * FROM something')
           async_statement.should_receive(:execute).and_return(another_future)
-          another_future.stub(:get).and_return(result)
+          another_future.stub(:value).and_return(result)
           statement.execute.should equal(result)
           statement.metadata.should equal(metadata)
         end
@@ -103,7 +103,7 @@ module Cql
         it 'replaces the backtrace of the asynchronous call to make it less confusing' do
           error = CqlError.new('Bork')
           error.set_backtrace(['Hello', 'World'])
-          future.stub(:get).and_raise(error)
+          future.stub(:value).and_raise(error)
           async_client.stub(:execute).and_return(future)
           begin
             client.execute('SELECT * FROM something')
@@ -113,7 +113,7 @@ module Cql
         end
 
         it 'does not replace the backtrace of non-CqlError errors' do
-          future.stub(:get).and_raise('Bork')
+          future.stub(:value).and_raise('Bork')
           async_client.stub(:execute).and_return(future)
           begin
             client.execute('SELECT * FROM something')

data/spec/cql/client/synchronous_prepared_statement_spec.rb

@@ -11,15 +11,19 @@ module Cql
       end
 
       let :async_statement do
-        stub(:async_statement, metadata: metadata)
+        double(:async_statement, metadata: metadata)
       end
 
       let :metadata do
-        stub(:metadata)
+        double(:metadata)
+      end
+
+      let :promise do
+        Promise.new
       end
 
       let :future do
-        Future.new
+        promise.future
       end
 
       describe '#metadata' do
@@ -30,19 +34,19 @@ module Cql
 
       describe '#execute' do
         it 'it calls #execute on the async statement and waits for the result' do
-          result = stub(:result)
+          result = double(:result)
           async_statement.should_receive(:execute).with('one', 'two', :three).and_return(future)
-          future.complete!(result)
+          promise.fulfill(result)
           statement.execute('one', 'two', :three).should equal(result)
         end
       end
 
       describe '#pipeline' do
         it 'executes the statement multiple times and waits for all the results' do
-          result1 = stub(:result1)
-          result2 = stub(:result2)
-          async_statement.stub(:execute).with('one', 'two', :three).and_return(Future.completed(result1))
-          async_statement.stub(:execute).with('four', 'file', :all).and_return(Future.completed(result2))
+          result1 = double(:result1)
+          result2 = double(:result2)
+          async_statement.stub(:execute).with('one', 'two', :three).and_return(Future.resolved(result1))
+          async_statement.stub(:execute).with('four', 'file', :all).and_return(Future.resolved(result2))
           results = statement.pipeline do |p|
             p.execute('one', 'two', :three)
             p.execute('four', 'file', :all)
@@ -65,7 +69,7 @@ module Cql
         it 'replaces the backtrace of the asynchronous call to make it less confusing' do
           error = CqlError.new('Bork')
           error.set_backtrace(['Hello', 'World'])
-          future.stub(:get).and_raise(error)
+          future.stub(:value).and_raise(error)
           async_statement.stub(:execute).and_return(future)
           begin
             statement.execute('SELECT * FROM something')
@@ -75,7 +79,7 @@ module Cql
         end
 
         it 'does not replace the backtrace of non-CqlError errors' do
-          future.stub(:get).and_raise('Bork')
+          future.stub(:value).and_raise('Bork')
           async_statement.stub(:execute).and_return(future)
           begin
             statement.execute('SELECT * FROM something')

data/spec/cql/future_spec.rb

@@ -4,457 +4,685 @@ require 'spec_helper'
 
 
 module Cql
-  describe Future do
-    let :future do
+  describe Promise do
+    let :promise do
       described_class.new
     end
 
-    context 'when completed' do
-      it 'is complete' do
-        future.complete!('foo')
-        future.should be_complete
+    let :future do
+      promise.future
+    end
+
+    let :error do
+      StandardError.new('bork')
+    end
+
+    describe '#fulfill' do
+      it 'resolves its future' do
+        promise.fulfill
+        future.should be_resolved
       end
 
-      it 'has a value' do
-        future.complete!('foo')
-        future.value.should == 'foo'
+      it 'raises an error if fulfilled a second time' do
+        promise.fulfill
+        expect { promise.fulfill }.to raise_error(FutureError)
       end
 
-      it 'is complete even when the value is falsy' do
-        future.complete!(nil)
-        future.should be_complete
+      it 'raises an error if failed after being fulfilled' do
+        promise.fulfill
+        expect { promise.fail(error) }.to raise_error(FutureError)
       end
 
-      it 'returns the value from #get, too' do
-        future.complete!('foo')
-        future.get.should == 'foo'
+      it 'returns nil' do
+        promise.fulfill(:foo).should be_nil
       end
+    end
 
-      it 'has the value nil by default' do
-        future.complete!
-        future.value.should be_nil
+    describe '#fail' do
+      it 'fails its future' do
+        promise.fail(error)
+        future.should be_failed
       end
 
-      it 'notifies all completion listeners' do
-        v1, v2 = nil, nil
-        future.on_complete { |v| v1 = v }
-        future.on_complete { |v| v2 = v }
-        future.complete!('bar')
-        v1.should == 'bar'
-        v2.should == 'bar'
+      it 'raises an error if failed a second time' do
+        promise.fail(error)
+        expect { promise.fail(error) }.to raise_error(FutureError)
       end
 
-      it 'notifies all listeners even when one raises an error' do
-        value = nil
-        future.on_complete { |v| raise 'Blurgh' }
-        future.on_complete { |v| value = v }
-        future.complete!('bar')
-        value.should == 'bar'
+      it 'raises an error if fulfilled after being failed' do
+        promise.fail(error)
+        expect { promise.fulfill }.to raise_error(FutureError)
       end
 
-      it 'notifies new listeners even when already completed' do
-        v1, v2 = nil, nil
-        future.complete!('bar')
-        future.on_complete { |v| v1 = v }
-        future.on_complete { |v| v2 = v }
-        v1.should == 'bar'
-        v2.should == 'bar'
+      it 'returns nil' do
+        promise.fail(error).should be_nil
       end
+    end
 
-      it 'does not raise any error when the listener raises an error when already completed' do
-        future.complete!('bar')
-        expect { future.on_complete { |v| raise 'Blurgh' } }.to_not raise_error
+    describe '#observe' do
+      it 'resolves its future when the specified future is resolved' do
+        p2 = Promise.new
+        promise.observe(p2.future)
+        p2.fulfill
+        promise.future.should be_resolved
       end
 
-      it 'blocks on #value until completed' do
-        Thread.start(future) do |f|
-          sleep 0.1
-          future.complete!('bar')
+      it 'fails its future when the specified future fails' do
+        p2 = Promise.new
+        promise.observe(p2.future)
+        p2.fail(error)
+        promise.future.should be_failed
+      end
+
+      it 'silently ignores double fulfillment/failure' do
+        p2 = Promise.new
+        promise.observe(p2.future)
+        promise.fail(error)
+        p2.fulfill
+      end
+
+      it 'returns nil' do
+        promise.observe(Promise.new.future).should be_nil
+      end
+    end
+
+    describe '#try' do
+      it 'fulfills the promise with the result of the block' do
+        promise.try do
+          3 + 4
         end
-        future.value.should == 'bar'
+        promise.future.value.should == 7
       end
 
-      it 'blocks on #value until completed, when value is nil' do
-        Thread.start(future) do |f|
-          sleep 0.1
-          future.complete!
+      it 'fails the promise when the block raises an error' do
+        promise.try do
+          raise error
         end
-        future.value.should be_nil
-        future.value.should be_nil
+        expect { promise.future.value }.to raise_error(/bork/)
       end
 
-      it 'blocks on #value until failed' do
-        Thread.start(future) do |f|
-          sleep 0.1
-          future.fail!(StandardError.new('FAIL!'))
+      it 'calls the block with the specified arguments' do
+        promise.try(:foo, 3) do |a, b|
+          a.length + b
         end
-        expect { future.value }.to raise_error('FAIL!')
+        promise.future.value.should == 6
       end
 
-      it 'cannot be completed again' do
-        future.complete!('bar')
-        expect { future.complete!('foo') }.to raise_error(FutureError)
+      it 'returns nil' do
+        promise.try { }.should be_nil
       end
+    end
+  end
+
+  describe Future do
+    let :promise do
+      Promise.new
+    end
 
-      it 'cannot be failed again' do
-        future.complete!('bar')
-        expect { future.fail!(StandardError.new('FAIL!')) }.to raise_error(FutureError)
+    let :future do
+      promise.future
+    end
+
+    let :error do
+      StandardError.new('bork')
+    end
+
+    def async(*context, &listener)
+      Thread.start(*context, &listener)
+    end
+
+    def delayed(*context, &listener)
+      async(*context) do |*ctx|
+        sleep(0.1)
+        listener.call(*context)
       end
     end
 
-    context 'when failed' do
-      it 'is failed' do
-        future.fail!(StandardError.new('FAIL!'))
-        future.should be_failed
+    describe '#completed?' do
+      it 'is true when the promise is fulfilled' do
+        promise.fulfill
+        future.should be_completed
       end
 
-      it 'raises the error from #value' do
-        future.fail!(StandardError.new('FAIL!'))
-        expect { future.value }.to raise_error('FAIL!')
+      it 'is true when the promise is failed' do
+        promise.fail(StandardError.new('bork'))
+        future.should be_completed
       end
+    end
 
-      it 'notifies all failure listeners' do
-        e1, e2 = nil, nil
-        future.on_failure { |e| e1 = e }
-        future.on_failure { |e| e2 = e }
-        future.fail!(StandardError.new('FAIL!'))
-        e1.message.should == 'FAIL!'
-        e2.message.should == 'FAIL!'
+    describe '#resolved?' do
+      it 'is true when the promise is fulfilled' do
+        promise.fulfill('foo')
+        future.should be_resolved
       end
 
-      it 'notifies all listeners even if one raises an error' do
-        error = nil
-        future.on_failure { |e| raise 'Blurgh' }
-        future.on_failure { |e| error = e }
-        future.fail!(StandardError.new('FAIL!'))
-        error.message.should == 'FAIL!'
+      it 'is true when the promise is fulfilled with something falsy' do
+        promise.fulfill(nil)
+        future.should be_resolved
       end
 
-      it 'notifies new listeners even when already failed' do
-        e1, e2 = nil, nil
-        future.fail!(StandardError.new('FAIL!'))
-        future.on_failure { |e| e1 = e }
-        future.on_failure { |e| e2 = e }
-        e1.message.should == 'FAIL!'
-        e2.message.should == 'FAIL!'
+      it 'is false when the promise is failed' do
+        promise.fail(StandardError.new('bork'))
+        future.should_not be_resolved
       end
+    end
 
-      it 'does not raise any error when the listener raises an error when already failed' do
-        future.fail!(StandardError.new('FAIL!'))
-        expect { future.on_failure { |e| raise 'Blurgh' } }.to_not raise_error
+    describe '#failed?' do
+      it 'is true when the promise is failed' do
+        promise.fail(error)
+        future.should be_failed
       end
 
-      it 'cannot be failed again' do
-        future.fail!(StandardError.new('FAIL!'))
-        expect { future.fail!(StandardError.new('FAIL!')) }.to raise_error(FutureError)
+      it 'is false when the promise is fulfilled' do
+        promise.fulfill
+        future.should_not be_failed
       end
+    end
+
+    describe '#on_complete' do
+      context 'registers listeners and' do
+        it 'notifies all listeners when the promise is fulfilled' do
+          v1, v2 = nil, nil
+          future.on_complete { |f| v1 = f.value }
+          future.on_complete { |f| v2 = f.value }
+          promise.fulfill('bar')
+          v1.should == 'bar'
+          v2.should == 'bar'
+        end
+
+        it 'notifies all listeners when the promise fails' do
+          e1, e2 = nil, nil
+          future.on_complete { |f| begin; f.value; rescue => err; e1 = err; end }
+          future.on_complete { |f| begin; f.value; rescue => err; e2 = err; end }
+          future.fail(error)
+          e1.message.should == error.message
+          e2.message.should == error.message
+        end
+
+        it 'notifies all listeners when the promise is fulfilled, even when one raises an error' do
+          value = nil
+          future.on_complete { |f| raise 'Blurgh' }
+          future.on_complete { |f| value = f.value }
+          promise.fulfill('bar')
+          value.should == 'bar'
+        end
 
-      it 'cannot be completed' do
-        future.fail!(StandardError.new('FAIL!'))
-        expect { future.complete!('hurgh') }.to raise_error(FutureError)
+        it 'notifies all listeners when the promise fails, even when one raises an error' do
+          err = nil
+          future.on_complete { |f| raise 'Blurgh' }
+          future.on_complete { |f| begin; f.value; rescue => err; e = err; end }
+          promise.fail(error)
+          err.message.should == 'bork'
+        end
+
+        it 'notifies listeners registered after the promise was fulfilled' do
+          promise.fulfill('bar')
+          expect { future.on_complete { |v| raise 'blurgh' } }.to_not raise_error
+        end
+
+        it 'notifies listeners registered after the promise failed' do
+          promise.fail(error)
+          expect { future.on_complete { |v| raise 'blurgh' } }.to_not raise_error
+        end
+
+        it 'returns nil' do
+          future.on_complete { :foo }.should be_nil
+        end
+
+        it 'returns nil when the future is already resolved' do
+          promise.fulfill
+          future.on_complete { :foo }.should be_nil
+        end
+
+        it 'returns nil when the future already has failed' do
+          promise.fail(error)
+          future.on_complete { :foo }.should be_nil
+        end
       end
     end
 
-    describe '.combine' do
-      context 'returns a new future which' do
-        it 'is complete when the source futures are complete' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.combine(f1, f2)
-          f1.complete!
-          f3.should_not be_complete
-          f2.complete!
-          f3.should be_complete
+    describe '#on_value' do
+      context 'registers listeners and' do
+        it 'notifies all value listeners when the promise is fulfilled' do
+          v1, v2 = nil, nil
+          future.on_value { |v| v1 = v }
+          future.on_value { |v| v2 = v }
+          promise.fulfill('bar')
+          v1.should == 'bar'
+          v2.should == 'bar'
         end
 
-        it 'completes when the source futures have completed' do
-          sequence = []
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          f4 = Future.combine(f1, f2, f3)
-          f1.on_complete { sequence << 1 } 
-          f2.on_complete { sequence << 2 } 
-          f3.on_complete { sequence << 3 }
-          f2.complete!
-          f1.complete!
-          f3.complete!
-          sequence.should == [2, 1, 3]
+        it 'notifies all listeners even when one raises an error' do
+          value = nil
+          future.on_value { |v| raise 'Blurgh' }
+          future.on_value { |v| value = v }
+          promise.fulfill('bar')
+          value.should == 'bar'
         end
 
-        it 'returns an array of the values of the source futures, in order' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          f4 = Future.combine(f1, f2, f3)
-          f2.complete!(2)
-          f1.complete!(1)
-          f3.complete!(3)
-          f4.get.should == [1, 2, 3]
+        it 'notifies listeners registered after the promise was resolved' do
+          v1, v2 = nil, nil
+          promise.fulfill('bar')
+          future.on_value { |v| v1 = v }
+          future.on_value { |v| v2 = v }
+          v1.should == 'bar'
+          v2.should == 'bar'
         end
 
-        it 'fails if any of the source futures fail' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          f4 = Future.new
-          f5 = Future.combine(f1, f2, f3, f4)
-          f2.complete!
-          f1.fail!(StandardError.new('hurgh'))
-          f3.fail!(StandardError.new('murgasd'))
-          f4.complete!
-          expect { f5.get }.to raise_error('hurgh')
-          f5.should be_failed
+        it 'does not raise any error when the listener raises an error when already resolved' do
+          promise.fulfill('bar')
+          expect { future.on_value { |v| raise 'blurgh' } }.to_not raise_error
         end
 
-        it 'raises an error when #complete! is called' do
-          f = Future.combine(Future.new, Future.new)
-          expect { f.complete! }.to raise_error(FutureError)
+        it 'returns nil' do
+          future.on_value { :foo }.should be_nil
         end
 
-        it 'raises an error when #fail! is called' do
-          f = Future.combine(Future.new, Future.new)
-          expect { f.fail!(StandardError.new('Blurgh')) }.to raise_error(FutureError)
+        it 'returns nil when the future is already resolved' do
+          promise.fulfill
+          future.on_failure { :foo }.should be_nil
         end
+      end
+    end
 
-        it 'completes with an empty list when no futures are given' do
-          Future.combine.get.should == []
+    describe '#on_failure' do
+      context 'registers listeners and' do
+        it 'notifies all failure listeners when the promise fails' do
+          e1, e2 = nil, nil
+          future.on_failure { |err| e1 = err }
+          future.on_failure { |err| e2 = err }
+          promise.fail(error)
+          e1.message.should eql(error.message)
+          e2.message.should eql(error.message)
+        end
+
+        it 'notifies all listeners even if one raises an error' do
+          e = nil
+          future.on_failure { |err| raise 'Blurgh' }
+          future.on_failure { |err| e = err }
+          promise.fail(error)
+          e.message.should eql(error.message)
+        end
+
+        it 'notifies new listeners even when already failed' do
+          e1, e2 = nil, nil
+          promise.fail(error)
+          future.on_failure { |e| e1 = e }
+          future.on_failure { |e| e2 = e }
+          e1.message.should eql(error.message)
+          e2.message.should eql(error.message)
+        end
+
+        it 'does not raise any error when the listener raises an error when already failed' do
+          promise.fail(error)
+          expect { future.on_failure { |e| raise 'Blurgh' } }.to_not raise_error
+        end
+
+        it 'returns nil' do
+          future.on_failure { :foo }.should be_nil
+        end
+
+        it 'returns nil when the future already has failed' do
+          promise.fail(error)
+          future.on_failure { :foo }.should be_nil
         end
       end
     end
 
-    describe '.first' do
-      context 'it returns a new future which' do
-        it 'is complete when the first of the source futures is complete' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          ff = Future.first(f1, f2, f3)
-          f2.complete!
-          ff.should be_complete
-        end
-
-        it 'completes with the value of the first source future' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          ff = Future.first(f1, f2, f3)
-          f2.complete!('foo')
-          ff.get.should == 'foo'
-        end
-
-        it 'is unaffected by the completion of the other futures' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          ff = Future.first(f1, f2, f3)
-          f2.complete!
-          f1.complete!
-          f3.complete!
+    describe '#value' do
+      it 'is nil by default' do
+        promise.fulfill
+        future.value.should be_nil
+      end
+
+      it 'is the object passed to Promise#fulfill' do
+        obj = 'hello world'
+        promise.fulfill(obj)
+        future.value.should equal(obj)
+      end
+
+      it 'raises the error passed to Promise#fail' do
+        promise.fail(StandardError.new('bork'))
+        expect { future.value }.to raise_error(/bork/)
+      end
+
+      it 'blocks until the promise is completed' do
+        d = delayed(promise) do |p|
+          p.fulfill('bar')
         end
+        d.value
+        future.value.should == 'bar'
+      end
 
-        it 'fails if all of the source futures fail' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          ff = Future.first(f1, f2, f3)
-          f2.fail!(StandardError.new('bork'))
-          f1.fail!(StandardError.new('bork'))
-          f3.fail!(StandardError.new('bork'))
-          ff.should be_failed
+      it 'blocks on #value until fulfilled, when value is nil' do
+        d = delayed(promise) do |p|
+          p.fulfill
         end
+        d.value
+        future.value.should be_nil
+      end
 
-        it 'fails with the error of the last future to fail' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
-          ff = Future.first(f1, f2, f3)
-          f2.fail!(StandardError.new('bork2'))
-          f1.fail!(StandardError.new('bork1'))
-          f3.fail!(StandardError.new('bork3'))
-          expect { ff.get }.to raise_error('bork3')
+      it 'blocks on #value until failed' do
+        d = delayed(promise) do |p|
+          p.fail(StandardError.new('bork'))
         end
+        d.value
+        expect { future.value }.to raise_error('bork')
+      end
+
+      it 'allows multiple threads to block on #value until fulfilled' do
+        listeners = Array.new(10) do
+          async(future) do |f|
+            f.value
+          end
+        end
+        sleep 0.1
+        promise.fulfill(:hello)
+        listeners.map(&:value).should == Array.new(10, :hello)
       end
     end
 
     describe '#map' do
       context 'returns a new future that' do
-        it 'will complete with the result of the given block' do
+        it 'will be fulfilled with the result of the given block' do
           mapped_value = nil
-          f1 = Future.new
-          f2 = f1.map { |v| v * 2 }
-          f2.on_complete { |v| mapped_value = v }
-          f1.complete!(3)
+          p = Promise.new
+          f = p.future.map { |v| v * 2 }
+          f.on_value { |v| mapped_value = v }
+          p.fulfill(3)
           mapped_value.should == 3 * 2
         end
 
         it 'fails when the original future fails' do
           failed = false
-          f1 = Future.new
-          f2 = f1.map { |v| v * 2 }
-          f2.on_failure { failed = true }
-          f1.fail!(StandardError.new('Blurgh'))
+          p = Promise.new
+          f = p.future.map { |v| v * 2 }
+          f.on_failure { failed = true }
+          p.fail(StandardError.new('Blurgh'))
           failed.should be_true
         end
 
         it 'fails when the block raises an error' do
-          f1 = Future.new
-          f2 = f1.map { |v| raise 'Blurgh' }
-          Thread.start do
-            sleep(0.01)
-            f1.complete!
+          p = Promise.new
+          f = p.future.map { |v| raise 'blurgh' }
+          d = delayed do
+            p.fulfill
           end
-          expect { f2.get }.to raise_error('Blurgh')
+          d.value
+          expect { f.value }.to raise_error('blurgh')
         end
       end
     end
 
     describe '#flat_map' do
       it 'works like #map, but expects that the block returns a future' do
-        f1 = Future.new
-        f2 = f1.flat_map { |v| Future.completed(v * 2) }
-        f1.complete!(3)
-        f2.value.should == 3 * 2
+        p = Promise.new
+        f = p.future.flat_map { |v| Future.resolved(v * 2) }
+        p.fulfill(3)
+        f.value.should == 3 * 2
       end
 
       it 'fails when the block raises an error' do
-        f1 = Future.new
-        f2 = f1.flat_map { |v| raise 'Hurgh' }
-        f1.complete!(3)
-        expect { f2.get }.to raise_error('Hurgh')
+        p = Promise.new
+        f = p.future.flat_map { |v| raise 'Hurgh' }
+        p.fulfill(3)
+        expect { f.value }.to raise_error('Hurgh')
       end
     end
 
     describe '#recover' do
       context 'returns a new future that' do
-        it 'completes with a value when the source future fails' do
-          f1 = Future.new
-          f2 = f1.recover { 'foo' }
-          f1.fail!(StandardError.new('Bork!'))
-          f2.get.should == 'foo'
+        it 'becomes fulfilled with a value when the source future fails' do
+          p = Promise.new
+          f = p.future.recover { 'foo' }
+          p.fail(error)
+          f.value.should == 'foo'
         end
 
         it 'yields the error to the block' do
-          f1 = Future.new
-          f2 = f1.recover { |e| e.message }
-          f1.fail!(StandardError.new('Bork!'))
-          f2.get.should == 'Bork!'
+          p = Promise.new
+          f = p.future.recover { |e| e.message }
+          p.fail(error)
+          f.value.should == error.message
         end
 
-        it 'completes with the value of the source future when the source future is successful' do
-          f1 = Future.new
-          f2 = f1.recover { 'foo' }
-          f1.complete!('bar')
-          f2.get.should == 'bar'
+        it 'becomes fulfilled with the value of the source future when the source future is fulfilled' do
+          p = Promise.new
+          f = p.future.recover { 'foo' }
+          p.fulfill('bar')
+          f.value.should == 'bar'
         end
 
         it 'fails with the error raised in the given block' do
-          f1 = Future.new
-          f2 = f1.recover { raise 'Snork!' }
-          f1.fail!(StandardError.new('Bork!'))
-          expect { f2.get }.to raise_error('Snork!')
+          p = Promise.new
+          f = p.future.recover { raise 'snork' }
+          p.fail(StandardError.new('bork'))
+          expect { f.value }.to raise_error('snork')
         end
       end
     end
 
     describe '#fallback' do
       context 'returns a new future that' do
-        it 'completes with the value of the fallback future when the source future fails' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = f1.fallback { f2 }
-          f1.fail!(StandardError.new('Bork!'))
-          f2.complete!('foo')
-          f3.get.should == 'foo'
+        it 'is resolved with the value of the fallback future when the source future fails' do
+          p1 = Promise.new
+          p2 = Promise.new
+          f = p1.future.fallback { p2.future }
+          p1.fail(error)
+          p2.fulfill('foo')
+          f.value.should == 'foo'
         end
 
         it 'yields the error to the block' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = f1.fallback do |error|
-            Future.completed(error.message)
+          p1 = Promise.new
+          p2 = Promise.new
+          f = p1.future.fallback do |error|
+            Future.resolved(error.message)
           end
-          f1.fail!(StandardError.new('Bork!'))
-          f3.get.should == 'Bork!'
+          p1.fail(error)
+          f.value.should == error.message
         end
 
-        it 'completes with the value of the source future when the source future succeeds' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = f1.fallback { f2 }
-          f2.complete!('bar')
-          f1.complete!('foo')
-          f3.get.should == 'foo'
+        it 'is resolved with the value of the source future when the source future fullfills' do
+          p1 = Promise.new
+          p2 = Promise.new
+          f = p1.future.fallback { p2.future }
+          p2.fulfill('bar')
+          p1.fulfill('foo')
+          f.value.should == 'foo'
         end
 
         it 'fails when the block raises an error' do
-          f1 = Future.new
-          f2 = f1.fallback { raise 'Bork!' }
-          f1.fail!(StandardError.new('Splork!'))
-          expect { f2.get }.to raise_error('Bork!')
+          p = Promise.new
+          f = p.future.fallback { raise 'bork' }
+          p.fail(StandardError.new('splork'))
+          expect { f.value }.to raise_error('bork')
         end
 
         it 'fails when the fallback future fails' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = f1.fallback { f2 }
-          f2.fail!(StandardError.new('Bork!'))
-          f1.fail!(StandardError.new('Fnork!'))
-          expect { f3.get }.to raise_error('Bork!')
+          p1 = Promise.new
+          p2 = Promise.new
+          f = p1.future.fallback { p2.future }
+          p2.fail(StandardError.new('bork'))
+          p1.fail(StandardError.new('fnork'))
+          expect { f.value }.to raise_error('bork')
         end
       end
     end
 
-    describe '.completed' do
-      let :future do
-        described_class.completed('hello world')
-      end
+    describe '.all' 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.all(p1.future, p2.future)
+          p1.fulfill
+          f.should_not be_resolved
+          p2.fulfill
+          f.should be_resolved
+        end
 
-      it 'is complete when created' do
-        future.should be_complete
-      end
+        it 'resolves when the source futures are resolved' do
+          sequence = []
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.all(p1.future, p2.future, p3.future)
+          p1.future.on_value { sequence << 1 } 
+          p2.future.on_value { sequence << 2 } 
+          p3.future.on_value { sequence << 3 }
+          p2.fulfill
+          p1.fulfill
+          p3.fulfill
+          sequence.should == [2, 1, 3]
+        end
 
-      it 'calls callbacks immediately' do
-        value = nil
-        future.on_complete { |v| value = v }
-        value.should == 'hello world'
-      end
+        it 'returns an array of the values of the source futures, in order ' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.all(p1.future, p2.future, p3.future)
+          p2.fulfill(2)
+          p1.fulfill(1)
+          p3.fulfill(3)
+          f.value.should == [1, 2, 3]
+        end
 
-      it 'does not block on #value' do
-        future.value.should == 'hello world'
-      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.all(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')
+          f.should be_failed
+        end
 
-      it 'defaults to the value nil' do
-        described_class.completed.value.should be_nil
+        it 'completes with an empty list when no futures are given' do
+          Future.all.value.should == []
+        end
       end
+    end
+
+    describe '.first' do
+      context 'it returns a new future which' do
+        it 'is resolved when the first of the source futures is resolved' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.first(p1.future, p2.future, p3.future)
+          p2.fulfill
+          f.should be_resolved
+        end
+
+        it 'fullfills with the value of the first source future' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.first(p1.future, p2.future, p3.future)
+          p2.fulfill('foo')
+          f.value.should == 'foo'
+        end
+
+        it 'is unaffected by the fullfillment of the other futures' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.first(p1.future, p2.future, p3.future)
+          p2.fulfill
+          p1.fulfill
+          p3.fulfill
+          f.value
+        end
+
+        it 'is unaffected by a future failing when at least one resolves' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.first(p1.future, p2.future, p3.future)
+          p2.fail(error)
+          p1.fail(error)
+          p3.fulfill
+          expect { f.value }.to_not raise_error
+        end
+
+        it 'fails if all of the source futures fail' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.first(p1.future, p2.future, p3.future)
+          p2.fail(error)
+          p1.fail(error)
+          p3.fail(error)
+          f.should be_failed
+        end
+
+        it 'fails with the error of the last future to fail' do
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
+          f = Future.first(p1.future, p2.future, p3.future)
+          p2.fail(StandardError.new('bork2'))
+          p1.fail(StandardError.new('bork1'))
+          p3.fail(StandardError.new('bork3'))
+          expect { f.value }.to raise_error('bork3')
+        end
 
-      it 'handles #map' do
-        described_class.completed('foo').map(&:upcase).value.should == 'FOO'
+        it 'completes with nil when no futures are given' do
+          Future.first.value.should be_nil
+        end
       end
+    end
 
-      it 'handles #map' do
-        f = described_class.completed('foo').map { |v| raise 'Blurgh' }
-        f.should be_failed
+    describe '.resolved' do
+      context 'returns a future which' do
+        let :future do
+          described_class.resolved('hello world')
+        end
+
+        it 'returns a future which is resolved' do
+          future.should be_resolved
+        end
+
+        it 'calls callbacks immediately' do
+          value = nil
+          future.on_value { |v| value = v }
+          value.should == 'hello world'
+        end
+
+        it 'does not block on #value' do
+          future.value.should == 'hello world'
+        end
+
+        it 'defaults to the value nil' do
+          described_class.resolved.value.should be_nil
+        end
       end
     end
 
     describe '.failed' do
       let :future do
-        described_class.failed(StandardError.new('Blurgh'))
+        described_class.failed(error)
       end
 
-      it 'is failed when created' do
-        future.should be_failed
-      end
+      context 'returns a future which' do
+        it 'is failed when created' do
+          future.should be_failed
+        end
 
-      it 'calls callbacks immediately' do
-        error = nil
-        future.on_failure { |e| error = e }
-        error.message.should == 'Blurgh'
-      end
+        it 'calls callbacks immediately' do
+          error = nil
+          future.on_failure { |e| error = e }
+          error.message.should == 'bork'
+        end
 
-      it 'does not block on #value' do
-        expect { future.value }.to raise_error('Blurgh')
+        it 'does not block on #value' do
+          expect { future.value }.to raise_error('bork')
+        end
       end
     end
   end