cql-rb 1.2.2 → 2.0.0.pre0

data/lib/cql/protocol/responses/authenticate_response.rb

@@ -5,7 +5,7 @@ module Cql
     class AuthenticateResponse < Response
       attr_reader :authentication_class
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(read_string!(buffer))
       end
 

data/lib/cql/protocol/responses/detailed_error_response.rb

@@ -10,7 +10,7 @@ module Cql
         @details = details
       end
 
-      def self.decode!(code, message, buffer, trace_id=nil)
+      def self.decode!(code, message, protocol_version, buffer, length, trace_id=nil)
         details = {}
         case code
         when 0x1000 # unavailable

data/lib/cql/protocol/responses/error_response.rb

@@ -9,12 +9,13 @@ module Cql
         @code, @message = args
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         code = read_int!(buffer)
         message = read_string!(buffer)
         case code
         when 0x1000, 0x1100, 0x1200, 0x2400, 0x2500
-          DetailedErrorResponse.decode!(code, message, buffer)
+          new_length = length - 4 - 4 - message.bytesize
+          DetailedErrorResponse.decode!(code, message, protocol_version, buffer, new_length)
         else
           new(code, message)
         end

data/lib/cql/protocol/responses/event_response.rb

@@ -3,11 +3,12 @@
 module Cql
   module Protocol
     class EventResponse < ResultResponse
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         type = read_string!(buffer)
         impl = EVENT_TYPES[type]
         raise UnsupportedEventTypeError, %(Unsupported event type: "#{type}") unless impl
-        impl.decode!(buffer, trace_id)
+        new_length = length - 4 - type.bytesize
+        impl.decode!(protocol_version, buffer, new_length, trace_id)
       end
 
       private

data/lib/cql/protocol/responses/prepared_result_response.rb

@@ -3,17 +3,21 @@
 module Cql
   module Protocol
     class PreparedResultResponse < ResultResponse
-      attr_reader :id, :metadata
+      attr_reader :id, :metadata, :result_metadata
 
-      def initialize(id, metadata, trace_id)
+      def initialize(id, metadata, result_metadata, trace_id)
         super(trace_id)
-        @id, @metadata = id, metadata
+        @id, @metadata, @result_metadata = id, metadata, result_metadata
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         id = read_short_bytes!(buffer)
-        metadata = RowsResultResponse.read_metadata!(buffer)
-        new(id, metadata, trace_id)
+        metadata, _ = RowsResultResponse.read_metadata!(protocol_version, buffer)
+        result_metadata = nil
+        if protocol_version > 1
+          result_metadata, _, _ = RowsResultResponse.read_metadata!(protocol_version, buffer)
+        end
+        new(id, metadata, result_metadata, trace_id)
       end
 
       def eql?(other)

data/lib/cql/protocol/responses/raw_rows_result_response.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class RawRowsResultResponse < RowsResultResponse
+      def initialize(protocol_version, raw_rows, paging_state, trace_id)
+        super(nil, nil, paging_state, trace_id)
+        @protocol_version = protocol_version
+        @raw_rows = raw_rows
+      end
+
+      def materialize(metadata)
+        @metadata = metadata
+        @rows = RowsResultResponse.read_rows!(@protocol_version, @raw_rows, @metadata)
+      end
+
+      def rows
+        raise UnmaterializedRowsError, 'Not materialized!' unless @rows
+        @rows
+      end
+
+      def to_s
+        %(RESULT ROWS (raw))
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/ready_response.rb

@@ -3,7 +3,7 @@
 module Cql
   module Protocol
     class ReadyResponse < Response
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new
       end
 

data/lib/cql/protocol/responses/result_response.rb

@@ -9,11 +9,11 @@ module Cql
         @trace_id = trace_id
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         kind = read_int!(buffer)
         impl = RESULT_TYPES[kind]
         raise UnsupportedResultKindError, %(Unsupported result kind: #{kind}) unless impl
-        impl.decode!(buffer, trace_id)
+        impl.decode!(protocol_version, buffer, length - 4, trace_id)
       end
 
       def void?

data/lib/cql/protocol/responses/rows_result_response.rb

@@ -3,16 +3,23 @@
 module Cql
   module Protocol
     class RowsResultResponse < ResultResponse
-      attr_reader :rows, :metadata
+      attr_reader :rows, :metadata, :paging_state
 
-      def initialize(rows, metadata, trace_id)
+      def initialize(rows, metadata, paging_state, trace_id)
         super(trace_id)
-        @rows, @metadata = rows, metadata
+        @rows, @metadata, @paging_state = rows, metadata, paging_state
       end
 
-      def self.decode!(buffer, trace_id=nil)
-        column_specs = read_metadata!(buffer)
-        new(read_rows!(buffer, column_specs), column_specs, trace_id)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
+        original_buffer_length = buffer.length
+        column_specs, columns_count, paging_state = read_metadata!(protocol_version, buffer)
+        if column_specs.nil?
+          consumed_bytes = original_buffer_length - buffer.length
+          remaining_bytes = ByteBuffer.new(buffer.read(length - consumed_bytes))
+          RawRowsResultResponse.new(protocol_version, remaining_bytes, paging_state, trace_id)
+        else
+          new(read_rows!(protocol_version, buffer, column_specs), column_specs, paging_state, trace_id)
+        end
       end
 
       def to_s
@@ -43,6 +50,12 @@ module Cql
         :inet,
       ].freeze
 
