cql-rb 1.2.2 → 2.0.0.pre0

data/spec/integration/protocol_spec.rb

@@ -4,8 +4,12 @@ require 'spec_helper'
 
 
 describe 'Protocol parsing and communication' do
+  let :protocol_version do
+    2
+  end
+
   let! :io_reactor do
-    ir = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
+    ir = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version) })
     ir.start
     connections << ir.connect(ENV['CASSANDRA_HOST'], 9042, 5).value
     ir
@@ -26,24 +30,42 @@ describe 'Protocol parsing and communication' do
     end
   end
 
+  def authentication_enabled?
+    ir = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version) })
+    ir.start
+    connected = ir.connect(ENV['CASSANDRA_HOST'], 9042, 5)
+    started = connected.flat_map do |connection|
+      connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+    end
+    response = started.value
+    required = response.is_a?(Cql::Protocol::AuthenticateResponse)
+    ir.stop.value
+    required
+  end
+
+
   def raw_execute_request(request)
     connection = connections.first
     connection.send_request(request).value
   end
 
-  def execute_request(request)
+  def execute_request(request, auto_authenticate=true)
     response = raw_execute_request(request)
-    if response.is_a?(Cql::Protocol::AuthenticateResponse)
+    if response.is_a?(Cql::Protocol::AuthenticateResponse) && auto_authenticate
       unless response.authentication_class == 'org.apache.cassandra.auth.PasswordAuthenticator'
         raise "Cassandra required an unsupported authenticator: #{response.authentication_class}"
       end
-      response = execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra'))
+      if protocol_version == 1
+        response = execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra'))
+      else
+        response = execute_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00cassandra"))
+      end
     end
     response
   end
 
   def query(cql, consistency=:one)
-    response = execute_request(Cql::Protocol::QueryRequest.new(cql, consistency))
+    response = execute_request(Cql::Protocol::QueryRequest.new(cql, nil, nil, consistency))
     raise response.to_s if response.is_a?(Cql::Protocol::ErrorResponse)
     response
   end
@@ -103,60 +125,87 @@ describe 'Protocol parsing and communication' do
       response.options.should have_key('CQL_VERSION')
     end
 
+    it 'sends a bad STARTUP and receives ERROR' do
+      response = execute_request(Cql::Protocol::StartupRequest.new('9.9.9'))
+      response.code.should == 10
+      response.message.should include('not supported')
+    end
+
     context 'when authentication is not required' do
       it 'sends STARTUP and receives READY' do
-        response = execute_request(Cql::Protocol::StartupRequest.new)
-        response.should be_a(Cql::Protocol::ReadyResponse)
-      end
-
-      it 'sends a bad STARTUP and receives ERROR' do
-        response = execute_request(Cql::Protocol::StartupRequest.new('9.9.9'))
-        response.code.should == 10
-        response.message.should include('not supported')
+        pending('authentication required', if: authentication_enabled?) do
+          response = execute_request(Cql::Protocol::StartupRequest.new('3.1.0'), false)
+          response.should be_a(Cql::Protocol::ReadyResponse)
+        end
       end
     end
 
     context 'when authentication is required' do
-      let :authentication_enabled do
-        ir = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
-        ir.start
-        connected = ir.connect(ENV['CASSANDRA_HOST'], 9042, 5)
-        started = connected.flat_map do |connection|
-          connection.send_request(Cql::Protocol::StartupRequest.new)
-        end
-        response = started.value
-        required = response.is_a?(Cql::Protocol::AuthenticateResponse)
-        ir.stop.value
-        required
-      end
+      context 'and the protocol version is 1' do
+        let :protocol_version do
+          1
+        end
 
-      it 'sends STARTUP and receives AUTHENTICATE' do
-        pending('authentication not configured', unless: authentication_enabled) do
-          response = raw_execute_request(Cql::Protocol::StartupRequest.new)
-          response.should be_a(Cql::Protocol::AuthenticateResponse)
+        it 'sends STARTUP and receives AUTHENTICATE' do
+          pending('authentication not configured', unless: authentication_enabled?) do
+            response = raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response.should be_a(Cql::Protocol::AuthenticateResponse)
+          end
         end
