cql-rb 1.0.0.pre4 → 1.0.0.pre5

data/spec/cql/io/io_reactor_spec.rb

@@ -177,47 +177,61 @@ module Cql
           Future.combine(*futures).get
         end
 
-        it 'performs the request using the connection with the given ID' do
-          future = Future.new
-          request = Cql::Protocol::StartupRequest.new
-          response = "\x81\x00\x00\x02\x00\x00\x00\x00"
-
-          io_reactor.start.on_complete do
-            io_reactor.add_connection(host, port).on_complete do |c1_id|
-              io_reactor.add_connection(host, port).on_complete do |c2_id|
-                q1_future = io_reactor.queue_request(request, c2_id)
-                q2_future = io_reactor.queue_request(request, c1_id)
-
-                Future.combine(q1_future, q2_future).on_complete do |(_, q1_id), (_, q2_id)|
-                  future.complete!([c1_id, c2_id, q1_id, q2_id])
+        context 'with a connection ID' do
+          it 'performs the request using the specified connection' do
+            future = Future.new
+            request = Cql::Protocol::StartupRequest.new
+            response = "\x81\x00\x00\x02\x00\x00\x00\x00"
+
+            io_reactor.start.on_complete do
+              io_reactor.add_connection(host, port).on_complete do |c1_id|
+                io_reactor.add_connection(host, port).on_complete do |c2_id|
+                  q1_future = io_reactor.queue_request(request, c2_id)
+                  q2_future = io_reactor.queue_request(request, c1_id)
+
+                  Future.combine(q1_future, q2_future).on_complete do |(_, q1_id), (_, q2_id)|
+                    future.complete!([c1_id, c2_id, q1_id, q2_id])
+                  end
+
+                  server.await_connects!(2)
+                  server.broadcast!(response.dup)
                 end
-
-                server.await_connects!(2)
-                server.broadcast!(response.dup)
               end
             end
-          end
 
-          connection1_id, connection2_id, query1_id, query2_id = future.value
+            connection1_id, connection2_id, query1_id, query2_id = future.value
 
-          connection1_id.should_not be_nil
-          connection2_id.should_not be_nil
-          query1_id.should == connection2_id
-          query2_id.should == connection1_id
-        end
+            connection1_id.should_not be_nil
+            connection2_id.should_not be_nil
+            query1_id.should == connection2_id
+            query2_id.should == connection1_id
+          end
 
-        it 'fails if the connection does not exist' do
-          f = io_reactor.start.flat_map do
-            io_reactor.add_connection(host, port).flat_map do
-              io_reactor.queue_request(Cql::Protocol::StartupRequest.new, 1234)
+          it 'fails if the connection does not exist' do
+            f = io_reactor.start.flat_map do
+              io_reactor.add_connection(host, port).flat_map do
+                io_reactor.queue_request(Cql::Protocol::StartupRequest.new, 1234)
+              end
             end
+            expect { f.get }.to raise_error(ConnectionNotFoundError)
           end
-          expect { f.get }.to raise_error(ConnectionNotFoundError)
-        end
 
-        it 'fails if the connection is busy' do
-          f = io_reactor.start.flat_map do
-            io_reactor.add_connection(host, port).flat_map do
+          it 'fails if the connection is busy' do
+            f = io_reactor.start.flat_map do
+              io_reactor.add_connection(host, port).flat_map do
+                io_reactor.add_connection(host, port).flat_map do |connection_id|
+                  200.times do
+                    io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
+                  end
+                  io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
+                end
+              end
+            end
+            expect { f.get }.to raise_error(ConnectionBusyError)
+          end
+
+          it 'fails if the connection is busy, when there is only one connection' do
+            f = io_reactor.start.flat_map do
               io_reactor.add_connection(host, port).flat_map do |connection_id|
                 200.times do
                   io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
@@ -225,12 +239,8 @@ module Cql
                 io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
               end
             end
+            expect { f.get }.to raise_error(ConnectionBusyError)
           end
-          expect { f.get }.to raise_error(ConnectionBusyError)
-        end
-
-        it 'fails if the connection is busy, when there is only one connection' do
-          pending 'as it is the reactor doesn\'t try to deliver requests when all connections are busy'
         end
 
         it 'fails if there is an error when encoding the request' do

data/spec/cql/protocol/encoding_spec.rb

