cql-rb 1.1.0.pre3 → 1.1.0.pre6

data/spec/cql/protocol/encoding_spec.rb

@@ -121,6 +121,11 @@ module Cql
           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)

data/spec/cql/protocol/type_converter_spec.rb

@@ -14,7 +14,7 @@ module Cql
         ''
       end
 
-      TYPES = [:ascii, :bigint, :blob, :boolean, :decimal, :double, :float, :inet, :int, :text, :varchar, :timestamp, :timeuuid, :uuid, :varint].freeze
+      TYPES = [:ascii, :bigint, :blob, :boolean, :counter, :decimal, :double, :float, :inet, :int, :text, :varchar, :timestamp, :timeuuid, :uuid, :varint].freeze
 
       describe '#to_bytes' do
         context 'when encoding normal value' do

data/spec/cql/time_uuid_spec.rb

@@ -20,11 +20,11 @@ module Cql
 
   describe TimeUuid::Generator do
     let :generator do
-      described_class.new(nil, nil, stub(now: clock))
+      described_class.new(nil, nil, double(now: clock))
     end
 
     let :clock do
-      stub(:clock, to_i: 1370771820, usec: 329394)
+      double(:clock, to_i: 1370771820, usec: 329394)
     end
 
     describe '#next' do
@@ -103,17 +103,17 @@ module Cql
 
     context 'when specifying a custom clock ID' do
       it 'uses the lower 14 bits of the specified clock ID' do
-        g = described_class.new(nil, 0x2bad, stub(now: clock))
+        g = described_class.new(nil, 0x2bad, double(now: clock))
         (g.next.value >> 48 & 0x3fff).should == 0x2bad
       end
 
       it 'ensures that the high bit of the clock ID is 1 (the variant)' do
-        g = described_class.new(nil, 0x2bad, stub(now: clock))
+        g = described_class.new(nil, 0x2bad, double(now: clock))
         (g.next.value >> 60 & 0b1000).should == 0b1000
       end
 
       it 'generates a new random clock ID if time has moved backwards' do
-        g = described_class.new(nil, 0x2bad, stub(now: clock))
+        g = described_class.new(nil, 0x2bad, double(now: clock))
         str1 = g.next.to_s.split('-')[3]
         clock.stub(:to_i).and_return(1370771820 - 2)
         str2 = g.next.to_s.split('-')[3]
@@ -123,12 +123,12 @@ module Cql
 
     context 'when specifying a custom node ID' do
       it 'uses the lower 48 bits of the specified node ID' do
-        g = described_class.new(0xd00b1ed00b1ed00b, 0x0000, stub(now: clock))
+        g = described_class.new(0xd00b1ed00b1ed00b, 0x0000, double(now: clock))
         g.next.to_s.should end_with('00-1ed00b1ed00b')
       end
 
       it 'does not modify the multicast bit' do
-        g = described_class.new(0x000000000000, 0x0000, stub(now: clock))
+        g = described_class.new(0x000000000000, 0x0000, double(now: clock))
         g.next.to_s.should end_with('00-000000000000')
       end
     end

data/spec/integration/client_spec.rb

@@ -109,7 +109,7 @@ describe 'A CQL client' do
 
   context 'with authentication' do
     let :client do
-      stub(:client, connect: nil, close: nil)
+      double(:client, connect: nil, close: nil)
     end
 
     let :authentication_enabled do
@@ -146,7 +146,7 @@ describe 'A CQL client' do
       expect { client.execute('BAD cql') }.to raise_error(Cql::CqlError)
     end
 
-    it 'raises an error for bad consistency levels' do
+    it 'raises an error for bad consistency' do
       expect { client.execute('SELECT * FROM system.peers', :helloworld) }.to raise_error(ArgumentError)
     end
 

data/spec/integration/io_spec.rb

@@ -29,7 +29,7 @@ describe 'An IO reactor' do
     end
 
     it 'receives data' do
-      protocol_handler = io_reactor.connect(ENV['CASSANDRA_HOST'], fake_server.port, 1).get
+      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 }
@@ -37,7 +37,7 @@ describe 'An IO reactor' do
     end
 
     it 'receives data on multiple connections' do
-      protocol_handlers = Array.new(10) { io_reactor.connect(ENV['CASSANDRA_HOST'], fake_server.port, 1).get }
+      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 } }
@@ -52,23 +52,23 @@ describe 'An IO reactor' do
 
     let :protocol_handler do
       begin
-        io_reactor.connect(ENV['CASSANDRA_HOST'], 6379, 1).get
+        io_reactor.connect(ENV['CASSANDRA_HOST'], 6379, 1).value
       rescue Cql::Io::ConnectionError
         nil
       end
     end
 
     before do
-      io_reactor.start.get
+      io_reactor.start.value
     end
 
     after do
-      io_reactor.stop.get
+      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').get
+      response = protocol_handler.send_request('SET', 'foo', 'bar').value
       response.should == 'OK'
     end
 