-      end
 
-      it 'ignores the AUTHENTICATE response and receives ERROR' do
-        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
+        it 'ignores the AUTHENTICATE response and receives ERROR' do
+          pending('authentication not configured', unless: authentication_enabled?) do
+            raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response = raw_execute_request(Cql::Protocol::RegisterRequest.new('TOPOLOGY_CHANGE'))
+            response.code.should == 10
+          end
         end
-      end
 
-      it 'sends STARTUP followed by CREDENTIALS and receives READY' do
-        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)
+        it 'sends STARTUP followed by CREDENTIALS and receives READY' do
+          raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+          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
+          pending('authentication not configured', unless: authentication_enabled?) do
+            raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response = raw_execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar'))
+            response.code.should == 0x100
+          end
+        end
       end
 
-      it 'sends bad username and password in CREDENTIALS and receives ERROR' do
-        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')
+      context 'and the protocol version is 2' do
+        it 'sends STARTUP and receives AUTHENTICATE' do
+          pending('authentication not configured', unless: authentication_enabled?) do
+            response = raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response.should be_a(Cql::Protocol::AuthenticateResponse)
+          end
+        end
+
+        it 'ignores the AUTHENTICATE response and receives ERROR' do
+          pending('authentication not configured', unless: authentication_enabled?) do
+            raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response = raw_execute_request(Cql::Protocol::RegisterRequest.new('TOPOLOGY_CHANGE'))
+            response.code.should == 10
+          end
+        end
+
+        it 'sends STARTUP followed by AUTH_RESPONSE and receives AUTH_SUCCESS' do
+          pending('authentication not configured', unless: authentication_enabled?) do
+            raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response = raw_execute_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00cassandra"))
+            response.should be_a(Cql::Protocol::AuthSuccessResponse)
+          end
+        end
+
+        it 'sends bad username and password in AUTH_RESPONSE and receives ERROR' do
+          pending('authentication not configured', unless: authentication_enabled?) do
+            raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+            response = raw_execute_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00ardnassac"))
+            response.code.should == 0x100
+          end
         end
       end
     end
@@ -164,7 +213,7 @@ describe 'Protocol parsing and communication' do
 
   context 'when set up' do
     before do
-      response = execute_request(Cql::Protocol::StartupRequest.new)
+      response = execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
       response
     end
 
@@ -201,7 +250,7 @@ describe 'Protocol parsing and communication' do
         end
 
         it 'sends a bad CQL string and receives ERROR' do
-          response = execute_request(Cql::Protocol::QueryRequest.new('HELLO WORLD', :any))
+          response = execute_request(Cql::Protocol::QueryRequest.new('HELLO WORLD', nil, nil, :any))
           response.should be_a(Cql::Protocol::ErrorResponse)
         end
 
@@ -320,6 +369,69 @@ describe 'Protocol parsing and communication' do
             ]
           end
         end
