cql-rb 1.0.0.pre2 → 1.0.0.pre3

data/lib/cql/protocol.rb

@@ -8,6 +8,7 @@ module Cql
     DecodingError = Class.new(ProtocolError)
     EncodingError = Class.new(ProtocolError)
     InvalidStreamIdError = Class.new(ProtocolError)
+    InvalidValueError = Class.new(ProtocolError)
     UnsupportedOperationError = Class.new(ProtocolError)
     UnsupportedFrameTypeError = Class.new(ProtocolError)
     UnsupportedResultKindError = Class.new(ProtocolError)

data/lib/cql/protocol/encoding.rb

@@ -15,14 +15,14 @@ module Cql
 
       def write_string(buffer, str)
         buffer << [str.bytesize].pack(Formats::SHORT_FORMAT)
-        buffer << str
+        buffer << binary_cast(str)
         buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 
       def write_long_string(buffer, str)
         buffer << [str.bytesize].pack(Formats::INT_FORMAT)
-        buffer << str
+        buffer << binary_cast(str)
         buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
@@ -42,7 +42,7 @@ module Cql
       def write_bytes(buffer, bytes)
         if bytes
           write_int(buffer, bytes.bytesize)
-          buffer << bytes
+          buffer << binary_cast(bytes)
         else
           write_int(buffer, -1)
         end
@@ -53,7 +53,7 @@ module Cql
       def write_short_bytes(buffer, bytes)
         if bytes
           write_short(buffer, bytes.bytesize)
-          buffer << bytes
+          buffer << binary_cast(bytes)
         else
           write_short(buffer, -1)
         end
@@ -108,6 +108,13 @@ module Cql
       def write_float(buffer, n)
         buffer << [n].pack(Formats::FLOAT_FORMAT)
       end
+
+      private
+
+      def binary_cast(str)
+        return str if str.ascii_only?
+        str.dup.force_encoding(::Encoding::BINARY)
+      end
     end
   end
 end

data/lib/cql/protocol/request_frame.rb

@@ -177,48 +177,79 @@ module Cql
       private
 
       def write_value(io, value, type)
-        case type
-        when :ascii
-          write_bytes(io, value.encode(::Encoding::ASCII))
-        when :bigint
-          write_int(io, 8)
-          write_long(io, value)
-        when :blob
-          write_bytes(io, value.encode(::Encoding::BINARY))
-        when :boolean
-          write_int(io, 1)
-          io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
-        when :decimal
-          raw = write_decimal('', value)
-          write_int(io, raw.size)
-          io << raw
-        when :double
-          write_int(io, 8)
-          write_double(io, value)
-        when :float
-          write_int(io, 4)
-          write_float(io, value)
-        when :inet
-          write_int(io, value.ipv6? ? 16 : 4)
-          io << value.hton
-        when :int
-          write_int(io, 4)
-          write_int(io, value)
-        when :text, :varchar
-          write_bytes(io, value.encode(::Encoding::UTF_8))
-        when :timestamp
-          ms = (value.to_f * 1000).to_i
-          write_int(io, 8)
-          write_long(io, ms)
-        when :timeuuid, :uuid
-          write_int(io, 16)
-          write_uuid(io, value)
-        when :varint
-          raw = write_varint('', value)
-          write_int(io, raw.length)
-          io << raw
+        if Array === type
+          raise InvalidValueError, 'Value for collection must be enumerable' unless value.is_a?(Enumerable)
+          case type.first
+          when :list, :set
+            _, sub_type = type
+            raw = ''
+            write_short(raw, value.size)
+            value.each do |element|
+              rr = ''
+              write_value(rr, element, sub_type)
+              raw << rr[2, rr.length - 2]
+            end
+            write_bytes(io, raw)
+          when :map
+            _, key_type, value_type = type
+            raw = ''
+            write_short(raw, value.size)
+            value.each do |key, value|
+              rr = ''
+              write_value(rr, key, key_type)
+              raw << rr[2, rr.length - 2]
+              rr = ''
+              write_value(rr, value, value_type)
+              raw << rr[2, rr.length - 2]
+            end
+            write_bytes(io, raw)
+          else
+            raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
+          end
         else
