cql-rb 1.1.0.pre1 → 1.1.0.pre2

data/README.md

@@ -1,7 +1,7 @@
 # Ruby CQL3 driver
 
 [![Build Status](https://travis-ci.org/iconara/cql-rb.png?branch=master)](https://travis-ci.org/iconara/cql-rb)
-[![Coverage Status](https://coveralls.io/repos/iconara/cql-rb/badge.png?branch=io_reactor_rewrite)](https://coveralls.io/r/iconara/cql-rb?branch=io_reactor_rewrite)
+[![Coverage Status](https://coveralls.io/repos/iconara/cql-rb/badge.png)](https://coveralls.io/r/iconara/cql-rb)
 
 # Requirements
 
@@ -28,7 +28,7 @@ rows.each do |row|
 end
 ```
 
-when you're done you can call `#close` to disconnect from Cassandra. You can connect to multiple Cassandra nodes by passing multiple comma separated host names to the `:host` option.
+when you're done you can call `#close` to disconnect from Cassandra. You can connect to multiple Cassandra nodes by passing multiple comma separated host names to the `:host` option -- _this is deprecated, in v1.1.0 there is a new option `:hosts` that takes a list of host names_.
 
 # Usage
 
@@ -203,19 +203,36 @@ Yes it is, and your data is probably safe. cql-rb is just not completely there y
 
 ## Something else is not working
 
-Open an issue and I'll do my best to help you. Please include the gem version, Casandra version and Ruby version, and explain as much about what you're doing as you can, preferably the smallest piece of code that reliably triggers the problem.
+Open an issue and someone will try to help you out. Please include the gem version, Casandra version and Ruby version, and explain as much about what you're doing as you can, preferably the smallest piece of code that reliably triggers the problem. The more information you give, the better the chances you will get help.
+
+# Changelog & versioning
+
+Check out the [releases on GitHub](https://github.com/iconara/cql-rb/releases). Version numbering follows the [semantic versioning](http://semver.org/) scheme.
 
 # Known bugs & limitations
 
-* No automatic peer discovery.
-* No automatic reconnection on connection failures.
-* JRuby 1.6.8 and earlier is not supported, although it probably works fine. The only known issue is that connection failures aren't handled gracefully.
-* Compression is not supported.
+* No automatic peer discovery -- _this is in HEAD and will be released with v1.1.0_.
+* No automatic reconnection on connection failures -- _this is planned for v1.1.0_.
+* No support for request timeouts (other than server-initiated), but requests to a node fail when that node goes down.
+* No support for compression.
+* No support for request tracing.
+* JRuby 1.6.8 and earlier is not supported, the tests pass in 1.6.8, but 1.6.4 is known not to work. Travis does not support JRuby 1.6.x so there's no way to get good coverage of what works and not. The only known issue in 1.6.8 is that connection failures aren't handled correctly.
 * Large results are buffered in memory until the whole response has been loaded, the protocol makes it possible to start to deliver rows to the client code as soon as the metadata is loaded, but this is not supported yet.
 * There is no cluster introspection utilities (like the `DESCRIBE` commands in `cqlsh`).
-* No support for request tracing.
 
-## Copyright
+# How to contribute
+
+Fork the repository, make your changes in a topic branch that branches off from the right place in the history (HEAD isn't necessarily always right), make your changes and finally submit a pull request.
+
+Follow the style of the existing code, make sure that existing tests pass, and that everything new has good test coverage. Put some effort into writing clear and concise commit messages, and write a good pull request description.
+
+It takes time to understand other people's code, and even more time to understand a patch, so do as much as you can to make the maintainers' work easier. Be prepared for rejection, many times a feature is already planned, or the proposed design would be in the way of other planned features, or the maintainers' just feel that it will be faster to implement the features themselves than to try to integrate your patch.
+
+Feel free to open a pull request before the feature is finished, that way you can have a conversation with the maintainers' during the development, and you can make adjustments to the design as you go along instead of having your whole feature rejected because of reasons such as those above. If you do, please make it clear that the pull request is a work in progress, or a request for comment.
+
+Always remember that the maintainers' work on this project in their free time and that they don't work for you, or for your benefit. They have no obligation to do what you think is right -- but if you're nice they might anyway.
+
+# Copyright
 
 Copyright 2013 Theo Hultberg/Iconara
 

data/lib/cql/client/asynchronous_client.rb

@@ -108,8 +108,9 @@ module Cql
 
       private
 
-      KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$/
+      KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$|^"\w[\w\d_]*"$/
       DEFAULT_CONSISTENCY_LEVEL = :quorum
+      BIND_ALL_IP = '0.0.0.0'.freeze
 
       class FailedConnection
         attr_reader :error
@@ -170,14 +171,21 @@ module Cql
         connected_seeds = seed_connections.select(&:connected?)
         connection = connected_seeds.sample
         return Future.completed([]) unless connection
-        request = Protocol::QueryRequest.new('SELECT data_center, host_id, rpc_address FROM system.peers', :one)
+        request = Protocol::QueryRequest.new('SELECT peer, data_center, host_id, rpc_address FROM system.peers', :one)
         peer_info = execute_request(request, connection)
         peer_info.flat_map do |result|
           seed_dcs = connected_seeds.map { |c| c[:data_center] }.uniq
           unconnected_peers = result.select do |row|
             seed_dcs.include?(row['data_center']) && connected_seeds.none? { |c| c[:host_id] == row['host_id'] }
           end
-          node_addresses = unconnected_peers.map { |row| row['rpc_address'].to_s }
+          node_addresses = unconnected_peers.map do |row|
+            rpc_address = row['rpc_address'].to_s
+            if rpc_address == BIND_ALL_IP
+              row['peer']
+            else
+              rpc_address
+            end
+          end
           if node_addresses.any?
             connect_to_hosts(node_addresses, initial_keyspace, false)
           else

data/lib/cql/io.rb

@@ -2,6 +2,7 @@
 
 module Cql
   IoError = Class.new(CqlError)
+  CancelledError = Class.new(CqlError)
 
   module Io
     ConnectionError = Class.new(IoError)

data/lib/cql/io/connection.rb

@@ -13,13 +13,13 @@ module Cql
       attr_reader :host, :port, :connection_timeout
 
       # @private
-      def initialize(host, port, connection_timeout, unblocker, socket_impl=Socket, clock=Time)
+      def initialize(host, port, connection_timeout, unblocker, clock, socket_impl=Socket)
         @host = host
         @port = port
         @connection_timeout = connection_timeout
         @unblocker = unblocker
-        @socket_impl = socket_impl
         @clock = clock
+        @socket_impl = socket_impl
         @lock = Mutex.new
         @connected = false
         @write_buffer = ByteBuffer.new

data/lib/cql/io/io_reactor.rb

@@ -89,6 +89,7 @@ module Cql
       #
       def initialize(protocol_handler_factory, options={})
         @protocol_handler_factory = protocol_handler_factory
+        @clock = options[:clock] || Time
         @unblocker = Unblocker.new
         @io_loop = IoLoopBody.new(options)
         @io_loop.add_socket(@unblocker)
@@ -138,6 +139,7 @@ module Cql
             @io_loop.tick until @stopped
           ensure
             @io_loop.close_sockets
+            @io_loop.cancel_timers
             @running = false
             if $!
               @stopped_future.fail!($!)
@@ -180,7 +182,7 @@ module Cql
       #   object that will be your interface to interact with the connection
       #
       def connect(host, port, timeout)
-        connection = Connection.new(host, port, timeout, @unblocker)
+        connection = Connection.new(host, port, timeout, @unblocker, @clock)
         f = connection.connect
         protocol_handler = @protocol_handler_factory.new(connection)
         @io_loop.add_socket(connection)
@@ -188,6 +190,18 @@ module Cql
         f.map { protocol_handler }
       end
 
+      # Returns a future that completes after the specified number of seconds.
+      #
+      # @param timeout [Float] the number of seconds to wait until the returned
+      #   future is completed
+      # @return [Cql::Future] a future that completes when the timer expires
+      #
+      def schedule_timer(timeout)
+        f = Future.new
+        @io_loop.schedule_timer(timeout, f)
+        f
+      end
+
       def to_s
         @io_loop.to_s
       end
@@ -250,8 +264,10 @@ module Cql
     class IoLoopBody
       def initialize(options={})
         @selector = options[:selector] || IO
+        @clock = options[:clock] || Time
         @lock = Mutex.new
         @sockets = []
+        @timers = []
       end
 
       def add_socket(socket)
@@ -262,6 +278,15 @@ module Cql
         end
       end
 
+      def schedule_timer(timeout, future)
+        @lock.synchronize do
+          timers = @timers.dup
+          timers << [@clock.now + timeout, future]
+          timers.sort_by(&:first)
+          @timers = timers
+        end
+      end
+
       def close_sockets
         @sockets.each do |s|
           begin
@@ -272,7 +297,27 @@ module Cql
         end
       end
 
+      def cancel_timers
+        @timers.each do |pair|
+          if pair[1]
+            pair[1].fail!(CancelledError.new)
+            pair[1] = nil
+          end
+        end
+      end
+
       def tick(timeout=1)
+        check_sockets!(timeout)
+        check_timers!
+      end
+
+      def to_s
+        %(#<#{IoReactor.name} @connections=[#{@sockets.map(&:to_s).join(', ')}]>)
+      end
+
+      private
+
+      def check_sockets!(timeout)
         readables, writables, connecting = [], [], []
         sockets = @sockets
         sockets.reject! { |s| s.closed? }
@@ -287,8 +332,14 @@ module Cql
         w && w.each(&:flush)
       end
 
-      def to_s
-        %(#<#{IoReactor.name} @connections=[#{@sockets.map(&:to_s).join(', ')}]>)
+      def check_timers!
+        timers = @timers
+        timers.each do |pair|
+          break unless pair[0] <= @clock.now && pair[1]
+          pair[1].complete!
+          pair[1] = nil
+        end
+        timers.reject! { |pair| pair[1].nil? }
       end
     end
   end

data/lib/cql/protocol/decoding.rb

@@ -31,15 +31,34 @@ module Cql
       def read_decimal!(buffer, length=buffer.length)
         size = read_int!(buffer)
         number_string = read_varint!(buffer, length - 4).to_s
-        fraction_string = number_string[0, number_string.length - size] << DECIMAL_POINT << number_string[number_string.length - size, number_string.length]
+        if number_string.length < size
+          if number_string.start_with?(MINUS)
+            number_string = number_string[1, number_string.length - 1]
+            fraction_string = MINUS + ZERO << DECIMAL_POINT
+          else
+            fraction_string = ZERO + DECIMAL_POINT
+          end
+          (size - number_string.length).times { fraction_string << ZERO }
+          fraction_string << number_string
+        else
+          fraction_string = number_string[0, number_string.length - size]
+          fraction_string << DECIMAL_POINT
+          fraction_string << number_string[number_string.length - size, number_string.length]
+        end
         BigDecimal.new(fraction_string)
       rescue RangeError => e
         raise DecodingError, e.message, e.backtrace
       end
 
       def read_long!(buffer)
-        top, bottom = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
-        (top << 32) | bottom
+        hi, lo = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
+        if (hi > 0x7fffffff)
+          hi ^= 0xffffffff
+          lo ^= 0xffffffff
+          0 - (hi << 32) - lo - 1
+        else
+          (hi << 32) + lo
+        end
       rescue RangeError => e
         raise DecodingError, e.message, e.backtrace
       end
@@ -57,7 +76,11 @@ module Cql
       end
 
       def read_int!(buffer)
-        buffer.read_int
+        val = buffer.read_int
+        if (val > 0x7fffffff)
+          val = 0 - ((val - 1) ^ 0xffffffff)
+        end
+        val
       rescue RangeError => e
         raise DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
       end
@@ -161,6 +184,8 @@ module Cql
 
       private
 
+      MINUS = '-'.freeze
+      ZERO = '0'.freeze
       DECIMAL_POINT = '.'.freeze
     end
   end

data/lib/cql/protocol/type_converter.rb

@@ -36,27 +36,35 @@ module Cql
       def to_bytes(io, type, value, size_bytes=4)
         case type
         when Array
-          unless value.is_a?(Enumerable)
+          unless value.nil? || value.is_a?(Enumerable)
             raise InvalidValueError, 'Value for collection must be enumerable'
           end
           case type.first
           when :list, :set
             _, sub_type = type
-            raw = ''
-            write_short(raw, value.size)
-            value.each do |element|
-              to_bytes(raw, sub_type, element, 2)
+            if value
+              raw = ''
+              write_short(raw, value.size)
+              value.each do |element|
+                to_bytes(raw, sub_type, element, 2)
+              end
+              write_bytes(io, raw)
+            else
+              nil_to_bytes(io, size_bytes)
             end
-            write_bytes(io, raw)
           when :map
             _, key_type, value_type = type
-            raw = ''
-            write_short(raw, value.size)
-            value.each do |key, value|
-              to_bytes(raw, key_type, key, 2)
-              to_bytes(raw, value_type, value, 2)
+            if value
+              raw = ''
+              write_short(raw, value.size)
+              value.each do |key, value|
+                to_bytes(raw, key_type, key, 2)
+                to_bytes(raw, value_type, value, 2)
+              end
+              write_bytes(io, raw)
+            else
+              nil_to_bytes(io, size_bytes)
             end
-            write_bytes(io, raw)
           else
             raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
           end
@@ -229,7 +237,7 @@ module Cql
       end
 
       def ascii_to_bytes(io, value, size_bytes)
-        v = value.encode(::Encoding::ASCII)
+        v = value && value.encode(::Encoding::ASCII)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -238,16 +246,16 @@ module Cql
       end
 
       def bigint_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 8)
+        if value
+          size_to_bytes(io, 8, size_bytes)
+          write_long(io, value)
         else
-          write_short(io, 8)
+          nil_to_bytes(io, size_bytes)
         end
-        write_long(io, value)
       end
 
       def blob_to_bytes(io, value, size_bytes)
-        v = value.encode(::Encoding::BINARY)
+        v = value && value.encode(::Encoding::BINARY)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -256,16 +264,16 @@ module Cql
       end
 
       def boolean_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 1)
+        if !value.nil?
+          size_to_bytes(io, 1, size_bytes)
+          io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
         else
-          write_short(io, 1)
+          nil_to_bytes(io, size_bytes)
         end
-        io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
       end
 
       def decimal_to_bytes(io, value, size_bytes)
-        raw = write_decimal('', value)
+        raw = value && write_decimal('', value)
         if size_bytes == 4
           write_bytes(io, raw)
         else
@@ -274,43 +282,43 @@ module Cql
       end
 
       def double_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 8)
+        if value
+          size_to_bytes(io, 8, size_bytes)
+          write_double(io, value)
         else
-          write_short(io, 8)
+          nil_to_bytes(io, size_bytes)
         end
-        write_double(io, value)
       end
 
       def float_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 4)
+        if value
+          size_to_bytes(io, 4, size_bytes)
+          write_float(io, value)
         else
-          write_short(io, 4)
+          nil_to_bytes(io, size_bytes)
         end
-        write_float(io, value)
       end
 
       def inet_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, value.ipv6? ? 16 : 4)
+        if value
+          size_to_bytes(io, value.ipv6? ? 16 : 4, size_bytes)
+          io << value.hton
         else
-          write_short(io, value.ipv6? ? 16 : 4)
+          nil_to_bytes(io, size_bytes)
         end
-        io << value.hton
       end
 
       def int_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 4)
+        if value
+          size_to_bytes(io, 4, size_bytes)
+          write_int(io, value)
         else
-          write_short(io, 4)
+          nil_to_bytes(io, size_bytes)
         end
-        write_int(io, value)
       end
 
       def varchar_to_bytes(io, value, size_bytes)
-        v = value.encode(::Encoding::UTF_8)
+        v = value && value.encode(::Encoding::UTF_8)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -319,32 +327,48 @@ module Cql
       end
 
       def timestamp_to_bytes(io, value, size_bytes)
-        ms = (value.to_f * 1000).to_i
-        if size_bytes == 4
-          write_int(io, 8)
+        if value
+          ms = (value.to_f * 1000).to_i
+          size_to_bytes(io, 8, size_bytes)
+          write_long(io, ms)
         else
-          write_short(io, 8)
+          nil_to_bytes(io, size_bytes)
         end
-        write_long(io, ms)
       end
 
       def uuid_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 16)
+        if value
+          size_to_bytes(io, 16, size_bytes)
+          write_uuid(io, value)
         else
-          write_short(io, 16)
+          nil_to_bytes(io, size_bytes)
         end
-        write_uuid(io, value)
       end
 
       def varint_to_bytes(io, value, size_bytes)
-        raw = write_varint('', value)
+        raw = value && write_varint('', value)
         if size_bytes == 4
           write_bytes(io, raw)
         else
           write_short_bytes(io, raw)
         end
       end
+
+      def size_to_bytes(io, size, size_bytes)
+        if size_bytes == 4
+          write_int(io, size)
+        else
+          write_short(io, size)
+        end
+      end
+
+      def nil_to_bytes(io, size_bytes)
+        if size_bytes == 4
+          write_int(io, -1)
+        else
+          write_short(io, -1)
+        end
+      end
     end
   end
 end

data/lib/cql/uuid.rb

@@ -52,7 +52,7 @@ module Cql
 
     # @private
     def eql?(other)
-      self.value == other.value
+      other.kind_of?(Uuid) && self.value == other.value
     end
     alias_method :==, :eql?
 
@@ -71,4 +71,4 @@ module Cql
       n
     end
   end
-end
+end

data/lib/cql/version.rb

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

data/spec/cql/client/asynchronous_client_spec.rb

@@ -188,6 +188,10 @@ module Cql
             Array.new(5) { IPAddr.new("127.0.#{rand(255)}.#{rand(255)}") }
           end
 
+          let :bind_all_rpc_addresses do
+            false
+          end
+
           before do
             uuid_generator = TimeUuid::Generator.new
             additional_rpc_addresses = additional_nodes.dup
@@ -210,7 +214,12 @@ module Cql
                     end
                     rows = other_host_ids.map do |host_id|
                       ip = additional_rpc_addresses.shift
-                      {'host_id' => host_id, 'data_center' => data_centers[ip], 'rpc_address' => ip}
+                      {
+                        'peer' => ip,
+                        'host_id' => host_id,
+                        'data_center' => data_centers[ip],
+                        'rpc_address' => bind_all_rpc_addresses ? IPAddr.new('0.0.0.0') : ip
+                      }
                     end
                     Protocol::RowsResultResponse.new(rows, peer_metadata)
                   end
@@ -224,6 +233,17 @@ module Cql
             connections.should have(3).items
           end
 
+          context 'when the nodes have 0.0.0.0 as rpc_address' do
+            let :bind_all_rpc_addresses do
+              true
+            end
+
+            it 'falls back on using the peer column' do
+              client.connect.get
+              connections.should have(3).items
+            end
+          end
+
           it 'connects to the other nodes in the same data center' do
             data_centers[additional_nodes[1]] = 'dc2'
             client.connect.get
@@ -408,6 +428,17 @@ module Cql
           client.connect.get
           expect { client.use('system; DROP KEYSPACE system').get }.to raise_error(InvalidKeyspaceNameError)
         end
+
+        it 'allows the keyspace name to be quoted' do
+          handle_request do |request|
+            if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE "system"'
+              Protocol::SetKeyspaceResultResponse.new('system')
+            end
+          end
+          client.connect.get
+          client.use('"system"').get
+          client.keyspace.should == "system"
+        end
       end
 
       describe '#execute' do
@@ -691,4 +722,4 @@ module Cql
       end
     end
   end
-end
+end

data/spec/cql/io/connection_spec.rb

@@ -7,7 +7,7 @@ module Cql
   module Io
     describe Connection do
       let :handler do
-        described_class.new('example.com', 55555, 5, unblocker, socket_impl, clock)
+        described_class.new('example.com', 55555, 5, unblocker, clock, socket_impl)
       end
 
       let :unblocker do

data/spec/cql/io/io_reactor_spec.rb

@@ -7,7 +7,7 @@ module Cql
   module Io
     describe IoReactor do
       let :reactor do
-        described_class.new(protocol_handler_factory, selector: selector)
+        described_class.new(protocol_handler_factory, selector: selector, clock: clock)
       end
 
       let :protocol_handler_factory do
@@ -18,6 +18,10 @@ module Cql
         IoReactorSpec::FakeSelector.new
       end
 
+      let :clock do
+        stub(:clock, now: 0)
+      end
+
       describe '#start' do
         after do
           reactor.stop.get if reactor.running?
@@ -84,6 +88,20 @@ module Cql
           reactor.stop.get
           connection.should be_closed
         end
+
+        it 'cancels all active timers' do
+          reactor.start.get
+          clock.stub(:now).and_return(1)
+          expired_timer = reactor.schedule_timer(1)
+          active_timer1 = reactor.schedule_timer(999)
+          active_timer2 = reactor.schedule_timer(111)
+          expired_timer.should_not_receive(:fail!)
+          clock.stub(:now).and_return(2)
+          await { expired_timer.complete? }
+          reactor.stop.get
+          active_timer1.should be_failed
+          active_timer2.should be_failed
+        end
       end
 
       describe '#on_error' do
@@ -163,6 +181,23 @@ module Cql
         end
       end
 
+      describe '#schedule_timer' do
+        before do
+          reactor.start.get
+        end
+
+        after do
+          reactor.stop.get
+        end
+
+        it 'returns a future that completes after the specified duration' do
+          clock.stub(:now).and_return(1)
+          f = reactor.schedule_timer(0.1)
+          clock.stub(:now).and_return(1.1)
+          await { f.complete? }
+        end
+      end
+
       describe '#to_s' do
         context 'returns a string that' do
           it 'includes the class name' do
@@ -179,13 +214,17 @@ module Cql
 
     describe IoLoopBody do
       let :loop_body do
-        described_class.new(selector: selector)
+        described_class.new(selector: selector, clock: clock)
       end
 
       let :selector do
         stub(:selector)
       end
 
+      let :clock do
+        stub(:clock, now: 0)
+      end
+
       let :socket do
         stub(:socket, connected?: false, connecting?: false, writable?: false, closed?: false)
       end
@@ -252,6 +291,30 @@ module Cql
           selector.should_receive(:select).with(anything, anything, anything, 99).and_return([[], [], []])
           loop_body.tick(99)
         end
+
+        it 'completes timers that have expired' do
+          selector.stub(:select).and_return([nil, nil, nil])
+          clock.stub(:now).and_return(1)
+          future = Future.new
+          loop_body.schedule_timer(1, future)
+          loop_body.tick
+          future.should_not be_complete
+          clock.stub(:now).and_return(2)
+          loop_body.tick
+          future.should be_complete
+        end
+
+        it 'clears out timers that have expired' do
+          selector.stub(:select).and_return([nil, nil, nil])
+          clock.stub(:now).and_return(1)
+          future = Future.new
+          loop_body.schedule_timer(1, future)
+          clock.stub(:now).and_return(2)
+          loop_body.tick
+          future.should be_complete
+          future.should_not_receive(:complete!)
+          loop_body.tick
+        end
       end
 
       describe '#close_sockets' do
@@ -282,6 +345,29 @@ module Cql
           loop_body.close_sockets
         end
       end
+
+      describe '#cancel_timers' do
+        before do
+          selector.stub(:select).and_return([nil, nil, nil])
+        end
+
+        it 'fails all active timers with a CancelledError' do
+          f1 = Future.new
+          f2 = Future.new
+          f3 = Future.new
+          clock.stub(:now).and_return(1)
+          loop_body.schedule_timer(1, f1)
+          loop_body.schedule_timer(3, f2)
+          loop_body.schedule_timer(3, f3)
+          clock.stub(:now).and_return(2)
+          loop_body.tick
+          loop_body.cancel_timers
+          f1.should be_complete
+          f2.should be_failed
+          f3.should be_failed
+          expect { f3.get }.to raise_error(CancelledError)
+        end
+      end
     end
   end
 end

data/spec/cql/protocol/decoding_spec.rb

@@ -62,6 +62,21 @@ module Cql
           Decoding.read_decimal!(buffer).should == BigDecimal.new('1042342234234.123423435647768234')
         end
 
+        it 'decodes a negative decimal' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x12\xF2\xD8\x02\xB6R\x7F\x99\xEE\x98#\x99\xA9V")
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('-1042342234234.123423435647768234')
+        end
+
+        it 'decodes a positive decimal with only fractions' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x13*\xF8\xC4\xDF\xEB]o")
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('0.0012095473475870063')
+        end
+
+        it 'decodes a negative decimal with only fractions' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x13\xD5\a;\x20\x14\xA2\x91")
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('-0.0012095473475870063')
+        end
+
         it 'consumes the bytes' do
           buffer << 'HELLO'
           Decoding.read_decimal!(buffer, buffer.length - 5)
@@ -79,11 +94,16 @@ module Cql
       end
 
       describe '#read_long!' do
-        it 'decodes a long' do
+        it 'decodes a positive long' do
           buffer = ByteBuffer.new("\x00\x00\xca\xfe\xba\xbe\x00\x00")
           Decoding.read_long!(buffer).should == 0x0000cafebabe0000
         end
 
+        it 'decodes a negative long' do
+          buffer = ByteBuffer.new("\xff\xff\xff\xff\xff\xff\xff\xff")
+          Decoding.read_long!(buffer).should == -1
+        end
+
         it 'consumes the bytes' do
           buffer = ByteBuffer.new("\xca\xfe\xba\xbe\xca\xfe\xba\xbe\xca\xfe\xba\xbe")
           Decoding.read_long!(buffer)
@@ -137,10 +157,15 @@ module Cql
           ByteBuffer.new("\x00\xff\x00\xff")
         end
 
-        it 'decodes an int' do
+        it 'decodes a positive int' do
           Decoding.read_int!(buffer).should == 0x00ff00ff
         end
 
+        it 'decodes a negative int' do
+          buffer = ByteBuffer.new("\xff\xff\xff\xff")
+          Decoding.read_int!(buffer).should == -1
+        end
+
         it 'consumes the bytes' do
           buffer << "\xab\xcd"
           Decoding.read_int!(buffer)

data/spec/cql/protocol/type_converter_spec.rb

@@ -0,0 +1,52 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe TypeConverter do
+      let :converter do
+        described_class.new
+      end
+
+      let :buffer do
+        ''
+      end
+
+      TYPES = [:ascii, :bigint, :blob, :boolean, :decimal, :double, :float, :inet, :int, :text, :varchar, :timestamp, :timeuuid, :uuid, :varint].freeze
+
+      describe '#to_bytes' do
+        context 'when encoding normal value' do
+          TYPES.each do |type|
+            it "encodes a null #{type.upcase}" do
+              converter.to_bytes(buffer, type, nil, 4).should == "\xff\xff\xff\xff"
+            end
+          end
+
+          it 'encodes a null LIST' do
+            converter.to_bytes(buffer, [:list, :int], nil, 4).should == "\xff\xff\xff\xff"
+          end
+
+          it 'encodes a null MAP' do
+            converter.to_bytes(buffer, [:map, :text, :text], nil, 4).should == "\xff\xff\xff\xff"
+
+          end
+
+          it 'encodes a null SET' do
+            converter.to_bytes(buffer, [:set, :uuid], nil, 4).should == "\xff\xff\xff\xff"
+
+          end
+        end
+
+        context 'when encoding collection values' do
+          TYPES.each do |type|
+            it "encodes a null #{type.upcase}" do
+              converter.to_bytes(buffer, type, nil, 2).should == "\xff\xff"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cql/uuid_spec.rb

@@ -36,6 +36,10 @@ module Cql
         Uuid.new(276263553384940695775376958868900023510).should eql(Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'))
       end
 
+      it 'is not equal when anything other than a Uuid is passed' do
+        [nil, 123, 'test'].each { |v| Uuid.new(276263553384940695775376958868900023510).should_not eql(v) }
+      end
+
       it 'aliases #== to #eql?' do
         Uuid.new(276263553384940695775376958868900023510).should == Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6')
       end
@@ -73,4 +77,4 @@ module Cql
       end
     end
   end
-end
+end

data/spec/integration/protocol_spec.rb

@@ -291,12 +291,12 @@ describe 'Protocol parsing and communication' do
           end
         end
 
-        # it 'sends a TRUNCATE command' do
-        #   in_keyspace_with_table do
-        #     response = query(%<TRUNCATE users>)
-        #     response.should be_void
-        #   end
-        # end
+        it 'sends a TRUNCATE command' do
+          in_keyspace_with_table do
+            response = query(%<TRUNCATE users>)
+            response.should be_void
+          end
+        end
 
         it 'sends a BATCH command' do
           in_keyspace_with_table do

data/spec/integration/regression_spec.rb

@@ -65,15 +65,7 @@ describe 'Regressions' do
   end
 
   context 'with null values' do
-    it 'decodes null counters' do
-      client.execute(%<CREATE TABLE counters (id ASCII, counter1 COUNTER, counter2 COUNTER, PRIMARY KEY (id))>)
-      client.execute(%<UPDATE counters SET counter1 = counter1 + 1 WHERE id = 'foo'>)
-      result = client.execute(%<SELECT counter1, counter2 FROM counters WHERE id = 'foo'>)
-      result.first['counter1'].should == 1
-      result.first['counter2'].should be_nil
-    end
-
-    it 'decodes null values' do
+    before do
       client.execute(<<-CQL)
         CREATE TABLE lots_of_types (
           id               INT,
@@ -98,6 +90,24 @@ describe 'Regressions' do
           PRIMARY KEY (id)
         )
       CQL
+      client.execute(<<-CQL)
+        CREATE TABLE counters (
+          id ASCII,
+          counter1 COUNTER,
+          counter2 COUNTER,
+          PRIMARY KEY (id)
+        )
+      CQL
+    end
+
+    it 'decodes null counters' do
+      client.execute(%<UPDATE counters SET counter1 = counter1 + 1 WHERE id = 'foo'>)
+      result = client.execute(%<SELECT counter1, counter2 FROM counters WHERE id = 'foo'>)
+      result.first['counter1'].should == 1
+      result.first['counter2'].should be_nil
+    end
+
+    it 'decodes null values' do
       client.execute(%<INSERT INTO lots_of_types (id) VALUES (3)>)
       result = client.execute(%<SELECT * FROM lots_of_types WHERE id = 3>)
       row = result.first
@@ -120,5 +130,79 @@ describe 'Regressions' do
       row['map_column'].should be_nil
       row['set_column'].should be_nil
     end
+
+    it 'encodes null values' do
+      statement = client.prepare(<<-CQL)
+        UPDATE lots_of_types
+        SET
+          ascii_column = ?,
+          bigint_column = ?,
+          blob_column = ?,
+          boolean_column = ?,
+          decimal_column = ?,
+          double_column = ?,
+          float_column = ?,
+          int_column = ?,
+          text_column = ?,
+          timestamp_column = ?,
+          uuid_column = ?,
+          varchar_column = ?,
+          varint_column = ?,
+          timeuuid_column = ?,
+          inet_column = ?,
+          list_column = ?,
+          map_column = ?,
+          set_column = ?
+        WHERE id = 1
+      CQL
+      statement.execute(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+    end
+  end
+
+  context 'with negative numbers' do
+    it 'decodes negative counters' do
+      client.execute(%<CREATE TABLE counters (id ASCII, counter1 COUNTER, PRIMARY KEY (id))>)
+      client.execute(%<UPDATE counters SET counter1 = counter1 - 1 WHERE id = 'foo'>)
+      result = client.execute(%<SELECT counter1 FROM counters WHERE id = 'foo'>)
+      result.first['counter1'].should == -1
+    end
+
+    it 'decodes negative numbers' do
+      client.execute(<<-CQL)
+        CREATE TABLE lots_of_types (
+          id               INT,
+          bigint_column    BIGINT,
+          decimal_column   DECIMAL,
+          double_column    DOUBLE,
+          float_column     FLOAT,
+          int_column       INT,
+          varint_column    VARINT,
+          PRIMARY KEY (id)
+        )
+      CQL
+      client.execute(%<INSERT INTO lots_of_types (id, bigint_column, decimal_column, double_column, float_column, int_column, varint_column) VALUES (0, -1, -1, -1, -1, -1, -1)>)
+      client.execute(%<INSERT INTO lots_of_types (id, bigint_column, decimal_column, double_column, float_column, int_column, varint_column) VALUES (1, -9223372036854775808, -0.0012095473475870063, -2.2250738585072014e-308, -1.175494351e-38, -2147483648, -23454545674351234123365765786894351234567456)>)
+      result = client.execute(%<SELECT * FROM lots_of_types WHERE id IN (0, 1)>)
+      row0, row1 = result.to_a
+      row0['bigint_column'].should == -1
+      row0['decimal_column'].should == -1
+      row0['double_column'].should == -1
+      row0['float_column'].should == -1
+      row0['int_column'].should == -1
+      row0['varint_column'].should == -1
+      row1['bigint_column'].should == -9223372036854775808
+      row1['decimal_column'].should == BigDecimal.new('-0.0012095473475870063')
+      row1['double_column'].should == be_within(1.0e-308).of(-2.2250738585072014e-308)
+      row1['float_column'].should be_within(1.0e-38).of(-1.175494351e-38)
+      row1['int_column'].should == -2147483648
+      row1['varint_column'].should == -23454545674351234123365765786894351234567456
+    end
+  end
+
+  context 'with quoted keyspace names' do
+    it 'handles quoted keyspace names' do
+      client.use('"system"')
+      client.keyspace.should == 'system'
+    end
   end
 end

data/spec/support/fake_io_reactor.rb

@@ -23,7 +23,9 @@ class FakeIoReactor
   end
 
   def connect(host, port, timeout)
-    if @down_nodes.include?(host)
+    if host == '0.0.0.0'
+      Cql::Future.failed(Cql::Io::ConnectionError.new('Can\'t connect to 0.0.0.0'))
+    elsif @down_nodes.include?(host)
       Cql::Future.failed(Cql::Io::ConnectionError.new('Node down'))
     else
       connection = FakeConnection.new(host, port, timeout)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 1.1.0.pre1
+  version: 1.1.0.pre2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-24 00:00:00.000000000 Z
+date: 2013-08-27 00:00:00.000000000 Z
 dependencies: []
 description: A pure Ruby CQL3 driver for Cassandra
 email:
@@ -91,6 +91,7 @@ files:
 - spec/cql/protocol/requests/startup_request_spec.rb
 - spec/cql/protocol/response_frame_spec.rb
 - spec/cql/protocol/responses/schema_change_result_response_spec.rb
+- spec/cql/protocol/type_converter_spec.rb
 - spec/cql/time_uuid_spec.rb
 - spec/cql/uuid_spec.rb
 - spec/integration/client_spec.rb
@@ -105,7 +106,7 @@ files:
 - spec/support/fake_server.rb
 homepage: http://github.com/iconara/cql-rb
 licenses:
-- Apache
+- Apache License 2.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -152,6 +153,7 @@ test_files:
 - spec/cql/protocol/requests/startup_request_spec.rb
 - spec/cql/protocol/response_frame_spec.rb
 - spec/cql/protocol/responses/schema_change_result_response_spec.rb
+- spec/cql/protocol/type_converter_spec.rb
 - spec/cql/time_uuid_spec.rb
 - spec/cql/uuid_spec.rb
 - spec/integration/client_spec.rb