cql-rb 1.0.6 → 1.1.0.pre0

data/spec/cql/uuid_spec.rb

@@ -36,10 +36,6 @@ 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
@@ -77,4 +73,4 @@ module Cql
       end
     end
   end
-end
+end

data/spec/integration/client_spec.rb

@@ -12,38 +12,36 @@ describe 'A CQL client' do
     Cql::Client.connect(connection_options)
   end
 
-  before do
-    client.connect
-  end
-
   after do
-    client.close
+    client.close rescue nil
   end
 
-  it 'executes a query and returns the result' do
-    result = client.execute('SELECT * FROM system.schema_keyspaces')
-    result.should_not be_empty
-  end
+  context 'with common operations' do
+    it 'executes a query and returns the result' do
+      result = client.execute('SELECT * FROM system.schema_keyspaces')
+      result.should_not be_empty
+    end
 
-  it 'knows which keyspace it\'s in' do
-    client.use('system')
-    client.keyspace.should == 'system'
-    client.use('system_auth')
-    client.keyspace.should == 'system_auth'
-  end
+    it 'knows which keyspace it\'s in' do
+      client.use('system')
+      client.keyspace.should == 'system'
+      client.use('system_auth')
+      client.keyspace.should == 'system_auth'
+    end
 
-  it 'is not in a keyspace initially' do
-    client.keyspace.should be_nil
-  end
+    it 'is not in a keyspace initially' do
+      client.keyspace.should be_nil
+    end
 
-  it 'can be initialized with a keyspace' do
-    c = Cql::Client.connect(connection_options.merge(:keyspace => 'system'))
-    c.connect
-    begin
-      c.keyspace.should == 'system'
-      expect { c.execute('SELECT * FROM schema_keyspaces') }.to_not raise_error
-    ensure
-      c.close
+    it 'can be initialized with a keyspace' do
+      c = Cql::Client.connect(connection_options.merge(:keyspace => 'system'))
+      c.connect
+      begin
+        c.keyspace.should == 'system'
+        expect { c.execute('SELECT * FROM schema_keyspaces') }.to_not raise_error
+      ensure
+        c.close
+      end
     end
   end
 
@@ -77,15 +75,14 @@ describe 'A CQL client' do
 
     before do
       client.close
-      multi_client.connect
-      multi_client.use('system')
     end
 
     after do
-      multi_client.close
+      multi_client.close rescue nil
     end
 
     it 'handles keyspace changes with #use' do
+      multi_client.use('system')
       100.times do
         result = multi_client.execute(%<SELECT * FROM schema_keyspaces WHERE keyspace_name = 'system'>)
         result.should have(1).item
@@ -93,6 +90,7 @@ describe 'A CQL client' do
     end
 
     it 'handles keyspace changes with #execute' do
+      multi_client.execute('USE system')
       100.times do
         result = multi_client.execute(%<SELECT * FROM schema_keyspaces WHERE keyspace_name = 'system'>)
         result.should have(1).item
@@ -100,6 +98,7 @@ describe 'A CQL client' do
     end
 
     it 'executes a prepared statement' do
+      multi_client.use('system')
       statement = multi_client.prepare('SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?')
       100.times do
         result = statement.execute('system')
@@ -122,25 +121,22 @@ describe 'A CQL client' do
       end
     end
 
-    it 'send credentials given in :credentials' do
+    it 'sends credentials given in :credentials' do
       client = Cql::Client.connect(connection_options.merge(credentials: {username: 'cassandra', password: 'cassandra'}))
       client.execute('SELECT * FROM system.schema_keyspaces')
     end
 
     it 'raises an error when no credentials have been given' do
-      if authentication_enabled
+      pending('authentication not configured', unless: authentication_enabled) do
         expect { Cql::Client.connect(connection_options.merge(credentials: nil)) }.to raise_error(Cql::AuthenticationError)
-      else
-        pending 'authentication not configured'
       end
     end
 
     it 'raises an error when the credentials are bad' do
-      if authentication_enabled
-        client = Cql::Client.connect(connection_options.merge(credentials: {username: 'foo', password: 'bar'}))
-        expect { client.connect }.to raise_error(Cql::AuthenticationError)
-      else
-        pending 'authentication not configured'
+      pending('authentication not configured', unless: authentication_enabled) do
+        expect {
+          Cql::Client.connect(connection_options.merge(credentials: {username: 'foo', password: 'bar'}))
+        }.to raise_error(Cql::AuthenticationError)
       end
     end
   end

