cql-rb 1.0.6 → 1.1.0.pre0

data/spec/cql/io/io_reactor_spec.rb

@@ -6,351 +6,298 @@ require 'spec_helper'
 module Cql
   module Io
     describe IoReactor do
-      let :host do
-        '127.0.0.1'
+      let :reactor do
+        described_class.new(protocol_handler_factory, selector: selector)
       end
 
-      let :port do
-        2**15 + rand(2**15)
+      let :protocol_handler_factory do
+        stub(:protocol_handler_factory)
       end
 
-      let :server do
-        FakeServer.new(port)
+      let! :selector do
+        IoReactorSpec::FakeSelector.new
       end
 
-      let :io_reactor do
-        described_class.new(connection_timeout: 1)
-      end
-
-      before do
-        server.start!
-      end
-
-      after do
-        begin
-          if io_reactor.running?
-            io_reactor.stop.get
-          end
-        ensure
-          server.stop!
+      describe '#start' do
+        after do
+          reactor.stop.get if reactor.running?
         end
-      end
 
-      describe '#initialize' do
-        it 'does not connect' do
-          described_class.new
-          sleep(0.1)
-          server.connects.should == 0
+        it 'returns a future that completes when the reactor has started' do
+          reactor.start.get
         end
-      end
 
-      describe '#running?' do
-        it 'is initially false' do
-          io_reactor.should_not be_running
+        it 'returns a future that resolves to the reactor' do
+          reactor.start.get.should equal(reactor)
         end
 
-        it 'is true when started' do
-          io_reactor.start.get
-          io_reactor.should be_running
+        it 'is running after being started' do
+          reactor.start.get
+          reactor.should be_running
         end
 
-        it 'is true when starting' do
-          f = io_reactor.start
-          io_reactor.should be_running
-          f.get
+        it 'cannot be started again once stopped' do
+          reactor.start.get
+          reactor.stop.get
+          expect { reactor.start }.to raise_error(ReactorError)
         end
 
-        it 'is false when stopped' do
-          io_reactor.start.get
-          io_reactor.stop.get
-          io_reactor.should_not be_running
+        it 'calls the selector' do
+          called = false
+          selector.handler { called = true; [[], [], []] }
+          reactor.start.get
+          await { called }
+          reactor.stop.get
+          called.should be_true, 'expected the selector to have been called'
         end
       end
 
       describe '#stop' do
-        it 'closes all connections' do
-          io_reactor.start.get
-          f1 = io_reactor.add_connection(host, port)
-          f2 = io_reactor.add_connection(host, port)
-          f3 = io_reactor.add_connection(host, port)
-          f4 = io_reactor.add_connection(host, port)
-          Future.combine(f1, f2, f3, f4).get
-          io_reactor.stop.get
-          server.await_disconnects!(4)
-          server.disconnects.should == 4
-        end
-
-        it 'succeeds connection futures when stopping while connecting' do
-          server.stop!
-          server.start!(accept_delay: 2)
-          f = io_reactor.add_connection(host, port)
-          io_reactor.start
-          io_reactor.stop
-          f.get
+        after do
+          reactor.stop.get if reactor.running?
         end
-      end
 
-      describe '#add_connection' do
-        before do
-          io_reactor.start.get
+        it 'returns a future which completes when the reactor has stopped' do
+          reactor.start.get
+          reactor.stop.get
         end
 
-        it 'connects to the specified host and port' do
-          future = io_reactor.add_connection(host, port)
-          future.get
-          server.await_connects!(1)
-          server.connects.should == 1
+        it 'returns a future which resolves to the reactor' do
+          reactor.start.get
+          reactor.stop.get.should equal(reactor)
         end
 
-        it 'yields the connection ID when completed' do
-          future = io_reactor.add_connection(host, port)
-          future.get.should_not be_nil
+        it 'is not running after being stopped' do
+          reactor.start.get
+          reactor.stop.get
+          reactor.should_not be_running
         end
 
-        it 'fails the returned future when it cannot connect to the host' do
-          future = io_reactor.add_connection('example.com', port)
-          expect { future.get }.to raise_error(ConnectionError)
+        it 'closes all sockets' do
+          connection = nil
+          protocol_handler_factory.stub(:new) do |sh|
+            connection = sh
+            stub(:protocol_handler)
+          end
+          reactor.start.get
+          reactor.connect('example.com', 9999, 5)
+          reactor.stop.get
+          connection.should be_closed
         end
