cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/spec/cql/protocol/encoding_spec.rb

@@ -1,386 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-
-module Cql
-  module Protocol
-    describe Encoding do
-      let :buffer do
-        ByteBuffer.new
-      end
-
-      describe '#write_int' do
-        it 'encodes an int' do
-          Encoding.write_int(buffer, 2323234234)
-          buffer.should eql_bytes("\x8a\x79\xbd\xba")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_int(buffer, 10)
-          buffer.should eql_bytes("\xab\x00\x00\x00\x0a")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_int(buffer, 2323234234)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_short' do
-        it 'encodes a short' do
-          Encoding.write_short(buffer, 0xabcd)
-          buffer.should eql_bytes("\xab\xcd")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_short(buffer, 10)
-          buffer.should eql_bytes("\xab\x00\x0a")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_short(buffer, 42)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_string' do
-        it 'encodes a string' do
-          Encoding.write_string(buffer, 'hello')
-          buffer.should eql_bytes("\x00\x05hello")
-        end
-
-        it 'encodes a string with multibyte characters' do
-          buffer << "\xff"
-          str = 'I love π'
-          Encoding.write_string(buffer, str)
-          buffer.should eql_bytes("\xff\x00\x09I love π")
-        end
-
-        it 'encodes an empty string' do
-          Encoding.write_string(buffer, '')
-          buffer.should eql_bytes("\x00\x00")
-        end
-
-        it 'encodes a non-string' do
-          Encoding.write_string(buffer, 42)
-          buffer.should eql_bytes("\x00\x0242")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_string(buffer, 'foo')
-          buffer.should eql_bytes("\xab\x00\x03foo")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_string(buffer, 'hello')
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_long_string' do
-        it 'encodes a string' do
-          Encoding.write_long_string(buffer, 'hello world ' * 100_000)
-          buffer.read(45).should eql_bytes("\x00\x12\x4f\x80hello world hello world hello world hello")
-        end
-
-        it 'encodes a string with multibyte characters' do
-          buffer << "\xff"
-          str = 'I love π'
-          Encoding.write_long_string(buffer, str)
-          buffer.should eql_bytes("\xff\x00\x00\x00\x09I love π")
-        end
-
-        it 'encodes an empty string' do
-          Encoding.write_long_string(buffer, '')
-          buffer.should eql_bytes("\x00\x00\x00\x00")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_long_string(buffer, 'foo')
-          buffer.should eql_bytes("\xab\x00\x00\x00\x03foo")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_long_string(buffer, 'hello')
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_uuid' do
-        let :uuid do
-          Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
-        end
-
-        it 'encodes an UUID' do
-          Encoding.write_uuid(buffer, uuid)
-          buffer.should eql_bytes("\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11")
-        end
-
-        it 'encodes a UUID as 16 bytes' do
-          Encoding.write_uuid(buffer, Uuid.new('00000000-24e1-11df-8924-001ff3591711'))
-          buffer.size.should eql(16)
-        end
-
-        it 'appends to the buffer' do
-          buffer << 'FOO'
-          Encoding.write_uuid(buffer, uuid)
-          buffer.read(3).should eql_bytes('FOO')
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_uuid(buffer, uuid)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_string_list' do
-        it 'encodes a string list' do
-          Encoding.write_string_list(buffer, %w[foo bar hello world])
-          buffer.should eql_bytes("\x00\x04\x00\x03foo\x00\x03bar\x00\x05hello\x00\x05world")
-        end
-
-        it 'encodes a string with multibyte characters' do
-          buffer << "\xff"
-          str = %w[I love π]
-          Encoding.write_string_list(buffer, str)
-          buffer.should eql_bytes("\xff\x00\x03\x00\x01I\x00\x04love\x00\x02π")
-        end
-
-        it 'encodes an empty string list' do
-          Encoding.write_string_list(buffer, [])
-          buffer.should eql_bytes("\x00\x00")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_string_list(buffer, %w[foo bar])
-          buffer.should eql_bytes("\xab\x00\x02\x00\x03foo\x00\x03bar")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_string_list(buffer, %w[foo])
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_bytes' do
-        it 'encodes a byte array' do
-          Encoding.write_bytes(buffer, "\xaa" * 2000)
-          buffer.should eql_bytes("\x00\x00\x07\xd0" << ("\xaa" * 2000))
-        end
-
-        it 'encodes a string with multibyte characters' do
-          buffer << "\xff"
-          str = 'I love π'
-          Encoding.write_bytes(buffer, str)
-          buffer.should eql_bytes("\xff\x00\x00\x00\x09I love π")
-        end
-
-        it 'encodes nil' do
-          Encoding.write_bytes(buffer, nil)
-          buffer.should eql_bytes("\xff\xff\xff\xff")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_bytes(buffer, "\xf0\x0b\xbar")
-          buffer.should eql_bytes("\xab\x00\x00\x00\x04\xf0\x0b\xbar")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_bytes(buffer, "\xab")
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_short_bytes' do
-        it 'encodes a byte array' do
-          Encoding.write_short_bytes(buffer, "\xaa\xbb\xcc")
-          buffer.should eql_bytes("\x00\x03\xaa\xbb\xcc")
-        end
-
-        it 'encodes a string with multibyte characters' do
-          buffer << "\xff"
-          str = 'I love π'
-          Encoding.write_short_bytes(buffer, str)
-          buffer.should eql_bytes("\xff\x00\x09I love π")
-        end
-
-        it 'encodes nil' do
-          Encoding.write_short_bytes(buffer, nil)
-          buffer.should eql_bytes("\xff\xff")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_short_bytes(buffer, "\xf0\x0b\xbar")
-          buffer.should eql_bytes("\xab\x00\x04\xf0\x0b\xbar")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_short_bytes(buffer, "\xab")
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_consistency' do
-        {
-          :any => "\x00\x00",
-          :one => "\x00\x01",
-          :two => "\x00\x02",
-          :three => "\x00\x03",
-          :quorum => "\x00\x04",
-          :all => "\x00\x05",
-          :local_quorum => "\x00\x06",
-          :each_quorum => "\x00\x07",
-          :serial => "\x00\x08",
-          :local_serial => "\x00\x09",
-          :local_one => "\x00\x0a",
-        }.each do |consistency, expected_encoding|
-          it "encodes #{consistency}" do
-            Encoding.write_consistency(buffer, consistency)
-            buffer.should eql_bytes(expected_encoding)
-          end
-        end
-
-        it 'raises an exception for an unknown consistency' do
-          expect { Encoding.write_consistency(buffer, :foo) }.to raise_error(EncodingError)
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_consistency(buffer, :one)
-          buffer.should eql_bytes("\xab\x00\x01")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_consistency(buffer, :quorum)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_string_map' do
-        it 'encodes a string map' do
-          Encoding.write_string_map(buffer, 'HELLO' => 'world', 'foo' => 'bar')
-          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 eql_bytes("\x00\x00")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\xab"
-          Encoding.write_string_map(buffer, 'foo' => 'bar')
-          buffer.should eql_bytes("\xab\x00\x01\x00\x03foo\x00\x03bar")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_string_map(buffer, 'HELLO' => 'world')
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_long' do
-        it 'encodes a long' do
-          Encoding.write_long(buffer, 0x0123456789)
-          buffer.should eql_bytes("\x00\x00\x00\x01\x23\x45\x67\x89")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\x99"
-          Encoding.write_long(buffer, 0x0123456789)
-          buffer.should eql_bytes("\x99\x00\x00\x00\x01\x23\x45\x67\x89")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_long(buffer, 1)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_varint' do
-        it 'encodes a variable length integer' do
-          Encoding.write_varint(buffer, 1231312312331283012830129382342342412123)
-          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 eql_bytes("\xC9v\x8D:\x86")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\x99"
-          Encoding.write_varint(buffer, -234234234234)
-          buffer.should eql_bytes("\x99\xC9v\x8D:\x86")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_varint(buffer, -234234234234)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_decimal' do
-        it 'encodes a BigDecimal as a decimal' do
-          Encoding.write_decimal(buffer, BigDecimal.new('1042342234234.123423435647768234'))
-          buffer.should eql_bytes("\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA")
-        end
-
-        it 'appends to the buffer' do
-          buffer << "\x99"
-          Encoding.write_decimal(buffer, BigDecimal.new('1042342234234.123423435647768234'))
-          buffer.read(1).should eql_bytes("\x99")
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_decimal(buffer, BigDecimal.new('3.14'))
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_double' do
-        it 'encodes a double' do
-          Encoding.write_double(buffer, 10000.123123123)
-          buffer.should eql_bytes("@\xC3\x88\x0F\xC2\x7F\x9DU")
-        end
-
-        it 'appends to the buffer' do
-          buffer << 'BEFORE'
-          Encoding.write_double(buffer, 10000.123123123)
-          buffer.read(6).should eql_bytes('BEFORE')
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_double(buffer, 10000.123123123)
-          result.should equal(buffer)
-        end
-      end
-
-      describe '#write_float' do
-        it 'encodes a float' do
-          Encoding.write_float(buffer, 12.13)
-          buffer.should eql_bytes("AB\x14{")
-        end
-
-        it 'appends to the buffer' do
-          buffer << 'BEFORE'
-          Encoding.write_float(buffer, 12.13)
-          buffer.read(6).should eql_bytes('BEFORE')
-        end
-
-        it 'returns the buffer' do
-          result = Encoding.write_float(buffer, 12.13)
-          result.should equal(buffer)
-        end
-      end
-    end
-  end
-end

