cql-rb 1.0.0.pre5 → 1.0.0.pre6

data/spec/cql/io/io_reactor_spec.rb

@@ -7,11 +7,11 @@ module Cql
   module Io
     describe IoReactor do
       let :host do
-        Socket.gethostname
+        '127.0.0.1'
       end
 
       let :port do
-        34535
+        2**15 + rand(2**15)
       end
 
       let :server do
@@ -143,7 +143,7 @@ module Cql
           io_reactor.add_connection(host, port).get
           io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
           await { server.received_bytes.bytesize > 0 }
-          server.received_bytes[3, 1].should == "\x01"
+          server.received_bytes.to_s[3, 1].should == "\x01"
         end
 
         it 'can be called before the reactor is started' do
@@ -183,22 +183,19 @@ module Cql
             request = Cql::Protocol::StartupRequest.new
             response = "\x81\x00\x00\x02\x00\x00\x00\x00"
 
-            io_reactor.start.on_complete do
-              io_reactor.add_connection(host, port).on_complete do |c1_id|
-                io_reactor.add_connection(host, port).on_complete do |c2_id|
-                  q1_future = io_reactor.queue_request(request, c2_id)
-                  q2_future = io_reactor.queue_request(request, c1_id)
-
-                  Future.combine(q1_future, q2_future).on_complete do |(_, q1_id), (_, q2_id)|
-                    future.complete!([c1_id, c2_id, q1_id, q2_id])
-                  end
+            io_reactor.start.get
+            c1_id = io_reactor.add_connection(host, port).get
+            c2_id = io_reactor.add_connection(host, port).get
+            q1_future = io_reactor.queue_request(request, c2_id)
+            q2_future = io_reactor.queue_request(request, c1_id)
 
-                  server.await_connects!(2)
-                  server.broadcast!(response.dup)
-                end
-              end
+            Future.combine(q1_future, q2_future).on_complete do |(_, q1_id), (_, q2_id)|
+              future.complete!([c1_id, c2_id, q1_id, q2_id])
             end
 
+            server.await_connects!(2)
+            server.broadcast!(response.dup)
+
             connection1_id, connection2_id, query1_id, query2_id = future.value
 
             connection1_id.should_not be_nil

data/spec/cql/protocol/decoding_spec.rb

@@ -8,7 +8,7 @@ module Cql
     describe Decoding do
       describe '#read_byte!' do
         let :buffer do
-          "\xab"
+          ByteBuffer.new("\xab")
         end
 
         it 'decodes a raw byte' do
@@ -21,47 +21,51 @@ module Cql
         end
 
         it 'raises an error when there is no byte available' do