+      end
 
-        it 'fails the returned future when it cannot connect to the port' do
-          future = io_reactor.add_connection(host, 9999)
-          expect { future.get }.to raise_error(ConnectionError)
+      describe '#on_error' do
+        before do
+          selector.handler { raise 'Blurgh' }
         end
 
-        it 'times out quickly when it cannot connect' do
-          started_at = Time.now
-          begin
-            future = io_reactor.add_connection(host, 9999)
-            future.get
-          rescue ConnectionError
-          end
-          time_taken = (Time.now - started_at).to_f
-          time_taken.should be < 1.5
+        it 'calls the listeners when the reactor crashes' do
+          error = nil
+          reactor.on_error { |e| error = e }
+          reactor.start
+          await { error }
+          error.message.should == 'Blurgh'
         end
 
-        it 'can be called before the reactor is started' do
-          r = described_class.new(connection_timeout: 1)
-          f1 = r.add_connection(host, port)
-          f2 = r.start
-          f2.get
-          f1.get
+        it 'calls the listener immediately when the reactor has already crashed' do
+          error = nil
+          reactor.start.get
+          await { !reactor.running? }
+          reactor.on_error { |e| error = e }
+          await { error }
         end
-      end
 
-      describe '#queue_request' do
-        it 'eventually sends the request' do
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-          io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-          await { server.received_bytes.bytesize > 0 }
-          server.received_bytes.to_s[3, 1].should == "\x01"
+        it 'ignores errors raised by listeners' do
+          called = false
+          reactor.on_error { raise 'Blurgh' }
+          reactor.on_error { called = true }
+          reactor.start
+          await { called }
+          called.should be_true, 'expected all close listeners to have been called'
         end
+      end
 
-        it 'can be called before the reactor is started' do
-          io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-          await { server.received_bytes.bytesize > 0 }
-          server.received_bytes[3, 1].should == "\x01"
+      describe '#connect' do
+        let :protocol_handler do
+          stub(:protocol_handler)
         end
 
-        it 'queues requests when all connections are busy' do
-          request = Cql::Protocol::QueryRequest.new('UPDATE x SET y = 1 WHERE z = 2', :one)
-
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-
-          futures = 200.times.map do
-            io_reactor.queue_request(request)
-          end
-
-          128.times do |i|
-            server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
+        before do
+          protocol_handler_factory.stub(:new) do |connection|
+            connection.to_io.stub(:connect_nonblock)
+            protocol_handler.stub(:connection).and_return(connection)
+            protocol_handler
           end
+        end
 
-          Future.combine(*futures.shift(128)).get
-
-          128.times do |i|
-            server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
+        before do
+          selector.handler do |readables, writables, _, _|
+            writables.each do |writable|
+              fake_connected(writable)
+            end
+            [[], writables, []]
           end
-
-          Future.combine(*futures).get
         end
 
-        context 'with a connection ID' do
-          it 'performs the request using the specified connection' do
-            future = Future.new
-            request = Cql::Protocol::StartupRequest.new
-            response = "\x81\x00\x00\x02\x00\x00\x00\x00"
-
-            io_reactor.start.get
-            c1_id = io_reactor.add_connection(host, port).get
-            c2_id = io_reactor.add_connection(host, port).get
-            q1_future = io_reactor.queue_request(request, c2_id)
-            q2_future = io_reactor.queue_request(request, c1_id)
+        def fake_connected(connection)
+          connection.to_io.stub(:connect_nonblock)
+        end
 
-            Future.combine(q1_future, q2_future).on_complete do |(_, q1_id), (_, q2_id)|
-              future.complete!([c1_id, c2_id, q1_id, q2_id])
-            end
+        after do
+          reactor.stop if reactor.running?
+        end
 
-            server.await_connects!(2)
-            server.broadcast!(response.dup)
+        it 'returns a future that resolves to a new protocol handler' do
+          reactor.start.get
+          f = reactor.connect('example.com', 9999, 5)
+          f.get.should equal(protocol_handler)
+        end
 
-            connection1_id, connection2_id, query1_id, query2_id = future.value
+        it 'returns a new protocol handler which wraps a socket handler' do
+          reactor.start.get
+          protocol_handler = reactor.connect('example.com', 9999, 5).get
+          protocol_handler.connection.should_not be_nil
+          protocol_handler.connection.host.should == 'example.com'
+          protocol_handler.connection.port.should == 9999
+          protocol_handler.connection.connection_timeout.should == 5
+        end
+      end
 