data/spec/integration/io_spec.rb

@@ -1,283 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-
-describe 'An IO reactor' do
-  context 'with a generic server' do
-    let :io_reactor do
-      Cql::Io::IoReactor.new(IoSpec::TestConnection)
-    end
-
-    let :fake_server do
-      FakeServer.new
-    end
-
-    before do
-      fake_server.start!
-      io_reactor.start
-    end
-
-    after do
-      io_reactor.stop
-      fake_server.stop!
-    end
-
-    it 'connects to the server' do
-      io_reactor.connect(ENV['CASSANDRA_HOST'], fake_server.port, 1)
-      fake_server.await_connects!(1)
-    end
-
-    it 'receives data' do
-      protocol_handler = io_reactor.connect(ENV['CASSANDRA_HOST'], fake_server.port, 1).value
-      fake_server.await_connects!(1)
-      fake_server.broadcast!('hello world')
-      await { protocol_handler.data.bytesize > 0 }
-      protocol_handler.data.should == 'hello world'
-    end
-
-    it 'receives data on multiple connections' do
-      protocol_handlers = Array.new(10) { io_reactor.connect(ENV['CASSANDRA_HOST'], fake_server.port, 1).value }
-      fake_server.await_connects!(10)
-      fake_server.broadcast!('hello world')
-      await { protocol_handlers.all? { |c| c.data.bytesize > 0 } }
-      protocol_handlers.sample.data.should == 'hello world'
-    end
-  end
-
-  context 'when talking to Redis' do
-    let :io_reactor do
-      Cql::Io::IoReactor.new(IoSpec::RedisProtocolHandler)
-    end
-
-    let :protocol_handler do
-      begin
-        io_reactor.connect(ENV['CASSANDRA_HOST'], 6379, 1).value
-      rescue Cql::Io::ConnectionError
-        nil
-      end
-    end
-
-    before do
-      io_reactor.start.value
-    end
-
-    after do
-      io_reactor.stop.value
-    end
-
-    it 'can set a value' do
-      pending('Redis not running', unless: protocol_handler)
-      response = protocol_handler.send_request('SET', 'foo', 'bar').value
-      response.should == 'OK'
-    end
-
-    it 'can get a value' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('SET', 'foo', 'bar').flat_map do
-        protocol_handler.send_request('GET', 'foo')
-      end
-      f.value.should == 'bar'
-    end
-
-    it 'can delete values' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('SET', 'hello', 'world').flat_map do
-        protocol_handler.send_request('DEL', 'hello')
-      end
-      f.value.should == 1
-    end
-
-    it 'handles nil values' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('DEL', 'hello').flat_map do
-        protocol_handler.send_request('GET', 'hello')
-      end
-      f.value.should be_nil
-    end
-
-    it 'handles errors' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('SET', 'foo')
-      expect { f.value }.to raise_error("ERR wrong number of arguments for 'set' command")
-    end
-
-    it 'handles replies with multiple elements' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('DEL', 'stuff')
-      f.value
-      f = protocol_handler.send_request('RPUSH', 'stuff', 'hello', 'world')
-      f.value.should == 2
-      f = protocol_handler.send_request('LRANGE', 'stuff', 0, 2)
-      f.value.should == ['hello', 'world']
-    end
-
-    it 'handles nil values when reading multiple elements' do
-      pending('Redis not running', unless: protocol_handler)
-      protocol_handler.send_request('DEL', 'things')
-      protocol_handler.send_request('HSET', 'things', 'hello', 'world')
-      f = protocol_handler.send_request('HMGET', 'things', 'hello', 'foo')
-      f.value.should == ['world', nil]
-    end
-  end
-end
-
-module IoSpec
-  class TestConnection
-    def initialize(connection, scheduler)
-      @connection = connection
-      @connection.on_data(&method(:receive_data))
-      @lock = Mutex.new
-      @data = Cql::ByteBuffer.new
-    end
-
-    def data
-      @lock.synchronize { @data.to_s }
-    end
-
-    private
-
-    def receive_data(new_data)
-      @lock.synchronize { @data << new_data }
-    end
-  end
-
-  class LineProtocolHandler
-    def initialize(connection, scheduler)
-      @connection = connection
-      @connection.on_data(&method(:process_data))
-      @lock = Mutex.new
-      @buffer = ''
-      @requests = []
-    end
-
-    def on_line(&listener)
-      @line_listener = listener
-    end
-
-    def write(command_string)
-      @connection.write(command_string)
-    end
-
-    def process_data(new_data)
-      lines = []
-      @lock.synchronize do
-        @buffer << new_data
-        while newline_index = @buffer.index("\r\n")
-          line = @buffer.slice!(0, newline_index + 2)
-          line.chomp!
-          lines << line
-        end
-      end
-      lines.each do |line|
-        @line_listener.call(line) if @line_listener
-      end
-    end
-  end
-
-  class RedisProtocolHandler
-    def initialize(connection, scheduler)
-      @line_protocol = LineProtocolHandler.new(connection, scheduler)
-      @line_protocol.on_line(&method(:handle_line))
-      @lock = Mutex.new
-      @responses = []
-      @state = BaseState.new(method(:handle_response))
-    end
-
-    def send_request(*args)
-      promise = Cql::Promise.new
-      @lock.synchronize do
-        @responses << promise
-      end
-      request = "*#{args.size}\r\n"
-      args.each do |arg|
-        arg_str = arg.to_s
-        request << "$#{arg_str.bytesize}\r\n#{arg_str}\r\n"
-      end
-      @line_protocol.write(request)
-      promise.future
-    end
-
-    def handle_response(result, error=false)
-      promise = @lock.synchronize do
-        @responses.shift
-      end
-      if error
-        promise.fail(StandardError.new(result))
-      else
-        promise.fulfill(result)
-      end
-    end
-
-    def handle_line(line)
-      @state = @state.handle_line(line)
-    end
-
-    class State
-      def initialize(result_handler)
-        @result_handler = result_handler
-      end
-
-      def complete!(result)
-        @result_handler.call(result)
-      end
-
-      def fail!(message)
-        @result_handler.call(message, true)
-      end
-    end
-
-    class BulkState < State
-      def handle_line(line)
-        complete!(line)
-        BaseState.new(@result_handler)
-      end
-    end
-
-    class MultiBulkState < State
-      def initialize(result_handler, expected_elements)
-        super(result_handler)
-        @expected_elements = expected_elements
-        @elements = []
-      end
-
-      def handle_line(line)
-        if line.start_with?('$')
-          line.slice!(0, 1)
-          if line.to_i == -1
-            @elements << nil
-          end
-        else
-          @elements << line
-        end
-        if @elements.size == @expected_elements
-          complete!(@elements)
-          BaseState.new(@result_handler)
-        else
-          self
-        end
-      end
-    end
-
-    class BaseState < State
-      def handle_line(line)
-        next_state = self
-        first_char = line.slice!(0, 1)
-        case first_char
-        when '+' then complete!(line)
-        when ':' then complete!(line.to_i)
-        when '-' then fail!(line)
-        when '$'
-          if line.to_i == -1
-            complete!(nil)
-          else
-            next_state = BulkState.new(@result_handler)
-          end
-        when '*'
-          next_state = MultiBulkState.new(@result_handler, line.to_i)
-        end
-        next_state
-      end
-    end
-  end
-end