+      TYPE_CONVERTER = TypeConverter.new
+
+      GLOBAL_TABLES_SPEC_FLAG = 0x01
+      HAS_MORE_PAGES_FLAG = 0x02
+      NO_METADATA_FLAG = 0x04
+
       def self.read_column_type!(buffer)
         id, type = read_option!(buffer) do |id, b|
           if id > 0 && id <= 0x10
@@ -64,35 +77,42 @@ module Cql
         type
       end
 
-      def self.read_metadata!(buffer)
+      def self.read_metadata!(protocol_version, buffer)
         flags = read_int!(buffer)
         columns_count = read_int!(buffer)
-        if flags & 0x01 == 0x01
-          global_keyspace_name = read_string!(buffer)
-          global_table_name = read_string!(buffer)
+        paging_state = nil
+        column_specs = nil
+        if flags & HAS_MORE_PAGES_FLAG != 0
+          paging_state = read_bytes!(buffer)
         end
-        column_specs = columns_count.times.map do
-          if global_keyspace_name
-            keyspace_name = global_keyspace_name
-            table_name = global_table_name
-          else
-            keyspace_name = read_string!(buffer)
-            table_name = read_string!(buffer)
+        if flags & NO_METADATA_FLAG == 0
+          if flags & GLOBAL_TABLES_SPEC_FLAG != 0
+            global_keyspace_name = read_string!(buffer)
+            global_table_name = read_string!(buffer)
+          end
+          column_specs = columns_count.times.map do
+            if global_keyspace_name
+              keyspace_name = global_keyspace_name
+              table_name = global_table_name
+            else
+              keyspace_name = read_string!(buffer)
+              table_name = read_string!(buffer)
+            end
+            column_name = read_string!(buffer)
+            type = read_column_type!(buffer)
+            [keyspace_name, table_name, column_name, type]
           end
-          column_name = read_string!(buffer)
-          type = read_column_type!(buffer)
-          [keyspace_name, table_name, column_name, type]
         end
+        [column_specs, columns_count, paging_state]
       end
 
-      def self.read_rows!(buffer, column_specs)
-        type_converter = TypeConverter.new
+      def self.read_rows!(protocol_version, buffer, column_specs)
         rows_count = read_int!(buffer)
         rows = []
         rows_count.times do |row_index|
           row = {}
           column_specs.each do |column_spec|
-            row[column_spec[2]] = type_converter.from_bytes(buffer, column_spec[3])
+            row[column_spec[2]] = TYPE_CONVERTER.from_bytes(buffer, column_spec[3])
           end
           rows << row
         end

data/lib/cql/protocol/responses/schema_change_event_response.rb

@@ -12,7 +12,7 @@ module Cql
         @type = TYPE
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(read_string!(buffer), read_string!(buffer), read_string!(buffer))
       end
 

data/lib/cql/protocol/responses/schema_change_result_response.rb

@@ -10,7 +10,7 @@ module Cql
         @change, @keyspace, @table = change, keyspace, table
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(read_string!(buffer), read_string!(buffer), read_string!(buffer), trace_id)
       end
 

data/lib/cql/protocol/responses/set_keyspace_result_response.rb

@@ -10,7 +10,7 @@ module Cql
         @keyspace = keyspace
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(read_string!(buffer), trace_id)
       end
 

data/lib/cql/protocol/responses/status_change_event_response.rb

@@ -12,7 +12,7 @@ module Cql
         @type = TYPE
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(read_string!(buffer), *read_inet!(buffer))
       end
 

data/lib/cql/protocol/responses/supported_response.rb

@@ -9,7 +9,7 @@ module Cql
         @options = options
       end
 
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(read_string_multimap!(buffer))
       end
 

data/lib/cql/protocol/responses/void_result_response.rb

@@ -3,7 +3,7 @@
 module Cql
   module Protocol
     class VoidResultResponse < ResultResponse
-      def self.decode!(buffer, trace_id=nil)
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
         new(trace_id)
       end
 

data/lib/cql/protocol/type_converter.rb

@@ -43,7 +43,7 @@ module Cql
           when :list, :set
             _, sub_type = type
             if value
-              raw = ByteBuffer.new
+              raw = ''
               write_short(raw, value.size)
               value.each do |element|
                 to_bytes(raw, sub_type, element, 2)
@@ -55,7 +55,7 @@ module Cql
           when :map
             _, key_type, value_type = type
             if value
-              raw = ByteBuffer.new
+              raw = ''
               write_short(raw, value.size)
               value.each do |key, value|
                 to_bytes(raw, key_type, key, 2)

data/lib/cql/uuid.rb

@@ -39,7 +39,7 @@ module Cql
     end
 
     def hash
-      @h ||= 0x7fffffffffffffff - ((@n & 0xffffffffffffffff) ^ ((@n >> 64) & 0xffffffffffffffff))
+      @h = (@n & 0xffffffffffffffff) ^ ((@n >> 64) & 0xffffffffffffffff)
     end
 
     # Returns the numerical representation of this UUID
