cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -23,7 +23,7 @@ module Cql
       end
 
       let :buffer do
-        ByteBuffer.new
+        CqlByteBuffer.new
       end
 
       before do

data/spec/cql/protocol/frame_decoder_spec.rb

@@ -13,21 +13,21 @@ module Cql
       describe '#decode_frame' do
         context 'with an uncompressed frame' do
           it 'returns a partial frame when not all the frame\'s bytes are in the buffer' do
-            frame = decoder.decode_frame(ByteBuffer.new)
+            frame = decoder.decode_frame(CqlByteBuffer.new)
             frame.should_not be_complete
-            frame = decoder.decode_frame(ByteBuffer.new("\x81\x00\x00\x02\x00\x00\x00\x16"))
+            frame = decoder.decode_frame(CqlByteBuffer.new("\x81\x00\x00\x02\x00\x00\x00\x16"))
             frame.should_not be_complete
-            frame = decoder.decode_frame(ByteBuffer.new("\x81\x00\x00\x02\x00\x00\x00\x16\x01\x23\x45"))
+            frame = decoder.decode_frame(CqlByteBuffer.new("\x81\x00\x00\x02\x00\x00\x00\x16\x01\x23\x45"))
             frame.should_not be_complete
           end
 
           it 'returns a partial frame less than eight bytes are missing' do
-            frame = decoder.decode_frame(ByteBuffer.new("\x81\x02\x00\x08\x00\x00\x00\x14\a\xE4\xBE\x10?\x03\x11\xE3\x951\xFBr\xEF\xF0_\xBB\x00\x00"))
+            frame = decoder.decode_frame(CqlByteBuffer.new("\x81\x02\x00\x08\x00\x00\x00\x14\a\xE4\xBE\x10?\x03\x11\xE3\x951\xFBr\xEF\xF0_\xBB\x00\x00"))
             frame.should_not be_complete
           end
 
           it 'returns a complete frame when all bytes are in the buffer' do
-            buffer = ByteBuffer.new
+            buffer = CqlByteBuffer.new
             buffer << "\x81\x00\x00\x06\x00\x00\x00\x27"
             buffer << "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00"
             frame = decoder.decode_frame(buffer)
@@ -36,19 +36,19 @@ module Cql
           end
 
           it 'returns the stream ID' do
-            buffer = ByteBuffer.new("\x81\x00\x03\x02\x00\x00\x00\x00")
+            buffer = CqlByteBuffer.new("\x81\x00\x03\x02\x00\x00\x00\x00")
             frame = decoder.decode_frame(buffer)
             frame.stream_id.should == 3
           end
 
           it 'returns the stream ID when it is negative' do
-            buffer = ByteBuffer.new("\x81\x00\xff\x02\x00\x00\x00\x00")
+            buffer = CqlByteBuffer.new("\x81\x00\xff\x02\x00\x00\x00\x00")
             frame = decoder.decode_frame(buffer)
             frame.stream_id.should == -1
           end
 
           it 'first returns a partial frame, then a complete frame' do
-            buffer = ByteBuffer.new
+            buffer = CqlByteBuffer.new
             buffer << "\x81\x00\x00\x06\x00\x00\x00\x27"
             frame = decoder.decode_frame(buffer)
             buffer << "\x00\x02\x00\x0bCQL_VERSION"
@@ -59,7 +59,7 @@ module Cql
           end
 
           it 'leaves extra bytes in the buffer' do
-            buffer = ByteBuffer.new
+            buffer = CqlByteBuffer.new
             buffer << "\x81\x00\x00\x06\x00\x00\x00\x27"
             buffer << "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00\xca\xfe"
             frame = decoder.decode_frame(buffer)
@@ -68,7 +68,7 @@ module Cql
           end
 
           it 'consumes the number of bytes specified in the frame header' do
