cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/spec/cql/io/io_reactor_spec.rb

@@ -1,402 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-
-module Cql
-  module Io
-    describe IoReactor do
-      let :reactor do
-        described_class.new(protocol_handler_factory, selector: selector, clock: clock)
-      end
-
-      let :protocol_handler_factory do
-        double(:protocol_handler_factory)
-      end
-
-      let! :selector do
-        IoReactorSpec::FakeSelector.new
-      end
-
-      let :clock do
-        double(:clock, now: 0)
-      end
-
-      describe '#start' do
-        after do
-          reactor.stop.value if reactor.running?
-        end
-
-        it 'returns a future that is resolved when the reactor has started' do
-          reactor.start.value
-        end
-
-        it 'returns a future that resolves to the reactor' do
-          reactor.start.value.should equal(reactor)
-        end
-
-        it 'is running after being started' do
-          reactor.start.value
-          reactor.should be_running
-        end
-
-        it 'cannot be started again once stopped' do
-          reactor.start.value
-          reactor.stop.value
-          expect { reactor.start }.to raise_error(ReactorError)
-        end
-
-        it 'calls the selector' do
-          called = false
-          selector.handler { called = true; [[], [], []] }
-          reactor.start.value
-          await { called }
-          reactor.stop.value
-          called.should be_true, 'expected the selector to have been called'
-        end
-      end
-
-      describe '#stop' do
-        after do
-          reactor.stop.value if reactor.running?
-        end
-
-        it 'returns a future that is resolved when the reactor has stopped' do
-          reactor.start.value
-          reactor.stop.value
-        end
-
-        it 'returns a future which resolves to the reactor' do
-          reactor.start.value
-          reactor.stop.value.should equal(reactor)
-        end
-
-        it 'is not running after being stopped' do
-          reactor.start.value
-          reactor.stop.value
-          reactor.should_not be_running
-        end
-
-        it 'closes all sockets' do
-          connection = nil
-          protocol_handler_factory.stub(:new) do |sh, _|
-            connection = sh
-            double(:protocol_handler)
-          end
-          reactor.start.value
-          reactor.connect('example.com', 9999, 5)
-          reactor.stop.value
-          connection.should be_closed
-        end
-
-        it 'cancels all active timers' do
-          reactor.start.value
-          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.completed? }
-          reactor.stop.value
-          active_timer1.should be_failed
-          active_timer2.should be_failed
-        end
-      end
-
-      describe '#on_error' do
-        before do
-          selector.handler { raise 'Blurgh' }
-        end
-
-        it 'calls the listeners when the reactor crashes' do
-          error = nil
-          reactor.on_error { |e| error = e }
-          reactor.start
-          await { error }
-          error.message.should == 'Blurgh'
-        end
-
-        it 'calls the listener immediately when the reactor has already crashed' do
-          error = nil
-          reactor.start.value
-          await { !reactor.running? }
-          reactor.on_error { |e| error = e }
-          await { error }
-        end
-
-        it 'ignores errors raised by listeners' do
-          called = false
-          reactor.on_error { raise 'Blurgh' }
-          reactor.on_error { called = true }
-          reactor.start
-          await { called }
-          called.should be_true, 'expected all close listeners to have been called'
-        end
-      end
-
-      describe '#connect' do
-        let :protocol_handler do
-          double(:protocol_handler)
-        end
-
-        before do
-          protocol_handler_factory.stub(:call) do |connection, _|
-            connection.to_io.stub(:connect_nonblock)
-            protocol_handler.stub(:connection).and_return(connection)
-            protocol_handler
-          end
-        end
-
-        before do
-          selector.handler do |readables, writables, _, _|
-            writables.each do |writable|
-              fake_connected(writable)
-            end
-            [[], writables, []]
-          end
-        end
-
-        def fake_connected(connection)
-          connection.to_io.stub(:connect_nonblock)
-        end
-
-        after do
-          reactor.stop if reactor.running?
-        end
-
-        it 'calls #call on the protocol handler factory with the connection and the reactor itself' do
-          reactor.start.value
-          reactor.connect('example.com', 9999, 5).value
-          protocol_handler_factory.should have_received(:call).with(an_instance_of(Connection), reactor)
-        end
-
-        it 'calls #new on the protocol handler factory with the connection and the reactor itself' do
-          protocol_handler_factory.stub(:new)
-          reactor.start.value
-          reactor.connect('example.com', 9999, 5).value
-          protocol_handler_factory.should have_received(:new).with(an_instance_of(Connection), reactor)
-        end
-
-        it 'returns a future that resolves to a new protocol handler' do
-          reactor.start.value
-          f = reactor.connect('example.com', 9999, 5)
-          f.value.should equal(protocol_handler)
-        end
-
-        it 'returns a new protocol handler which wraps a socket handler' do
-          reactor.start.value
-          protocol_handler = reactor.connect('example.com', 9999, 5).value
-          protocol_handler.connection.should_not be_nil
-          protocol_handler.connection.host.should == 'example.com'
-          protocol_handler.connection.port.should == 9999
-          protocol_handler.connection.connection_timeout.should == 5
-        end
-      end
-
-      describe '#schedule_timer' do
-        before do
-          reactor.start.value
-        end
-
-        after do
-          reactor.stop.value
-        end
-
-        it 'returns a future that is resolved 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.resolved? }
-        end
-      end
-
-      describe '#to_s' do
-        context 'returns a string that' do
-          it 'includes the class name' do
-            reactor.to_s.should include('Cql::Io::IoReactor')
-          end
-
-          it 'includes a list of its connections' do
-            reactor.to_s.should include('@connections=[')
-            reactor.to_s.should include('#<Cql::Io::Unblocker>')
-          end
-        end
-      end
-    end
-
-    describe IoLoopBody do
-      let :loop_body do
-        described_class.new(selector: selector, clock: clock)
-      end
-
-      let :selector do
-        double(:selector)
-      end
-
-      let :clock do
-        double(:clock, now: 0)
-      end
-
-      let :socket do
-        double(:socket, connected?: false, connecting?: false, writable?: false, closed?: false)
-      end
-
-      describe '#tick' do
-        before do
-          loop_body.add_socket(socket)
-        end
-
-        it 'passes connected sockets as readables to the selector' do
-          socket.stub(:connected?).and_return(true)
-          selector.should_receive(:select).with([socket], anything, anything, anything).and_return([nil, nil, nil])
-          loop_body.tick
-        end
-
-        it 'passes writable sockets as writable to the selector' do
-          socket.stub(:writable?).and_return(true)
-          selector.should_receive(:select).with(anything, [socket], anything, anything).and_return([nil, nil, nil])
-          loop_body.tick
-        end
-
-        it 'passes connecting sockets as writable to the selector' do
-          socket.stub(:connecting?).and_return(true)
-          socket.stub(:connect)
-          selector.should_receive(:select).with(anything, [socket], anything, anything).and_return([nil, nil, nil])
-          loop_body.tick
-        end
-
-        it 'filters out closed sockets' do
-          socket.stub(:closed?).and_return(true)
-          selector.should_receive(:select).with([], [], anything, anything).and_return([nil, nil, nil])
-          loop_body.tick
-          socket.stub(:connected?).and_return(true)
-          selector.should_receive(:select).with([], [], anything, anything).and_return([nil, nil, nil])
-          loop_body.tick
-        end
-
-        it 'calls #read on all readable sockets returned by the selector' do
-          socket.stub(:connected?).and_return(true)
-          socket.should_receive(:read)
-          selector.stub(:select) do |r, w, _, _|
-            [[socket], nil, nil]
-          end
-          loop_body.tick
-        end
-
-        it 'calls #connect on all connecting sockets' do
-          socket.stub(:connecting?).and_return(true)
-          socket.should_receive(:connect)
-          selector.stub(:select).and_return([nil, nil, nil])
-          loop_body.tick
-        end
-
-        it 'calls #flush on all writable sockets returned by the selector' do
-          socket.stub(:writable?).and_return(true)
-          socket.should_receive(:flush)
-          selector.stub(:select) do |r, w, _, _|
-            [nil, [socket], nil]
-          end
-          loop_body.tick
-        end
-
-        it 'allows the caller to specify a custom timeout' do
-          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)
-          promise = Promise.new
-          loop_body.schedule_timer(1, promise)
-          loop_body.tick
-          promise.future.should_not be_completed
-          clock.stub(:now).and_return(2)
-          loop_body.tick
-          promise.future.should be_completed
-        end
-
-        it 'clears out timers that have expired' do
-          selector.stub(:select).and_return([nil, nil, nil])
-          clock.stub(:now).and_return(1)
-          promise = Promise.new
-          loop_body.schedule_timer(1, promise)
-          clock.stub(:now).and_return(2)
-          loop_body.tick
-          promise.future.should be_completed
-          promise.should_not_receive(:fulfill)
-          loop_body.tick
-        end
-      end
-
-      describe '#close_sockets' do
-        it 'closes all sockets' do
-          socket1 = double(:socket1, closed?: false)
-          socket2 = double(:socket2, closed?: false)
-          socket1.should_receive(:close)
-          socket2.should_receive(:close)
-          loop_body.add_socket(socket1)
-          loop_body.add_socket(socket2)
-          loop_body.close_sockets
-        end
-
-        it 'closes all sockets, even when one of them raises an error' do
-          socket1 = double(:socket1, closed?: false)
-          socket2 = double(:socket2, closed?: false)
-          socket1.stub(:close).and_raise('Blurgh')
-          socket2.should_receive(:close)
-          loop_body.add_socket(socket1)
-          loop_body.add_socket(socket2)
-          loop_body.close_sockets
-        end
-
-        it 'does not close already closed sockets' do
-          socket.stub(:closed?).and_return(true)
-          socket.should_not_receive(:close)
-          loop_body.add_socket(socket)
-          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
-          p1 = Promise.new
-          p2 = Promise.new
-          p3 = Promise.new
-          clock.stub(:now).and_return(1)
-          loop_body.schedule_timer(1, p1)
-          loop_body.schedule_timer(3, p2)
-          loop_body.schedule_timer(3, p3)
-          clock.stub(:now).and_return(2)
-          loop_body.tick
-          loop_body.cancel_timers
-          p1.future.should be_completed
-          p2.future.should be_failed
-          p3.future.should be_failed
-          expect { p3.future.value }.to raise_error(CancelledError)
-        end
-      end
-    end
-  end
-end
-
-module IoReactorSpec
-  class FakeSelector
-    def initialize
-      handler { [[], [], []] }
-    end
-
-    def handler(&body)
-      @body = body
-    end
-
-    def select(*args)
-      @body.call(*args)
-    end
-  end
-end