@@ -52,7 +52,7 @@ module Cql
 
     # @private
     def eql?(other)
-      other.kind_of?(Uuid) && self.value == other.value
+      other.respond_to?(:value) && self.value == other.value
     end
     alias_method :==, :eql?
 

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '1.2.2'.freeze
+  VERSION = '2.0.0.pre0'.freeze
 end

data/spec/cql/client/asynchronous_client_spec.rb

@@ -10,10 +10,14 @@ module Cql
         described_class.new(connection_options)
       end
 
-      let :connection_options do
+      let :default_connection_options do
         {:host => 'example.com', :port => 12321, :io_reactor => io_reactor, :logger => logger}
       end
 
+      let :connection_options do
+        default_connection_options
+      end
+
       let :io_reactor do
         FakeIoReactor.new
       end
@@ -109,9 +113,11 @@ module Cql
                 Protocol::ReadyResponse.new
               when Protocol::QueryRequest
                 case request.cql
+                when /USE\s+"?(\S+)"?/
+                  Cql::Protocol::SetKeyspaceResultResponse.new($1, nil)
                 when /FROM system\.local/
                   row = {'host_id' => connection[:spec_host_id], 'data_center' => connection[:spec_data_center]}
-                  Protocol::RowsResultResponse.new([row], local_metadata, nil)
+                  Protocol::RowsResultResponse.new([row], local_metadata, nil, nil)
                 when /FROM system\.peers/
                   other_host_ids = connections.reject { |c| c[:spec_host_id] == connection[:spec_host_id] }.map { |c| c[:spec_host_id] }
                   until other_host_ids.size >= min_peers[0]
@@ -126,7 +132,7 @@ module Cql
                       'rpc_address' => bind_all_rpc_addresses ? IPAddr.new('0.0.0.0') : ip
                     }
                   end
-                  Protocol::RowsResultResponse.new(rows, peer_metadata, nil)
+                  Protocol::RowsResultResponse.new(rows, peer_metadata, nil, nil)
                 end
               end
             end
@@ -146,6 +152,16 @@ module Cql
           connections.should have(1).item
         end
 
+        it 'starts the IO reactor' do
+          client.connect.value
+          io_reactor.should be_running
+        end
+
+        it 'fails when the IO reactor fails to start' do
+          io_reactor.stub(:start).and_return(Future.failed(StandardError.new('bork')))
+          expect { client.connect.value }.to raise_error('bork')
+        end
+
         context 'when connecting to multiple hosts' do
           before do
             client.close.value
@@ -193,6 +209,129 @@ module Cql
           end
         end
 
+        context 'when negotiating protocol version' do
+          let :client do
+            described_class.new(connection_options.merge(protocol_version: 7))
+          end
+
+          it 'tries decreasing protocol versions until one succeeds' do
+            counter = 0
+            handle_request do |request|
+              if counter < 3
+                counter += 1
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              elsif counter == 3
+                counter += 1
+                Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.0.0], 'COMPRESSION' => %w[lz4 snappy])
+              else
+                Protocol::RowsResultResponse.new([], [], nil, nil)
+              end
+            end
+            client.connect.value
+            client.should be_connected
+          end
+
+          it 'logs when it tries the next protocol version' do
+            logger.stub(:warn)
+            counter = 0
+            handle_request do |request|
+              if counter < 3
+                counter += 1
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              elsif counter == 3
+                counter += 1
+                Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.0.0], 'COMPRESSION' => %w[lz4 snappy])
+              else
+                Protocol::RowsResultResponse.new([], [], nil, nil)
+              end
+            end
+            client.connect.value
+            logger.should have_received(:warn).with(/could not connect using protocol version 7 \(will try again with 6\): bork version, dummy!/i)
+          end
+
+          it 'gives up when the protocol version is zero' do
+            handle_request do |request|
+              Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+            end
+            expect { client.connect.value }.to raise_error(QueryError)
+            client.should_not be_connected
+          end
+
+          it 'gives up when a non-protocol version related error is raised' do
+            counter = 0
+            handle_request do |request|
+              if counter == 4
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              else
+                counter += 1
+                Protocol::ErrorResponse.new(0x1001, 'Get off my lawn!')
+              end
+            end
+            expect { client.connect.value }.to raise_error(/Get off my lawn/)
+            client.should_not be_connected
+          end
+
+          it 'uses different authentication mechanisms for different protocol versions' do
+            client = described_class.new(connection_options.merge(protocol_version: 3, credentials: {username: 'foo', password: 'bar'}))
+            auth_requests = []
+            handle_request do |request|
+              case request
+              when Protocol::OptionsRequest
+                Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.0.0], 'COMPRESSION' => %w[lz4 snappy])
+              when Protocol::StartupRequest
+                Protocol::AuthenticateResponse.new('org.apache.cassandra.auth.PasswordAuthenticator')
+              when Protocol::AuthResponseRequest
+                auth_requests << request
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              when Protocol::CredentialsRequest
+                auth_requests << request
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              else
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              end
+            end
+            client.connect.value rescue nil
+            auth_requests[0].should be_a(Protocol::AuthResponseRequest)
+            auth_requests[1].should be_a(Protocol::AuthResponseRequest)
+            auth_requests[2].should be_a(Protocol::CredentialsRequest)
+          end
+
+          it 'fails authenticating when an auth provider has been specified but the protocol is negotiated to v1' do
+            client = described_class.new(connection_options.merge(protocol_version: 2, auth_provider: double(:auth_provider)))
+            counter = 0
+            handle_request do |request|
+              if counter == 0
+                counter += 1
+                Protocol::ErrorResponse.new(0x0a, 'Bork version, dummy!')
+              else
+                case request
+                when Protocol::OptionsRequest
+                  Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.0.0], 'COMPRESSION' => %w[lz4 snappy])
+                when Protocol::StartupRequest
+                  Protocol::AuthenticateResponse.new('org.apache.cassandra.auth.PasswordAuthenticator')
+                end
+              end
+            end
+            expect { client.connect.value }.to raise_error(AuthenticationError)
+            counter.should == 1
+          end
+
+          it 'defaults to different CQL versions for the different protocols' do
+            cql_versions = []
+            handle_request do |request|
+              if request.is_a?(Protocol::StartupRequest)
+                cql_versions << request.options['CQL_VERSION']
+              end
+              nil
+            end
+            [1, 2, 3].map do |protocol_version|
+              client = described_class.new(connection_options.merge(protocol_version: protocol_version))
+              client.connect.value
+            end
+            cql_versions.should == ['3.0.0', '3.1.0', '3.1.0']
+          end
+        end
+
         it 'returns itself' do
           client.connect.value.should equal(client)
         end
