cql-rb 1.0.6 → 1.1.0.pre0

data/spec/cql/client/client_shared.rb

@@ -13,12 +13,12 @@ shared_context 'client setup' do
     io_reactor.connections
   end
 
-  def connection
-    connections.first
+  def last_connection
+    connections.last
   end
 
   def requests
-    connection[:requests]
+    last_connection.requests
   end
 
   def last_request

data/spec/cql/client/column_metadata_spec.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe ColumnMetadata do
+      describe '#eql?' do
+        it 'is equal to another column metadata with the same properties' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm1.should eql(cm2)
+        end
+
+        it 'is aliased as #==' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm1.should == cm2
+        end
+
+        it 'is not equal to another column metadata when the keyspace names differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('another_keyspace', 'my_table', 'my_column', :uuid)
+          cm1.should_not eql(cm2)
+        end
+
+        it 'is not equal to another column metadata when the table names differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'another_table', 'my_column', :uuid)
+          cm1.should_not eql(cm2)
+        end
+
+        it 'is not equal to another column metadata when the column names differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'another_column', :uuid)
+          cm1.should_not eql(cm2)
+        end
+
+        it 'is not equal to another column metadata when the types differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :timestamp)
+          cm1.should_not eql(cm2)
+        end
+      end
+
+      describe '#hash' do
+        it 'is the same to another column metadata with the same properties' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm1.hash.should == cm2.hash
+        end
+
+        it 'is not the same when the keyspace names differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('another_keyspace', 'my_table', 'my_column', :uuid)
+          cm1.hash.should_not == cm2.hash
+        end
+
+        it 'is not the same when the table names differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'another_table', 'my_column', :uuid)
+          cm1.hash.should_not == cm2.hash
+        end
+
+        it 'is not the same when the column names differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'another_column', :uuid)
+          cm1.hash.should_not == cm2.hash
+        end
+
+        it 'is not the same when the types differ' do
+          cm1 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :uuid)
+          cm2 = ColumnMetadata.new('my_keyspace', 'my_table', 'my_column', :timestamp)
+          cm1.hash.should_not == cm2.hash
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/request_runner_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe RequestRunner do
+      let :runner do
+        described_class.new
+      end
+
+      let :connection do
+        stub(:connection)
+      end
+
+      let :request do
+        stub(:request)
+      end
+
+      let :metadata do
+        [
+          ['my_keyspace', 'my_table', 'my_column', :int],
+          ['my_keyspace', 'my_table', 'my_other_column', :text],
+        ]
+      end
+
+      let :rows do
+        [
+          {'my_column' => 11, 'my_other_column' => 'hello'},
+          {'my_column' => 22, 'my_other_column' => 'foo'},
+          {'my_column' => 33, 'my_other_column' => 'bar'},
+        ]
+      end
+
+      describe '#execute' do
+        let :rows_response do
+          Protocol::RowsResultResponse.new(rows, metadata)
+        end
+
+        let :void_response do
+          Protocol::VoidResultResponse.new
+        end
+
+        let :prepared_response do
+          Protocol::PreparedResultResponse.new("\x2a", metadata)
+        end
+
+        let :error_response do
+          Protocol::ErrorResponse.new(0xbad, 'Bork')
+        end
+
+        let :authenticate_response do
+          Protocol::AuthenticateResponse.new('TheAuthenticator')
+        end
+
+        let :set_keyspace_response do
+          Protocol::SetKeyspaceResultResponse.new('some_keyspace')
+        end
+
+        def run(response, rq=request)
+          connection.stub(:send_request).and_return(Future.completed(response))
+          runner.execute(connection, rq).get
+        end
+
+        it 'executes the request' do
+          connection.should_receive(:send_request).and_return(Future.completed(rows_response))
+          runner.execute(connection, request)
+        end
+
+        it 'transforms a RowsResultResponse to a query result' do
+          result = run(rows_response)
+          result.should have(3).items
+        end
+
+        it 'transforms a VoidResultResponse to nil' do
+          result = run(void_response)
+          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)
+          result.authentication_class.should == 'TheAuthenticator'
+        end
+
+        it 'transforms a SetKeyspaceResultResponse into a keyspace changed object' do
+          result = run(set_keyspace_response)
+          result.should be_a(KeyspaceChanged)
+          result.keyspace.should == 'some_keyspace'
+        end
+
+        it 'intercepts an ErrorResponse and fails the result future' do
+          expect { run(error_response) }.to raise_error(QueryError)
+        end
+
+        it 'sets the #cql field of QueryError when the request is a query request' do
+          begin
+            run(error_response, Protocol::QueryRequest.new('SELECT * FROM everything', :all))
+          rescue QueryError => e
+            e.cql.should == 'SELECT * FROM everything'
+          else
+            fail!('No error was raised')
+          end
+        end
+
+        it 'transforms all other responses to nil' do
+          result = run('hibbly hobbly')
+          result.should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/cql/future_spec.rb