-          raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
+          case type
+          when :ascii
+            write_bytes(io, value.encode(::Encoding::ASCII))
+          when :bigint
+            write_int(io, 8)
+            write_long(io, value)
+          when :blob
+            write_bytes(io, value.encode(::Encoding::BINARY))
+          when :boolean
+            write_int(io, 1)
+            io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
+          when :decimal
+            raw = write_decimal('', value)
+            write_int(io, raw.size)
+            io << raw
+          when :double
+            write_int(io, 8)
+            write_double(io, value)
+          when :float
+            write_int(io, 4)
+            write_float(io, value)
+          when :inet
+            write_int(io, value.ipv6? ? 16 : 4)
+            io << value.hton
+          when :int
+            write_int(io, 4)
+            write_int(io, value)
+          when :text, :varchar
+            write_bytes(io, value.encode(::Encoding::UTF_8))
+          when :timestamp
+            ms = (value.to_f * 1000).to_i
+            write_int(io, 8)
+            write_long(io, ms)
+          when :timeuuid, :uuid
+            write_int(io, 16)
+            write_uuid(io, value)
+          when :varint
+            raw = write_varint('', value)
+            write_int(io, raw.length)
+            io << raw
+          else
+            raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
+          end
         end
       rescue TypeError => e
         raise TypeError, %("#{value}" cannot be encoded as #{type.to_s.upcase}: #{e.message}), e.backtrace

data/lib/cql/uuid.rb

@@ -36,6 +36,10 @@ module Cql
       end
     end
 
+    def hash
+      @h = (@n & 0xffffffffffffffff) ^ ((@n >> 64) & 0xffffffffffffffff)
+    end
+
     # Returns the numerical representation of this UUID
     #
     # @return [Bignum] the 128 bit numerical representation

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '1.0.0.pre2'.freeze
+  VERSION = '1.0.0.pre3'.freeze
 end

data/spec/cql/protocol/encoding_spec.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 require 'spec_helper'
 
@@ -7,19 +7,20 @@ module Cql
   module Protocol
     describe Encoding do
       let :buffer do
-        ''
+        ''.force_encoding(::Encoding::BINARY)
       end
 
       describe '#write_int' do
         it 'encodes an int' do
           Encoding.write_int(buffer, 2323234234)
-          buffer.should == "\x8a\x79\xbd\xba"
+          buffer.should eql_bytes("\x8a\x79\xbd\xba")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_int(buffer, 10)
-          buffer.should == "\xab\x00\x00\x00\x0a"
+          buffer.should eql_bytes("\xab\x00\x00\x00\x0a")
         end
 
         it 'returns the buffer' do
@@ -31,13 +32,14 @@ module Cql
       describe '#write_short' do
         it 'encodes a short' do
           Encoding.write_short(buffer, 0xabcd)
-          buffer.should == "\xab\xcd"
+          buffer.should eql_bytes("\xab\xcd")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_short(buffer, 10)
-          buffer.should == "\xab\x00\x0a"
+          buffer.should eql_bytes("\xab\x00\x0a")
         end
 
         it 'returns the buffer' do
@@ -49,30 +51,33 @@ module Cql
       describe '#write_string' do
         it 'encodes a string' do
           Encoding.write_string(buffer, 'hello')
-          buffer.should == "\x00\x05hello"
+          buffer.should eql_bytes("\x00\x05hello")
         end
 
         it 'returns a binary string' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          str = 'I love π'
           Encoding.write_string(buffer, str)
           buffer.encoding.should == ::Encoding::BINARY
         end
 
         it 'encodes a string with multibyte characters' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          buffer << "\xff"
+          buffer.force_encoding(::Encoding::BINARY)
+          str = 'I love π'
           Encoding.write_string(buffer, str)
-          buffer.should == "\x00\x09I love π"
+          buffer.should eql_bytes("\xff\x00\x09I love π")
         end
 
         it 'encodes an empty string' do
           Encoding.write_string(buffer, '')
-          buffer.should == "\x00\x00"
+          buffer.should eql_bytes("\x00\x00")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_string(buffer, 'foo')
-          buffer.should == "\xab\x00\x03foo"
+          buffer.should eql_bytes("\xab\x00\x03foo")
         end
 
         it 'returns the buffer' do
@@ -84,30 +89,33 @@ module Cql
       describe '#write_long_string' do
         it 'encodes a string' do
           Encoding.write_long_string(buffer, 'hello world ' * 100_000)
-          buffer.should start_with("\x00\x12\x4f\x80hello world hello world hello world hello")
+          buffer[0, 45].should eql_bytes("\x00\x12\x4f\x80hello world hello world hello world hello")
         end
 
         it 'returns a binary string' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          str = 'I love π'
           Encoding.write_long_string(buffer, str)
           buffer.encoding.should == ::Encoding::BINARY
         end
 
         it 'encodes a string with multibyte characters' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          buffer << "\xff"
+          buffer.force_encoding(::Encoding::BINARY)
+          str = 'I love π'
           Encoding.write_long_string(buffer, str)
-          buffer.should == "\x00\x00\x00\x09I love π"
+          buffer.should eql_bytes("\xff\x00\x00\x00\x09I love π")
         end
 
         it 'encodes an empty string' do
           Encoding.write_long_string(buffer, '')
-          buffer.should == "\x00\x00\x00\x00"
+          buffer.should eql_bytes("\x00\x00\x00\x00")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_long_string(buffer, 'foo')
-          buffer.should == "\xab\x00\x00\x00\x03foo"
+          buffer.should eql_bytes("\xab\x00\x00\x00\x03foo")
         end
 
         it 'returns the buffer' do
@@ -123,11 +131,12 @@ module Cql
 
         it 'encodes an UUID' do
           Encoding.write_uuid(buffer, uuid)
-          buffer.should == "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"
+          buffer.should eql_bytes("\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11")
         end
 
         it 'appends to the buffer' do
           buffer << 'FOO'
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_uuid(buffer, uuid)
           buffer.should start_with('FOO')
         end
@@ -141,19 +150,21 @@ module Cql
       describe '#write_string_list' do
         it 'encodes a string list' do
           Encoding.write_string_list(buffer, %w[foo bar hello world])
-          buffer.should == "\x00\x04\x00\x03foo\x00\x03bar\x00\x05hello\x00\x05world"
+          buffer.should eql_bytes("\x00\x04\x00\x03foo\x00\x03bar\x00\x05hello\x00\x05world")
         end
 
         it 'returns a binary string' do
-          str = %w[I love π].map { |str| str.force_encoding(::Encoding::UTF_8) }
+          str = %w[I love π]
           Encoding.write_string_list(buffer, str)
           buffer.encoding.should == ::Encoding::BINARY
         end
 
         it 'encodes a string with multibyte characters' do
-          str = %w[I love π].map { |str| str.force_encoding(::Encoding::UTF_8) }
+          buffer << "\xff"
+          buffer.force_encoding(::Encoding::BINARY)
+          str = %w[I love π]
           Encoding.write_string_list(buffer, str)
-          buffer.should == "\x00\x03\x00\x01I\x00\x04love\x00\x02π"
+          buffer.should eql_bytes("\xff\x00\x03\x00\x01I\x00\x04love\x00\x02π")
         end
 
         it 'encodes an empty string list' do
@@ -163,8 +174,9 @@ module Cql
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_string_list(buffer, %w[foo bar])
-          buffer.should == "\xab\x00\x02\x00\x03foo\x00\x03bar"
+          buffer.should eql_bytes("\xab\x00\x02\x00\x03foo\x00\x03bar")
         end
 
         it 'returns the buffer' do
@@ -176,30 +188,33 @@ module Cql
       describe '#write_bytes' do
         it 'encodes a byte array' do
           Encoding.write_bytes(buffer, "\xaa" * 2000)
-          buffer.should == ("\x00\x00\x07\xd0" << ("\xaa" * 2000))
+          buffer.should eql_bytes("\x00\x00\x07\xd0" << ("\xaa" * 2000))
         end
 
         it 'returns a binary string' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          str = 'I love π'
           Encoding.write_bytes(buffer, str)
           buffer.encoding.should == ::Encoding::BINARY
         end
 
         it 'encodes a string with multibyte characters' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          buffer << "\xff"
+          buffer.force_encoding(::Encoding::BINARY)
+          str = 'I love π'
           Encoding.write_bytes(buffer, str)
-          buffer.should == "\x00\x00\x00\x09I love π"
+          buffer.should eql_bytes("\xff\x00\x00\x00\x09I love π")
         end
 
         it 'encodes nil' do
           Encoding.write_bytes(buffer, nil)
-          buffer.should == "\xff\xff\xff\xff"
+          buffer.should eql_bytes("\xff\xff\xff\xff")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_bytes(buffer, "\xf0\x0b\xbar")
-          buffer.should == "\xab\x00\x00\x00\x04\xf0\x0b\xbar"
+          buffer.should eql_bytes("\xab\x00\x00\x00\x04\xf0\x0b\xbar")
         end
 
         it 'returns the buffer' do
@@ -211,30 +226,33 @@ module Cql
       describe '#write_short_bytes' do
         it 'encodes a byte array' do
           Encoding.write_short_bytes(buffer, "\xaa\xbb\xcc")
-          buffer.should == "\x00\x03\xaa\xbb\xcc"
+          buffer.should eql_bytes("\x00\x03\xaa\xbb\xcc")
         end
 
         it 'returns a binary string' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          str = 'I love π'
           Encoding.write_short_bytes(buffer, str)
           buffer.encoding.should == ::Encoding::BINARY
         end
 
         it 'encodes a string with multibyte characters' do
-          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          buffer << "\xff"
+          buffer.force_encoding(::Encoding::BINARY)
+          str = 'I love π'
           Encoding.write_short_bytes(buffer, str)
-          buffer.should == "\x00\x09I love π"
+          buffer.should eql_bytes("\xff\x00\x09I love π")
         end
 
         it 'encodes nil' do
           Encoding.write_short_bytes(buffer, nil)
-          buffer.should == "\xff\xff"
+          buffer.should eql_bytes("\xff\xff")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_short_bytes(buffer, "\xf0\x0b\xbar")
-          buffer.should == "\xab\x00\x04\xf0\x0b\xbar"
+          buffer.should eql_bytes("\xab\x00\x04\xf0\x0b\xbar")
         end
 
         it 'returns the buffer' do
@@ -266,8 +284,9 @@ module Cql
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_consistency(buffer, :one)
-          buffer.should == "\xab\x00\x01"
+          buffer.should eql_bytes("\xab\x00\x01")
         end
 
         it 'returns the buffer' do
@@ -279,18 +298,19 @@ module Cql
       describe '#write_string_map' do
         it 'encodes a string map' do
           Encoding.write_string_map(buffer, 'HELLO' => 'world', 'foo' => 'bar')
-          buffer.should == "\x00\x02\x00\x05HELLO\x00\x05world\x00\x03foo\x00\x03bar"
+          buffer.should eql_bytes("\x00\x02\x00\x05HELLO\x00\x05world\x00\x03foo\x00\x03bar")
         end
 
         it 'encodes an empty map' do
           Encoding.write_string_map(buffer, {})
-          buffer.should == "\x00\x00"
+          buffer.should eql_bytes("\x00\x00")
         end
 
         it 'appends to the buffer' do
           buffer << "\xab"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_string_map(buffer, 'foo' => 'bar')
-          buffer.should == "\xab\x00\x01\x00\x03foo\x00\x03bar"
+          buffer.should eql_bytes("\xab\x00\x01\x00\x03foo\x00\x03bar")
         end
 
         it 'returns the buffer' do
@@ -302,13 +322,14 @@ module Cql
       describe '#write_long' do
         it 'encodes a long' do
           Encoding.write_long(buffer, 0x0123456789)
-          buffer.should == "\x00\x00\x00\x01\x23\x45\x67\x89"
+          buffer.should eql_bytes("\x00\x00\x00\x01\x23\x45\x67\x89")
         end
 
         it 'appends to the buffer' do
           buffer << "\x99"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_long(buffer, 0x0123456789)
-          buffer.should == "\x99\x00\x00\x00\x01\x23\x45\x67\x89"
+          buffer.should eql_bytes("\x99\x00\x00\x00\x01\x23\x45\x67\x89")
         end
 
         it 'returns the buffer' do
@@ -320,18 +341,19 @@ module Cql
       describe '#write_varint' do
         it 'encodes a variable length integer' do
           Encoding.write_varint(buffer, 1231312312331283012830129382342342412123)
-          buffer.should == "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["
+          buffer.should eql_bytes("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[")
         end
 
         it 'encodes a negative variable length integer' do
           Encoding.write_varint(buffer, -234234234234)
-          buffer.should == "\xC9v\x8D:\x86"
+          buffer.should eql_bytes("\xC9v\x8D:\x86")
         end
 
         it 'appends to the buffer' do
           buffer << "\x99"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_varint(buffer, -234234234234)
-          buffer.should == "\x99\xC9v\x8D:\x86"
+          buffer.should eql_bytes("\x99\xC9v\x8D:\x86")
         end
 
         it 'returns the buffer' do
@@ -343,13 +365,14 @@ module Cql
       describe '#write_decimal' do
         it 'encodes a BigDecimal as a decimal' do
           Encoding.write_decimal(buffer, BigDecimal.new('1042342234234.123423435647768234'))
-          buffer.should == "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"
+          buffer.should eql_bytes("\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA")
         end
 
         it 'appends to the buffer' do
           buffer << "\x99"
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_decimal(buffer, BigDecimal.new('1042342234234.123423435647768234'))
-          buffer.should start_with("\x99")
+          buffer[0].should eql_bytes("\x99")
         end
 
         it 'returns the buffer' do
@@ -361,11 +384,12 @@ module Cql
       describe '#write_double' do
         it 'encodes a double' do
           Encoding.write_double(buffer, 10000.123123123)
-          buffer.should == "@\xC3\x88\x0F\xC2\x7F\x9DU"
+          buffer.should eql_bytes("@\xC3\x88\x0F\xC2\x7F\x9DU")
         end
 
         it 'appends to the buffer' do
           buffer << 'BEFORE'
+          buffer.force_encoding(::Encoding::BINARY)
           Encoding.write_double(buffer, 10000.123123123)
           buffer.should start_with('BEFORE')
         end
@@ -379,7 +403,7 @@ module Cql
       describe '#write_float' do
         it 'encodes a float' do
           Encoding.write_float(buffer, 12.13)
-          buffer.should == "AB\x14{"
+          buffer.should eql_bytes("AB\x14{")
         end
 
         it 'appends to the buffer' do

data/spec/cql/protocol/request_frame_spec.rb

@@ -78,7 +78,15 @@ module Cql
           [:uuid, Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), "\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6"],
           [:varchar, 'hello', 'hello'],
           [:varint, 1231312312331283012830129382342342412123, "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["],