-            buffer = ByteBuffer.new
+            buffer = CqlByteBuffer.new
             buffer << "\x81\x00\x00\x06\x00\x00\x00\x29"
             buffer << "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00\xca\xfe"
             frame = decoder.decode_frame(buffer)
@@ -77,18 +77,18 @@ module Cql
           end
 
           it 'extracts a trace ID' do
-            buffer = ByteBuffer.new
+            buffer = CqlByteBuffer.new
             buffer << "\x81\x02\x00\x08\x00\x00\x00\x14\a\xE4\xBE\x10?\x03\x11\xE3\x951\xFBr\xEF\xF0_\xBB\x00\x00\x00\x01"
             frame = decoder.decode_frame(buffer)
             frame.body.trace_id.should == Uuid.new('07e4be10-3f03-11e3-9531-fb72eff05fbb')
           end
 
           it 'complains when the frame is a request frame' do
-            expect { decoder.decode_frame(ByteBuffer.new("\x01\x00\x00\x05\x00\x00\x00\x00")) }.to raise_error(UnsupportedFrameTypeError)
+            expect { decoder.decode_frame(CqlByteBuffer.new("\x01\x00\x00\x05\x00\x00\x00\x00")) }.to raise_error(UnsupportedFrameTypeError)
           end
 
           it 'complains when the opcode is unknown' do
-            expect { decoder.decode_frame(ByteBuffer.new("\x81\x00\x00\xff\x00\x00\x00\x00")) }.to raise_error(UnsupportedOperationError)
+            expect { decoder.decode_frame(CqlByteBuffer.new("\x81\x00\x00\xff\x00\x00\x00\x00")) }.to raise_error(UnsupportedOperationError)
           end
         end
 
@@ -102,7 +102,7 @@ module Cql
           end
 
           let :buffer do
-            ByteBuffer.new("\x81\x01\x00\x06\x00\x00\x00\x12FAKECOMPRESSEDBODY")
+            CqlByteBuffer.new("\x81\x01\x00\x06\x00\x00\x00\x12FAKECOMPRESSEDBODY")
           end
 
           before do

data/spec/cql/protocol/frame_encoder_spec.rb

@@ -24,11 +24,11 @@ module Cql
         it 'asks the request to write itself to a buffer' do
           encoder = described_class.new(1)
           encoder.encode_frame(request)
-          request.should have_received(:write).with(anything, an_instance_of(ByteBuffer))
+          request.should have_received(:write).with(anything, an_instance_of(CqlByteBuffer))
         end
 
         it 'appends what the request wrote to the specified buffer, after a header' do
-          buffer = ByteBuffer.new('hello')
+          buffer = CqlByteBuffer.new('hello')
           request.stub(:write) { |pv, bb| bb << "\x01\x02\x03" }
           encoder = described_class.new(1)
           encoder.encode_frame(request, 0, buffer)
@@ -37,7 +37,7 @@ module Cql
         end
 
         it 'returns the specified buffer' do
-          buffer = ByteBuffer.new('hello')
+          buffer = CqlByteBuffer.new('hello')
           encoder = described_class.new(1)
           returned_buffer = encoder.encode_frame(request, 0, buffer)
           returned_buffer.should equal(buffer)
@@ -81,7 +81,7 @@ module Cql
         end
 
         it 'encodes the body size' do
-          request.stub(:write).and_return(ByteBuffer.new('helloworld'))
+          request.stub(:write).and_return(CqlByteBuffer.new('helloworld'))
           encoder = described_class.new(1)
           buffer = encoder.encode_frame(request, 9)
           buffer.to_s[4, 4].should == "\x00\x00\x00\x0a"
@@ -90,7 +90,7 @@ module Cql
         context 'when a compressor has been specified' do
           before do
             request.stub(:compressable?).and_return(true)
-            request.stub(:write).and_return(ByteBuffer.new('helloworld'))
+            request.stub(:write).and_return(CqlByteBuffer.new('helloworld'))
             compressor.stub(:compress?).and_return(true)
             compressor.stub(:compress).with('helloworld').and_return('COMPRESSEDFRAME')
           end