@@ -44,6 +44,14 @@ module Cql
         v2.should == 'bar'
       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'
+      end
+
       it 'notifies new listeners even when already completed' do
         v1, v2 = nil, nil
         future.complete!('bar')
@@ -53,6 +61,11 @@ module Cql
         v2.should == 'bar'
       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
+      end
+
       it 'blocks on #value until completed' do
         Thread.start(future) do |f|
           sleep 0.1
@@ -78,17 +91,6 @@ module Cql
         expect { future.value }.to raise_error('FAIL!')
       end
 
-      it 'allows multiple thread to block on #value until completed' do
-        listeners = Array.new(10) do
-          Thread.start do
-            future.value
-          end
-        end
-        sleep 0.1
-        future.complete!(:hello)
-        listeners.map(&:value).should == Array.new(10, :hello)
-      end
-
       it 'cannot be completed again' do
         future.complete!('bar')
         expect { future.complete!('foo') }.to raise_error(FutureError)
@@ -120,6 +122,14 @@ module Cql
         e2.message.should == 'FAIL!'
       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!'
+      end
+
       it 'notifies new listeners even when already failed' do
         e1, e2 = nil, nil
         future.fail!(StandardError.new('FAIL!'))
@@ -129,6 +139,11 @@ module Cql
         e2.message.should == 'FAIL!'
       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
+      end
+
       it 'cannot be failed again' do
         future.fail!(StandardError.new('FAIL!'))
         expect { future.fail!(StandardError.new('FAIL!')) }.to raise_error(FutureError)

data/spec/cql/io/connection_spec.rb

