cql-rb 1.2.2 → 2.0.0.pre0

data/spec/cql/protocol/responses/rows_result_response_spec.rb

@@ -9,7 +9,8 @@ module Cql
       describe '.decode!' do
         context 'with rows from the same table' do
           let :response do
-            described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x03\x00\ncql_rb_126\x00\x05users\x00\tuser_name\x00\r\x00\x05email\x00\r\x00\bpassword\x00\r\x00\x00\x00\x02\x00\x00\x00\x04phil\x00\x00\x00\rphil@heck.com\xFF\xFF\xFF\xFF\x00\x00\x00\x03sue\x00\x00\x00\rsue@inter.net\xFF\xFF\xFF\xFF"))
+            buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x03\x00\ncql_rb_126\x00\x05users\x00\tuser_name\x00\r\x00\x05email\x00\r\x00\bpassword\x00\r\x00\x00\x00\x02\x00\x00\x00\x04phil\x00\x00\x00\rphil@heck.com\xFF\xFF\xFF\xFF\x00\x00\x00\x03sue\x00\x00\x00\rsue@inter.net\xFF\xFF\xFF\xFF")
+            described_class.decode!(1, buffer, buffer.length)
           end
 
           it 'decodes the rows as hashes of column name => column value' do
@@ -43,7 +44,7 @@ module Cql
             buffer << "\x00\ncql_rb_127\x00\x06users2\x00\x05email\x00\r"
             buffer << "\x00\ncql_rb_128\x00\x06users3\x00\bpassword\x00\r"
             buffer << "\x00\x00\x00\x02\x00\x00\x00\x04phil\x00\x00\x00\rphil@heck.com\xFF\xFF\xFF\xFF\x00\x00\x00\x03sue\x00\x00\x00\rsue@inter.net\xFF\xFF\xFF\xFF"
-            described_class.decode!(buffer)
+            described_class.decode!(1, buffer, buffer.length)
           end
 
           it 'decodes the rows' do
@@ -62,6 +63,46 @@ module Cql
           end
         end
 
+        context 'when there is no metadata' do
+          let :response do
+            buffer = ByteBuffer.new
+            buffer << "\x00\x00\x00\x05" # flags (global_tables_spec | no_metadata)
+            buffer << "\x00\x00\x00\x03" # column count
+            buffer << "\x00\x00\x00\x02\x00\x00\x00\x04phil\x00\x00\x00\rphil@heck.com\xFF\xFF\xFF\xFF\x00\x00\x00\x03sue\x00\x00\x00\rsue@inter.net\xFF\xFF\xFF\xFF"
+            described_class.decode!(2, buffer, buffer.length)
+          end
+
+          it 'returns a RawRowsResultResponse' do
+            metadata = [
+              ['cql_rb_126', 'users', 'user_name', :varchar],
+              ['cql_rb_126', 'users', 'email', :varchar],
+              ['cql_rb_126', 'users', 'password', :varchar]
+            ]
+            response.materialize(metadata)
+            response.rows.should == [
+              {'user_name' => 'phil', 'email' => 'phil@heck.com', 'password' => nil},
+              {'user_name' => 'sue',  'email' => 'sue@inter.net', 'password' => nil}
+            ]
+          end
+        end
+
+        context 'when there are more pages' do
+          let :response do
+            buffer = ByteBuffer.new
+            buffer << "\x00\x00\x00\x03" # flags (global_tables_spec | has_more_pages)
+            buffer << "\x00\x00\x00\x03" # column count
+            buffer << "\x00\x00\x00\x03foo" # paging state
+            buffer << "\x00\ncql_rb_126\x00\x05users"
+            buffer << "\x00\tuser_name\x00\r\x00\x05email\x00\r\x00\bpassword\x00\r"
+            buffer << "\x00\x00\x00\x02\x00\x00\x00\x04phil\x00\x00\x00\rphil@heck.com\xFF\xFF\xFF\xFF\x00\x00\x00\x03sue\x00\x00\x00\rsue@inter.net\xFF\xFF\xFF\xFF"
+            described_class.decode!(2, buffer, buffer.length)
+          end
+
+          it 'extracts the paging state' do
+            response.paging_state.should == 'foo'
+          end
+        end
+
         context 'with different column types' do
           let :response do
             # The following test was created by intercepting the frame for the