-          [:varint, -234234234234, "\xC9v\x8D:\x86"]
+          [:varint, -234234234234, "\xC9v\x8D:\x86"],
+          [[:list, :timestamp], [Time.at(1358013521.123)], "\x00\x01" + "\x00\x08\x00\x00\x01</\xE9\xDC\xE3"],
+          [[:list, :boolean], [true, false, true, true], "\x00\x04" + "\x00\x01\x01" + "\x00\x01\x00"  + "\x00\x01\x01" + "\x00\x01\x01"],
+          [[:map, :uuid, :int], {Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6') => 45345, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711') => 98765}, "\x00\x02" + "\x00\x10\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6" + "\x00\x04\x00\x00\xb1\x21" + "\x00\x10\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11" + "\x00\x04\x00\x01\x81\xcd"],
+          [[:map, :ascii, :blob], {'hello' => 'world', 'one' => "\x01", 'two' => "\x02"}, "\x00\x03" + "\x00\x05hello" + "\x00\x05world" + "\x00\x03one" + "\x00\x01\x01" + "\x00\x03two" + "\x00\x01\x02"],
+          [[:set, :int], Set.new([13, 3453, 456456, 123, 768678]), "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"],
+          [[:set, :varchar], Set.new(['foo', 'bar', 'baz']), "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"],
+          [[:set, :int], [13, 3453, 456456, 123, 768678], "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"],
+          [[:set, :varchar], ['foo', 'bar', 'baz'], "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"]
         ]
         specs.each do |type, value, expected_bytes|
           it "encodes #{type} values" do