@@ -73,6 +73,11 @@ module Cql
           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"
           buffer.force_encoding(::Encoding::BINARY)

data/spec/cql/protocol/request_frame_spec.rb

@@ -6,6 +6,21 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe RequestFrame do
+      context 'with CREDENTIALS requests' do
+        it 'encodes a CREDENTIALS request' do
+          bytes = RequestFrame.new(CredentialsRequest.new('username' => 'cassandra', 'password' => 'ardnassac')).write('')
+          bytes.should == (
+            "\x01\x00\x00\04" +
+            "\x00\x00\x00\x2c" +
+            "\x00\x02" +
+            "\x00\x08username" +
+            "\x00\x09cassandra" +
+            "\x00\x08password" +
+            "\x00\x09ardnassac"
+          )
+        end
+      end
+
       context 'with OPTIONS requests' do
         it 'encodes an OPTIONS request' do
           bytes = RequestFrame.new(OptionsRequest.new).write('')
@@ -150,6 +165,65 @@ module Cql
         end
       end
 
+      describe CredentialsRequest do
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = CredentialsRequest.new('foo' => 'bar', 'hello' => 'world')
+            request.to_s.should == 'CREDENTIALS {"foo"=>"bar", "hello"=>"world"}'
+          end
+        end
+
+        describe '#eql?' do
+          it 'returns when the credentials are the same' do
+            c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c2.should eql(c2)
+          end
+
+          it 'returns when the credentials are equivalent' do
+            pending 'this would be nice, but is hardly necessary' do
+              c1 = CredentialsRequest.new(:username => 'foo', :password => 'bar')
+              c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+              c1.should eql(c2)
+            end
+          end
+
+          it 'returns false when the credentials are different' do
+            c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'world')
+            c2 = CredentialsRequest.new('username' => 'foo', 'hello' => 'world')
+            c1.should_not eql(c2)
+          end
+
+          it 'is aliased as ==' do
+            c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c1.should == c2
+          end
+        end
+
+        describe '#hash' do
+          it 'has the same hash code as another identical object' do
+            c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c1.hash.should == c2.hash
+          end
+
+          it 'has the same hash code as another object with equivalent credentials' do
+            pending 'this would be nice, but is hardly necessary' do
+              c1 = CredentialsRequest.new(:username => 'foo', :password => 'bar')
+              c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+              c1.hash.should == c2.hash
+            end
+          end
+
+          it 'does not have the same hash code when the credentials are different' do
+            c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'world')
+            c2 = CredentialsRequest.new('username' => 'foo', 'hello' => 'world')
+            c1.hash.should_not == c2.hash
+          end
+        end
+      end
+
       describe OptionsRequest do
         describe '#to_s' do
           it 'returns a pretty string' do

data/spec/cql/protocol/response_frame_spec.rb

@@ -201,6 +201,24 @@ module Cql
         end
       end
 
+      context 'when fed a complete AUTHENTICATE frame' do
+        before do
+          frame << "\x81\x00\x00\x03\x00\x00\x001\x00/org.apache.cassandra.auth.PasswordAuthenticator"
+        end
+
+        it 'is complete' do
+          frame.should be_complete
+        end
+
+        it 'has an authentication class' do
+          frame.body.authentication_class.should == 'org.apache.cassandra.auth.PasswordAuthenticator'
+        end
+
+        it 'has a pretty #to_s representation' do
+          frame.body.to_s.should == 'AUTHENTICATE org.apache.cassandra.auth.PasswordAuthenticator'
+        end
+      end
+
       context 'when fed a complete SUPPORTED frame' do
         before do
           frame << "\x81\x00\x00\x06\x00\x00\x00\x27"

data/spec/integration/client_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe 'A CQL client' do
   let :connection_options do
-    {:host => ENV['CASSANDRA_HOST']}
+    {:host => ENV['CASSANDRA_HOST'], :credentials => {:username => 'cassandra', :password => 'cassandra'}}
   end
 
   let :client do
@@ -13,11 +13,11 @@ describe 'A CQL client' do
   end
 
   before do
-    client.start!
+    client.connect
   end
 
   after do
-    client.shutdown!
+    client.close
   end
 
   it 'executes a query and returns the result' do