@@ -213,6 +352,13 @@ module Cql
           client.keyspace.should be_nil
         end
 
+        it 'sends the specified CQL version in the startup message' do
+          c = described_class.new(connection_options.merge(cql_version: '5.0.1'))
+          c.connect.value
+          request = requests.find { |rq| rq.is_a?(Protocol::StartupRequest) }
+          request.options.should include('CQL_VERSION' => '5.0.1')
+        end
+
         it 'enables compression when a compressor is specified' do
           handle_request do |request|
             case request
@@ -227,22 +373,54 @@ module Cql
           request.options.should include('COMPRESSION' => 'lz4')
         end
 
+        it 'does not enable compression when the algorithm is not supported' do
+          handle_request do |request|
+            case request
+            when Protocol::OptionsRequest
+              Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.0.0], 'COMPRESSION' => %w[snappy])
+            end
+          end
+          compressor = double(:compressor, algorithm: 'lz4')
+          c = described_class.new(connection_options.merge(compressor: compressor))
+          c.connect.value
+          request = requests.find { |rq| rq.is_a?(Protocol::StartupRequest) }
+          request.options.should_not include('COMPRESSION' => 'lz4')
+        end
+
+        it 'logs a warning when compression was disabled because the algorithm was not supported' do
+          logger.stub(:warn)
+          handle_request do |request|
+            case request
+            when Protocol::OptionsRequest
+              Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.0.0], 'COMPRESSION' => %w[snappy])
+            end
+          end
+          compressor = double(:compressor, algorithm: 'lz4')
+          c = described_class.new(connection_options.merge(compressor: compressor))
+          c.connect.value
+          logger.should have_received(:warn).with(/not supported/)
+        end
+
         it 'changes to the keyspace given as an option' do
           c = described_class.new(connection_options.merge(:keyspace => 'hello_world'))
           c.connect.value
-          request = requests.find { |rq| rq == Protocol::QueryRequest.new('USE hello_world', :one) }
+          request = requests.find { |rq| rq == Protocol::QueryRequest.new('USE hello_world', nil, nil, :one) }
           request.should_not be_nil, 'expected a USE request to have been sent'
         end
 
         it 'validates the keyspace name before sending the USE command' do
           c = described_class.new(connection_options.merge(:keyspace => 'system; DROP KEYSPACE system'))
           expect { c.connect.value }.to raise_error(InvalidKeyspaceNameError)
-          requests.should_not include(Protocol::QueryRequest.new('USE system; DROP KEYSPACE system', :one))
+          requests.should_not include(Protocol::QueryRequest.new('USE system; DROP KEYSPACE system', nil, nil, :one))
         end
 
         context 'with automatic peer discovery' do
           include_context 'peer discovery setup'
 
+          let :connection_options do
+            default_connection_options.merge(keyspace: 'foo')
+          end
+
           it 'connects to the other nodes in the cluster' do
             client.connect.value
             connections.should have(3).items
@@ -290,6 +468,15 @@ module Cql
             client.connect.value
             connections.should have(2).items
           end
+
+          it 'makes sure the new connections use the specified initial keyspace' do
+            client.connect.value
+            use_keyspace_requests = connections.map { |c| c.requests.find { |r| r.is_a?(Protocol::QueryRequest) && r.cql.include?('USE') }}
+            use_keyspace_requests.should have(3).items
+            use_keyspace_requests.each do |rq|
+              rq.cql.should match(/USE foo/)
+            end
+          end
         end
 
         it 're-raises any errors raised' do
@@ -322,21 +509,36 @@ module Cql
         end
 
         context 'when the server requests authentication' do
+          let :auth_provider do
+            PlainTextAuthProvider.new('foo', 'bar')
+          end
+
           def accepting_request_handler(request, *)
             case request
             when Protocol::StartupRequest
