cql-rb 1.1.0.pre3 → 1.1.0.pre6

data/spec/cql/io/connection_spec.rb

@@ -11,19 +11,19 @@ module Cql
       end
 
       let :unblocker do
-        stub(:unblocker, unblock!: nil)
+        double(:unblocker, unblock!: nil)
       end
 
       let :socket_impl do
-        stub(:socket_impl)
+        double(:socket_impl)
       end
 
       let :clock do
-        stub(:clock, now: 0)
+        double(:clock, now: 0)
       end
 
       let :socket do
-        stub(:socket)
+        double(:socket)
       end
 
       before do
@@ -76,10 +76,10 @@ module Cql
         end
 
         shared_examples 'on successfull connection' do
-          it 'completes the returned future and returns itself' do
+          it 'fulfilles the returned future and returns itself' do
             f = handler.connect
-            f.should be_complete
-            f.get.should equal(handler)
+            f.should be_resolved
+            f.value.should equal(handler)
           end
 
           it 'is connected' do
@@ -108,7 +108,7 @@ module Cql
           it 'it does nothing' do
             socket.stub(:connect_nonblock).and_raise(Errno::EALREADY)
             f = handler.connect
-            f.should_not be_complete
+            f.should_not be_resolved
             f.should_not be_failed
           end
         end
@@ -133,7 +133,7 @@ module Cql
           it 'fails if there are no more addresses to try' do
             socket.stub(:connect_nonblock).and_raise(Errno::EINVAL)
             f = handler.connect
-            expect { f.get }.to raise_error(ConnectionError)
+            expect { f.value }.to raise_error(ConnectionError)
           end
         end
 
@@ -145,7 +145,7 @@ module Cql
 
           it 'fails the future with a ConnectionError' do
             f = handler.connect
-            expect { f.get }.to raise_error(ConnectionError)
+            expect { f.value }.to raise_error(ConnectionError)
           end
 
           it 'closes the socket' do
@@ -180,7 +180,7 @@ module Cql
 
           it 'fails the returned future with a ConnectionError' do
             f = handler.connect
-            expect { f.get }.to raise_error(ConnectionError)
+            expect { f.value }.to raise_error(ConnectionError)
           end
 
           it 'calls the close listener' do
@@ -217,7 +217,7 @@ module Cql
             clock.stub(:now).and_return(7)
             handler.connect
             f.should be_failed
-            expect { f.get }.to raise_error(ConnectionTimeoutError)
+            expect { f.value }.to raise_error(ConnectionTimeoutError)
           end
 
           it 'closes the connection' do

data/spec/cql/io/io_reactor_spec.rb

@@ -11,7 +11,7 @@ module Cql
       end
 
       let :protocol_handler_factory do
-        stub(:protocol_handler_factory)
+        double(:protocol_handler_factory)
       end
 
       let! :selector do
@@ -19,61 +19,61 @@ module Cql
       end
 
       let :clock do
-        stub(:clock, now: 0)
+        double(:clock, now: 0)
       end
 
       describe '#start' do
         after do
-          reactor.stop.get if reactor.running?
+          reactor.stop.value if reactor.running?
         end
 
-        it 'returns a future that completes when the reactor has started' do
-          reactor.start.get
+        it 'returns a future that is resolved when the reactor has started' do
+          reactor.start.value
         end
 
         it 'returns a future that resolves to the reactor' do
-          reactor.start.get.should equal(reactor)
+          reactor.start.value.should equal(reactor)
         end
 
         it 'is running after being started' do
-          reactor.start.get
+          reactor.start.value
           reactor.should be_running
         end
 
         it 'cannot be started again once stopped' do
-          reactor.start.get
-          reactor.stop.get
+          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; [[], [], []] }
-          reactor.start.get
+          reactor.start.value
           await { called }
-          reactor.stop.get
+          reactor.stop.value
           called.should be_true, 'expected the selector to have been called'
         end
       end
 
       describe '#stop' do
         after do
-          reactor.stop.get if reactor.running?
+          reactor.stop.value if reactor.running?
         end
 
-        it 'returns a future which completes when the reactor has stopped' do
-          reactor.start.get
-          reactor.stop.get
+        it 'returns a future that is resolved when the reactor has stopped' do
+          reactor.start.value
+          reactor.stop.value
         end
 
         it 'returns a future which resolves to the reactor' do
-          reactor.start.get
-          reactor.stop.get.should equal(reactor)
+          reactor.start.value
+          reactor.stop.value.should equal(reactor)
         end
 
         it 'is not running after being stopped' do
-          reactor.start.get
-          reactor.stop.get
+          reactor.start.value
+          reactor.stop.value
           reactor.should_not be_running
         end
 
@@ -81,24 +81,24 @@ module Cql
           connection = nil
           protocol_handler_factory.stub(:new) do |sh|
             connection = sh