@@ -113,8 +154,8 @@ module Cql
             # );
             #
             # SELECT * FROM lots_of_types WHERE ascii_column = 'hello';
-
-            described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x12\x00\x04test\x00\rlots_of_types\x00\fascii_column\x00\x01\x00\rbigint_column\x00\x02\x00\vblob_column\x00\x03\x00\x0Eboolean_column\x00\x04\x00\x0Edecimal_column\x00\x06\x00\rdouble_column\x00\a\x00\ffloat_column\x00\b\x00\vinet_column\x00\x10\x00\nint_column\x00\t\x00\vlist_column\x00 \x00\x01\x00\nmap_column\x00!\x00\r\x00\x04\x00\nset_column\x00\"\x00\x03\x00\vtext_column\x00\r\x00\x10timestamp_column\x00\v\x00\x0Ftimeuuid_column\x00\x0F\x00\vuuid_column\x00\f\x00\x0Evarchar_column\x00\r\x00\rvarint_column\x00\x0E\x00\x00\x00\x01\x00\x00\x00\x05hello\x00\x00\x00\b\x00\x03\x98\xB1S\xC8\x7F\xAB\x00\x00\x00\x05\xFA\xB4^4V\x00\x00\x00\x01\x01\x00\x00\x00\x11\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA\x00\x00\x00\b@\xC3\x88\x0F\xC2\x7F\x9DU\x00\x00\x00\x04AB\x14{\x00\x00\x00\x04\n\x00\x01\x02\x00\x00\x00\x04\x00\xBCj\xC2\x00\x00\x00\x11\x00\x03\x00\x03foo\x00\x03foo\x00\x03bar\x00\x00\x00\x14\x00\x02\x00\x03foo\x00\x01\x01\x00\x05hello\x00\x01\x00\x00\x00\x00\r\x00\x02\x00\x03\xABC!\x00\x04\xAF\xD8~\xCD\x00\x00\x00\vhello world\x00\x00\x00\b\x00\x00\x01</\xE9\xDC\xE3\x00\x00\x00\x10\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11\x00\x00\x00\x10\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6\x00\x00\x00\x03foo\x00\x00\x00\x11\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["))
+            buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x12\x00\x04test\x00\rlots_of_types\x00\fascii_column\x00\x01\x00\rbigint_column\x00\x02\x00\vblob_column\x00\x03\x00\x0Eboolean_column\x00\x04\x00\x0Edecimal_column\x00\x06\x00\rdouble_column\x00\a\x00\ffloat_column\x00\b\x00\vinet_column\x00\x10\x00\nint_column\x00\t\x00\vlist_column\x00 \x00\x01\x00\nmap_column\x00!\x00\r\x00\x04\x00\nset_column\x00\"\x00\x03\x00\vtext_column\x00\r\x00\x10timestamp_column\x00\v\x00\x0Ftimeuuid_column\x00\x0F\x00\vuuid_column\x00\f\x00\x0Evarchar_column\x00\r\x00\rvarint_column\x00\x0E\x00\x00\x00\x01\x00\x00\x00\x05hello\x00\x00\x00\b\x00\x03\x98\xB1S\xC8\x7F\xAB\x00\x00\x00\x05\xFA\xB4^4V\x00\x00\x00\x01\x01\x00\x00\x00\x11\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA\x00\x00\x00\b@\xC3\x88\x0F\xC2\x7F\x9DU\x00\x00\x00\x04AB\x14{\x00\x00\x00\x04\n\x00\x01\x02\x00\x00\x00\x04\x00\xBCj\xC2\x00\x00\x00\x11\x00\x03\x00\x03foo\x00\x03foo\x00\x03bar\x00\x00\x00\x14\x00\x02\x00\x03foo\x00\x01\x01\x00\x05hello\x00\x01\x00\x00\x00\x00\r\x00\x02\x00\x03\xABC!\x00\x04\xAF\xD8~\xCD\x00\x00\x00\vhello world\x00\x00\x00\b\x00\x00\x01</\xE9\xDC\xE3\x00\x00\x00\x10\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11\x00\x00\x00\x10\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6\x00\x00\x00\x03foo\x00\x00\x00\x11\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[")
+            described_class.decode!(1, buffer, buffer.length)
           end
 
           it 'decodes ASCII as an ASCII encoded string' do