@@ -136,14 +136,14 @@ module Cql
         end
 
         it 'changes the stream ID byte' do
-          buffer = ByteBuffer.new("\x01\x00\x03\x02\x00\x00\x00\x00")
+          buffer = CqlByteBuffer.new("\x01\x00\x03\x02\x00\x00\x00\x00")
           encoder.change_stream_id(99, buffer)
           buffer.discard(2)
           buffer.read_byte.should == 99
         end
 
         it 'changes the stream ID byte of the frame starting at the specified offset' do
-          buffer = ByteBuffer.new("hello foo\x01\x00\x03\x02\x00\x00\x00\x00")
+          buffer = CqlByteBuffer.new("hello foo\x01\x00\x03\x02\x00\x00\x00\x00")
           encoder.change_stream_id(99, buffer, 9)
           buffer.discard(11)
           buffer.read_byte.should == 99

data/spec/cql/protocol/requests/auth_response_request_spec.rb

@@ -8,13 +8,13 @@ module Cql
     describe AuthResponseRequest do
       describe '#write' do
         it 'encodes an AUTH_RESPONSE request frame' do
-          bytes = described_class.new('bingbongpong').write(2, '')
-          bytes.should == "\x00\x00\x00\x0cbingbongpong"
+          bytes = described_class.new('bingbongpong').write(2, CqlByteBuffer.new)
+          bytes.should eql_bytes("\x00\x00\x00\x0cbingbongpong")
         end
 
         it 'encodes a nil token' do
-          bytes = described_class.new(nil).write(2, '')
-          bytes.should == "\xff\xff\xff\xff"
+          bytes = described_class.new(nil).write(2, CqlByteBuffer.new)
+          bytes.should eql_bytes("\xff\xff\xff\xff")
         end
       end
 

data/spec/cql/protocol/requests/batch_request_spec.rb

@@ -18,8 +18,8 @@ module Cql
         it 'encodes a BATCH request frame with a single prepared query' do
           batch = described_class.new(described_class::LOGGED_TYPE, :two)
           batch.add_prepared(statement_id, metadata, ['arg', 3])