-            stub(:protocol_handler)
+            double(:protocol_handler)
           end
-          reactor.start.get
+          reactor.start.value
           reactor.connect('example.com', 9999, 5)
-          reactor.stop.get
+          reactor.stop.value
           connection.should be_closed
         end
 
         it 'cancels all active timers' do
-          reactor.start.get
+          reactor.start.value
           clock.stub(:now).and_return(1)
           expired_timer = reactor.schedule_timer(1)
           active_timer1 = reactor.schedule_timer(999)
           active_timer2 = reactor.schedule_timer(111)
-          expired_timer.should_not_receive(:fail!)
+          expired_timer.should_not_receive(:fail)
           clock.stub(:now).and_return(2)
-          await { expired_timer.complete? }
-          reactor.stop.get
+          await { expired_timer.completed? }
+          reactor.stop.value
           active_timer1.should be_failed
           active_timer2.should be_failed
         end
@@ -119,7 +119,7 @@ module Cql
 
         it 'calls the listener immediately when the reactor has already crashed' do
           error = nil
-          reactor.start.get
+          reactor.start.value
           await { !reactor.running? }
           reactor.on_error { |e| error = e }
           await { error }
@@ -137,7 +137,7 @@ module Cql
 
       describe '#connect' do
         let :protocol_handler do
-          stub(:protocol_handler)
+          double(:protocol_handler)
         end
 
         before do
@@ -166,14 +166,14 @@ module Cql
         end
 
         it 'returns a future that resolves to a new protocol handler' do
-          reactor.start.get
+          reactor.start.value
           f = reactor.connect('example.com', 9999, 5)
-          f.get.should equal(protocol_handler)
+          f.value.should equal(protocol_handler)
         end
 
         it 'returns a new protocol handler which wraps a socket handler' do
-          reactor.start.get
-          protocol_handler = reactor.connect('example.com', 9999, 5).get
+          reactor.start.value
+          protocol_handler = reactor.connect('example.com', 9999, 5).value
           protocol_handler.connection.should_not be_nil
           protocol_handler.connection.host.should == 'example.com'
           protocol_handler.connection.port.should == 9999
@@ -183,18 +183,18 @@ module Cql
 
       describe '#schedule_timer' do
         before do
-          reactor.start.get
+          reactor.start.value
         end
 
         after do
-          reactor.stop.get
+          reactor.stop.value
         end
 
-        it 'returns a future that completes after the specified duration' do
+        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.complete? }
+          await { f.resolved? }
         end
       end
 
@@ -218,15 +218,15 @@ module Cql
       end
 
       let :selector do
-        stub(:selector)
+        double(:selector)
       end
 
       let :clock do
-        stub(:clock, now: 0)
+        double(:clock, now: 0)
       end
 
       let :socket do
-        stub(:socket, connected?: false, connecting?: false, writable?: false, closed?: false)
+        double(:socket, connected?: false, connecting?: false, writable?: false, closed?: false)
       end
 
       describe '#tick' do
@@ -295,32 +295,32 @@ module Cql
         it 'completes timers that have expired' do
           selector.stub(:select).and_return([nil, nil, nil])
           clock.stub(:now).and_return(1)
-          future = Future.new
-          loop_body.schedule_timer(1, future)
+          promise = Promise.new
+          loop_body.schedule_timer(1, promise)
           loop_body.tick
-          future.should_not be_complete
+          promise.future.should_not be_completed
           clock.stub(:now).and_return(2)
           loop_body.tick
-          future.should be_complete
+          promise.future.should be_completed
         end
 
         it 'clears out timers that have expired' do
           selector.stub(:select).and_return([nil, nil, nil])
           clock.stub(:now).and_return(1)
-          future = Future.new
-          loop_body.schedule_timer(1, future)
+          promise = Promise.new
+          loop_body.schedule_timer(1, promise)
           clock.stub(:now).and_return(2)
           loop_body.tick
-          future.should be_complete
-          future.should_not_receive(:complete!)
+          promise.future.should be_completed
+          promise.should_not_receive(:fulfill)
           loop_body.tick
         end
       end
 
       describe '#close_sockets' do
         it 'closes all sockets' do
-          socket1 = stub(:socket1, closed?: false)
-          socket2 = stub(:socket2, closed?: false)
+          socket1 = double(:socket1, closed?: false)
+          socket2 = double(:socket2, closed?: false)
           socket1.should_receive(:close)
           socket2.should_receive(:close)
           loop_body.add_socket(socket1)
@@ -329,8 +329,8 @@ module Cql
         end
 
         it 'closes all sockets, even when one of them raises an error' do