@@ -196,7 +237,8 @@ module Cql
 
         context 'with null values' do
           it 'decodes nulls' do
-            response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x13\x00\x12cql_rb_client_spec\x00\rlots_of_types\x00\x02id\x00\t\x00\fascii_column\x00\x01\x00\rbigint_column\x00\x02\x00\vblob_column\x00\x03\x00\x0Eboolean_column\x00\x04\x00\x0Edecimal_column\x00\x06\x00\rdouble_column\x00\a\x00\ffloat_column\x00\b\x00\vinet_column\x00\x10\x00\nint_column\x00\t\x00\vlist_column\x00 \x00\x01\x00\nmap_column\x00!\x00\r\x00\x04\x00\nset_column\x00\"\x00\x03\x00\vtext_column\x00\r\x00\x10timestamp_column\x00\v\x00\x0Ftimeuuid_column\x00\x0F\x00\vuuid_column\x00\f\x00\x0Evarchar_column\x00\r\x00\rvarint_column\x00\x0E\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x03\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"))
+            buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x13\x00\x12cql_rb_client_spec\x00\rlots_of_types\x00\x02id\x00\t\x00\fascii_column\x00\x01\x00\rbigint_column\x00\x02\x00\vblob_column\x00\x03\x00\x0Eboolean_column\x00\x04\x00\x0Edecimal_column\x00\x06\x00\rdouble_column\x00\a\x00\ffloat_column\x00\b\x00\vinet_column\x00\x10\x00\nint_column\x00\t\x00\vlist_column\x00 \x00\x01\x00\nmap_column\x00!\x00\r\x00\x04\x00\nset_column\x00\"\x00\x03\x00\vtext_column\x00\r\x00\x10timestamp_column\x00\v\x00\x0Ftimeuuid_column\x00\x0F\x00\vuuid_column\x00\f\x00\x0Evarchar_column\x00\r\x00\rvarint_column\x00\x0E\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x03\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
+            response = described_class.decode!(1, buffer, buffer.length)
             response.rows.first.should eql(
               'id' => 3,
               'ascii_column' => nil,
@@ -223,19 +265,22 @@ module Cql
 
         context 'with COUNTER columns' do
           it 'decodes COUNTER as a number' do
-            response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x03\x00\x04test\x00\x04cnts\x00\x02id\x00\r\x00\x02c1\x00\x05\x00\x02c2\x00\x05\x00\x00\x00\x01\x00\x00\x00\x04theo\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00\x01"))
+            buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x03\x00\x04test\x00\x04cnts\x00\x02id\x00\r\x00\x02c1\x00\x05\x00\x02c2\x00\x05\x00\x00\x00\x01\x00\x00\x00\x04theo\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00\x01")
+            response = described_class.decode!(1, buffer, buffer.length)
             response.rows.first['c1'].should == 3
           end
 
           it 'decodes a null COUNTER as nil' do
-            response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x02\x00\x12cql_rb_client_spec\x00\bcounters\x00\bcounter1\x00\x05\x00\bcounter2\x00\x05\x00\x00\x00\x01\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00\x01\xFF\xFF\xFF\xFF"))
+            buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x02\x00\x12cql_rb_client_spec\x00\bcounters\x00\bcounter1\x00\x05\x00\bcounter2\x00\x05\x00\x00\x00\x01\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00\x01\xFF\xFF\xFF\xFF")
+            response = described_class.decode!(1, buffer, buffer.length)
             response.rows.first['counter2'].should be_nil
           end
         end
 
         context 'with an INET column' do
           let :response do
-            described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x01\x00\ntest_types\x00\rlots_of_types\x00\vinet_column\x00\x10\x00\x00\x00\x02\x00\x00\x00\x04\x7F\x00\x00\x01\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"))
+            buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x01\x00\ntest_types\x00\rlots_of_types\x00\vinet_column\x00\x10\x00\x00\x00\x02\x00\x00\x00\x04\x7F\x00\x00\x01\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01")
+            described_class.decode!(1, buffer, buffer.length)
           end
 
           it 'decodes IPv4 values' do
@@ -250,21 +295,21 @@ module Cql
         context 'with an unknown column type' do
           it 'raises an error when encountering an unknown column type' do
             buffer = ByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x03\x00\ncql_rb_328\x00\x05users\x00\tuser_name\x00\xff\x00\x05email\x00\r\x00\bpassword\x00\r\x00\x00\x00\x00")
-            expect { described_class.decode!(buffer) }.to raise_error(UnsupportedColumnTypeError)
+            expect { described_class.decode!(1, buffer, buffer.length) }.to raise_error(UnsupportedColumnTypeError)
           end
         end
       end
 
       describe '#void?' do
         it 'is not void' do
-          response = RowsResultResponse.new([{'col' => 'foo'}], [['ks', 'tbl', 'col', :varchar]], nil)
+          response = RowsResultResponse.new([{'col' => 'foo'}], [['ks', 'tbl', 'col', :varchar]], nil, nil)
           response.should_not be_void
         end
       end
 
       describe '#to_s' do
         it 'returns a string with metadata and rows' do
-          response = RowsResultResponse.new([{'col' => 'foo'}], [['ks', 'tbl', 'col', :varchar]], nil)
+          response = RowsResultResponse.new([{'col' => 'foo'}], [['ks', 'tbl', 'col', :varchar]], nil, nil)
           response.to_s.should == 'RESULT ROWS [["ks", "tbl", "col", :varchar]] [{"col"=>"foo"}]'
         end
       end

data/spec/cql/protocol/responses/schema_change_event_response_spec.rb

@@ -8,7 +8,8 @@ module Cql
     describe SchemaChangeEventResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\aDROPPED\x00\ncql_rb_609\x00\x05users"))
+          buffer = ByteBuffer.new("\x00\aDROPPED\x00\ncql_rb_609\x00\x05users")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the change' do

data/spec/cql/protocol/responses/schema_change_result_response_spec.rb

@@ -8,7 +8,8 @@ module Cql
     describe SchemaChangeResultResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\aUPDATED\x00\ncql_rb_973\x00\x05users"))
+          buffer = ByteBuffer.new("\x00\aUPDATED\x00\ncql_rb_973\x00\x05users")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the description' do

data/spec/cql/protocol/responses/set_keyspace_result_response_spec.rb

@@ -8,7 +8,7 @@ module Cql
     describe SetKeyspaceResultResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\x06system"))
+          described_class.decode!(1, ByteBuffer.new("\x00\x06system"), 8)
         end
 
         it 'decodes the keyspace' do

data/spec/cql/protocol/responses/status_change_event_response_spec.rb

@@ -8,7 +8,8 @@ module Cql
     describe StatusChangeEventResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\x04DOWN\x04\x00\x00\x00\x00\x00\x00#R"))
+          buffer = ByteBuffer.new("\x00\x04DOWN\x04\x00\x00\x00\x00\x00\x00#R")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the change' do

data/spec/cql/protocol/responses/supported_response_spec.rb

@@ -8,7 +8,8 @@ module Cql
     describe SupportedResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00"))
+          buffer = ByteBuffer.new("\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the options' do

data/spec/cql/protocol/responses/topology_change_event_response_spec.rb

@@ -8,7 +8,8 @@ module Cql
     describe TopologyChangeEventResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\fREMOVED_NODE\x04\x00\x00\x00\x00\x00\x00#R"))
+          buffer = ByteBuffer.new("\x00\fREMOVED_NODE\x04\x00\x00\x00\x00\x00\x00#R")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the change' do

data/spec/cql/protocol/responses/void_result_response_spec.rb

@@ -9,7 +9,7 @@ module Cql
       describe '.decode!' do
         it 'returns a new instance' do
           unused_byte_buffer = nil
-          described_class.decode!(unused_byte_buffer).should be_a(described_class)
+          described_class.decode!(1, unused_byte_buffer, 0).should be_a(described_class)
         end
       end
 

data/spec/cql/protocol/type_converter_spec.rb

@@ -14,11 +14,28 @@ module Cql
         ''
       end
 
-      TYPES = [:ascii, :bigint, :blob, :boolean, :counter, :decimal, :double, :float, :inet, :int, :text, :varchar, :timestamp, :timeuuid, :uuid, :varint].freeze
-
       describe '#to_bytes' do
+        types = [
+          :ascii,
+          :bigint,
+          :blob,
+          :boolean,
+          :counter,
+          :decimal,
+          :double,
+          :float,
+          :inet,
+          :int,
+          :text,
+          :varchar,
+          :timestamp,
+          :timeuuid,
+          :uuid,
+          :varint
+        ]
+
         context 'when encoding normal value' do
-          TYPES.each do |type|
+          types.each do |type|
             it "encodes a null #{type.upcase}" do
               converter.to_bytes(buffer, type, nil, 4).should == "\xff\xff\xff\xff"
             end
@@ -40,7 +57,7 @@ module Cql
         end
 
         context 'when encoding collection values' do
-          TYPES.each do |type|
+          types.each do |type|
             it "encodes a null #{type.upcase}" do
               converter.to_bytes(buffer, type, nil, 2).should == "\xff\xff"
             end

data/spec/cql/uuid_spec.rb

@@ -36,8 +36,15 @@ module Cql
         Uuid.new(276263553384940695775376958868900023510).should eql(Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'))
       end
 
-      it 'is not equal when anything other than a Uuid is passed' do
-        [nil, 123, 'test'].each { |v| Uuid.new(276263553384940695775376958868900023510).should_not eql(v) }
+      it 'uses #value to determine equality' do
+        Uuid.new(276263553384940695775376958868900023510).should eql(Future.resolved(276263553384940695775376958868900023510))
+      end
+
+      it 'does not attempt to call #value on object that do not respond to it' do
+        uuid = Uuid.new(276263553384940695775376958868900023510)
+        expect { uuid.should_not eql(nil) }.to_not raise_error
+        expect { uuid.should_not eql(123) }.to_not raise_error
+        expect { uuid.should_not eql('test') }.to_not raise_error
       end
 
       it 'aliases #== to #eql?' do
@@ -53,7 +60,7 @@ module Cql
 
     describe '#hash' do
       it 'calculates a 64 bit hash of the UUID' do
-        h = Uuid.new(162917432198567078063626261009205865234).hash
+        h = Uuid.new(276263553384940695775376958868900023510).hash
         h.should be < 2**63
         h.should be > -2**63
       end

data/spec/integration/client_spec.rb

@@ -5,7 +5,10 @@ require 'spec_helper'
 
 describe 'A CQL client' do
   let :connection_options do
-    {:host => ENV['CASSANDRA_HOST'], :credentials => {:username => 'cassandra', :password => 'cassandra'}}
+    {
+      :host => ENV['CASSANDRA_HOST'],
+      :credentials => {:username => 'cassandra', :password => 'cassandra'},
+    }
   end
 
   let :client do
@@ -16,6 +19,18 @@ describe 'A CQL client' do
     client.close rescue nil
   end
 
+  def create_keyspace_and_table
+    begin
+      client.execute(%(DROP KEYSPACE cql_rb_client_spec))
+    rescue Cql::QueryError => e
+      raise e unless e.code == 0x2300
+    end
+    client.execute(%(CREATE KEYSPACE cql_rb_client_spec WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1}))
+    client.use('cql_rb_client_spec')
+    client.execute(%(CREATE TABLE users (user_id VARCHAR PRIMARY KEY, first VARCHAR, last VARCHAR, age INT)))
+    client.execute(%(CREATE TABLE counters (id VARCHAR PRIMARY KEY, count COUNTER)))
+  end
+
   context 'with common operations' do
     it 'executes a query and returns the result' do
       result = client.execute('SELECT * FROM system.schema_keyspaces')
@@ -47,11 +62,12 @@ describe 'A CQL client' do
 
   context 'when using prepared statements' do
     before do
-      client.use('system')
+      create_keyspace_and_table
+      client.execute(%(UPDATE users SET first = 'Sue', last = 'Smith', age = 34 WHERE user_id = 'sue'))
     end
 
     let :statement do
-      client.prepare('SELECT * FROM schema_keyspaces WHERE keyspace_name = ?')
+      client.prepare('SELECT * FROM users WHERE user_id = ?')
     end
 
     it 'prepares a statement' do
@@ -59,11 +75,39 @@ describe 'A CQL client' do
     end
 
     it 'executes a prepared statement' do
-      result = statement.execute('system')
+      result = statement.execute('sue')
       result.should have(1).item
-      result = statement.execute('system', :one)
+      result = statement.execute('sue', :one)
       result.should have(1).item
     end
+
+    it 'executes a prepared statement with no bound values' do
+      statement = client.prepare('SELECT * FROM users')
+      result = statement.execute(:one)
+      result.should_not be_empty
+    end
+
+    it 'executes a batch' do
+      statement = client.prepare('UPDATE users SET first = ?, last = ?, age = ? WHERE user_id = ?')
+      statement.batch do |batch|
+        batch.add('Sam', 'Miller', 23, 'sam')
+        batch.add('Kim', 'Jones', 62, 'kim')
+      end
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'kim'))
+      result.first['last'].should == 'Jones'
+    end
+
+    it 'executes a counter batch' do
+      statement = client.prepare('UPDATE counters SET count = count + ? WHERE id = ?')
+      batch = statement.batch(:counter, consistency: :quorum)
+      batch.add(5, 'foo')
+      batch.add(3, 'bar')
+      batch.add(6, 'foo')
+      batch.execute
+      result = client.execute('SELECT * FROM counters')
+      counters = result.each_with_object({}) { |row, acc| acc[row['id']] = row['count'] }
+      counters.should eql('foo' => 11, 'bar' => 3)
+    end
   end
 
   context 'with multiple connections' do
@@ -113,41 +157,88 @@ describe 'A CQL client' do
       double(:client, connect: nil, close: nil)
     end
 
-    let :authentication_enabled do
-      begin
-        Cql::Client.connect(connection_options.merge(credentials: nil))
-        false
-      rescue Cql::AuthenticationError
-        true
+    context 'and protocol v1' do
+      let :authentication_enabled do
+        begin
+          Cql::Client.connect(connection_options.merge(credentials: nil, protocol_version: 1))
+          false
+        rescue Cql::AuthenticationError
+          true
+        end
       end
-    end
 
-    it 'sends credentials given in :credentials' do
-      client = Cql::Client.connect(connection_options.merge(credentials: {username: 'cassandra', password: 'cassandra'}))
-      client.execute('SELECT * FROM system.schema_keyspaces')
-    end
+      let :credentials do
+        {:username => 'cassandra', :password => 'cassandra'}
+      end
+
+      it 'authenticates using the credentials given in the :credentials option' do
+        client = Cql::Client.connect(connection_options.merge(credentials: credentials, protocol_version: 1))
+        client.execute('SELECT * FROM system.schema_keyspaces')
+      end
 
-    it 'raises an error when no credentials have been given' do
-      pending('authentication not configured', unless: authentication_enabled) do
-        expect { Cql::Client.connect(connection_options.merge(credentials: nil)) }.to raise_error(Cql::AuthenticationError)
+      it 'raises an error when no credentials have been given' do
+        pending('authentication not configured', unless: authentication_enabled) do
+          expect { Cql::Client.connect(connection_options.merge(credentials: nil, protocol_version: 1)) }.to raise_error(Cql::AuthenticationError)
+        end
+      end
+
+      it 'raises an error when the credentials are bad' do
+        pending('authentication not configured', unless: authentication_enabled) do
+          expect {
+            Cql::Client.connect(connection_options.merge(credentials: {:username => 'foo', :password => 'bar'}, protocol_version: 1))
+          }.to raise_error(Cql::AuthenticationError)
+        end
+      end
+
+      it 'raises an error when only an auth provider has been given' do
+        pending('authentication not configured', unless: authentication_enabled) do
+          auth_provider = Cql::Client::PlainTextAuthProvider.new('cassandra', 'cassandra')
+          expect { Cql::Client.connect(connection_options.merge(credentials: nil, auth_provider: auth_provider, protocol_version: 1)) }.to raise_error(Cql::AuthenticationError)
+        end
       end
     end
 