@@ -100,6 +108,16 @@ module Cql
           expect { RequestFrame.new(ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum)).write('') }.to raise_error(UnsupportedColumnTypeError)
         end
 
+        it 'raises an error for unsupported column collection types' do
+          column_metadata[2][3] = [:imaginary, :varchar]
+          expect { RequestFrame.new(ExecuteRequest.new(id, column_metadata, ['hello', 42, ['foo']], :each_quorum)).write('') }.to raise_error(UnsupportedColumnTypeError)
+        end
+
+        it 'raises an error when collection values are not enumerable' do
+          column_metadata[2][3] = [:set, :varchar]
+          expect { RequestFrame.new(ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum)).write('') }.to raise_error(InvalidValueError)
+        end
+
         it 'raises an error when it cannot encode the argument' do
           expect { ExecuteRequest.new(id, column_metadata, ['hello', 'not an int', 'foo'], :each_quorum).write('') }.to raise_error(TypeError, /cannot be encoded as INT/)
         end

data/spec/cql/uuid_spec.rb

@@ -47,6 +47,26 @@ module Cql
       end
     end
 
+    describe '#hash' do
+      it 'calculates a 64 bit hash of the UUID' do
+        h = Uuid.new(276263553384940695775376958868900023510).hash
+        h.should be < 2**63
+        h.should be > -2**63
+      end
+
+      it 'has the same hash code when #eql?' do
+        uuid1 = Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
+        uuid2 = Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
+        uuid1.hash.should == uuid2.hash
+      end
+
+      it 'has a different hash when not #eql?' do
+        uuid1 = Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
+        uuid2 = Uuid.new('b4a70900-24e1-11df-8924-001ff3591711')
+        uuid1.hash.should_not == uuid2.hash
+      end
+    end
+
     describe '#value' do
       it 'returns the numeric value' do
         Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6').value.should == 276263553384940695775376958868900023510

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ require 'cql'
 ENV['CASSANDRA_HOST'] ||= 'localhost'
 
 
+require 'support/bytes_helper'
 require 'support/await_helper'
 require 'support/fake_server'
 require 'support/fake_io_reactor'

data/spec/support/bytes_helper.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+RSpec::Matchers.define :eql_bytes do |expected|
+  match do |actual|
+    actual.unpack('c*') == expected.unpack('c*')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre2
+  version: 1.0.0.pre3
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-08 00:00:00.000000000 Z
+date: 2013-03-18 00:00:00.000000000 Z
 dependencies: []
 description: A pure Ruby CQL3 driver for Cassandra
 email:
@@ -44,6 +44,7 @@ files:
 - spec/integration/protocol_spec.rb
 - spec/spec_helper.rb
 - spec/support/await_helper.rb
+- spec/support/bytes_helper.rb
 - spec/support/fake_io_reactor.rb
 - spec/support/fake_server.rb
 homepage: http://github.com/iconara/cql-rb
@@ -84,6 +85,7 @@ test_files:
 - spec/integration/protocol_spec.rb
 - spec/spec_helper.rb
 - spec/support/await_helper.rb
+- spec/support/bytes_helper.rb
 - spec/support/fake_io_reactor.rb
 - spec/support/fake_server.rb
 has_rdoc: