cql-rb 1.2.2 → 2.0.0.pre0

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

@@ -0,0 +1,31 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe AuthSuccessResponse do
+      describe '.decode!' do
+        it 'decodes the token' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x0cbingbongpong")
+          response = described_class.decode!(1, buffer, buffer.length)
+          response.token.should == 'bingbongpong'
+        end
+
+        it 'decodes a nil token' do
+          buffer = ByteBuffer.new("\xff\xff\xff\xff")
+          response = described_class.decode!(1, buffer, buffer.length)
+          response.token.should be_nil
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns a string with number of bytes in the token' do
+          response = described_class.new('bingbongpong')
+          response.to_s.should == 'AUTH_SUCCESS 12'
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,8 @@ module Cql
     describe AuthenticateResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\x2forg.apache.cassandra.auth.PasswordAuthenticator"))
+          buffer = ByteBuffer.new("\x00\x2forg.apache.cassandra.auth.PasswordAuthenticator")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the authentication class' do

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

@@ -8,7 +8,8 @@ module Cql
     describe DetailedErrorResponse do
       describe '.decode!' do
         it 'decodes an unavailable error' do
-          response = described_class.decode!(0x1000, '', ByteBuffer.new("\x00\x05\x00\x00\x00\x03\x00\x00\x00\x02"))
+          buffer = ByteBuffer.new("\x00\x05\x00\x00\x00\x03\x00\x00\x00\x02")
+          response = described_class.decode!(0x1000, '', 1, buffer, buffer.length)
           response.details.should == {
             :cl => :all,
             :required => 3,
@@ -17,7 +18,8 @@ module Cql
         end
 
         it 'decodes a write_timeout error' do
-          response = described_class.decode!(0x1100, '', ByteBuffer.new("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\tBATCH_LOG"))
+          buffer = ByteBuffer.new("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\tBATCH_LOG")
+          response = described_class.decode!(0x1100, '', 1, buffer, buffer.length)
           response.details.should == {
             :cl => :one,
             :received => 0,
@@ -27,14 +29,16 @@ module Cql
         end
 
         it 'decodes a read_timeout error' do
-          response = described_class.decode!(0x1200, '', ByteBuffer.new("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x01"))
+          buffer = ByteBuffer.new("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x01")
+          response = described_class.decode!(0x1200, '', 1, buffer, buffer.length)
           response.details.should == {
             :cl => :one,
             :received => 0,
             :blockfor => 1,
             :data_present => true
           }
-          response = described_class.decode!(0x1200, '', ByteBuffer.new("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00"))
+          buffer = ByteBuffer.new("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00")
+          response = described_class.decode!(0x1200, '', 1, buffer, buffer.length)
           response.details.should == {
             :cl => :one,
             :received => 0,
@@ -44,7 +48,8 @@ module Cql
         end
 
         it 'decodes an already_exists error with a keyspace' do
-          response = described_class.decode!(0x2400, '', ByteBuffer.new("\x00\x05stuff\x00\x00"))
+          buffer = ByteBuffer.new("\x00\x05stuff\x00\x00")
+          response = described_class.decode!(0x2400, '', 1, buffer, buffer.length)
           response.details.should == {
             :ks => 'stuff',
             :table => '',
@@ -52,7 +57,8 @@ module Cql
         end
 
         it 'decodes an already_exists error with a keyspace and table' do
-          response = described_class.decode!(0x2400, '', ByteBuffer.new("\x00\x05stuff\x00\x06things"))
+          buffer = ByteBuffer.new("\x00\x05stuff\x00\x06things")
+          response = described_class.decode!(0x2400, '', 1, buffer, buffer.length)
           response.details.should == {
             :ks => 'stuff',
             :table => 'things',
@@ -60,7 +66,8 @@ module Cql
         end
 
         it 'decodes unprepared error' do
-          response = described_class.decode!(0x2500, '', ByteBuffer.new("\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"))
+          buffer = ByteBuffer.new("\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/")
+          response = described_class.decode!(0x2500, '', 1, buffer, buffer.length)
           response.details.should == {
             :id => "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
           }

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

@@ -8,7 +8,8 @@ module Cql
     describe ErrorResponse do
       describe '.decode!' do
         let :response do
-          described_class.decode!(ByteBuffer.new("\x00\x00\x00\n\x00PProvided version 4.0.0 is not supported by this server (supported: 2.0.0, 3.0.0)"))
+          buffer = ByteBuffer.new("\x00\x00\x00\n\x00PProvided version 4.0.0 is not supported by this server (supported: 2.0.0, 3.0.0)")
+          described_class.decode!(1, buffer, buffer.length)
         end
 
         it 'decodes the error code' do
@@ -20,7 +21,8 @@ module Cql
         end
 
         it 'decodes error frames with details' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x11\x00\x000Operation timed out - received only 0 responses.\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\tBATCH_LOG"))
+          buffer = ByteBuffer.new("\x00\x00\x11\x00\x000Operation timed out - received only 0 responses.\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\tBATCH_LOG")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.details.should_not be_nil
         end
       end

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

@@ -8,7 +8,8 @@ module Cql
     describe EventResponse do
       describe '.decode!' do
         it 'decodes a SCHEMA_CHANGE event' do
-          response = described_class.decode!(ByteBuffer.new("\x00\rSCHEMA_CHANGE\x00\aDROPPED\x00\ncql_rb_609\x00\x05users"))
+          buffer = ByteBuffer.new("\x00\rSCHEMA_CHANGE\x00\aDROPPED\x00\ncql_rb_609\x00\x05users")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.type.should == 'SCHEMA_CHANGE'
           response.change.should == 'DROPPED'
           response.keyspace.should == 'cql_rb_609'
@@ -16,7 +17,8 @@ module Cql
         end
 
         it 'decodes a STATUS_CHANGE event' do
-          response = described_class.decode!(ByteBuffer.new("\x00\rSTATUS_CHANGE\x00\x04DOWN\x04\x00\x00\x00\x00\x00\x00#R"))
+          buffer = ByteBuffer.new("\x00\rSTATUS_CHANGE\x00\x04DOWN\x04\x00\x00\x00\x00\x00\x00#R")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.type.should == 'STATUS_CHANGE'
           response.change.should == 'DOWN'
           response.address.should == IPAddr.new('0.0.0.0')
@@ -24,7 +26,8 @@ module Cql
         end
 
         it 'decodes a TOPOLOGY_CHANGE event' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x0FTOPOLOGY_CHANGE\x00\fREMOVED_NODE\x04\x00\x00\x00\x00\x00\x00#R"))
+          buffer = ByteBuffer.new("\x00\x0FTOPOLOGY_CHANGE\x00\fREMOVED_NODE\x04\x00\x00\x00\x00\x00\x00#R")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.type.should == 'TOPOLOGY_CHANGE'
           response.change.should == 'REMOVED_NODE'
           response.address.should == IPAddr.new('0.0.0.0')
@@ -32,7 +35,7 @@ module Cql
         end
 
         it 'complains when asked to decode an unknown event type' do
-          expect { described_class.decode!(ByteBuffer.new("\x00\x04PING")) }.to raise_error(UnsupportedEventTypeError, /PING/)
+          expect { described_class.decode!(1, ByteBuffer.new("\x00\x04PING"), 6) }.to raise_error(UnsupportedEventTypeError, /PING/)
         end
       end
     end

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

@@ -7,99 +7,154 @@ module Cql
   module Protocol
     describe PreparedResultResponse do
       describe '.decode!' do
-        let :response do
-          described_class.decode!(ByteBuffer.new("\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/\x00\x00\x00\x01\x00\x00\x00\x01\x00\ncql_rb_911\x00\x05users\x00\tuser_name\x00\r"))
-        end
-
-        it 'decodes the ID' do
-          response.id.should == "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
-        end
-
-        it 'decodes the column metadata' do
-          response.metadata.should == [['cql_rb_911', 'users', 'user_name', :varchar]]
+        context 'with a protocol v1 frame' do
+          let :response do
+            buffer = ByteBuffer.new
+            buffer << "\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/" # statement ID
+            buffer << "\x00\x00\x00\x01" # flags (global_tables_spec)
+            buffer << "\x00\x00\x00\x01" # column count
+            buffer << "\x00\ncql_rb_911\x00\x05users" # global_tables_spec
+            buffer << "\x00\tuser_name\x00\r" # col_spec (name + type)
+            described_class.decode!(1, buffer, buffer.length)
+          end
+
+          it 'decodes the ID' do
+            response.id.should == "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
+          end
+
+          it 'decodes the column metadata' do
+            response.metadata.should == [['cql_rb_911', 'users', 'user_name', :varchar]]
+          end
+        end
+
+        context 'with a protocol v2 frame' do
+          let :response do
+            buffer = ByteBuffer.new
+            buffer << "\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/" # statement ID
+            buffer << "\x00\x00\x00\x01" # flags (global_tables_spec)
+            buffer << "\x00\x00\x00\x01" # column count
+            buffer << "\x00\ncql_rb_911\x00\x05users" # global_tables_spec
+            buffer << "\x00\tuser_name\x00\r" # col_spec (name + type)
+            buffer << "\x00\x00\x00\x01" # flags (global_tables_spec)
+            buffer << "\x00\x00\x00\x02" # column count
+            buffer << "\x00\ncql_rb_911\x00\x05users" # global_tables_spec
+            buffer << "\x00\tuser_name\x00\r" # col_spec (name + type)
+            buffer << "\x00\x05email\x00\r" # col_spec (name + type)
+            described_class.decode!(2, buffer, buffer.length)
+          end
+
+          it 'decodes the ID' do
+            response.id.should == "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
+          end
+
+          it 'decodes the column metadata' do
+            response.metadata.should == [
+              ['cql_rb_911', 'users', 'user_name', :varchar]
+            ]
+          end
+
+          it 'decodes the result metadata' do
+            response.result_metadata.should == [
+              ['cql_rb_911', 'users', 'user_name', :varchar],
+              ['cql_rb_911', 'users', 'email', :varchar]
+            ]
+          end
+
+          it 'decodes the absence of result metadata' do
+            buffer = ByteBuffer.new
+            buffer << "\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/" # statement ID
+            buffer << "\x00\x00\x00\x01" # flags (global_tables_spec)
+            buffer << "\x00\x00\x00\x01" # column count
+            buffer << "\x00\ncql_rb_911\x00\x05users" # global_tables_spec
+            buffer << "\x00\tuser_name\x00\r" # col_spec (name + type)
+            buffer << "\x00\x00\x00\x04" # flags (no_metadata)
+            buffer << "\x00\x00\x00\x00" # column count
+            response = described_class.decode!(2, buffer, buffer.length)
+            response.result_metadata.should be_nil
+          end
         end
       end
 
       describe '#void?' do
         it 'is not void' do
-          response = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
+          response = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           response.should_not be_void
         end
       end
 
       describe '#to_s' do
         it 'returns a string with the ID and metadata' do
-          response = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\x00/", [['ks', 'tbl', 'col', :varchar]], nil)
+          response = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\x00/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           response.to_s.should match(/^RESULT PREPARED [0-9a-f]{32} \[\["ks", "tbl", "col", :varchar\]\]$/)
         end
       end
 
       describe '#eql?' do
         it 'is equal to an identical response' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.should eql(r2)
         end
 
         it 'is not equal when the IDs differ' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\x00" * 16, [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\x00" * 16, [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.should_not eql(r2)
         end
 
         it 'is not equal when the metadata differ' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar], ['ks', 'tbl', 'col2', :uuid]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar], ['ks', 'tbl', 'col2', :uuid]], nil, nil)
           r1.should_not eql(r2)
         end
 
         it 'is not equal when one has a trace ID' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.should_not eql(r2)
         end
 
         it 'is not equal when the trace IDs differ' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], Uuid.new('11111111-d0e1-11e2-8b8b-0800200c9a66'))
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, Uuid.new('11111111-d0e1-11e2-8b8b-0800200c9a66'))
           r1.should_not eql(r2)
         end
 
         it 'is aliased as ==' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.should == r2
         end
       end
 
       describe '#hash' do
         it 'is the same for an identical response' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.hash.should == r2.hash
         end
 
         it 'is not the same when the IDs differ' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\x00" * 16, [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\x00" * 16, [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.hash.should_not == r2.hash
         end
 
         it 'is not the same when the metadata differ' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar], ['ks', 'tbl', 'col2', :uuid]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar], ['ks', 'tbl', 'col2', :uuid]], nil, nil)
           r1.hash.should_not == r2.hash
         end
 
         it 'is not the same when one has a trace ID' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil)
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, nil)
           r1.hash.should_not == r2.hash
         end
 
         it 'is not equal when the trace IDs differ' do