-    it 'raises an error when the credentials are bad' do
-      pending('authentication not configured', unless: authentication_enabled) do
-        expect {
-          Cql::Client.connect(connection_options.merge(credentials: {username: 'foo', password: 'bar'}))
-        }.to raise_error(Cql::AuthenticationError)
+    context 'and protocol v2' do
+      let :authentication_enabled do
+        begin
+          Cql::Client.connect(connection_options.merge(auth_provider: nil, credentials: nil))
+          false
+        rescue Cql::AuthenticationError
+          true
+        end
+      end
+
+      it 'uses the auth provider given in the :auth_provider option' do
+        auth_provider = Cql::Client::PlainTextAuthProvider.new('cassandra', 'cassandra')
+        client = Cql::Client.connect(connection_options.merge(auth_provider: auth_provider, credentials: nil))
+        client.execute('SELECT * FROM system.schema_keyspaces')
+      end
+
+      it 'falls back on creating a PlainTextAuthProvider using the credentials given in the :credentials option' do
+        client = Cql::Client.connect(connection_options.merge(auth_provider: nil, credentials: {:username => 'cassandra', :password => 'cassandra'}))
+        client.execute('SELECT * FROM system.schema_keyspaces')
+      end
+
+      it 'raises an error when no auth provider or credentials have been given' do
+        pending('authentication not configured', unless: authentication_enabled) do
+          expect { Cql::Client.connect(connection_options.merge(auth_provider: nil, credentials: nil)) }.to raise_error(Cql::AuthenticationError)
+        end
+      end
+
+      it 'raises an error when the credentials are bad' do
+        pending('authentication not configured', unless: authentication_enabled) do
+          expect {
+            auth_provider = Cql::Client::PlainTextAuthProvider.new('foo', 'bar')
+            Cql::Client.connect(connection_options.merge(auth_provider: auth_provider, credentials: nil))
+          }.to raise_error(Cql::AuthenticationError)
+        end
       end
     end
   end
 
   context 'with tracing' do
     before do