-              Protocol::AuthenticateResponse.new('com.example.Auth')
+              Protocol::AuthenticateResponse.new('org.apache.cassandra.auth.PasswordAuthenticator')
             when Protocol::CredentialsRequest
               Protocol::ReadyResponse.new
+            when Protocol::AuthResponseRequest
+              Protocol::AuthSuccessResponse.new('hello!')
             end
           end
 
           def denying_request_handler(request, *)
             case request
             when Protocol::StartupRequest
-              Protocol::AuthenticateResponse.new('com.example.Auth')
+              Protocol::AuthenticateResponse.new('org.apache.cassandra.auth.PasswordAuthenticator')
             when Protocol::CredentialsRequest
               Protocol::ErrorResponse.new(256, 'No way, José')
+            when Protocol::AuthResponseRequest
+              Protocol::ErrorResponse.new(256, 'No way, José')
+            end
+          end
+
+          def custom_request_handler(request, *)
+            case request
+            when Protocol::StartupRequest
+              Protocol::AuthenticateResponse.new('org.acme.Auth')
             end
           end
 
@@ -344,11 +546,34 @@ module Cql
             handle_request(&method(:accepting_request_handler))
           end
 
-          it 'sends credentials' do
-            client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
-            client.connect.value
-            request = requests.find { |rq| rq == Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar') }
-            request.should_not be_nil, 'expected a credentials request to have been sent'
+          context 'with protocol v1' do
+            it 'uses an auth provider to authenticate' do
+              client = described_class.new(connection_options.merge(credentials: {:username => 'foo', :password => 'bar'}, protocol_version: 1))
+              client.connect.value
+              request = requests.find { |rq| rq.is_a?(Protocol::CredentialsRequest) }
+              request.credentials.should eql(:username => 'foo', :password => 'bar')
+            end
+
+            it 'fails to authenticate when only an auth provider has been specified' do
+              client = described_class.new(connection_options.merge(auth_provider: auth_provider, protocol_version: 1))
+              expect { client.connect.value }.to raise_error(AuthenticationError)
+            end
+          end
+
+          context 'with protocol v2' do
+            it 'uses an auth provider to authenticate' do
+              client = described_class.new(connection_options.merge(auth_provider: auth_provider))
+              client.connect.value
+              request = requests.find { |rq| rq == Protocol::AuthResponseRequest.new("\x00foo\x00bar") }
+              request.should_not be_nil, 'expected an auth response request to have been sent'
+            end
+
+            it 'creates a PlainTextAuthProvider when the :credentials options is given' do
+              client = described_class.new(connection_options.merge(credentials: {:username => 'foo', :password => 'bar'}))
+              client.connect.value
+              request = requests.find { |rq| rq == Protocol::AuthResponseRequest.new("\x00foo\x00bar") }
+              request.should_not be_nil, 'expected a auth response request to have been sent'
+            end
           end
 
           it 'raises an error when no credentials have been given' do
@@ -358,13 +583,19 @@ module Cql
 
           it 'raises an error when the server responds with an error to the credentials request' do
             handle_request(&method(:denying_request_handler))
-            client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
+            client = described_class.new(connection_options.merge(connection_options.merge(auth_provider: auth_provider)))
+            expect { client.connect.value }.to raise_error(AuthenticationError)
+          end
+
+          it 'raises an error when the server requests authentication that the auth provider does not support' do
+            handle_request(&method(:custom_request_handler))
+            client = described_class.new(connection_options.merge(connection_options.merge(auth_provider: auth_provider)))
             expect { client.connect.value }.to raise_error(AuthenticationError)
           end
 
           it 'shuts down the client when there is an authentication error' do
             handle_request(&method(:denying_request_handler))
-            client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
+            client = described_class.new(connection_options.merge(connection_options.merge(auth_provider: auth_provider)))
             client.connect.value rescue nil
             client.should_not be_connected
             io_reactor.should_not be_running
@@ -403,6 +634,38 @@ module Cql
           client.close.value
           expect { client.connect.value }.to raise_error(ClientError)
         end
+
+        it 'waits for #connect to complete before attempting to close' do
+          order = []
+          reactor_start_promise = Promise.new
+          io_reactor.stub(:start).and_return(reactor_start_promise.future)
+          io_reactor.stub(:stop).and_return(Future.resolved)
+          connected = client.connect
+          connected.on_value { order << :connected }
+          closed = client.close
+          closed.on_value { order << :closed }
+          connected.should_not be_completed
+          reactor_start_promise.fulfill
+          connected.value
+          closed.value
+          order.should == [:connected, :closed]
+        end
+
+        it 'waits for #connect to complete before attempting to close, when #connect fails' do
+          order = []
+          reactor_start_promise = Promise.new
+          io_reactor.stub(:start).and_return(reactor_start_promise.future)
+          io_reactor.stub(:stop).and_return(Future.resolved)
+          connected = client.connect
+          connected.on_failure { order << :connect_failed }
+          closed = client.close
+          closed.on_value { order << :closed }
+          connected.should_not be_completed
+          reactor_start_promise.fail(StandardError.new('bork'))
+          connected.value rescue nil
+          closed.value
+          order.should == [:connect_failed, :closed]
+        end
       end
 
       describe '#use' do
@@ -414,7 +677,7 @@ module Cql
           end
           client.connect.value
           client.use('system').value
-          last_request.should == Protocol::QueryRequest.new('USE system', :one)
+          last_request.should == Protocol::QueryRequest.new('USE system', nil, nil, :one)
         end
 
         it 'executes a USE query for each connection' do
@@ -428,9 +691,9 @@ module Cql
           c.use('system').value
           last_requests = connections.select { |c| c.host =~ /^h\d\.example\.com$/ }.sort_by(&:host).map { |c| c.requests.last }
           last_requests.should == [
-            Protocol::QueryRequest.new('USE system', :one),
-            Protocol::QueryRequest.new('USE system', :one),
-            Protocol::QueryRequest.new('USE system', :one)
+            Protocol::QueryRequest.new('USE system', nil, nil, :one),
+            Protocol::QueryRequest.new('USE system', nil, nil, :one),
+            Protocol::QueryRequest.new('USE system', nil, nil, :one),
           ]
         end
 
@@ -449,17 +712,6 @@ module Cql
           client.connect.value
           expect { client.use('system; DROP KEYSPACE system').value }.to raise_error(InvalidKeyspaceNameError)
         end
-
-        it 'allows the keyspace name to be quoted' do
-          handle_request do |request|
-            if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE "system"'
-              Protocol::SetKeyspaceResultResponse.new('system', nil)
-            end
-          end
-          client.connect.value
-          client.use('"system"').value
-          client.keyspace.should == "system"
-        end
       end
 
       describe '#execute' do
@@ -473,24 +725,46 @@ module Cql
 
         it 'asks the connection to execute the query using the default consistency level' do
           client.execute(cql).value
-          last_request.should == Protocol::QueryRequest.new(cql, :quorum)
+          last_request.should == Protocol::QueryRequest.new(cql, nil, nil, :quorum)
         end
 
         it 'uses the consistency specified when the client was created' do
           client = described_class.new(connection_options.merge(default_consistency: :all))
           client.connect.value
           client.execute(cql).value
-          last_request.should == Protocol::QueryRequest.new(cql, :all)
+          last_request.should == Protocol::QueryRequest.new(cql, nil, nil, :all)
         end
 
         it 'uses the consistency given as last argument' do
           client.execute('UPDATE stuff SET thing = 1 WHERE id = 3', :three).value
-          last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :three)
+          last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', nil, nil, :three)
         end
 
         it 'uses the consistency given as an option' do
           client.execute('UPDATE stuff SET thing = 1 WHERE id = 3', consistency: :local_quorum).value