@@ -77,7 +77,7 @@ describe 'An IO reactor' do
       f = protocol_handler.send_request('SET', 'foo', 'bar').flat_map do
         protocol_handler.send_request('GET', 'foo')
       end
-      f.get.should == 'bar'
+      f.value.should == 'bar'
     end
 
     it 'can delete values' do
@@ -85,7 +85,7 @@ describe 'An IO reactor' do
       f = protocol_handler.send_request('SET', 'hello', 'world').flat_map do
         protocol_handler.send_request('DEL', 'hello')
       end
-      f.get.should == 1
+      f.value.should == 1
     end
 
     it 'handles nil values' do
@@ -93,23 +93,23 @@ describe 'An IO reactor' do
       f = protocol_handler.send_request('DEL', 'hello').flat_map do
         protocol_handler.send_request('GET', 'hello')
       end
-      f.get.should be_nil
+      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.get }.to raise_error("ERR wrong number of arguments for 'set' command")
+      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.get
+      f.value
       f = protocol_handler.send_request('RPUSH', 'stuff', 'hello', 'world')
-      f.get.should == 2
+      f.value.should == 2
       f = protocol_handler.send_request('LRANGE', 'stuff', 0, 2)
-      f.get.should == ['hello', 'world']
+      f.value.should == ['hello', 'world']
     end
 
     it 'handles nil values when reading multiple elements' do
@@ -117,7 +117,7 @@ describe 'An IO reactor' do
       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]
+      f.value.should == ['world', nil]
     end
   end
 end
@@ -185,9 +185,9 @@ module IoSpec
     end
 
     def send_request(*args)
-      future = Cql::Future.new
+      promise = Cql::Promise.new
       @lock.synchronize do
-        @responses << future
+        @responses << promise
       end
       request = "*#{args.size}\r\n"
       args.each do |arg|
@@ -195,17 +195,17 @@ module IoSpec
         request << "$#{arg_str.bytesize}\r\n#{arg_str}\r\n"
       end
       @line_protocol.write(request)
-      future
+      promise.future
     end
 
     def handle_response(result, error=false)
-      future = @lock.synchronize do
+      promise = @lock.synchronize do
         @responses.shift
       end
       if error
-        future.fail!(StandardError.new(result))
+        promise.fail(StandardError.new(result))
       else
-        future.complete!(result)
+        promise.fulfill(result)
       end
     end
 

data/spec/integration/protocol_spec.rb

@@ -7,7 +7,7 @@ describe 'Protocol parsing and communication' do
   let! :io_reactor do
     ir = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
     ir.start
-    connections << ir.connect(ENV['CASSANDRA_HOST'], 9042, 5).get
+    connections << ir.connect(ENV['CASSANDRA_HOST'], 9042, 5).value
     ir
   end
 
@@ -22,13 +22,13 @@ describe 'Protocol parsing and communication' do
   after do
     if io_reactor.running?
       drop_keyspace! rescue nil
-      io_reactor.stop.get rescue nil
+      io_reactor.stop.value rescue nil
     end
   end
 
   def raw_execute_request(request)
     connection = connections.first
-    connection.send_request(request).get
+    connection.send_request(request).value
   end
 
   def execute_request(request)
@@ -124,9 +124,9 @@ describe 'Protocol parsing and communication' do
         started = connected.flat_map do |connection|
           connection.send_request(Cql::Protocol::StartupRequest.new)
         end
-        response = started.get
+        response = started.value
         required = response.is_a?(Cql::Protocol::AuthenticateResponse)
-        ir.stop.get
+        ir.stop.value
         required
       end
 
@@ -359,7 +359,7 @@ describe 'Protocol parsing and communication' do
 
             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
+            Cql::Future.all(*futures).value
           end
         end
 
@@ -370,7 +370,7 @@ describe 'Protocol parsing and communication' do
                 futures = 200.times.map do
                   connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
                 end
-                Cql::Future.combine(*futures).get
+                Cql::Future.all(*futures).value
               end
             end
             threads.each(&:join)
@@ -383,22 +383,22 @@ 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(Cql::Protocol::CqlProtocolHandler)
-      io_reactor.start.get
-      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
+      io_reactor.start.value
+      expect { io_reactor.connect('example.com', 9042, 0.1).value }.to raise_error(Cql::Io::ConnectionError)
+      expect { io_reactor.connect('blackhole', 9042, 0.1).value }.to raise_error(Cql::Io::ConnectionError)
+      io_reactor.stop.value
     end
 
     it 'does nothing the second time #start is called' do
       io_reactor = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
-      io_reactor.start.get
-      connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).get
-      response = connection.send_request(Cql::Protocol::StartupRequest.new).get
+      io_reactor.start.value
+      connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).value
+      response = connection.send_request(Cql::Protocol::StartupRequest.new).value
       if response.is_a?(Cql::Protocol::AuthenticateResponse)
-        connection.send_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra')).get
+        connection.send_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra')).value
       end