@@ -38,12 +38,12 @@ describe 'A CQL client' do
 
   it 'can be initialized with a keyspace' do
     c = Cql::Client.new(connection_options.merge(:keyspace => 'system'))
-    c.start!
+    c.connect
     begin
       c.keyspace.should == 'system'
       expect { c.execute('SELECT * FROM schema_keyspaces') }.to_not raise_error
     ensure
-      c.shutdown!
+      c.close
     end
   end
 
@@ -68,12 +68,12 @@ describe 'A CQL client' do
     end
 
     before do
-      client.shutdown!
-      multi_client.start!
+      client.close
+      multi_client.connect
     end
 
     after do
-      multi_client.shutdown!
+      multi_client.close
     end
 
     it 'handles keyspace changes with #use' do
@@ -101,6 +101,43 @@ describe 'A CQL client' do
     end
   end
 
+  context 'with authentication' do
+    let :client do
+      stub(:client, connect: nil, close: nil)
+    end
+
+    let :authentication_enabled do
+      begin
+        Cql::Client.connect(connection_options.merge(credentials: nil))
+        false
+      rescue Cql::AuthenticationError
+        true
+      end
+    end
+
+    it 'send 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
+        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.new(connection_options.merge(credentials: {username: 'foo', password: 'bar'}))
+        expect { client.connect }.to raise_error(Cql::AuthenticationError)
+      else
+        pending 'authentication not configured'
+      end
+    end
+  end
+
   context 'with error conditions' do
     it 'raises an error for CQL syntax errors' do
       expect { client.execute('BAD cql') }.to raise_error(Cql::CqlError)
@@ -112,7 +149,7 @@ describe 'A CQL client' do
 
     it 'fails gracefully when connecting to the Thrift port' do
       client = Cql::Client.new(connection_options.merge(port: 9160))
-      expect { client.start! }.to raise_error(Cql::IoError)
+      expect { client.connect }.to raise_error(Cql::IoError)
     end
   end
 end

data/spec/integration/protocol_spec.rb

@@ -19,10 +19,21 @@ describe 'Protocol parsing and communication' do
     io_reactor.stop.get if io_reactor.running?
   end
 
-  def execute_request(request)
+  def raw_execute_request(request)
     io_reactor.queue_request(request).get.first
   end
 
+  def execute_request(request)
+    response = raw_execute_request(request)
+    if response.is_a?(Cql::Protocol::AuthenticateResponse)
+      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'))
+    end
+    response
+  end
+
   def query(cql, consistency=:one)
     response = execute_request(Cql::Protocol::QueryRequest.new(cql, consistency))
     raise response.to_s if response.is_a?(Cql::Protocol::ErrorResponse)
@@ -83,15 +94,73 @@ describe 'Protocol parsing and communication' do
       response.options.should have_key('CQL_VERSION')
     end
 
-    it 'sends STARTUP and receives READY' do
-      response = execute_request(Cql::Protocol::StartupRequest.new)
-      response.should be_a(Cql::Protocol::ReadyResponse)
+    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')
+      end
     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')
+    context 'when authentication is required' do
+      let :authentication_enabled do
+        ir = Cql::Io::IoReactor.new
+        ir.start
+        connected = ir.add_connection(ENV['CASSANDRA_HOST'], 9042)
+        started = connected.flat_map do
+          ir.queue_request(Cql::Protocol::StartupRequest.new)
+        end
+        response = started.get.first
+        required = response.is_a?(Cql::Protocol::AuthenticateResponse)
+        ir.stop.get
+        required
+      end
+
+      it 'sends STARTUP and receives AUTHENTICATE' do
+        if authentication_enabled
+          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
+          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
+      end
+
+      it 'sends bad username and password in CREDENTIALS and receives ERROR' do
+        if authentication_enabled
+          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
   end
 
@@ -223,12 +292,12 @@ describe 'Protocol parsing and communication' do
           end
         end
 
-        it 'sends a TRUNCATE command' do
-          in_keyspace_with_table do
-            response = query(%<TRUNCATE users>)
-            response.should be_void
-          end
-        end
+        # it 'sends a TRUNCATE command' do
+        #   in_keyspace_with_table do
+        #     response = query(%<TRUNCATE users>)
+        #     response.should be_void
+        #   end
+        # end
 
         it 'sends a BATCH command' do
           in_keyspace_with_table do