-          last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :local_quorum)
+          last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', nil, nil, :local_quorum)
+        end
+
+        context 'with multiple arguments' do
+          it 'passes the arguments as bound values' do
+            client.execute('UPDATE stuff SET thing = ? WHERE id = ?', 'foo', 'bar').value
+            last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = ? WHERE id = ?', ['foo', 'bar'], nil, :quorum)
+          end
+
+          it 'passes the type hints option to the request' do
+            client.execute('UPDATE stuff SET thing = ? WHERE id = ?', 'foo', 3, type_hints: [nil, :int]).value
+            last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = ? WHERE id = ?', ['foo', 3], [nil, :int], :quorum)
+          end
+
+          it 'detects when the last argument is the consistency' do
+            client.execute('UPDATE stuff SET thing = ? WHERE id = ?', 'foo', 'bar', :each_quorum).value
+            last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = ? WHERE id = ?', ['foo', 'bar'], nil, :each_quorum)
+          end
+
+          it 'detects when the last arguments is an options hash' do
+            client.execute('UPDATE stuff SET thing = ? WHERE id = ?', 'foo', 'bar', consistency: :all, tracing: true).value
+            last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = ? WHERE id = ?', ['foo', 'bar'], nil, :all, nil, nil, nil, true)
+          end
         end
 
         context 'with a void CQL query' do
@@ -545,9 +819,9 @@ module Cql
 
             last_requests = connections.select { |c| c.host =~ /^h\d\.example\.com$/ }.sort_by(&:host).map { |c| c.requests.last }
             last_requests.should == [
-              Protocol::QueryRequest.new('USE system', :one),
-              Protocol::QueryRequest.new('USE system', :one),
-              Protocol::QueryRequest.new('USE system', :one)
+              Protocol::QueryRequest.new('USE system', nil, nil, :one),
+              Protocol::QueryRequest.new('USE system', nil, nil, :one),
+              Protocol::QueryRequest.new('USE system', nil, nil, :one),
             ]
           end
         end
@@ -568,7 +842,7 @@ module Cql
           before do
             handle_request do |request|
               if request.is_a?(Protocol::QueryRequest) && request.cql =~ /FROM things/
-                Protocol::RowsResultResponse.new(rows, metadata, nil)
+                Protocol::RowsResultResponse.new(rows, metadata, nil, nil)
               end
             end
           end
@@ -662,13 +936,76 @@ module Cql
             trace_id = Uuid.new('a1028490-3f05-11e3-9531-fb72eff05fbb')
             handle_request do |request|
               if request.is_a?(Protocol::QueryRequest) && request.cql == cql
-                Protocol::RowsResultResponse.new([], [], trace_id)
+                Protocol::RowsResultResponse.new([], [], nil, trace_id)
               end
             end
             result = client.execute(cql, trace: true).value
             result.trace_id.should == trace_id
           end
         end