@@ -0,0 +1,460 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Io
+    describe Connection do
+      let :handler do
+        described_class.new('example.com', 55555, 5, unblocker, socket_impl, clock)
+      end
+
+      let :unblocker do
+        stub(:unblocker, unblock!: nil)
+      end
+
+      let :socket_impl do
+        stub(:socket_impl)
+      end
+
+      let :clock do
+        stub(:clock, now: 0)
+      end
+
+      let :socket do
+        stub(:socket)
+      end
+
+      before do
+        socket_impl.stub(:getaddrinfo)
+          .with('example.com', 55555, nil, Socket::SOCK_STREAM)
+          .and_return([[nil, 'PORT', nil, 'IP1', 'FAMILY1', 'TYPE1'], [nil, 'PORT', nil, 'IP2', 'FAMILY2', 'TYPE2']])
+        socket_impl.stub(:sockaddr_in)
+          .with('PORT', 'IP1')
+          .and_return('SOCKADDR1')
+        socket_impl.stub(:new)
+          .with('FAMILY1', 'TYPE1', 0)
+          .and_return(socket)
+      end
+
+      describe '#connect' do
+        it 'creates a socket and calls #connect_nonblock' do
+          socket.should_receive(:connect_nonblock).with('SOCKADDR1')
+          handler.connect
+        end
+
+        it 'handles EINPROGRESS that #connect_nonblock raises' do
+          socket.stub(:connect_nonblock).and_raise(Errno::EINPROGRESS)
+          handler.connect
+        end
+
+        it 'is connecting after #connect has been called' do
+          socket.stub(:connect_nonblock).and_raise(Errno::EINPROGRESS)
+          handler.connect
+          handler.should be_connecting
+        end
+
+        it 'is connecting even after the second call' do
+          socket.should_receive(:connect_nonblock).twice.and_raise(Errno::EINPROGRESS)
+          handler.connect
+          handler.connect
+          handler.should be_connecting
+        end
+
+        it 'does not create a new socket the second time' do
+          socket_impl.should_receive(:new).once.and_return(socket)
+          socket.stub(:connect_nonblock).and_raise(Errno::EINPROGRESS)
+          handler.connect
+          handler.connect
+        end
+
+        it 'attempts another connect the second time' do
+          socket.should_receive(:connect_nonblock).twice.and_raise(Errno::EINPROGRESS)
+          handler.connect
+          handler.connect
+        end
+
+        shared_examples 'on successfull connection' do
+          it 'completes the returned future and returns itself' do
+            f = handler.connect
+            f.should be_complete
+            f.get.should equal(handler)
+          end
+
+          it 'is connected' do
+            handler.connect
+            handler.should be_connected
+          end
+        end
+
+        context 'when #connect_nonblock does not raise any error' do
+          before do
+            socket.stub(:connect_nonblock)
+          end
+
+          include_examples 'on successfull connection'
+        end
+
+        context 'when #connect_nonblock raises EISCONN' do
+          before do
+            socket.stub(:connect_nonblock).and_raise(Errno::EISCONN)
+          end
+
+          include_examples 'on successfull connection'
+        end
+
+        context 'when #connect_nonblock raises EALREADY' do
+          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_failed
+          end
+        end
+
+        context 'when #connect_nonblock raises EINVAL' do
+          before do
+            socket_impl.stub(:sockaddr_in)
+              .with('PORT', 'IP2')
+              .and_return('SOCKADDR2')
+            socket_impl.stub(:new)
+              .with('FAMILY2', 'TYPE2', 0)
+              .and_return(socket)
+            socket.stub(:close)
+          end
+
+          it 'attempts to connect to the next address given by #getaddinfo' do
+            socket.should_receive(:connect_nonblock).with('SOCKADDR1').and_raise(Errno::EINVAL)
+            socket.should_receive(:connect_nonblock).with('SOCKADDR2')
+            handler.connect
+          end
+
+          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)
+          end
+        end
+
+        context 'when #connect_nonblock raises SystemCallError' do
+          before do
+            socket.stub(:connect_nonblock).and_raise(SystemCallError.new('Bork!', 9999))
+            socket.stub(:close)
+          end
+
+          it 'fails the future with a ConnectionError' do
+            f = handler.connect
+            expect { f.get }.to raise_error(ConnectionError)
+          end
+
+          it 'closes the socket' do
+            socket.should_receive(:close)
+            handler.connect
+          end
+
+          it 'calls the closed listener' do
+            called = false
+            handler.on_closed { called = true }
+            handler.connect
+            called.should be_true, 'expected the close listener to have been called'
+          end
+
+          it 'passes the error to the close listener' do
+            error = nil
+            handler.on_closed { |e| error = e }
+            handler.connect
+            error.should be_a(Exception)
+          end
+
+          it 'is closed' do
+            handler.connect
+            handler.should be_closed
+          end
+        end
+
+        context 'when Socket.getaddrinfo raises SocketError' do
+          before do
+            socket_impl.stub(:getaddrinfo).and_raise(SocketError)
+          end
+
+          it 'fails the returned future with a ConnectionError' do
+            f = handler.connect
+            expect { f.get }.to raise_error(ConnectionError)
+          end
+
+          it 'calls the close listener' do
+            called = false
+            handler.on_closed { called = true }
+            handler.connect
+            called.should be_true, 'expected the close listener to have been called'
+          end
+
+          it 'passes the error to the close listener' do
+            error = nil
+            handler.on_closed { |e| error = e }
+            handler.connect
+            error.should be_a(Exception)
+          end
+
+          it 'is closed' do
+            handler.connect
+            handler.should be_closed
+          end
+        end
+
+        context 'when it takes longer than the connection timeout to connect' do
+          before do
+            socket.stub(:connect_nonblock).and_raise(Errno::EINPROGRESS)
+            socket.stub(:close)
+          end
+
+          it 'fails the returned future with a ConnectionTimeoutError' do
+            f = handler.connect
+            clock.stub(:now).and_return(1)
+            handler.connect
+            socket.should_receive(:close)
+            clock.stub(:now).and_return(7)
+            handler.connect
+            f.should be_failed
+            expect { f.get }.to raise_error(ConnectionTimeoutError)
+          end
+
+          it 'closes the connection' do
+            handler.connect
+            clock.stub(:now).and_return(1)
+            handler.connect
+            socket.should_receive(:close)
+            clock.stub(:now).and_return(7)
+            handler.connect
+          end
+
+          it 'delivers a ConnectionTimeoutError to the close handler' do
+            error = nil
+            handler.on_closed { |e| error = e }
+            handler.connect
+            clock.stub(:now).and_return(7)
+            handler.connect
+            error.should be_a(ConnectionTimeoutError)
+          end
+        end
+      end
+
+      describe '#close' do
+        before do
+          socket.stub(:connect_nonblock)
+          socket.stub(:close)
+          handler.connect
+        end
+
+        it 'closes the socket' do
+          socket.should_receive(:close)
+          handler.close
+        end
+
+        it 'returns true' do
+          handler.close.should be_true
+        end
+
+        it 'swallows SystemCallErrors' do
+          socket.stub(:close).and_raise(SystemCallError.new('Bork!', 9999))
+          handler.close
+        end
+
+        it 'swallows IOErrors' do
+          socket.stub(:close).and_raise(IOError.new('Bork!'))
+          handler.close
+        end
+
+        it 'calls the closed listener' do
+          called = false
+          handler.on_closed { called = true }
+          handler.close
+          called.should be_true, 'expected the close listener to have been called'
+        end
+
+        it 'does nothing when closed a second time' do
+          socket.should_receive(:close).once
+          calls = 0
+          handler.on_closed { calls += 1 }
+          handler.close
+          handler.close
+          calls.should == 1
+        end
+
+        it 'returns false if it did nothing' do
+          handler.close
+          handler.close.should be_false
+        end
+
+        it 'is not writable when closed' do
+          handler.write('foo')
+          handler.close
+          handler.should_not be_writable
+        end
+      end
+
+      describe '#to_io' do
+        before do
+          socket.stub(:connect_nonblock)
+          socket.stub(:close)
+        end
+
+        it 'returns nil initially' do
+          handler.to_io.should be_nil
+        end
+
+        it 'returns the socket when connected' do
+          handler.connect
+          handler.to_io.should equal(socket)
+        end
+
+        it 'returns nil when closed' do
+          handler.connect
+          handler.close
+          handler.to_io.should be_nil
+        end
+      end
+
+      describe '#write/#flush' do
+        before do
+          socket.stub(:connect_nonblock)
+          handler.connect
+        end
+
+        it 'appends to its buffer when #write is called' do
+          handler.write('hello world')
+        end
+
+        it 'unblocks the reactor' do
+          unblocker.should_receive(:unblock!)
+          handler.write('hello world')
+        end
+
+        it 'is writable when there are bytes to write' do
+          handler.should_not be_writable
+          handler.write('hello world')
+          handler.should be_writable
+          socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+          handler.flush
+          handler.should_not be_writable
+        end
+
+        it 'writes to the socket from its buffer when #flush is called' do
+          handler.write('hello world')
+          socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+          handler.flush
+        end
+
+        it 'takes note of how much the #write_nonblock call consumed and writes the rest of the buffer on the next call to #flush' do
+          handler.write('hello world')
+          socket.should_receive(:write_nonblock).with('hello world').and_return(6)
+          handler.flush
+          socket.should_receive(:write_nonblock).with('world').and_return(5)
+          handler.flush
+        end
+
+        it 'does not call #write_nonblock if the buffer is empty' do
+          handler.flush
+          handler.write('hello world')
+          socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+          handler.flush
+          socket.should_not_receive(:write_nonblock)
+          handler.flush
+        end
+
+        context 'with a block' do
+          it 'yields a byte buffer to the block' do
+            socket.should_receive(:write_nonblock).with('hello world').and_return(11)
+            handler.write do |buffer|
+              buffer << 'hello world'
+            end
+            handler.flush
+          end
+        end
+
+        context 'when #write_nonblock raises an error' do
+          before do
+            socket.stub(:close)
+            socket.stub(:write_nonblock).and_raise('Bork!')
+          end
+
+          it 'closes the socket' do
+            socket.should_receive(:close)
+            handler.write('hello world')
+            handler.flush
+          end
+
+          it 'passes the error to the close handler' do
+            error = nil
+            handler.on_closed { |e| error = e }
+            handler.write('hello world')
+            handler.flush
+            error.should be_a(Exception)
+          end
+        end
+      end
+
+      describe '#read' do
+        before do
+          socket.stub(:connect_nonblock)
+          handler.connect
+        end
+
+        it 'reads a chunk from the socket' do
+          socket.should_receive(:read_nonblock).with(instance_of(Fixnum)).and_return('foo bar')
+          handler.read
+        end
+
+        it 'calls the data listener with the new data' do
+          socket.should_receive(:read_nonblock).with(instance_of(Fixnum)).and_return('foo bar')
+          data = nil
+          handler.on_data { |d| data = d }
+          handler.read
+          data.should == 'foo bar'
+        end
+
+        context 'when #read_nonblock raises an error' do
+          before do
+            socket.stub(:close)
+            socket.stub(:read_nonblock).and_raise('Bork!')
+          end
+
+          it 'closes the socket' do
+            socket.should_receive(:close)
+            handler.read
+          end
+
+          it 'passes the error to the close handler' do
+            error = nil
+            handler.on_closed { |e| error = e }
+            handler.read
+            error.should be_a(Exception)
+          end
+        end
+      end
+
+      describe '#to_s' do
+        context 'returns a string that' do
+          it 'includes the class name' do
+            handler.to_s.should include('Cql::Io::Connection')
+          end
+
+          it 'includes the host and port' do
+            handler.to_s.should include('example.com:55555')
+          end
+
+          it 'includes the connection state' do
+            handler.to_s.should include('closed')
+            socket.stub(:connect_nonblock).and_raise(Errno::EINPROGRESS)
+            handler.connect
+            handler.to_s.should include('connecting')
+            socket.stub(:connect_nonblock)
+            handler.connect
+            handler.to_s.should include('connected')
+          end
+        end
+      end
+    end
+  end
+end