-          bytes = batch.write(2, '')
-          bytes.should == (
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.should eql_bytes(
             "\x00" +
             "\x00\x01" +
             "\x01" +
@@ -32,8 +32,8 @@ module Cql
         it 'encodes a BATCH request frame with a single query' do
           batch = described_class.new(described_class::LOGGED_TYPE, :one)
           batch.add_query(%<INSERT INTO things (a, b) VALUES ('foo', 3)>)
-          bytes = batch.write(2, '')
-          bytes.should == (
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.should eql_bytes(
             "\x00" +
             "\x00\x01" +
             "\x00" +
@@ -46,8 +46,8 @@ module Cql
         it 'encodes a BATCH request frame with a single query with on-the-fly bound values' do
           batch = described_class.new(described_class::LOGGED_TYPE, :two)
           batch.add_query('INSERT INTO things (a, b) VALUES (?, ?)', ['foo', 5])
-          bytes = batch.write(2, '')
-          bytes.should == (
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.should eql_bytes(
             "\x00" +
             "\x00\x01" +
             "\x00" +
@@ -62,8 +62,8 @@ module Cql
           batch.add_prepared(statement_id, metadata, ['arg', 3])
           batch.add_query(%<INSERT INTO things (a, b) VALUES (?, ?)>, ['foo', 5])
           batch.add_query(%<INSERT INTO things (a, b) VALUES ('foo', 3)>)
-          bytes = batch.write(2, '')
-          bytes.should == (
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.should eql_bytes(
             "\x00" +
             "\x00\x03" +
             "\x01" +
@@ -82,22 +82,22 @@ module Cql
         it 'encodes the type when it is "logged"' do
           batch = described_class.new(described_class::LOGGED_TYPE, :two)
           batch.add_prepared(statement_id, metadata, ['arg', 3])
-          bytes = batch.write(2, '')
-          bytes[0].should == "\x00"
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.to_s[0].should == "\x00"
         end
 
         it 'encodes the type when it is "unlogged"' do
           batch = described_class.new(described_class::UNLOGGED_TYPE, :two)
           batch.add_prepared(statement_id, metadata, ['arg', 3])
-          bytes = batch.write(2, '')
-          bytes[0].should == "\x01"
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.to_s[0].should == "\x01"
         end
 
         it 'encodes the type when it is "counter"' do
           batch = described_class.new(described_class::COUNTER_TYPE, :two)
           batch.add_prepared(statement_id, metadata, ['arg', 3])
-          bytes = batch.write(2, '')
-          bytes[0].should == "\x02"
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.to_s[0].should == "\x02"
         end
 
         it 'encodes the number of statements in the batch' do
@@ -105,24 +105,24 @@ module Cql
           batch.add_prepared(statement_id, metadata, ['arg', 3])
           batch.add_prepared(statement_id, metadata, ['foo', 4])
           batch.add_prepared(statement_id, metadata, ['bar', 5])
-          bytes = batch.write(2, '')
-          bytes[1, 2].should == "\x00\x03"
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.to_s[1, 2].should == "\x00\x03"
         end
 
         it 'encodes the type of each statement' do
           batch = described_class.new(described_class::LOGGED_TYPE, :two)
           batch.add_prepared(statement_id, metadata, ['arg', 3])
           batch.add_query(%<INSERT INTO things (a, b) VALUES ('arg', 3)>)
-          bytes = batch.write(2, '')
-          bytes[3, 1].should == "\x01"
-          bytes[39, 1].should == "\x00"
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.to_s[3, 1].should == "\x01"
+          bytes.to_s[39, 1].should == "\x00"
         end
 
         it 'uses the type hints given to #add_query' do
           batch = described_class.new(described_class::LOGGED_TYPE, :two)
           batch.add_query(%<INSERT INTO things (a, b) VALUES (?, ?)>, ['foo', 3], [nil, :int])
-          bytes = batch.write(2, '')
-          bytes[56, 8].should == "\x00\x00\x00\x04\x00\x00\x00\x03"
+          bytes = batch.write(2, CqlByteBuffer.new)
+          bytes.to_s[56, 8].should == "\x00\x00\x00\x04\x00\x00\x00\x03"
         end
       end
 

data/spec/cql/protocol/requests/credentials_request_spec.rb

@@ -8,8 +8,8 @@ module Cql
     describe CredentialsRequest do
       describe '#write' do
         it 'encodes a CREDENTIALS request frame' do
-          bytes = CredentialsRequest.new('username' => 'cassandra', 'password' => 'ardnassac').write(1, '')
-          bytes.should == (
+          bytes = CredentialsRequest.new('username' => 'cassandra', 'password' => 'ardnassac').write(1, CqlByteBuffer.new)
+          bytes.should eql_bytes(
             "\x00\x02" +
             "\x00\x08username" +
             "\x00\x09cassandra" +

data/spec/cql/protocol/requests/execute_request_spec.rb

@@ -66,7 +66,7 @@ module Cql
       describe '#write' do
         context 'when the protocol version is 1' do
           let :frame_bytes do
-            ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :each_quorum, nil, nil, nil, false).write(1, '')
+            ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :each_quorum, nil, nil, nil, false).write(1, CqlByteBuffer.new)
           end
 
           it 'writes the statement ID' do
@@ -88,7 +88,7 @@ module Cql
 
         context 'when the protocol version is 2' do
           let :frame_bytes do
-            ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :each_quorum, nil, nil, nil, false).write(2, '')
+            ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :each_quorum, nil, nil, nil, false).write(2, CqlByteBuffer.new)
           end
 
           it 'writes the statement ID' do
@@ -104,12 +104,12 @@ module Cql
           end
 
           it 'does not write the bound values flag when there are no values, and does not write anything more' do
-            frame_bytes = ExecuteRequest.new(id, [], [], true, :each_quorum, nil, nil, nil, false).write(2, '')
+            frame_bytes = ExecuteRequest.new(id, [], [], true, :each_quorum, nil, nil, nil, false).write(2, CqlByteBuffer.new)
             frame_bytes.to_s[20, 999].should == "\x00"
           end
 
           it 'writes flags saying that the result doesn\'t need to contain metadata' do
-            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], false, :each_quorum, nil, nil, nil, false).write(2, '')
+            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], false, :each_quorum, nil, nil, nil, false).write(2, CqlByteBuffer.new)
             frame_bytes.to_s[20, 1].should == "\x03"
           end
 
@@ -122,22 +122,22 @@ module Cql
           end
 
           it 'sets the serial flag and includes the serial consistency' do
-            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], false, :each_quorum, :local_serial, false).write(2, '')
+            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], false, :each_quorum, :local_serial, false).write(2, CqlByteBuffer.new)
             frame_bytes.to_s[20, 1].should == "\x13"
             frame_bytes.to_s[47, 2].should == "\x00\x09"
           end
 
           it 'writes the page size flag and page size' do