-          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
-          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], Uuid.new('11111111-d0e1-11e2-8b8b-0800200c9a66'))
+          r1 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'))
+          r2 = described_class.new("\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/", [['ks', 'tbl', 'col', :varchar]], nil, Uuid.new('11111111-d0e1-11e2-8b8b-0800200c9a66'))
           r1.hash.should_not == r2.hash
         end
       end

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

@@ -0,0 +1,66 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe RawRowsResultResponse do
+      let :response do
+        described_class.new(2, raw_rows, nil, nil)
+      end
+
+      let :raw_rows do
+        ByteBuffer.new("\x00\x00\x00\x02\x00\x00\x00\x04phil\x00\x00\x00\x0dphil@heck.com\xff\xff\xff\xff\x00\x00\x00\x03sue\x00\x00\x00\x0dsue@inter.net\xff\xff\xff\xff")
+      end
+
+      let :metadata do
+        [
+          ['ks', 'users', 'user_name', :varchar],
+          ['ks', 'users', 'email', :varchar],
+          ['ks', 'users', 'password', :varchar],
+        ]
+      end
+
+      describe '#materialize' do
+        it 'decodes the rows using the given metadata' do
+          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
+
+        it 'returns the rows' do
+          rows = response.materialize(metadata)
+          rows.should == [
+            {'user_name' => 'phil', 'email' => 'phil@heck.com', 'password' => nil},
+            {'user_name' => 'sue', 'email' => 'sue@inter.net', 'password' => nil},
+          ]
+        end
+      end
+
+      describe '#rows' do
+        it 'raises an error before #materialize has been called' do
+          expect { response.rows }.to raise_error(UnmaterializedRowsError)
+          response.materialize(metadata)
+          response.rows
+        end
+      end
+
+      describe '#metadata' do
+        it 'returns nil before #materialize has been called' do
+          response.metadata.should be_nil
+          response.materialize(metadata)
+          response.metadata.should == metadata
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns a static string' do
+          response.to_s.should == 'RESULT ROWS (raw)'
+        end
+      end
+    end
+  end
+end