+
+        context 'with paging' do
+          let :cql do
+            'SELECT * FROM foo'
+          end
+
+          let :rows do
+            [['xyz', 'abc'], ['abc', 'xyz'], ['123', 'xyz']]
+          end
+
+          let :metadata do
+            [['thingies', 'things', 'thing', :text], ['thingies', 'things', 'item', :text]]
+          end
+
+          before do
+            handle_request do |request|
+              if request.is_a?(Protocol::QueryRequest) && request.cql == cql
+                if request.paging_state.nil?
+                  Protocol::RowsResultResponse.new(rows.take(2), metadata, 'foobar', nil)
+                elsif request.paging_state == 'foobar'
+                  Protocol::RowsResultResponse.new(rows.drop(2), metadata, nil, nil)
+                end
+              end
+            end
+          end
+
+          it 'sets the page size' do
+            client.execute(cql, page_size: 100).value
+            last_request.page_size.should == 100
+          end
+
+          it 'sets the page size and paging state' do
+            client.execute(cql, page_size: 100, paging_state: 'foobar').value
+            last_request.page_size.should == 100
+            last_request.paging_state.should == 'foobar'
+          end
+
+          it 'returns a result which can load the next page' do
+            result = client.execute(cql, page_size: 2).value
+            result.next_page.value
+            last_request.paging_state.should == 'foobar'
+          end
+
+          it 'returns a result which knows when there are no more pages' do
+            result = client.execute(cql, page_size: 2).value
+            result = result.next_page.value
+            result.should be_last_page
+          end
+
+          it 'passes the same options when loading the next page' do
+            sent_timeout = nil
+            handle_request do |_, _, _, timeout|
+              sent_timeout = timeout
+              nil
+            end
+            result = client.execute('SELECT * FROM something WHERE x = ? AND y = ?', 'foo', 'bar', page_size: 100, paging_state: 'foobar', trace: true, timeout: 3, type_hints: [:varchar, nil]).value
+            result.next_page.value
+            last_request.trace.should be_true
+            last_request.values.should == ['foo', 'bar']
+            last_request.type_hints.should == [:varchar, nil]
+            sent_timeout.should == 3
+          end
+        end
       end
 
       describe '#prepare' do
@@ -687,7 +1024,7 @@ module Cql
         before do
           handle_request do |request|
             if request.is_a?(Protocol::PrepareRequest)
-              Protocol::PreparedResultResponse.new(id, metadata, nil)
+              Protocol::PreparedResultResponse.new(id, metadata, nil, nil)
             end
           end
         end
@@ -709,7 +1046,7 @@ module Cql
         it 'executes a prepared statement using the default consistency level' do
           statement = client.prepare(cql).value
           statement.execute('foo').value
-          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :quorum)
+          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], true, :quorum)
         end
 
         it 'executes a prepared statement using the consistency specified when the client was created' do
@@ -717,7 +1054,7 @@ module Cql
           client.connect.value
           statement = client.prepare(cql).value
           statement.execute('foo').value
-          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :all)
+          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], true, :all)
         end
 
         it 'returns a prepared statement that knows the metadata' do
@@ -728,7 +1065,7 @@ module Cql
         it 'executes a prepared statement with a specific consistency level' do
           statement = client.prepare(cql).value
           statement.execute('thing', :local_quorum).value
-          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['thing'], :local_quorum)
+          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['thing'], true, :local_quorum)
         end
 
         context 'when there is an error creating the request' do
@@ -742,7 +1079,7 @@ module Cql
           it 'returns a failed future' do
             handle_request do |request|
               if request.is_a?(Protocol::PrepareRequest)
-                Protocol::PreparedResultResponse.new(id, metadata, nil)
+                Protocol::PreparedResultResponse.new(id, metadata, nil, nil)
               end
             end
             statement = client.prepare(cql).value
@@ -753,7 +1090,7 @@ module Cql
 
         context 'with multiple connections' do
           let :connection_options do
-            {:hosts => %w[host1 host2], :port => 12321, :io_reactor => io_reactor, :logger => logger}
+            default_connection_options.merge(hosts: %w[host1 host2])
           end
 
           it 'prepares the statement on all connections' do
@@ -764,11 +1101,102 @@ module Cql
               raise 'Did not receive EXECUTE requests on all connections within 5s' if (Time.now - started_at) > 5
             end
             connections.map { |c| c.requests.last }.should == [
-              Protocol::ExecuteRequest.new(id, metadata, ['hello'], :quorum),
-              Protocol::ExecuteRequest.new(id, metadata, ['hello'], :quorum),
+              Protocol::ExecuteRequest.new(id, metadata, ['hello'], true, :quorum),
+              Protocol::ExecuteRequest.new(id, metadata, ['hello'], true, :quorum),
             ]
           end
         end