-          socket1 = stub(:socket1, closed?: false)
-          socket2 = stub(:socket2, closed?: false)
+          socket1 = double(:socket1, closed?: false)
+          socket2 = double(:socket2, closed?: false)
           socket1.stub(:close).and_raise('Blurgh')
           socket2.should_receive(:close)
           loop_body.add_socket(socket1)
@@ -352,20 +352,20 @@ module Cql
         end
 
         it 'fails all active timers with a CancelledError' do
-          f1 = Future.new
-          f2 = Future.new
-          f3 = Future.new
+          p1 = Promise.new
+          p2 = Promise.new
+          p3 = Promise.new
           clock.stub(:now).and_return(1)
-          loop_body.schedule_timer(1, f1)
-          loop_body.schedule_timer(3, f2)
-          loop_body.schedule_timer(3, f3)
+          loop_body.schedule_timer(1, p1)
+          loop_body.schedule_timer(3, p2)
+          loop_body.schedule_timer(3, p3)
           clock.stub(:now).and_return(2)
           loop_body.tick
           loop_body.cancel_timers
-          f1.should be_complete
-          f2.should be_failed
-          f3.should be_failed
-          expect { f3.get }.to raise_error(CancelledError)
+          p1.future.should be_completed
+          p2.future.should be_failed
+          p3.future.should be_failed
+          expect { p3.future.value }.to raise_error(CancelledError)
         end
       end
     end

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -11,7 +11,7 @@ module Cql
       end
 
       let :connection do
-        stub(:connection)
+        double(:connection)
       end
 
       let :request do
@@ -48,6 +48,20 @@ module Cql
         end
       end
 
+      describe '#host' do
+        it 'delegates to the connection' do
+          connection.stub(:host).and_return('example.com')
+          protocol_handler.host.should == 'example.com'
+        end
+      end
+
+      describe '#port' do
+        it 'delegates to the connection' do
+          connection.stub(:port).and_return(9042)
+          protocol_handler.port.should == 9042
+        end
+      end
+
       describe '#send_request' do
         before do
           connection.stub(:write).and_yield(buffer)
@@ -71,27 +85,27 @@ module Cql
           protocol_handler.send_request(request).should be_a(Future)
         end
 
-        it 'completes the future when it receives a response frame with the corresponding stream ID' do
+        it 'succeeds the future when it receives a response frame with the corresponding stream ID' do
           3.times { protocol_handler.send_request(request) }
           future = protocol_handler.send_request(request)
           connection.data_listener.call([0x81, 0, 3, 2, 0].pack('C4N'))
-          await(0.1) { future.complete? }
+          await(0.1) { future.resolved? }
         end
 
         it 'handles multiple response frames in the same data packet' do
           futures = Array.new(4) { protocol_handler.send_request(request) }
           connection.data_listener.call([0x81, 0, 2, 2, 0].pack('C4N') + [0x81, 0, 3, 2, 0].pack('C4N'))
-          await(0.1) { futures[2].complete? && futures[3].complete? }
+          await(0.1) { futures[2].resolved? && futures[3].resolved? }
         end
 
         it 'queues the request when there are too many in flight, sending it as soon as a stream is available' do
           connection.stub(:write)
           futures = Array.new(130) { protocol_handler.send_request(request) }
           128.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
-          futures[127].should be_complete
-          futures[128].should_not be_complete
+          futures[127].should be_resolved
+          futures[128].should_not be_resolved
           2.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
-          futures[128].should be_complete
+          futures[128].should be_resolved
         end
 
         context 'when the protocol handler closes' do
@@ -113,7 +127,7 @@ module Cql
             connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N'))
             connection.closed_listener.call(nil)
             begin
-              future.get
+              future.value
             rescue => e
               e.should be_a(Cql::Io::ConnectionClosedError)
             else
@@ -134,7 +148,7 @@ module Cql
           it 'fails all requests with NotConnectedError' do
             connection.stub(:closed?).and_return(true)
             f = protocol_handler.send_request(request)
-            expect { f.get }.to raise_error(NotConnectedError)
+            expect { f.value }.to raise_error(NotConnectedError)
           end
         end
       end
@@ -145,11 +159,11 @@ module Cql
           protocol_handler.close
         end
 
-        it 'returns a future which completes when the socket has closed' do
+        it 'returns a future which succeeds when the socket has closed' do
           connection.stub(:close) do
             connection.closed_listener.call(nil)
           end
-          protocol_handler.close.get
+          protocol_handler.close.value
         end
       end
 
@@ -167,7 +181,7 @@ module Cql
         it 'registers the keyspace it has changed to' do
           f = protocol_handler.send_request(Protocol::QueryRequest.new('USE hello', :one))
           connection.data_listener.call([0x81, 0, 0, 8, 4 + 2 + 5, 3, 5].pack('C4N2n') + 'hello')
-          f.get
+          f.value
           protocol_handler.keyspace.should == 'hello'
         end
       end