-      client.execute(%(DROP KEYSPACE cql_rb_client_spec)) rescue nil
-      client.execute(%(CREATE KEYSPACE cql_rb_client_spec WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1}))
-      client.use('cql_rb_client_spec')
-      client.execute(%(CREATE TABLE users (user_id VARCHAR PRIMARY KEY, first VARCHAR, last VARCHAR, age INT)))
+      create_keyspace_and_table
     end
 
     it 'requests tracing and returns the trace ID, for row returning operations' do
@@ -187,6 +278,138 @@ describe 'A CQL client' do
     end
   end
 
+  context 'with on-the-fly bound variables' do
+    before do
+      create_keyspace_and_table
+    end
+
+    it 'executes a query and sends the values separately' do
+      result = client.execute(%<INSERT INTO users (user_id, first, last) VALUES (?, ?, ?)>, 'sue', 'Sue', 'Smith')
+      result.should be_empty
+    end
+
+    it 'encodes the values using the provided type hints' do
+      result = client.execute(%<INSERT INTO users (user_id, first, last, age) VALUES (?, ?, ?, ?)>, 'sue', 'Sue', 'Smith', 35, type_hints: [nil, nil, nil, :int])
+      result.should be_empty
+    end
+  end
+
+  context 'when batching operations' do
+    before do
+      create_keyspace_and_table
+    end
+
+    it 'sends the operations as a single request' do
+      batch = client.batch
+      batch.add(%(UPDATE users SET last = 'Smith' WHERE user_id = 'smith'))
+      batch.add(%(UPDATE users SET last = 'Jones' WHERE user_id = 'jones'))
+      batch.execute
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'jones'))
+      result.first.should include('last' => 'Jones')
+    end
+
+    it 'accepts prepared statements' do
+      prepared_statement = client.prepare(%(UPDATE users SET last = ? WHERE user_id = ?))
+      batch = client.batch
+      batch.add(prepared_statement, 'Smith', 'smith')
+      batch.add(prepared_statement, 'Jones', 'jones')
+      batch.execute
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'jones'))
+      result.first.should include('last' => 'Jones')
+    end
+
+    it 'accepts a mix of prepared, regular and statements with on-the-fly bound variables' do
+      prepared_statement = client.prepare(%(UPDATE users SET last = ? WHERE user_id = ?))
+      batch = client.batch
+      batch.add(prepared_statement, 'Smith', 'smith')
+      batch.add(%(UPDATE users SET last = 'Jones' WHERE user_id = 'jones'))
+      batch.add(%(UPDATE users SET last = ?, age = ? WHERE user_id = ?), 'Taylor', 53, 'taylor', type_hints: [nil, :int, nil])
+      batch.execute
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'jones'))
+      result.first.should include('last' => 'Jones')
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'taylor'))
+      result.first.should include('last' => 'Taylor')
+    end
+
+    it 'yields the batch to a block and executes it afterwards' do
+      client.batch do |batch|
+        batch.add(%(UPDATE users SET last = 'Jones' WHERE user_id = 'jones'))
+      end
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'jones'))
+      result.first.should include('last' => 'Jones')
+    end
+
+    it 'can be used for counter increments' do
+      client.batch(:counter) do |batch|
+        batch.add(%(UPDATE counters SET count = count + 1 WHERE id = 'foo'))
+        batch.add(%(UPDATE counters SET count = count + 2 WHERE id = 'bar'))
+        batch.add(%(UPDATE counters SET count = count + 3 WHERE id = 'baz'))
+      end
+      result = client.execute('SELECT * FROM counters')
+      counters = result.each_with_object({}) { |row, acc| acc[row['id']] = row['count'] }
+      counters.should eql('foo' => 1, 'bar' => 2, 'baz' => 3)
+    end
+
+    it 'can be unlogged' do
+      client.batch(:unlogged) do |batch|
+        batch.add(%(UPDATE users SET last = 'Jones' WHERE user_id = 'jones'))
+      end
+      result = client.execute(%(SELECT * FROM users WHERE user_id = 'jones'))
+      result.first.should include('last' => 'Jones')
+    end
+
+    it 'can be traced' do
+      batch = client.batch(:unlogged)
+      batch.add(%(UPDATE users SET last = 'Jones' WHERE user_id = 'jones'))
+      result = batch.execute(trace: true)
+      result.trace_id.should_not be_nil
+      result = client.batch(:unlogged, trace: true) do |batch|
+        batch.add(%(UPDATE users SET last = 'Jones' WHERE user_id = 'jones'))
+      end
+      result.trace_id.should_not be_nil
+    end
+  end
+
+  context 'when paging large result sets' do
+    let :row_count do
+      200
+    end
+
+    before do
+      create_keyspace_and_table
+      statement = client.prepare('UPDATE counters SET count = count + ? WHERE id = ?')
+      ids = Set.new
+      ids << rand(234234).to_s(36) until ids.size == row_count
+      ids = ids.to_a
+      client.batch(:counter) do |batch|
+        row_count.times do |i|
+          batch.add(statement, rand(234), ids[i])
+        end
+      end
+    end
+
+    it 'returns the first page, and a way to retrieve the next when using #execute' do
+      page_size = row_count/2 + 10
+      result_page = client.execute('SELECT * FROM counters', page_size: page_size)
+      result_page.count.should == page_size
+      result_page.should_not be_last_page
+      result_page = result_page.next_page
+      result_page.count.should == row_count - page_size
+      result_page.should be_last_page
+    end
+
+    it 'returns the first page, and a way to retrieve the next when using a prepared statement' do
+      page_size = row_count/2 + 10
+      statement = client.prepare('SELECT * FROM counters')
+      result_page = statement.execute(page_size: page_size)
+      result_page.count.should == page_size
+      result_page.should_not be_last_page
+      result_page = result_page.next_page
+      result_page.count.should == row_count - page_size
+      result_page.should be_last_page
+    end
+  end
+
   context 'with error conditions' do
     it 'raises an error for CQL syntax errors' do
       expect { client.execute('BAD cql') }.to raise_error(Cql::CqlError)