data/spec/cql/protocol/decoding_spec.rb

@@ -1,547 +0,0 @@
-# encoding: ascii-8bit
-
-require 'spec_helper'
-
-
-module Cql
-  module Protocol
-    describe Decoding do
-      describe '#read_byte!' do
-        let :buffer do
-          ByteBuffer.new("\xab")
-        end
-
-        it 'decodes a raw byte' do
-          Decoding.read_byte!(buffer).should == 0xab
-        end
-
-        it 'consumes the byte' do
-          Decoding.read_byte!(buffer)
-          buffer.should be_empty
-        end
-
-        it 'raises an error when there is no byte available' do
-          expect { Decoding.read_byte!(ByteBuffer.new) }.to raise_error(DecodingError)
-        end
-      end
-
-      describe '#read_varint!' do
-        it 'decodes a variable length integer' do
-          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
-          buffer = ByteBuffer.new("\xC9v\x8D:\x86")
-          Decoding.read_varint!(buffer, 5).should == -234234234234
-        end
-
-        it 'decodes an unsigned variable length integer' do
-          buffer = ByteBuffer.new("\xC9v\x8D:\x86")
-          Decoding.read_varint!(buffer, 5, false).should == 865277393542
-        end
-
-        it 'consumes the bytes' do
-          buffer = ByteBuffer.new("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[\x01\x02\x03")
-          Decoding.read_varint!(buffer, 17)
-          buffer.should eql_bytes("\x01\x02\x03")
-        end
-
-        it 'raises an error when there is not enough bytes available' do
-          buffer = ByteBuffer.new("\xC9v\x8D:")
-          expect { Decoding.read_varint!(buffer, 7) }.to raise_error(DecodingError)
-        end
-      end
-
-      describe '#read_decimal!' do
-        let :buffer do
-          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).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)
-          buffer.should eql_bytes('HELLO')
-        end
-
-        it 'defaults to using the buffer length' do
-          Decoding.read_decimal!(buffer.dup).should == Decoding.read_decimal!(buffer, buffer.length)
-        end
-
-        it 'raises an error when there is not enough bytes available' do
-          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 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\xee\xdd\xcc\xbb\xaa\x99\x88")
-          Decoding.read_long!(buffer).should == 0xffeeddccbbaa9988 - 0x10000000000000000
-        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)
-          buffer.should eql_bytes("\xca\xfe\xba\xbe")
-        end
-
-        it 'raises an error when there is not enough bytes available' do
-          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
-          buffer = ByteBuffer.new("@\xC3\x88\x0F\xC2\x7F\x9DU")
-          Decoding.read_double!(buffer).should == 10000.123123123
-        end
-
-        it 'consumes the bytes' do
-          buffer = ByteBuffer.new("@\xC3\x88\x0F\xC2\x7F\x9DUxyz")
-          Decoding.read_double!(buffer)
-          buffer.should eql_bytes('xyz')
-        end
-
-        it 'raises an error when there is not enough bytes available' do
-          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
-          buffer = ByteBuffer.new("AB\x14{")
-          Decoding.read_float!(buffer).should be_within(0.00001).of(12.13)
-        end
-
-        it 'consumes the bytes' do
-          buffer = ByteBuffer.new("AB\x14{xyz")
-          Decoding.read_float!(buffer)
-          buffer.should eql_bytes('xyz')
-        end
-
-        it 'raises an error when there is not enough bytes available' do
-          buffer = ByteBuffer.new("\x0F")
-          expect { Decoding.read_float!(buffer) }.to raise_error(DecodingError)
-        end
-      end
-
-      describe '#read_int!' do
-        let :buffer do
-          ByteBuffer.new("\x00\xff\x00\xff")
-        end
-
-        it 'decodes a positive int' do
-          Decoding.read_int!(buffer).should == 0x00ff00ff
-        end
-
-        it 'decodes a negative int' do
-          buffer = ByteBuffer.new("\xff\xee\xdd\xcc")
-          Decoding.read_int!(buffer).should == 0xffeeddcc - 0x100000000
-        end
-
-        it 'consumes the bytes' do
-          buffer << "\xab\xcd"
-          Decoding.read_int!(buffer)
-          buffer.should eql_bytes("\xab\xcd")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          buffer = ByteBuffer.new("\x01\xab")
-          expect { Decoding.read_int!(buffer) }.to raise_error(DecodingError)
-        end
-      end
-
-      describe '#read_short!' do
-        let :buffer do
-          ByteBuffer.new("\x00\x02")
-        end
-
-        it 'decodes a short' do
-          Decoding.read_short!(buffer).should == 2
-        end
-
-        it 'consumes the bytes' do
-          buffer << "\xff\xff"
-          Decoding.read_short!(buffer)
-          buffer.should eql_bytes("\xff\xff")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          buffer = ByteBuffer.new("\x01")
-          expect { Decoding.read_short!(buffer) }.to raise_error(DecodingError)
-        end
-      end
-
-      describe '#read_string!' do
-        let :buffer do
-          ByteBuffer.new("\x00\x0bhej och hå")
-        end
-
-        it 'decodes a string' do
-          Decoding.read_string!(buffer).should == 'hej och hå'.force_encoding(::Encoding::UTF_8)
-        end
-
-        it 'decodes a string as UTF-8' do
-          Decoding.read_string!(buffer).encoding.should == ::Encoding::UTF_8
-        end
-
-        it 'decodes an empty string' do
-          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 eql_bytes("\xff\xff")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          ByteBuffer.new("\x00\x01\x00\00" << ('x' * 0x10000))
-        end
-
-        it 'decodes a string' do
-          Decoding.read_long_string!(buffer.dup).should start_with('xxx')
-          Decoding.read_long_string!(buffer).length.should == 0x10000
-        end
-
-        it 'decodes a string as UTF-8' do
-          Decoding.read_long_string!(buffer).encoding.should == ::Encoding::UTF_8
-        end
-
-        it 'consumes the bytes' do
-          buffer << "\xff\xff"
-          Decoding.read_long_string!(buffer)
-          buffer.should eql_bytes("\xff\xff")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          ByteBuffer.new("\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11")
-        end
-
-        it 'decodes a UUID as a Cql::Uuid' do
-          Decoding.read_uuid!(buffer).should == Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
-        end
-        
-        it 'decodes a UUID as a Cql::TimeUuid' do
-          uuid = Decoding.read_uuid!(buffer, TimeUuid)
-          uuid.should == TimeUuid.new('a4a70900-24e1-11df-8924-001ff3591711')
-          uuid.should be_a(TimeUuid)
-        end
-
-        it 'consumes the bytes' do
-          Decoding.read_uuid!(buffer)
-          buffer.should be_empty
-        end
-        
-        it 'raises an error when there a not enough bytes in the buffer' do
-          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
-          ByteBuffer.new("\x00\x02\x00\x05hello\x00\x05world")
-        end
-
-        it 'decodes a string list' do
-          Decoding.read_string_list!(buffer).should == %w[hello world]
-        end
-
-        it 'decodes an empty string list' do
-          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 eql_bytes("\xff\xff")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          ByteBuffer.new("\x00\x01\x00\x00" << ("\x42" * 0x10000))
-        end
-
-        it 'decodes a byte array' do
-          Decoding.read_bytes!(buffer).should eql_bytes("\x42" * 0x10000)
-        end
-
-        it 'decodes an empty byte array' do
-          buffer = ByteBuffer.new("\x00\x00\x00\x00")
-          Decoding.read_bytes!(buffer).should be_empty
-        end
-
-        it 'decodes null' do
-          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 eql_bytes("\xab\xcd")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          ByteBuffer.new("\x01\x00" << ("\x42" * 0x100))
-        end
-
-        it 'decodes a byte array' do
-          Decoding.read_short_bytes!(buffer).should eql_bytes("\x42" * 0x100)
-        end
-
-        it 'decodes an empty byte array' do
-          buffer = ByteBuffer.new("\x00\x00\x00\x00")
-          Decoding.read_short_bytes!(buffer).should be_empty
-        end
-
-        it 'decodes null' do
-          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 eql_bytes("\xab\xcd")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          buffer = ByteBuffer.new("\x00\x01\x00\x03foo")
-          id, value = Decoding.read_option!(buffer) do |id, buffer|
-            Decoding.read_string!(buffer)
-          end
-          id.should == 1
-          value.should == 'foo'
-        end
-
-        it 'decodes an option ID and nil value when there is no block' do
-          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 = ByteBuffer.new("\x00\x01\x00\x03\xab")
-          id, value = Decoding.read_option!(buffer) do |id, buffer|
-            Decoding.read_short!(buffer)
-          end
-          buffer.should eql_bytes("\xab")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          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
-          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 = ByteBuffer.new("\x04\x00\x00\x00\x00\x00\x00#R\xff\xaa")
-          Decoding.read_inet!(buffer)
-          buffer.should eql_bytes("\xff\xaa")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          buffer = ByteBuffer.new("\x00\x00")
-          Decoding.read_consistency!(buffer).should == :any
-        end
-
-        it 'decodes ONE' do
-          buffer = ByteBuffer.new("\x00\x01")
-          Decoding.read_consistency!(buffer).should == :one
-        end
-
-        it 'decodes TWO' do
-          buffer = ByteBuffer.new("\x00\x02")
-          Decoding.read_consistency!(buffer).should == :two
-        end
-
-        it 'decodes THREE' do
-          buffer = ByteBuffer.new("\x00\x03")
-          Decoding.read_consistency!(buffer).should == :three
-        end
-
-        it 'decodes QUORUM' do
-          buffer = ByteBuffer.new("\x00\x04")
-          Decoding.read_consistency!(buffer).should == :quorum
-        end
-
-        it 'decodes ALL' do
-          buffer = ByteBuffer.new("\x00\x05")
-          Decoding.read_consistency!(buffer).should == :all
-        end
-
-        it 'decodes LOCAL_QUORUM' do
-          buffer = ByteBuffer.new("\x00\x06")
-          Decoding.read_consistency!(buffer).should == :local_quorum
-        end
-
-        it 'decodes EACH_QUORUM' do
-          buffer = ByteBuffer.new("\x00\x07")
-          Decoding.read_consistency!(buffer).should == :each_quorum
-        end
-
-        it 'decodes SERIAL' do
-          buffer = ByteBuffer.new("\x00\x08")
-          Decoding.read_consistency!(buffer).should == :serial
-        end
-
-        it 'decodes LOCAL_SERIAL' do
-          buffer = ByteBuffer.new("\x00\x09")
-          Decoding.read_consistency!(buffer).should == :local_serial
-        end
-
-        it 'decodes LOCAL_ONE' do
-          buffer = ByteBuffer.new("\x00\x0a")
-          Decoding.read_consistency!(buffer).should == :local_one
-        end
-
-        it 'raises an exception for an unknown consistency' do
-          expect { Decoding.read_consistency!(ByteBuffer.new("\xff\xff")) }.to raise_error(DecodingError)
-          expect { Decoding.read_consistency!(ByteBuffer.new("\x00\x0f")) }.to raise_error(DecodingError)
-        end
-      end
-
-      describe '#read_string_map!' do
-        let :buffer do
-          ByteBuffer.new("\x00\x02\x00\x05hello\x00\x05world\x00\x03foo\x00\x03bar")
-        end
-
-        it 'decodes a string multimap' do
-          Decoding.read_string_map!(buffer).should == {'hello' => 'world', 'foo' => 'bar'}
-        end
-
-        it 'decodes an empty string map' do
-          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 eql_bytes("\xff")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          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
-          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
-          Decoding.read_string_multimap!(buffer).should == {'CQL_VERSION' => ['3.0.0'], 'COMPRESSION' => ['snappy', 'gzip']}
-        end
-
-        it 'decodes an empty string multimap' do
-          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 eql_bytes("\xff")
-        end
-
-        it 'raises an error when there are not enough bytes in the buffer' do
-          b = ByteBuffer.new(buffer.read(40))
-          expect { Decoding.read_string_multimap!(b) }.to raise_error(DecodingError)
-        end
-      end
-    end
-  end
-end