-            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :one, nil, 10, nil, false).write(2, '')
-            (frame_bytes[20, 1].ord & 0x04).should == 0x04
-            frame_bytes[47, 4].should == "\x00\x00\x00\x0a"
+            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :one, nil, 10, nil, false).write(2, CqlByteBuffer.new)
+            (frame_bytes.to_s[20, 1].ord & 0x04).should == 0x04
+            frame_bytes.to_s[47, 4].should == "\x00\x00\x00\x0a"
           end
 
           it 'writes the page size and paging state flag and the page size and paging state' do
-            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :one, nil, 10, 'foobar', false).write(2, '')
-            (frame_bytes[20, 1].ord & 0x0c).should == 0x0c
-            frame_bytes[47, 4].should == "\x00\x00\x00\x0a"
-            frame_bytes[51, 10].should == "\x00\x00\x00\x06foobar"
+            frame_bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :one, nil, 10, 'foobar', false).write(2, CqlByteBuffer.new)
+            (frame_bytes.to_s[20, 1].ord & 0x0c).should == 0x0c
+            frame_bytes.to_s[47, 4].should == "\x00\x00\x00\x0a"
+            frame_bytes.to_s[51, 10].should == "\x00\x00\x00\x06foobar"
           end
         end
 
@@ -173,7 +173,7 @@ module Cql
           specs.each do |type, value, expected_bytes|
             it "encodes #{type} values" do
               metadata = [['ks', 'tbl', 'id_column', type]]
-              buffer = ExecuteRequest.new(id, metadata, [value], true, :one, nil, nil, nil, false).write(1, ByteBuffer.new)
+              buffer = ExecuteRequest.new(id, metadata, [value], true, :one, nil, nil, nil, false).write(1, CqlByteBuffer.new)
               buffer.discard(2 + 16 + 2)
               length = buffer.read_int
               result_bytes = buffer.read(length)

data/spec/cql/protocol/requests/options_request_spec.rb

@@ -14,7 +14,7 @@ module Cql
 
       describe '#write' do
         it 'encodes an OPTIONS request frame (i.e. an empty body)' do
-          bytes = OptionsRequest.new.write(1, '')
+          bytes = OptionsRequest.new.write(1, CqlByteBuffer.new)
           bytes.should be_empty
         end
       end

data/spec/cql/protocol/requests/prepare_request_spec.rb

@@ -14,8 +14,8 @@ module Cql
 
       describe '#write' do
         it 'encodes a PREPARE request frame' do