-      io_reactor.start.get
-      response = connection.send_request(Cql::Protocol::QueryRequest.new('USE system', :any)).get
+      io_reactor.start.value
+      response = connection.send_request(Cql::Protocol::QueryRequest.new('USE system', :any)).value
       response.should_not be_a(Cql::Protocol::ErrorResponse)
     end
   end

data/spec/integration/regression_spec.rb

@@ -205,4 +205,10 @@ describe 'Regressions' do
       client.keyspace.should == 'system'
     end
   end
+
+  context 'with prepared statements where the table does not exist' do
+    it 'raises an error when a statement is prepared on a table that does not exist' do
+      expect { client.prepare('SELECT * FROM table_that_does_not_exist') }.to raise_error(Cql::QueryError)
+    end
+  end
 end

data/spec/integration/uuid_spec.rb

@@ -44,6 +44,10 @@ describe 'Loading and storing UUIDs' do
       store_statement.execute(Cql::Uuid.new('39bc6ab8-d0f5-11e2-b041-adb2253022a3'), 'hello world')
       client.execute(%<SELECT * FROM ids>).first['id'].should == Cql::Uuid.new('39bc6ab8-d0f5-11e2-b041-adb2253022a3')
     end
+
+    it 'works even when the UUID could be represented as fewer than 16 bytes' do
+      store_statement.execute(Cql::Uuid.new('00853800-5400-11e2-90c5-3409d6a3565d'), 'hello world')
+    end
   end
 
   context Cql::TimeUuid::Generator do

data/spec/support/fake_io_reactor.rb

@@ -9,7 +9,7 @@ class FakeIoReactor
     @queued_responses = Hash.new { |h, k| h[k] = [] }
     @default_host = nil
     @connection_listeners = []
-    @started_future = Cql::Future.new
+    @started_promise = Cql::Promise.new
     @before_startup_handler = nil
     @down_nodes = []
   end
@@ -18,6 +18,10 @@ class FakeIoReactor
     @down_nodes << hostname
   end
 
+  def node_up(hostname)
+    @down_nodes.delete(hostname)
+  end
+
   def before_startup(&handler)
     @before_startup_handler = handler
   end
@@ -33,7 +37,7 @@ class FakeIoReactor
       @connection_listeners.each do |listener|
         listener.call(connection)
       end
-      Cql::Future.completed(connection)
+      Cql::Future.resolved(connection)
     end
   end
 
@@ -47,18 +51,18 @@ class FakeIoReactor
       @before_startup_handler = nil
       Thread.start do
         @before_startup_handler.call
-        @started_future.complete!(self)
+        @started_promise.fulfill(self)
       end
-    elsif !(@started_future.complete? || @started_future.failed?)
-      @started_future.complete!(self)
+    elsif !@started_promise.future.completed?
+      @started_promise.fulfill(self)
     end
-    @started_future
+    @started_promise.future
   end
 
   def stop
     @running = false
     @connections.each(&:close)
-    Cql::Future.completed
+    Cql::Future.resolved
   end
 
   def running?
@@ -78,6 +82,9 @@ class FakeConnection
     @closed = false
     @keyspace = nil
     @data = {}
+    @registered_event_types = []
+    @event_listeners = []
+    @closed_listeners = []
     @request_handler = method(:default_request_handler)
   end
 
@@ -95,22 +102,45 @@ class FakeConnection
 
   def close
     @closed = true
+    @closed_listeners.each(&:call)
   end
 
   def handle_request(&handler)
     @request_handler = handler
   end
 
+  def on_closed(&listener)
+    @closed_listeners << listener
+  end
+
+  def on_event(&listener)
+    @event_listeners << listener
+  end
+
+  def trigger_event(response)
+    if @event_listeners.any? && @registered_event_types.include?(response.type)
+      @event_listeners.each { |l| l.call(response) }
+    end
+  end
+
+  def has_event_listener?
+    @event_listeners.any? && @registered_event_types.any?
+  end
+
   def send_request(request)
     if @closed
       Cql::Future.failed(Cql::NotConnectedError.new)
     else
       @requests << request
+      case request
+      when Cql::Protocol::RegisterRequest
+        @registered_event_types.concat(request.events)
+      end
       response = @request_handler.call(request)
       if response.is_a?(Cql::Protocol::SetKeyspaceResultResponse)
         @keyspace = response.keyspace
       end
-      Cql::Future.completed(response)
+      Cql::Future.resolved(response)
     end
   end
 

data/spec/support/fake_server.rb

@@ -19,14 +19,14 @@ class FakeServer
       @running = true
     end
     @sockets = [TCPServer.new(@port)]
-    @started = Cql::Future.new
+    @started = Cql::Promise.new
     @thread = Thread.start do
       Thread.current.abort_on_exception = true
       sleep(options[:accept_delay] || 0)
-      @started.complete!
+      @started.fulfill
       io_loop
     end
-    @started.get
+    @started.future.value
     self
   end