+
+        context 'with paging' do
+          let :statement do
+            client.prepare(cql).value
+          end
+
+          let :rows do
+            [['xyz', 'abc'], ['abc', 'xyz'], ['123', 'xyz']]
+          end
+
+          let :metadata do
+            [['thingies', 'things', 'thing', :text]]
+          end
+
+          let :result_metadata do
+            [['thingies', 'things', 'thing', :text], ['thingies', 'things', 'item', :text]]
+          end
+
+          before do
+            handle_request do |request|
+              case request
+              when Protocol::PrepareRequest
+                Protocol::PreparedResultResponse.new(id, metadata, nil, nil)
+              when Protocol::ExecuteRequest
+                if request.paging_state.nil?
+                  Protocol::RowsResultResponse.new(rows.take(2), result_metadata, 'foobar', nil)
+                elsif request.paging_state == 'foobar'
+                  Protocol::RowsResultResponse.new(rows.drop(2), result_metadata, nil, nil)
+                end
+              end
+            end
+          end
+
+          it 'sets the page size' do
+            statement.execute('foo', page_size: 100).value
+            last_request.page_size.should == 100
+          end
+
+          it 'sets the page size and paging state' do
+            statement.execute('foo', page_size: 100, paging_state: 'foobar').value
+            last_request.page_size.should == 100
+            last_request.paging_state.should == 'foobar'
+          end
+        end
+      end
+
+      describe '#batch' do
+        before do
+          client.connect.value
+        end
+
+        context 'when called witout a block' do
+          it 'returns a batch' do
+            batch = client.batch
+            batch.add('UPDATE x SET y = 3 WHERE z = 1')
+            batch.execute.value
+            last_request.should be_a(Protocol::BatchRequest)
+          end
+
+          it 'creates a batch of the right type' do
+            batch = client.batch(:unlogged)
+            batch.add('UPDATE x SET y = 3 WHERE z = 1')
+            batch.execute.value
+            last_request.type.should == Protocol::BatchRequest::UNLOGGED_TYPE
+          end
+
+          it 'passes the options to the batch' do
+            batch = client.batch(trace: true)
+            batch.add('UPDATE x SET y = 3 WHERE z = 1')
+            batch.execute.value
+            last_request.trace.should be_true
+          end
+        end
+
+        context 'when called with a block' do
+          it 'yields and executes a batch' do
+            f = client.batch do |batch|
+              batch.add('UPDATE x SET y = 3 WHERE z = 1')
+            end
+            f.value
+            last_request.should be_a(Protocol::BatchRequest)
+          end
+
+          it 'passes the options to the batch\'s #execute' do
+            f = client.batch(:unlogged, trace: true) do |batch|
+              batch.add('UPDATE x SET y = 3 WHERE z = 1')
+            end
+            f.value
+            last_request.trace.should be_true
+          end
+        end
       end
 
       context 'when not connected' do
@@ -815,7 +1243,7 @@ module Cql
         it 'complains when #execute of a prepared statement is called after #close' do
           handle_request do |request|
             if request.is_a?(Protocol::PrepareRequest)
-              Protocol::PreparedResultResponse.new('A' * 32, [], nil)
+              Protocol::PreparedResultResponse.new('A' * 32, [], nil, nil)
             end
           end
           client.connect.value
@@ -829,7 +1257,7 @@ module Cql
         include_context 'peer discovery setup'
 
         let :connection_options do
-          {:hosts => %w[host1 host2 host3], :port => 12321, :io_reactor => io_reactor}
+          default_connection_options.merge(hosts: %w[host1 host2 host3], keyspace: 'foo')
         end
 
         before do
@@ -860,6 +1288,14 @@ module Cql
           connections.select(&:connected?).should have(3).items
         end
 
+        it 'makes sure the new connections use the same keyspace as the existing' do
+          connections.first.close
+          event = Protocol::TopologyChangeEventResponse.new('NEW_NODE', IPAddr.new('1.1.1.1'), 9999)
+          connections.select(&:has_event_listener?).first.trigger_event(event)
+          use_keyspace_request = connections.last.requests.find { |r| r.is_a?(Protocol::QueryRequest) && r.cql.include?('USE') }
+          use_keyspace_request.cql.should == 'USE foo'
+        end
+
         it 'eventually reconnects even when the node doesn\'t respond at first' do
           timer_promise = Promise.new
           io_reactor.stub(:schedule_timer).and_return(timer_promise.future)
@@ -947,14 +1383,21 @@ module Cql
           logger.stub(:warn)
           io_reactor.stub(:connect).and_return(Future.failed(StandardError.new('Hurgh blurgh')))
           client.connect.value rescue nil
-          logger.should have_received(:warn).with(/Failed connecting to node at example\.com:12321: Hurgh blurgh/)
+          logger.should have_received(:warn).with(/Failed connecting to node at example\.com: Hurgh blurgh/)
         end
 
         it 'logs when a connection fails' do
           logger.stub(:warn)
           client.connect.value
+          connections.sample.close(StandardError.new('bork'))
+          logger.should have_received(:warn).with(/Connection to node .{36} at .+:\d+ in data center .+ closed unexpectedly: bork/)
+        end
+
+        it 'logs when a connection closes' do
+          logger.stub(:info)
+          client.connect.value
           connections.sample.close
-          logger.should have_received(:warn).with(/Connection to node .{36} at .+:\d+ in data center .+ unexpectedly closed/)
+          logger.should have_received(:info).with(/Connection to node .{36} at .+:\d+ in data center .+ closed/)
         end
 
         it 'logs when it does a peer discovery' do