data/spec/cql/protocol/responses/ready_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/responses/result_response_spec.rb

@@ -8,13 +8,15 @@ module Cql
     describe ResultResponse do
       describe '.decode!' do
         it 'decodes a set_keyspace result' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x03\x00\x06system"))
+          buffer = ByteBuffer.new("\x00\x00\x00\x03\x00\x06system")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.should_not be_void
           response.keyspace.should == 'system'
         end
 
         it 'decodes a schema_change CREATED result' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x05\x00\aCREATED\x00\ncql_rb_477\x00\x00"))
+          buffer = ByteBuffer.new("\x00\x00\x00\x05\x00\aCREATED\x00\ncql_rb_477\x00\x00")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.should_not be_void
           response.change.should == 'CREATED'
           response.keyspace.should == 'cql_rb_477'
@@ -22,7 +24,8 @@ module Cql
         end
 
         it 'decodes a schema_change UPDATED result' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x05\x00\aUPDATED\x00\ncql_rb_973\x00\x05users"))
+          buffer = ByteBuffer.new("\x00\x00\x00\x05\x00\aUPDATED\x00\ncql_rb_973\x00\x05users")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.should_not be_void
           response.change.should == 'UPDATED'
           response.keyspace.should == 'cql_rb_973'
@@ -30,26 +33,35 @@ module Cql
         end
 
         it 'decodes a void result' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x01"))