-            connection1_id.should_not be_nil
-            connection2_id.should_not be_nil
-            query1_id.should == connection2_id
-            query2_id.should == connection1_id
+      describe '#to_s' do
+        context 'returns a string that' do
+          it 'includes the class name' do
+            reactor.to_s.should include('Cql::Io::IoReactor')
           end
 
-          it 'fails if the connection does not exist' do
-            f = io_reactor.start.flat_map do
-              io_reactor.add_connection(host, port).flat_map do
-                io_reactor.queue_request(Cql::Protocol::StartupRequest.new, 1234)
-              end
-            end
-            expect { f.get }.to raise_error(ConnectionNotFoundError)
+          it 'includes a list of its connections' do
+            reactor.to_s.should include('@connections=[')
+            reactor.to_s.should include('#<Cql::Io::Unblocker>')
           end
+        end
+      end
+    end
 
-          it 'queues requests when the connection is busy' do
-            request = Cql::Protocol::QueryRequest.new('UPDATE x SET y = 1 WHERE z = 2', :one)
-
-            io_reactor.start
-            connection_id = io_reactor.add_connection(host, port).get
-
-            futures = 200.times.map do
-              io_reactor.queue_request(request, connection_id)
-            end
-
-            128.times do |i|
-              server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
-            end
-
-            Future.combine(*futures.shift(128)).get
+    describe IoLoopBody do
+      let :loop_body do
+        described_class.new(selector: selector)
+      end
 
-            128.times do |i|
-              server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
-            end
+      let :selector do
+        stub(:selector)
+      end
 
-            Future.combine(*futures).get
-          end
+      let :socket do
+        stub(:socket, connected?: false, connecting?: false, writable?: false, closed?: false)
+      end
 
-          it 'fails queued requests when the connection closes' do
-            request = Cql::Protocol::QueryRequest.new('UPDATE x SET y = 1 WHERE z = 2', :one)
+      describe '#tick' do
+        before do
+          loop_body.add_socket(socket)
+        end
 
-            io_reactor.start
-            connection_id = io_reactor.add_connection(host, port).get
+        it 'passes connected sockets as readables to the selector' do
+          socket.stub(:connected?).and_return(true)
+          selector.should_receive(:select).with([socket], anything, anything, anything).and_return([nil, nil, nil])
+          loop_body.tick
+        end
 
-            failures = 0
+        it 'passes writable sockets as writable to the selector' do
+          socket.stub(:writable?).and_return(true)
+          selector.should_receive(:select).with(anything, [socket], anything, anything).and_return([nil, nil, nil])
+          loop_body.tick
+        end
 
-            200.times do
-              f = io_reactor.queue_request(request, connection_id)
-              f.on_failure do
-                failures += 1
-              end
-            end
+        it 'passes connecting sockets as writable to the selector' do
+          socket.stub(:connecting?).and_return(true)
+          socket.stub(:connect)
+          selector.should_receive(:select).with(anything, [socket], anything, anything).and_return([nil, nil, nil])
+          loop_body.tick
+        end
 
-            server.broadcast!("\x01\x00\x00\x02\x00\x00\x00\x16")
+        it 'filters out closed sockets' do
+          socket.stub(:closed?).and_return(true)
+          selector.should_receive(:select).with([], [], anything, anything).and_return([nil, nil, nil])
+          loop_body.tick
+          socket.stub(:connected?).and_return(true)
+          selector.should_receive(:select).with([], [], anything, anything).and_return([nil, nil, nil])
+          loop_body.tick
+        end
 
-            await { failures == 200 }
+        it 'calls #read on all readable sockets returned by the selector' do
+          socket.stub(:connected?).and_return(true)
+          socket.should_receive(:read)
+          selector.stub(:select) do |r, w, _, _|
+            [[socket], nil, nil]
           end
+          loop_body.tick
         end
 
-        it 'fails if there is an error when encoding the request' do
-          request = stub(:request)
-          request.stub(:encode_frame).and_raise(Cql::ProtocolError.new('Boork!'))
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-          f = io_reactor.queue_request(request)
-          expect { f.get }.to raise_error(Cql::ProtocolError)
+        it 'calls #connect on all connecting sockets' do
+          socket.stub(:connecting?).and_return(true)
+          socket.should_receive(:connect)
+          selector.stub(:select).and_return([nil, nil, nil])
+          loop_body.tick
         end
 