data/spec/integration/io_spec.rb

@@ -0,0 +1,283 @@
+# 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).get
+      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).get }
+      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).get
+      rescue Cql::Io::ConnectionError
+        nil
+      end
+    end
+
+    before do
+      io_reactor.start.get
+    end
+
+    after do
+      io_reactor.stop.get
+    end
+
+    it 'can set a value' do
+      pending('Redis not running', unless: protocol_handler)
+      response = protocol_handler.send_request('SET', 'foo', 'bar').get
+      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.get.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.get.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.get.should be_nil
+    end
+
+    it 'handles errors' do
+      pending('Redis not running', unless: protocol_handler)
+      f = protocol_handler.send_request('SET', 'foo')
+      expect { f.get }.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.get
+      f = protocol_handler.send_request('RPUSH', 'stuff', 'hello', 'world')
+      f.get.should == 2
+      f = protocol_handler.send_request('LRANGE', 'stuff', 0, 2)
+      f.get.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.get.should == ['world', nil]
+    end
+  end
+end
+
+module IoSpec
+  class TestConnection
+    def initialize(connection)
+      @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)
+      @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)
+      @line_protocol = LineProtocolHandler.new(connection)
+      @line_protocol.on_line(&method(:handle_line))
+      @lock = Mutex.new
+      @responses = []
+      @state = BaseState.new(method(:handle_response))
+    end
+
+    def send_request(*args)
+      future = Cql::Future.new
+      @lock.synchronize do
+        @responses << future
+      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)
+      future
+    end
+
+    def handle_response(result, error=false)
+      future = @lock.synchronize do
+        @responses.shift
+      end
+      if error
+        future.fail!(StandardError.new(result))
+      else
+        future.complete!(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

data/spec/integration/protocol_spec.rb

@@ -4,23 +4,31 @@ require 'spec_helper'
 
 
 describe 'Protocol parsing and communication' do
-  let :io_reactor do
-    ir = Cql::Io::IoReactor.new
+  let! :io_reactor do
+    ir = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
     ir.start
-    ir.add_connection(ENV['CASSANDRA_HOST'], 9042).get
+    connections << ir.connect(ENV['CASSANDRA_HOST'], 9042, 5).get
     ir
   end
 
+  let :connections do
+    []
+  end
+
   let :keyspace_name do
     "cql_rb_#{rand(1000)}"
   end
 
   after do
-    io_reactor.stop.get if io_reactor.running?
+    if io_reactor.running?
+      drop_keyspace! rescue nil
+      io_reactor.stop.get rescue nil
+    end
   end
 
   def raw_execute_request(request)
-    io_reactor.queue_request(request).get.first
+    connection = connections.first
+    connection.send_request(request).get
   end
 
   def execute_request(request)
@@ -41,7 +49,7 @@ describe 'Protocol parsing and communication' do
   end
 
   def create_keyspace!
-    query("CREATE KEYSPACE #{keyspace_name} WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1}")
+    query("CREATE KEYSPACE #{keyspace_name} WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}")
   end
 
   def use_keyspace!
@@ -68,8 +76,9 @@ describe 'Protocol parsing and communication' do
     ensure
       begin
         drop_keyspace!
-      rescue  Errno::EPIPE => e
-        # ignore since we're shutting down
+      rescue Cql::NotConnectedError, Errno::EPIPE => e
+        # ignore since we're shutting down, and these errors are likely caused
+        # by the code under test, re-raising them would mask the real errors
       end
     end
   end
@@ -109,56 +118,46 @@ describe 'Protocol parsing and communication' do
 
     context 'when authentication is required' do
       let :authentication_enabled do
-        ir = Cql::Io::IoReactor.new
+        ir = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
         ir.start
-        connected = ir.add_connection(ENV['CASSANDRA_HOST'], 9042)
-        started = connected.flat_map do
-          ir.queue_request(Cql::Protocol::StartupRequest.new)
+        connected = ir.connect(ENV['CASSANDRA_HOST'], 9042, 5)
+        started = connected.flat_map do |connection|
+          connection.send_request(Cql::Protocol::StartupRequest.new)
         end
-        response = started.get.first
+        response = started.get
         required = response.is_a?(Cql::Protocol::AuthenticateResponse)
         ir.stop.get
         required
       end
 
       it 'sends STARTUP and receives AUTHENTICATE' do
-        if authentication_enabled
+        pending('authentication not configured', unless: authentication_enabled) do
           response = raw_execute_request(Cql::Protocol::StartupRequest.new)
           response.should be_a(Cql::Protocol::AuthenticateResponse)
-        else
-          pending 'authentication not configured'
         end
       end
 
       it 'ignores the AUTHENTICATE response and receives ERROR' do
-        if authentication_enabled
+        pending('authentication not configured', unless: authentication_enabled) do
           raw_execute_request(Cql::Protocol::StartupRequest.new)
           response = raw_execute_request(Cql::Protocol::RegisterRequest.new('TOPOLOGY_CHANGE'))
           response.code.should == 10
           response.message.should include('needs authentication')
-        else
-          pending 'authentication not configured'
         end
       end
 
       it 'sends STARTUP followed by CREDENTIALS and receives READY' do
-        if authentication_enabled
-          raw_execute_request(Cql::Protocol::StartupRequest.new)
-          response = raw_execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra'))
-          response.should be_a(Cql::Protocol::ReadyResponse)
-        else
-          pending 'authentication not configured'
-        end
+        raw_execute_request(Cql::Protocol::StartupRequest.new)
+        response = raw_execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra'))
+        response.should be_a(Cql::Protocol::ReadyResponse)
       end
 
       it 'sends bad username and password in CREDENTIALS and receives ERROR' do
-        if authentication_enabled
+        pending('authentication not configured', unless: authentication_enabled) do
           raw_execute_request(Cql::Protocol::StartupRequest.new)
           response = raw_execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar'))
           response.code.should == 0x100
           response.message.should include('Username and/or password are incorrect')
-        else
-          pending 'authentication not configured'
         end
       end
     end
@@ -180,7 +179,7 @@ describe 'Protocol parsing and communication' do
         semaphore = Queue.new
         event = nil
         execute_request(Cql::Protocol::RegisterRequest.new('SCHEMA_CHANGE'))
-        io_reactor.add_event_listener do |event_response|
+        connections.first.on_event do |event_response|
           event = event_response
           semaphore << :ping
         end
@@ -285,76 +284,6 @@ describe 'Protocol parsing and communication' do
           end
         end
 
-        it 'decodes positive counters' do
-          in_keyspace_with_counters_table do
-            max_long = (1 << 63) -1
-            response = query(%<UPDATE counters SET c1 = c1 + 1, c2 = c2 +#{max_long} WHERE id = 'positive'>)
-            response = query(%<SELECT * FROM counters>, :quorum)
-            response.rows.should == [
-              {'id' => 'positive', 'c1' => 1, 'c2' => max_long},
-            ]
-          end
-        end
-
-        it 'decodes negative counters' do
-          in_keyspace_with_counters_table do
-            min_long = 0 - (1 << 63)
-            response = query(%<UPDATE counters SET c1 = c1 - 1 , c2 = c2 -#{min_long.abs} WHERE id = 'negative'>)
-            response = query(%<SELECT * FROM counters>, :quorum)
-            response.rows.should == [
-              {'id' => 'negative', 'c1' => -1 , 'c2' => min_long}
-            ]
-          end
-        end
-
-        it 'decodes positive bigints' do
-          in_keyspace do
-            max_long = (1 << 63) -1
-            response = query('CREATE TABLE stuff (id VARCHAR, c1 bigint, c2 bigint, PRIMARY KEY (id))')
-            response = query(%<UPDATE stuff SET c1 = 1, c2 = #{max_long} WHERE id = 'stuff'>)
-            response = query(%<SELECT * FROM stuff>, :quorum)
-            response.rows.should == [
-              {'id' => 'stuff', 'c1' => 1, 'c2' => max_long}
-            ]
-          end
-        end
-
-        it 'decodes negative bigints' do
-          in_keyspace do
-            min_long = 0 - (1 << 63)
-            response = query('CREATE TABLE stuff (id VARCHAR, c1 bigint, c2 bigint, PRIMARY KEY (id))')
-            response = query(%<UPDATE stuff SET c1 = -1, c2 = #{min_long} WHERE id = 'stuff'>)
-            response = query(%<SELECT * FROM stuff>, :quorum)
-            response.rows.should == [
-              {'id' => 'stuff', 'c1' => -1, 'c2' => min_long}
-            ]
-          end
-        end
-
-        it 'decodes positive ints' do
-          in_keyspace do
-            max_int = (1 << 31) -1
-            response = query('CREATE TABLE stuff (id VARCHAR, c1 int, c2 int, PRIMARY KEY (id))')
-            response = query(%<UPDATE stuff SET c1 = 1, c2 = #{max_int} WHERE id = 'stuff'>)
-            response = query(%<SELECT * FROM stuff>, :quorum)
-            response.rows.should == [
-              {'id' => 'stuff', 'c1' => 1, 'c2' => max_int}
-            ]
-          end
-        end
-
-        it 'decodes negative ints' do
-          in_keyspace do
-            min_int = 0 - (1 << 31)
-            response = query('CREATE TABLE stuff (id VARCHAR, c1 int, c2 int, PRIMARY KEY (id))')
-            response = query(%<UPDATE stuff SET c1 = -1, c2 = #{min_int} WHERE id = 'stuff'>)
-            response = query(%<SELECT * FROM stuff>, :quorum)
-            response.rows.should == [
-              {'id' => 'stuff', 'c1' => -1, 'c2' => min_int}
-            ]
-          end
-        end
-
         it 'sends a DELETE command' do
           in_keyspace_with_table do
             response = query(%<DELETE email FROM users WHERE user_name = 'sue'>)
@@ -418,13 +347,17 @@ describe 'Protocol parsing and communication' do
       end
 
       context 'with pipelining' do
+        let :connection do
+          connections.first
+        end
+
         it 'handles multiple concurrent requests' do
           in_keyspace_with_table do
             futures = 10.times.map do
-              io_reactor.queue_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
+              connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
             end
 
-            futures << io_reactor.queue_request(Cql::Protocol::QueryRequest.new(%<INSERT INTO users (user_name, email) VALUES ('sam', 'sam@ham.com')>, :one))
+            futures << connection.send_request(Cql::Protocol::QueryRequest.new(%<INSERT INTO users (user_name, email) VALUES ('sam', 'sam@ham.com')>, :one))
             
             Cql::Future.combine(*futures).get
           end
@@ -432,11 +365,15 @@ describe 'Protocol parsing and communication' do
 
         it 'handles lots of concurrent requests' do
           in_keyspace_with_table do
-            futures = 2000.times.map do
-              io_reactor.queue_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
+            threads = Array.new(10) do
+              Thread.new do
+                futures = 200.times.map do
+                  connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
+                end
+                Cql::Future.combine(*futures).get
+              end
             end
-
-            Cql::Future.combine(*futures).get
+            threads.each(&:join)
           end
         end
       end
@@ -445,20 +382,23 @@ describe 'Protocol parsing and communication' do
 
   context 'in special circumstances' do
     it 'raises an exception when it cannot connect to Cassandra' do
-      io_reactor = Cql::Io::IoReactor.new(connection_timeout: 0.1)
+      io_reactor = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
       io_reactor.start.get
-      expect { io_reactor.add_connection('example.com', 9042).get }.to raise_error(Cql::Io::ConnectionError)
-      expect { io_reactor.add_connection('blackhole', 9042).get }.to raise_error(Cql::Io::ConnectionError)
+      expect { io_reactor.connect('example.com', 9042, 0.1).get }.to raise_error(Cql::Io::ConnectionError)
+      expect { io_reactor.connect('blackhole', 9042, 0.1).get }.to raise_error(Cql::Io::ConnectionError)
       io_reactor.stop.get
     end
 
     it 'does nothing the second time #start is called' do
-      io_reactor = Cql::Io::IoReactor.new
+      io_reactor = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
       io_reactor.start.get
-      io_reactor.add_connection(ENV['CASSANDRA_HOST'], 9042)
-      io_reactor.queue_request(Cql::Protocol::StartupRequest.new).get
+      connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).get
+      response = connection.send_request(Cql::Protocol::StartupRequest.new).get
+      if response.is_a?(Cql::Protocol::AuthenticateResponse)
+        connection.send_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra')).get
+      end
       io_reactor.start.get
-      response = io_reactor.queue_request(Cql::Protocol::QueryRequest.new('USE system', :any)).get
+      response = connection.send_request(Cql::Protocol::QueryRequest.new('USE system', :any)).get
       response.should_not be_a(Cql::Protocol::ErrorResponse)
     end
   end