-          bytes = PrepareRequest.new('UPDATE users SET email = ? WHERE user_name = ?').write(1, '')
-          bytes.should == "\x00\x00\x00\x2eUPDATE users SET email = ? WHERE user_name = ?"
+          bytes = PrepareRequest.new('UPDATE users SET email = ? WHERE user_name = ?').write(1, CqlByteBuffer.new)
+          bytes.should eql_bytes("\x00\x00\x00\x2eUPDATE users SET email = ? WHERE user_name = ?")
         end
       end
 

data/spec/cql/protocol/requests/query_request_spec.rb

@@ -35,7 +35,7 @@ module Cql
       describe '#write' do
         context 'when the protocol version is 1' do
           let :frame_bytes do
-            QueryRequest.new('USE system', [], [], :all, nil, nil, nil, false).write(1, '')
+            QueryRequest.new('USE system', [], [], :all, nil, nil, nil, false).write(1, CqlByteBuffer.new)
           end
 
           it 'encodes the CQL' do
@@ -50,7 +50,7 @@ module Cql
         context 'when the protocol version is 2' do
           context 'and there are no bound values' do
             let :frame_bytes do
-              QueryRequest.new('USE system', [], [], :all, nil, nil, nil, false).write(2, '')
+              QueryRequest.new('USE system', [], [], :all, nil, nil, nil, false).write(2, CqlByteBuffer.new)
             end
 
             it 'encodes the CQL' do
@@ -66,12 +66,12 @@ module Cql
             end
 
             it 'accepts that the bound values list is nil' do
-              frame_bytes = QueryRequest.new('USE system', nil, [], :all, nil, nil, nil, false).write(2, '')
+              frame_bytes = QueryRequest.new('USE system', nil, [], :all, nil, nil, nil, false).write(2, CqlByteBuffer.new)
               frame_bytes.to_s[16, 999].should == "\x00"
             end
 
             it 'accepts that the type hints list is nil' do
-              expect { QueryRequest.new('SELECT * FROM foo WHERE a = ? AND b = ?', ['x', 'y'], nil, :all, nil, nil, nil, false).write(2, '') }.to_not raise_error
+              expect { QueryRequest.new('SELECT * FROM foo WHERE a = ? AND b = ?', ['x', 'y'], nil, :all, nil, nil, nil, false).write(2, CqlByteBuffer.new) }.to_not raise_error
             end
           end
 
@@ -81,7 +81,7 @@ module Cql
             end
 
             let :frame_bytes do
-              QueryRequest.new(cql, ['foobar'], nil, :all, nil, nil, nil, false).write(2, '')
+              QueryRequest.new(cql, ['foobar'], nil, :all, nil, nil, nil, false).write(2, CqlByteBuffer.new)
             end
 
             it 'encodes the CQL' do
@@ -121,23 +121,23 @@ module Cql
               [[Math::PI, Math::PI/2].to_set, 'SET<DOUBLE>', "\x00\x00\x00\x16\x00\x02\x00\x08\x40\x09\x21\xfb\x54\x44\x2d\x18\x00\x08\x3f\xf9\x21\xfb\x54\x44\x2d\x18"],
             ].each do |value, cql_type, expected_bytes|
               it "encodes bound #{value.class}s as #{cql_type}" do
-                frame_bytes = QueryRequest.new(cql, [value], nil, :all, nil, nil, nil, false).write(2, '')
+                frame_bytes = QueryRequest.new(cql, [value], nil, :all, nil, nil, nil, false).write(2, CqlByteBuffer.new)
                 frame_bytes.to_s[45, 999].should == expected_bytes
               end
             end
 
             it 'complains if it cannot guess the type to encode a value as' do
-              expect { QueryRequest.new(cql, [self], nil, :all, nil, nil, nil, false).write(2, '') }.to raise_error(EncodingError)
+              expect { QueryRequest.new(cql, [self], nil, :all, nil, nil, nil, false).write(2, CqlByteBuffer.new) }.to raise_error(EncodingError)
             end
 
             it 'uses the type hints to encode values' do