+
+        it 'sends an INSERT command with bound values' do
+          in_keyspace_with_table do
+            cql = %<INSERT INTO users (user_name, email) VALUES (?, ?)>
+            response = execute_request(Cql::Protocol::QueryRequest.new(cql, ['sue', 'sue@inter.net'], nil, :one))
+            response.should be_void
+          end
+        end
+
+        it 'sends an UPDATE command with bound values' do
+          in_keyspace_with_table do
+            cql = %<UPDATE users SET email = ? WHERE user_name = ?>
+            response = execute_request(Cql::Protocol::QueryRequest.new(cql, ['sue@inter.net', 'sue'], nil, :one))
+            response.should be_void
+          end
+        end
+
+        it 'sends a SELECT command with bound values' do
+          in_keyspace_with_table do
+            query(%<INSERT INTO users (user_name, email) VALUES ('phil', 'phil@heck.com')>)
+            query(%<INSERT INTO users (user_name, email) VALUES ('sue', 'sue@inter.net')>)
+            cql = %<SELECT * FROM users WHERE user_name = ?>
+            response = execute_request(Cql::Protocol::QueryRequest.new(cql, ['sue'], nil, :one))
+            response.rows.should == [
+              {'user_name' => 'sue',  'email' => 'sue@inter.net', 'password' => nil}
+            ]
+          end
+        end
+
+        it 'guesses the types of bound values' do
+          in_keyspace do
+            query('CREATE TABLE types (a BIGINT PRIMARY KEY, b DOUBLE, c ASCII, d BOOLEAN, e TIMESTAMP, f UUID, g DECIMAL, h BLOB)')
+            cql = %<UPDATE types SET b = ?, c = ?, d = ?, e = ?, f = ?, g = ?, h = ? WHERE a = ?>
+            values = [123.456, 'foo', true, Time.now, Cql::TimeUuid::Generator.new.next, BigDecimal.new('0.01'), 'hello', 3]
+            response = execute_request(Cql::Protocol::QueryRequest.new(cql, values, nil, :one))
+            response.should be_void
+          end
+        end
+
+        it 'uses the provided type hints to encode bound values' do
+          in_keyspace do
+            query('CREATE TABLE types (a INT PRIMARY KEY, b FLOAT)')
+            cql = %<UPDATE types SET b = ? WHERE a = ?>
+            values = [123.456, 3]
+            hints = [:float, :int]
+            response = execute_request(Cql::Protocol::QueryRequest.new(cql, values, hints, :one))
+            response.should be_void
+          end
+        end
+
+        it 'sends a SELECT command with a page size and receives a ROWS RESULT with a paging state' do
+          in_keyspace_with_table do
+            10.times do
+              query(%<INSERT INTO users (user_name, email) VALUES ('#{rand(234234).to_s(36)}', 'someone@somewhere.sx')>)
+            end
+            response = execute_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', nil, nil, :one, nil, 6))
+            response.paging_state.should_not be_nil
+            response.rows.size.should == 6
+            response = execute_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', nil, nil, :one, nil, 6, response.paging_state))
+            response.paging_state.should be_nil
+            response.rows.size.should == 4
+          end
+        end
       end
 
       context 'with PREPARE requests' do
@@ -335,20 +447,58 @@ describe 'Protocol parsing and communication' do
           in_keyspace do
             create_table_cql = %<CREATE TABLE stuff (id1 UUID, id2 VARINT, id3 TIMESTAMP, value1 DOUBLE, value2 TIMEUUID, value3 BLOB, PRIMARY KEY (id1, id2, id3))>
             insert_cql = %<INSERT INTO stuff (id1, id2, id3, value1, value2, value3) VALUES (?, ?, ?, ?, ?, ?)>
-            create_response = execute_request(Cql::Protocol::QueryRequest.new(create_table_cql, :one))
+            create_response = execute_request(Cql::Protocol::QueryRequest.new(create_table_cql, nil, nil, :one))
             create_response.should_not be_a(Cql::Protocol::ErrorResponse)
             prepare_response = execute_request(Cql::Protocol::PrepareRequest.new(insert_cql))
             prepare_response.should_not be_a(Cql::Protocol::ErrorResponse)
-            execute_response = execute_request(Cql::Protocol::ExecuteRequest.new(prepare_response.id, prepare_response.metadata, [Cql::Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), -12312312312, Time.now, 345345.234234, Cql::Uuid.new('a4a70900-24e1-11df-8924-001ff3591711'), "\xab\xcd\xef".force_encoding(::Encoding::BINARY)], :one))
+            values = [Cql::Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), -12312312312, Time.now, 345345.234234, Cql::Uuid.new('a4a70900-24e1-11df-8924-001ff3591711'), "\xab\xcd\xef".force_encoding(::Encoding::BINARY)]
+            execute_response = execute_request(Cql::Protocol::ExecuteRequest.new(prepare_response.id, prepare_response.metadata, values, nil, :one, nil, nil, nil, true))
             execute_response.should_not be_a(Cql::Protocol::ErrorResponse)
           end
         end