-        it 'yields the response when completed' do
-          response = nil
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-          f = io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-          f.on_complete do |r, _|
-            response = r
+        it 'calls #flush on all writable sockets returned by the selector' do
+          socket.stub(:writable?).and_return(true)
+          socket.should_receive(:flush)
+          selector.stub(:select) do |r, w, _, _|
+            [nil, [socket], nil]
           end
-          sleep(0.1)
-          server.broadcast!("\x81\x00\x00\x02\x00\x00\x00\x00")
-          await { response }
-          response.should == Cql::Protocol::ReadyResponse.new
+          loop_body.tick
         end
 
-        it 'yields the connection ID when completed' do
-          connection = nil
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-          f = io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-          f.on_complete do |_, c|
-            connection = c
-          end
-          sleep(0.1)
-          server.broadcast!("\x81\x00\x00\x02\x00\x00\x00\x00")
-          await { connection }
-          connection.should_not be_nil
+        it 'allows the caller to specify a custom timeout' do
+          selector.should_receive(:select).with(anything, anything, anything, 99).and_return([[], [], []])
+          loop_body.tick(99)
         end
       end
 
-      describe '#add_event_listener' do
-        it 'calls the listener when frames with stream ID -1 arrives' do
-          event = nil
-          io_reactor.start
-          io_reactor.add_connection(host, port).get
-          io_reactor.add_event_listener { |e| event = e }
-          sleep(0.1)
-          server.broadcast!("\x81\x00\xFF\f\x00\x00\x00+\x00\rSCHEMA_CHANGE\x00\aDROPPED\x00\nkeyspace01\x00\x05users")
-          await { event }
-          event.should == Cql::Protocol::SchemaChangeEventResponse.new('DROPPED', 'keyspace01', 'users')
+      describe '#close_sockets' do
+        it 'closes all sockets' do
+          socket1 = stub(:socket1, closed?: false)
+          socket2 = stub(:socket2, closed?: false)
+          socket1.should_receive(:close)
+          socket2.should_receive(:close)
+          loop_body.add_socket(socket1)
+          loop_body.add_socket(socket2)
+          loop_body.close_sockets
         end
-      end
 
-      context 'with error conditions' do
-        context 'when receiving a bad frame' do
-          before do
-            io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-            io_reactor.start
-            @connection_id = io_reactor.add_connection(host, port).get
-            @request_future = io_reactor.queue_request(Cql::Protocol::OptionsRequest.new)
-            await { server.received_bytes.bytesize > 0 }
-            server.broadcast!("\x01\x00\x00\x02\x00\x00\x00\x16")
-            expect { @request_future.get }.to raise_error(Protocol::UnsupportedFrameTypeError)
-          end
-
-          it 'does not kill the reactor' do
-            io_reactor.should be_running
-          end
-
-          it 'cleans out failed connections' do
-            pending 'There\'s some kind of race condition in the setup for this test'
-            f = io_reactor.queue_request(Protocol::QueryRequest.new('USE system', :one), @connection_id)
-            expect { f.get }.to raise_error(ConnectionNotFoundError)
-          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.stub(:close).and_raise('Blurgh')
+          socket2.should_receive(:close)
+          loop_body.add_socket(socket1)
+          loop_body.add_socket(socket2)
+          loop_body.close_sockets
         end
 
-        context 'when there is an error while sending a frame' do
-          before do
-            io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-            io_reactor.start
-            @connection_id = io_reactor.add_connection(host, port).get
-            @bad_request_future = io_reactor.queue_request(BadRequest.new)
-          end
-
-          it 'does not kill the reactor' do
-            @bad_request_future.get rescue nil
-            io_reactor.should be_running
-          end
+        it 'does not close already closed sockets' do
+          socket.stub(:closed?).and_return(true)
+          socket.should_not_receive(:close)
+          loop_body.add_socket(socket)
+          loop_body.close_sockets
         end
       end
     end
+  end
+end
 
-    class BadRequest < Protocol::OptionsRequest
-      def write(io)
-        raise 'Blurgh!'
-      end
+module IoReactorSpec
+  class FakeSelector
+    def initialize
+      handler { [[], [], []] }
+    end
+
+    def handler(&body)
+      @body = body
+    end
+
+    def select(*args)
+      @body.call(*args)
     end
   end
 end