-              frame_bytes = QueryRequest.new(cql, [4, 3.14], [:int, :float], :all, nil, nil, nil, false).write(2, '')
+              frame_bytes = QueryRequest.new(cql, [4, 3.14], [:int, :float], :all, nil, nil, nil, false).write(2, CqlByteBuffer.new)
               frame_bytes.to_s[45, 8].should == "\x00\x00\x00\x04\x00\x00\x00\x04"
               frame_bytes.to_s[45 + 8, 8].should == "\x00\x00\x00\x04\x40\x48\xf5\xc3"
             end
 
             it 'accepts that some hints are nil and defaults to guessing' do
-              frame_bytes = QueryRequest.new(cql, [4, 4], [:int, nil], :all, nil, nil, nil, false).write(2, '')
+              frame_bytes = QueryRequest.new(cql, [4, 4], [:int, nil], :all, nil, nil, nil, false).write(2, CqlByteBuffer.new)
               frame_bytes.to_s[45, 8].should == "\x00\x00\x00\x04\x00\x00\x00\x04"
               frame_bytes.to_s[45 + 8, 12].should == "\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04"
             end
@@ -145,7 +145,7 @@ module Cql
 
           context 'and the serial consistency is LOCAL_SERIAL' do
             it 'sets the serial flag' do
-              frame_bytes = QueryRequest.new('UPDATE x SET y = 3 WHERE z = 4 IF w = 6', nil, nil, :two, :local_serial, nil, nil, false).write(2, '')
+              frame_bytes = QueryRequest.new('UPDATE x SET y = 3 WHERE z = 4 IF w = 6', nil, nil, :two, :local_serial, nil, nil, false).write(2, CqlByteBuffer.new)
               frame_bytes.to_s[43, 2].should == "\x00\x02"
               frame_bytes.to_s[45, 1].should == "\x10"
               frame_bytes.to_s[46, 2].should == "\x00\x09"
@@ -154,13 +154,13 @@ module Cql
 
           context 'and page size and/or page state is set' do
             it 'sets the page size flag and includes the page size' do
-              frame_bytes = QueryRequest.new('SELECT * FROM users', nil, nil, :one, nil, 10, nil, false).write(2, '')
+              frame_bytes = QueryRequest.new('SELECT * FROM users', nil, nil, :one, nil, 10, nil, false).write(2, CqlByteBuffer.new)
               frame_bytes.to_s[25, 1].should == "\x04"
               frame_bytes.to_s[26, 4].should == "\x00\x00\x00\x0a"
             end
 
             it 'sets both the page size and paging state flags and includes both the page size and the paging state' do
-              frame_bytes = QueryRequest.new('SELECT * FROM users', nil, nil, :one, nil, 10, 'foo', false).write(2, '')
+              frame_bytes = QueryRequest.new('SELECT * FROM users', nil, nil, :one, nil, 10, 'foo', false).write(2, CqlByteBuffer.new)
               frame_bytes.to_s[25, 1].should == "\x0c"
               frame_bytes.to_s[26, 4].should == "\x00\x00\x00\x0a"
               frame_bytes.to_s[30, 7].should == "\x00\x00\x00\x03foo"
@@ -170,7 +170,7 @@ module Cql
 
         context 'with multibyte characters' do
           it 'correctly encodes the frame' do
-            bytes = QueryRequest.new("INSERT INTO users (user_id, first, last, age) VALUES ('test', 'ümlaut', 'test', 1)", nil, nil, :all, nil, nil, nil, false).write(1, '')
+            bytes = QueryRequest.new("INSERT INTO users (user_id, first, last, age) VALUES ('test', 'ümlaut', 'test', 1)", nil, nil, :all, nil, nil, nil, false).write(1, CqlByteBuffer.new)
             bytes.should eql_bytes("\x00\x00\x00SINSERT INTO users (user_id, first, last, age) VALUES ('test', '\xC3\xBCmlaut', 'test', 1)\x00\x05")
           end
         end