+          buffer = ByteBuffer.new("\x00\x00\x00\x01")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.should be_void
         end
 
         it 'decodes a rows result' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x02\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\x02\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")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.should_not be_void
           response.rows.size.should == 2
           response.metadata.size.should == 3
         end
 
+        it 'decodes a rows result' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x03\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")
+          response = described_class.decode!(1, buffer, buffer.length)
+          response.should_not be_void
+        end
+
         it 'decodes a prepared result' do
-          response = described_class.decode!(ByteBuffer.new("\x00\x00\x00\x04\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/\x00\x00\x00\x01\x00\x00\x00\x01\x00\ncql_rb_911\x00\x05users\x00\tuser_name\x00\r"))
+          buffer = ByteBuffer.new("\x00\x00\x00\x04\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/\x00\x00\x00\x01\x00\x00\x00\x01\x00\ncql_rb_911\x00\x05users\x00\tuser_name\x00\r")
+          response = described_class.decode!(1, buffer, buffer.length)
           response.should_not be_void
           response.id.should == "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
           response.metadata.size.should == 1
         end
 
         it 'complains when asked to decode an unknown result type' do
-          expect { described_class.decode!(ByteBuffer.new("\x00\x00\x00\xffhello")) }.to raise_error(UnsupportedResultKindError)
+          expect { described_class.decode!(1, ByteBuffer.new("\x00\x00\x00\xffhello"), 9) }.to raise_error(UnsupportedResultKindError)
         end
       end
     end