+
+        it 'sends an EXECUTE with a page size and receives a RESULT with a paging state' do
+          in_keyspace_with_table do
+            10.times do
+              query(%<INSERT INTO users (user_name, email) VALUES ('#{rand(234234).to_s(36)}', 'someone@somewhere.sx')>)
+            end
+            response = execute_request(Cql::Protocol::PrepareRequest.new('SELECT * FROM users'))
+            statement_id = response.id
+            metadata = response.metadata
+            response = execute_request(Cql::Protocol::ExecuteRequest.new(statement_id, metadata, [], true, :one, nil, 6, nil))
+            response.paging_state.should_not be_nil
+            response.rows.size.should == 6
+            response = execute_request(Cql::Protocol::ExecuteRequest.new(statement_id, metadata, [], true, :one, nil, 6, response.paging_state))
+            response.paging_state.should be_nil
+            response.rows.size.should == 4
+          end
+        end
+      end
+
+      context 'with BATCH requests' do
+        it 'sends a BATCH request and receives RESULT' do
+          in_keyspace_with_table do
+            cql1 = %<INSERT INTO users (user_name, email) VALUES (?, ?)>
+            cql2 = %<UPDATE users SET email = ? WHERE user_name = 'sue'>
+            cql3 = %<INSERT INTO users (user_name, email) VALUES ('tim', 'tim@pim.com')>
+            prepared_response1 = execute_request(Cql::Protocol::PrepareRequest.new(cql1))
+            prepared_response2 = execute_request(Cql::Protocol::PrepareRequest.new(cql3))
+            request = Cql::Protocol::BatchRequest.new(0, :quorum)
+            request.add_query(cql1, ['sue', 'sue@inter.net'])
+            request.add_query(cql2, ['eve'])
+            request.add_query(cql3)
+            request.add_prepared(prepared_response1.id, prepared_response1.metadata, ['phil', 'phil@heck.com'])
+            request.add_prepared(prepared_response2.id, prepared_response2.metadata, [])
+            response = execute_request(request)
+            response.should be_void
+          end
+        end
       end
 
       context 'with tracing' do
         it 'sends a QUERY request with the tracing flag and receives a RESULT with a trace ID' do
           in_keyspace_with_table do
-            response = execute_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum, true))
+            response = execute_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', nil, nil, :quorum, nil, nil, nil, true))
             response.trace_id.should_not be_nil
           end
         end
@@ -363,7 +513,7 @@ describe 'Protocol parsing and communication' do
         it 'sends an EXECUTE request with the tracing flag and receives a RESULT with a trace ID' do
           in_keyspace_with_table do
             prepare_response = execute_request(Cql::Protocol::PrepareRequest.new('SELECT * FROM users'))
-            execute_response = execute_request(Cql::Protocol::ExecuteRequest.new(prepare_response.id, prepare_response.metadata, [], :one, true))
+            execute_response = execute_request(Cql::Protocol::ExecuteRequest.new(prepare_response.id, prepare_response.metadata, [], true, :one, nil, nil, nil, true))
             execute_response.trace_id.should_not be_nil
           end
         end
@@ -377,11 +527,11 @@ describe 'Protocol parsing and communication' do
         it 'sends a compressed request and receives a compressed response' do
           compressor.stub(:compress).and_call_original
           compressor.stub(:decompress).and_call_original
-          io_reactor = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, compressor) })
+          io_reactor = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version, compressor) })
           io_reactor.start.value
           begin
             connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).value
-            connection.send_request(Cql::Protocol::StartupRequest.new(nil, 'snappy')).value
+            connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0', 'snappy')).value
             connection.send_request(Cql::Protocol::PrepareRequest.new('SELECT * FROM system.peers')).value
             compressor.should have_received(:compress).at_least(1).times
             compressor.should have_received(:decompress).at_least(1).times
@@ -399,10 +549,10 @@ describe 'Protocol parsing and communication' do
         it 'handles multiple concurrent requests' do
           in_keyspace_with_table do
             futures = 10.times.map do