-          expect { Decoding.read_byte!('') }.to raise_error(DecodingError)
+          expect { Decoding.read_byte!(ByteBuffer.new) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_varint!' do
         it 'decodes a variable length integer' do
-          Decoding.read_varint!("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[", 17).should == 1231312312331283012830129382342342412123
+          buffer = ByteBuffer.new("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[")
+          Decoding.read_varint!(buffer, 17).should == 1231312312331283012830129382342342412123
         end
 
         it 'decodes a negative variable length integer' do
-          Decoding.read_varint!("\xC9v\x8D:\x86", 5).should == -234234234234
+          buffer = ByteBuffer.new("\xC9v\x8D:\x86")
+          Decoding.read_varint!(buffer, 5).should == -234234234234
         end
 
         it 'decodes an unsigned variable length integer' do
-          Decoding.read_varint!("\xC9v\x8D:\x86", 5, false).should == 865277393542
+          buffer = ByteBuffer.new("\xC9v\x8D:\x86")
+          Decoding.read_varint!(buffer, 5, false).should == 865277393542
         end
 
         it 'consumes the bytes' do
-          buffer = "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[\x01\x02\x03"
+          buffer = ByteBuffer.new("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[\x01\x02\x03")
           Decoding.read_varint!(buffer, 17)
-          buffer.should == "\x01\x02\x03"
+          buffer.should eql_bytes("\x01\x02\x03")
         end
 
         it 'raises an error when there is not enough bytes available' do
-          expect { Decoding.read_varint!("\xC9v\x8D:", 7) }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\xC9v\x8D:")
+          expect { Decoding.read_varint!(buffer, 7) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_decimal!' do
         let :buffer do
-          "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"
+          ByteBuffer.new("\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA")
         end
 
         it 'decodes a decimal to a BigDecimal' do
-          Decoding.read_decimal!(buffer, buffer.length).should == BigDecimal.new('1042342234234.123423435647768234')
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('1042342234234.123423435647768234')
         end
 
         it 'consumes the bytes' do
           buffer << 'HELLO'
           Decoding.read_decimal!(buffer, buffer.length - 5)
-          buffer.should == 'HELLO'
+          buffer.should eql_bytes('HELLO')
         end
 
         it 'defaults to using the buffer length' do
@@ -69,61 +73,68 @@ module Cql
         end
 
         it 'raises an error when there is not enough bytes available' do
-          expect { Decoding.read_decimal!(buffer[0, 3], 7) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(3))
+          expect { Decoding.read_decimal!(b, 7) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_long!' do
         it 'decodes a long' do
-          Decoding.read_long!("\x00\x00\xca\xfe\xba\xbe\x00\x00").should == 0x0000cafebabe0000
+          buffer = ByteBuffer.new("\x00\x00\xca\xfe\xba\xbe\x00\x00")
+          Decoding.read_long!(buffer).should == 0x0000cafebabe0000
         end
 
         it 'consumes the bytes' do
-          buffer = "\xca\xfe\xba\xbe\xca\xfe\xba\xbe\xca\xfe\xba\xbe"
+          buffer = ByteBuffer.new("\xca\xfe\xba\xbe\xca\xfe\xba\xbe\xca\xfe\xba\xbe")
           Decoding.read_long!(buffer)
-          buffer.should == "\xca\xfe\xba\xbe"
+          buffer.should eql_bytes("\xca\xfe\xba\xbe")
         end
 
         it 'raises an error when there is not enough bytes available' do
-          expect { Decoding.read_long!("\xca\xfe\xba\xbe\x00") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\xca\xfe\xba\xbe\x00")
+          expect { Decoding.read_long!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_double!' do
         it 'decodes a double' do
-          Decoding.read_double!("@\xC3\x88\x0F\xC2\x7F\x9DU").should == 10000.123123123
+          buffer = ByteBuffer.new("@\xC3\x88\x0F\xC2\x7F\x9DU")
+          Decoding.read_double!(buffer).should == 10000.123123123
         end
 
         it 'consumes the bytes' do
-          buffer = "@\xC3\x88\x0F\xC2\x7F\x9DUxyz"
+          buffer = ByteBuffer.new("@\xC3\x88\x0F\xC2\x7F\x9DUxyz")
           Decoding.read_double!(buffer)
-          buffer.should == 'xyz'
+          buffer.should eql_bytes('xyz')
         end
 
         it 'raises an error when there is not enough bytes available' do
-          expect { Decoding.read_double!("@\xC3\x88\x0F") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("@\xC3\x88\x0F")
+          expect { Decoding.read_double!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_float!' do
         it 'decodes a float' do
-          Decoding.read_float!("AB\x14{").should be_within(0.00001).of(12.13)
+          buffer = ByteBuffer.new("AB\x14{")
+          Decoding.read_float!(buffer).should be_within(0.00001).of(12.13)
         end
 
         it 'consumes the bytes' do
-          buffer = "AB\x14{xyz"
+          buffer = ByteBuffer.new("AB\x14{xyz")
           Decoding.read_float!(buffer)
-          buffer.should == 'xyz'
+          buffer.should eql_bytes('xyz')
         end
 
         it 'raises an error when there is not enough bytes available' do
-          expect { Decoding.read_float!("\x0F") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\x0F")
+          expect { Decoding.read_float!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_int!' do
         let :buffer do
-          "\x00\xff\x00\xff"
+          ByteBuffer.new("\x00\xff\x00\xff")
         end
 
         it 'decodes an int' do
@@ -133,17 +144,18 @@ module Cql
         it 'consumes the bytes' do
           buffer << "\xab\xcd"
           Decoding.read_int!(buffer)
-          buffer.should == "\xab\xcd"
+          buffer.should eql_bytes("\xab\xcd")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_int!("\x01\xab") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\x01\xab")
+          expect { Decoding.read_int!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_short!' do
         let :buffer do
-          "\x00\x02"
+          ByteBuffer.new("\x00\x02")
         end
 
         it 'decodes a short' do
@@ -153,17 +165,18 @@ module Cql
         it 'consumes the bytes' do
           buffer << "\xff\xff"
           Decoding.read_short!(buffer)
-          buffer.should == "\xff\xff"
+          buffer.should eql_bytes("\xff\xff")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_short!("\x01") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\x01")
+          expect { Decoding.read_short!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_string!' do
         let :buffer do
-          "\x00\x0bhej och hå"
+          ByteBuffer.new("\x00\x0bhej och hå")
         end
 
         it 'decodes a string' do
@@ -175,23 +188,25 @@ module Cql
         end
 
         it 'decodes an empty string' do
-          Decoding.read_string!("\x00\x00").should be_empty
+          buffer = ByteBuffer.new("\x00\x00")
+          Decoding.read_string!(buffer).should be_empty
         end
 
         it 'consumes the bytes' do
           buffer << "\xff\xff"
           Decoding.read_string!(buffer)
-          buffer.should == "\xff\xff"
+          buffer.should eql_bytes("\xff\xff")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_string!(buffer.slice(0, 5)) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(5))
+          expect { Decoding.read_string!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_long_string!' do
         let :buffer do
-          "\x00\x01\x00\00" << ('x' * 0x10000)
+          ByteBuffer.new("\x00\x01\x00\00" << ('x' * 0x10000))
         end
 
         it 'decodes a string' do
@@ -206,17 +221,18 @@ module Cql
         it 'consumes the bytes' do
           buffer << "\xff\xff"
           Decoding.read_long_string!(buffer)
-          buffer.should == "\xff\xff"
+          buffer.should eql_bytes("\xff\xff")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_long_string!(buffer.slice(0, 246)) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(246))
+          expect { Decoding.read_long_string!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_uuid!' do
         let :buffer do
-          "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"
+          ByteBuffer.new("\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11")
         end
 
         it 'decodes a UUID' do
@@ -229,13 +245,14 @@ module Cql
         end
         
         it 'raises an error when there a not enough bytes in the buffer' do
-          expect { Decoding.read_uuid!(buffer[2, 5]) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.discard(2).read(5))
+          expect { Decoding.read_uuid!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_string_list!' do
         let :buffer do
-          "\x00\x02\x00\x05hello\x00\x05world"
+          ByteBuffer.new("\x00\x02\x00\x05hello\x00\x05world")
         end
 
         it 'decodes a string list' do
@@ -243,87 +260,88 @@ module Cql
         end
 
         it 'decodes an empty string list' do
-          Decoding.read_string_list!("\x00\x00").should == []
+          buffer = ByteBuffer.new("\x00\x00")
+          Decoding.read_string_list!(buffer).should == []
         end
 
         it 'consumes the bytes' do
           buffer << "\xff\xff"
           Decoding.read_string_list!(buffer)
-          buffer.should == "\xff\xff"
+          buffer.should eql_bytes("\xff\xff")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_string_list!(buffer.slice(0, 13)) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(13))
+          expect { Decoding.read_string_list!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_bytes!' do
         let :buffer do
-          "\x00\x01\x00\x00" << ("\x42" * 0x10000)
+          ByteBuffer.new("\x00\x01\x00\x00" << ("\x42" * 0x10000))
         end
 
         it 'decodes a byte array' do
-          Decoding.read_bytes!(buffer).should == ("\x42" * 0x10000)
+          Decoding.read_bytes!(buffer).should eql_bytes("\x42" * 0x10000)
         end
 
         it 'decodes an empty byte array' do
-          Decoding.read_bytes!("\x00\x00\x00\x00").should == ''
-        end
-
-        it 'returns an ASCII-8BIT encoded string' do
-          Decoding.read_bytes!("\x00\x00\x00\x01\xaa").encoding.should == ::Encoding::BINARY
+          buffer = ByteBuffer.new("\x00\x00\x00\x00")
+          Decoding.read_bytes!(buffer).should be_empty
         end
 
         it 'decodes null' do
-          Decoding.read_bytes!("\x80\x00\x00\x00").should be_nil
+          buffer = ByteBuffer.new("\x80\x00\x00\x00")
+          Decoding.read_bytes!(buffer).should be_nil
         end
 
         it 'consumes the bytes' do
           buffer << "\xab\xcd"
           Decoding.read_bytes!(buffer)
-          buffer.should == "\xab\xcd"
+          buffer.should eql_bytes("\xab\xcd")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_bytes!(buffer[0, 10]) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(10))
+          expect { Decoding.read_bytes!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_short_bytes!' do
         let :buffer do
-          "\x01\x00" << ("\x42" * 0x100)
+          ByteBuffer.new("\x01\x00" << ("\x42" * 0x100))
         end
 
         it 'decodes a byte array' do
-          Decoding.read_short_bytes!(buffer).should == ("\x42" * 0x100)
+          Decoding.read_short_bytes!(buffer).should eql_bytes("\x42" * 0x100)
         end
 
         it 'decodes an empty byte array' do
-          Decoding.read_short_bytes!("\x00\x00\x00\x00").should == ''
-        end
-
-        it 'returns an ASCII-8BIT encoded string' do
-          Decoding.read_short_bytes!("\x00\x00\x00\x01\xaa").encoding.should == ::Encoding::BINARY
+          buffer = ByteBuffer.new("\x00\x00\x00\x00")
+          Decoding.read_short_bytes!(buffer).should be_empty
         end
 
         it 'decodes null' do
-          Decoding.read_short_bytes!("\x80\x00").should be_nil
+          buffer = ByteBuffer.new("\x80\x00")
+          Decoding.read_short_bytes!(buffer).should be_nil
         end
 
         it 'consumes the bytes' do
           buffer << "\xab\xcd"
           Decoding.read_short_bytes!(buffer)
-          buffer.should == "\xab\xcd"
+          buffer.should eql_bytes("\xab\xcd")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_short_bytes!(buffer[0, 10]) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(10))
+          expect { Decoding.read_short_bytes!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_option!' do
         it 'decodes an option ID and value with instructions from a block' do
-          id, value = Decoding.read_option!("\x00\x01\x00\x03foo") do |id, buffer|
+          buffer = ByteBuffer.new("\x00\x01\x00\x03foo")
+          id, value = Decoding.read_option!(buffer) do |id, buffer|
             Decoding.read_string!(buffer)
           end
           id.should == 1
@@ -331,90 +349,105 @@ module Cql
         end
 
         it 'decodes an option ID and nil value when there is no block' do
-          id, value = Decoding.read_option!("\xaa\xbb")
+          buffer = ByteBuffer.new("\xaa\xbb")
+          id, value = Decoding.read_option!(buffer)
           id.should == 0xaabb
           value.should be_nil
         end
 
         it 'consumes the bytes' do
-          buffer = "\x00\x01\x00\x03\xab"
+          buffer = ByteBuffer.new("\x00\x01\x00\x03\xab")
           id, value = Decoding.read_option!(buffer) do |id, buffer|
             Decoding.read_short!(buffer)
           end
-          buffer.should == "\xab"
+          buffer.should eql_bytes("\xab")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_option!("\xaa") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\xaa")
+          expect { Decoding.read_option!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_inet!' do
         it 'decodes an IPv4 + port pair' do
-          ip_addr, port = Decoding.read_inet!("\x04\x00\x00\x00\x00\x00\x00#R")
+          buffer = ByteBuffer.new("\x04\x00\x00\x00\x00\x00\x00#R")
+          ip_addr, port = Decoding.read_inet!(buffer)
           ip_addr.should == IPAddr.new('0.0.0.0')
           port.should == 9042
         end
 
         it 'decodes an IPv6 + port pair' do
-          ip_addr, port = Decoding.read_inet!("\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00#R")
+          buffer = ByteBuffer.new("\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00#R")
+          ip_addr, port = Decoding.read_inet!(buffer)
           ip_addr.should == IPAddr.new('::1')
           port.should == 9042
         end
 
         it 'consumes the bytes' do
-          buffer = "\x04\x00\x00\x00\x00\x00\x00#R\xff\xaa"
+          buffer = ByteBuffer.new("\x04\x00\x00\x00\x00\x00\x00#R\xff\xaa")
           Decoding.read_inet!(buffer)
-          buffer.should == "\xff\xaa"
+          buffer.should eql_bytes("\xff\xaa")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_inet!("\x04\x00\x00\x00\x00\x00\x00") }.to raise_error(DecodingError)
-          expect { Decoding.read_inet!("\x04\x00\x00\x00") }.to raise_error(DecodingError)
+          buffer1 = ByteBuffer.new("\x04\x00\x00\x00\x00\x00\x00")
+          expect { Decoding.read_inet!(buffer1) }.to raise_error(DecodingError)
+          buffer2 = ByteBuffer.new("\x04\x00\x00\x00")
+          expect { Decoding.read_inet!(buffer2) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_consistency!' do
         it 'decodes ANY' do
-          Decoding.read_consistency!("\x00\x00").should == :any
+          buffer = ByteBuffer.new("\x00\x00")
+          Decoding.read_consistency!(buffer).should == :any
         end
 
         it 'decodes ONE' do
-          Decoding.read_consistency!("\x00\x01").should == :one
+          buffer = ByteBuffer.new("\x00\x01")
+          Decoding.read_consistency!(buffer).should == :one
         end
 
         it 'decodes TWO' do
-          Decoding.read_consistency!("\x00\x02").should == :two
+          buffer = ByteBuffer.new("\x00\x02")
+          Decoding.read_consistency!(buffer).should == :two
         end
 
         it 'decodes THREE' do
-          Decoding.read_consistency!("\x00\x03").should == :three
+          buffer = ByteBuffer.new("\x00\x03")
+          Decoding.read_consistency!(buffer).should == :three
         end
 
         it 'decodes QUORUM' do
-          Decoding.read_consistency!("\x00\x04").should == :quorum
+          buffer = ByteBuffer.new("\x00\x04")
+          Decoding.read_consistency!(buffer).should == :quorum
         end
 
         it 'decodes ALL' do
-          Decoding.read_consistency!("\x00\x05").should == :all
+          buffer = ByteBuffer.new("\x00\x05")
+          Decoding.read_consistency!(buffer).should == :all
         end
 
         it 'decodes LOCAL_QUORUM' do
-          Decoding.read_consistency!("\x00\x06").should == :local_quorum
+          buffer = ByteBuffer.new("\x00\x06")
+          Decoding.read_consistency!(buffer).should == :local_quorum
         end
 
         it 'decodes EACH_QUORUM' do
-          Decoding.read_consistency!("\x00\x07").should == :each_quorum
+          buffer = ByteBuffer.new("\x00\x07")
+          Decoding.read_consistency!(buffer).should == :each_quorum
         end
 
         it 'raises an exception for an unknown consistency' do
-          expect { Decoding.read_consistency!("\xff\xff") }.to raise_error(DecodingError)
+          buffer = ByteBuffer.new("\xff\xff")
+          expect { Decoding.read_consistency!(buffer) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_string_map!' do
         let :buffer do
-          "\x00\x02\x00\x05hello\x00\x05world\x00\x03foo\x00\x03bar"
+          ByteBuffer.new("\x00\x02\x00\x05hello\x00\x05world\x00\x03foo\x00\x03bar")
         end
 
         it 'decodes a string multimap' do
@@ -422,23 +455,25 @@ module Cql
         end
 
         it 'decodes an empty string map' do
-          Decoding.read_string_map!("\x00\x00").should == {}
+          buffer = ByteBuffer.new("\x00\x00")
+          Decoding.read_string_map!(buffer).should == {}
         end
 
         it 'consumes the bytes' do
           buffer << "\xff"
           Decoding.read_string_map!(buffer)
-          buffer.should == "\xff"
+          buffer.should eql_bytes("\xff")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_string_map!(buffer.slice(0, 20)) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(20))
+          expect { Decoding.read_string_map!(b) }.to raise_error(DecodingError)
         end
       end
 
       describe '#read_string_multimap!' do
         let :buffer do
-          "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x02\x00\x06snappy\x00\x04gzip"
+          ByteBuffer.new("\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x02\x00\x06snappy\x00\x04gzip")
         end
 
         it 'decodes a string multimap' do
@@ -446,17 +481,19 @@ module Cql
         end
 
         it 'decodes an empty string multimap' do
-          Decoding.read_string_multimap!("\x00\x00").should == {}
+          buffer = ByteBuffer.new("\x00\x00")
+          Decoding.read_string_multimap!(buffer).should == {}
         end
 
         it 'consumes the bytes' do
           buffer << "\xff"
           Decoding.read_string_multimap!(buffer)
-          buffer.should == "\xff"
+          buffer.should eql_bytes("\xff")
         end
 
         it 'raises an error when there are not enough bytes in the buffer' do
-          expect { Decoding.read_string_multimap!(buffer.slice(0, 40)) }.to raise_error(DecodingError)
+          b = ByteBuffer.new(buffer.read(40))
+          expect { Decoding.read_string_multimap!(b) }.to raise_error(DecodingError)
         end
       end
     end