-              connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
+              connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', nil, nil, :quorum))
             end
 
-            futures << connection.send_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')>, nil, nil, :one))
             
             Cql::Future.all(*futures).value
           end
@@ -413,7 +563,7 @@ describe 'Protocol parsing and communication' do
             threads = Array.new(10) do
               Thread.new do
                 futures = 200.times.map do
-                  connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', :quorum))
+                  connection.send_request(Cql::Protocol::QueryRequest.new('SELECT * FROM users', nil, nil, :quorum))
                 end
                 Cql::Future.all(*futures).value
               end
@@ -427,7 +577,7 @@ 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 = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version) })
       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)
@@ -435,15 +585,16 @@ describe 'Protocol parsing and communication' do
     end
 
     it 'does nothing the second time #start is called' do
-      io_reactor = Cql::Io::IoReactor.new(Cql::Protocol::CqlProtocolHandler)
+      io_reactor = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, 2) })
       io_reactor.start.value
       connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).value
-      response = connection.send_request(Cql::Protocol::StartupRequest.new).value
+      response = connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0')).value
       if response.is_a?(Cql::Protocol::AuthenticateResponse)
-        connection.send_request(Cql::Protocol::CredentialsRequest.new('username' => 'cassandra', 'password' => 'cassandra')).value
+        response = connection.send_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00cassandra")).value
+        response.should be_a(Cql::Protocol::AuthSuccessResponse)
       end
       io_reactor.start.value
-      response = connection.send_request(Cql::Protocol::QueryRequest.new('USE system', :any)).value
+      response = connection.send_request(Cql::Protocol::QueryRequest.new('USE system', nil, nil, :any)).value
       response.should_not be_a(Cql::Protocol::ErrorResponse)
     end
   end

data/spec/integration/regression_spec.rb

@@ -5,7 +5,10 @@ require 'spec_helper'
 
 describe 'Regressions' do
   let :connection_options do
-    {:host => ENV['CASSANDRA_HOST'], :credentials => {:username => 'cassandra', :password => 'cassandra'}}
+    {
+      :host => ENV['CASSANDRA_HOST'],
+      :credentials => {:username => 'cassandra', :password => 'cassandra'},
+    }
   end
 
   let :client do

data/spec/integration/uuid_spec.rb

@@ -5,7 +5,10 @@ require 'spec_helper'
 
 describe 'Loading and storing UUIDs' do
   let :connection_options do
-    {:host => ENV['CASSANDRA_HOST'], :credentials => {:username => 'cassandra', :password => 'cassandra'}}
+    {
+      :host => ENV['CASSANDRA_HOST'],
+      :credentials => {:username => 'cassandra', :password => 'cassandra'},
+    }
   end
 
   let :client do

data/spec/support/fake_io_reactor.rb

@@ -73,7 +73,7 @@ end
 class FakeConnection
   attr_reader :host, :port, :timeout, :requests, :keyspace
 
-  def initialize(host, port, timeout)
+  def initialize(host, port, timeout, data={})
     @host = host
     @port = port
     @timeout = timeout
@@ -81,7 +81,7 @@ class FakeConnection
     @responses = []
     @closed = false
     @keyspace = nil
-    @data = {}
+    @data = data
     @registered_event_types = []
     @event_listeners = []
     @closed_listeners = []
@@ -100,9 +100,9 @@ class FakeConnection
     !@closed
   end
 
-  def close
+  def close(cause=nil)
     @closed = true
-    @closed_listeners.each(&:call)
+    @closed_listeners.each { |listener| listener.call(cause) }
   end
 
   def handle_request(&handler)
@@ -151,7 +151,7 @@ class FakeConnection
       when Cql::Protocol::StartupRequest
         Cql::Protocol::ReadyResponse.new
       when Cql::Protocol::QueryRequest
-        Cql::Protocol::RowsResultResponse.new([], [], nil)
+        Cql::Protocol::RowsResultResponse.new([], [], nil, nil)
       end
     end
   end