cql-rb 1.1.3 → 1.2.0.pre0

data/spec/cql/client/asynchronous_prepared_statement_spec.rb

@@ -46,9 +46,9 @@ module Cql
         when Protocol::PrepareRequest
           statement_id = [rand(2**31)].pack('c*')
           connection[:last_prepared_statement_id] = statement_id
-          Protocol::PreparedResultResponse.new(statement_id, raw_metadata)
+          Protocol::PreparedResultResponse.new(statement_id, raw_metadata, nil)
         when Protocol::ExecuteRequest
-          Protocol::RowsResultResponse.new(rows, raw_metadata)
+          Protocol::RowsResultResponse.new(rows, raw_metadata, nil)
         else
           raise %(Unexpected request: #{request})
         end
@@ -190,6 +190,20 @@ module Cql
           expect { f1.value }.to raise_error(NoMethodError)
           expect { f2.value }.to raise_error(ArgumentError)
         end
+
+        it 'sets the trace flag' do
+          tracing = false
+          connections.each do |c|
+            c.handle_request do |r, t|
+              if r.is_a?(Protocol::ExecuteRequest)
+                tracing = r.trace
+              end
+              handle_request(c, r, t)
+            end
+          end
+          statement.execute(11, 'hello', trace: true).value
+          tracing.should be_true
+        end
       end
     end
   end

data/spec/cql/client/connection_helper_spec.rb

@@ -7,7 +7,7 @@ module Cql
   module Client
     describe ConnectionHelper do
       let :connection_helper do
-        described_class.new(io_reactor, 9876, nil, 1, 7, logger)
+        described_class.new(io_reactor, 9876, nil, 1, 7, compressor, logger)
       end
 
       let :io_reactor do
@@ -18,6 +18,10 @@ module Cql
         NullLogger.new
       end
 
+      let :compressor do
+        nil
+      end
+
       describe '#connect' do
         let :hosts do
           %w[host0 host1]
@@ -92,10 +96,26 @@ module Cql
           io_reactor.stub(:connect).with('host1', 9876, 7).and_return(Future.resolved(connection1))
           connection_helper.connect(hosts, 'some_keyspace')
           [connection0, connection1].each do |c|
-            c.requests[0].should be_a(Protocol::StartupRequest)
-            c.requests[1].cql.should match(/SELECT .* FROM system.local/)
-            c.requests[2].cql.should == 'USE some_keyspace'
+            c.requests[0].should be_a(Protocol::OptionsRequest)
+            c.requests[1].should be_a(Protocol::StartupRequest)
+            c.requests[2].cql.should match(/SELECT .* FROM system.local/)
+            c.requests[3].cql.should == 'USE some_keyspace'
+          end
+        end
+
+        it 'saves the supported CQL version and compression algorithms on the connection' do
+          connection = FakeConnection.new('host0', 9876, 7)
+          connection.handle_request do |request, timeout|
+            if request.is_a?(Protocol::OptionsRequest)
+              Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.1.1], 'COMPRESSION' => %w[lz4 snappy])
+            else
+              connection.default_request_handler(request, timeout)
+            end
           end
+          io_reactor.stub(:connect).with('host0', 9876, 7).and_return(Future.resolved(connection))
+          connection_helper.connect(hosts.take(1), 'some_keyspace')
+          connection[:cql_version].should == %w[3.1.1]
+          connection[:compression].should == %w[lz4 snappy]
         end
 
         it 'fails if authentication is required and no credentials were specified' do
@@ -114,7 +134,7 @@ module Cql
 
         it 'authenticates when authentication is required and credentials were specified' do
           credentials = {'username' => 'foo', 'password' => 'bar'}
-          connection_helper = described_class.new(io_reactor, 9876, credentials, 1, 7, logger)
+          connection_helper = described_class.new(io_reactor, 9876, credentials, 1, 7, nil, logger)
           connection = FakeConnection.new('host0', 9876, 7)
           authentication_sent = false
           connection.handle_request do |request|
@@ -138,7 +158,7 @@ module Cql
           connection.handle_request do |request|
             if request.is_a?(Protocol::QueryRequest) && request.cql =~ /SELECT .* FROM system\.local/
               row = {'data_center' => 'dc1', 'host_id' => Uuid.new('eac69196-1e28-11e3-8e2b-191b6d153d0c')}
-              Protocol::RowsResultResponse.new([row], local_metadata)
+              Protocol::RowsResultResponse.new([row], local_metadata, nil)
             else
               connection.default_request_handler(request)
             end
@@ -180,11 +200,68 @@ module Cql
         end
 
         it 'connects to each node a configurable number of times' do
-          connection_helper = described_class.new(io_reactor, 9876, nil, connections_per_node = 3, 7, logger)
+          connection_helper = described_class.new(io_reactor, 9876, nil, connections_per_node = 3, 7, nil, logger)
           connection_helper.connect(hosts, nil)
           io_reactor.should have_received(:connect).with('host0', 9876, 7).exactly(3).times
           io_reactor.should have_received(:connect).with('host1', 9876, 7).exactly(3).times
         end
+
+        context 'when a compressor is specified' do
+          let :compressor do
+            double(:compressor, algorithm: 'snappy')
+          end
+
+          let :connection do
+            FakeConnection.new('host0', 9876, 7)
+          end
+
+          it 'enables compression by sending the algorithm with the STARTUP request' do
+            connection.handle_request do |request, timeout|
+              if request.is_a?(Protocol::OptionsRequest)
+                Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.1.1], 'COMPRESSION' => %w[lz4 snappy])
+              else
+                connection.default_request_handler(request, timeout)
+              end
+            end
+            io_reactor.stub(:connect).with('host0', 9876, 7).and_return(Future.resolved(connection))
+            connection_helper.connect(hosts.take(1), 'some_keyspace')
+            connection.requests[1].options['COMPRESSION'].should == 'snappy'
+          end
+
+          it 'does not enable compression when the algorithm is not supported' do
+            connection.handle_request do |request, timeout|
+              if request.is_a?(Protocol::OptionsRequest)
+                Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.1.1], 'COMPRESSION' => %w[lz4])
+              else
+                connection.default_request_handler(request, timeout)
+              end
+            end
+            io_reactor.stub(:connect).with('host0', 9876, 7).and_return(Future.resolved(connection))
+            connection_helper.connect(hosts.take(1), 'some_keyspace')
+            connection.requests[1].options.should_not have_key('COMPRESSION')
+          end
+
+          it 'logs a warning when compression was disabled because the algorithm was not supported' do
+            logger.stub(:warn)
+            connection.handle_request do |request, timeout|
+              if request.is_a?(Protocol::OptionsRequest)
+                Protocol::SupportedResponse.new('CQL_VERSION' => %w[3.1.1], 'COMPRESSION' => %w[lz4])
+              else
+                connection.default_request_handler(request, timeout)
+              end
+            end
+            io_reactor.stub(:connect).with('host0', 9876, 7).and_return(Future.resolved(connection))
+            connection_helper.connect(hosts.take(1), 'some_keyspace')
+            logger.should have_received(:warn).with(/not supported/)
+          end
+
+          it 'logs the name of the compression algorithm when connecting' do
+            logger.stub(:debug)
+            io_reactor.stub(:connect).with('host0', 9876, 7).and_return(Future.resolved(connection))
+            connection_helper.connect(hosts.take(1), 'some_keyspace')
+            logger.should have_received(:debug).with(/using "snappy" compression/)
+          end
+        end
       end
 
       describe '#discover_peers' do
@@ -232,7 +309,7 @@ module Cql
           seed_connections.each do |c|
             c.handle_request do |request|
               if request.cql =~ /SELECT .* FROM system\.peers/
-                Protocol::RowsResultResponse.new(yield, peer_metadata)
+                Protocol::RowsResultResponse.new(yield, peer_metadata, nil)
               end
             end
           end
@@ -308,9 +385,10 @@ module Cql
           peer_request_response { seed_connection_rows + extra_connection_rows.take(1) }
           f = connection_helper.discover_peers(seed_connections, 'some_keyspace')
           f.value
-          connection.requests[0].should be_a(Protocol::StartupRequest)
-          connection.requests[1].cql.should match(/SELECT .* FROM system.local/)
-          connection.requests[2].cql.should == 'USE some_keyspace'
+          connection.requests[0].should be_a(Protocol::OptionsRequest)
+          connection.requests[1].should be_a(Protocol::StartupRequest)
+          connection.requests[2].cql.should match(/SELECT .* FROM system.local/)
+          connection.requests[3].cql.should == 'USE some_keyspace'
         end
 
         it 'connects only to node in the same data centers as the seed nodes' do
@@ -338,7 +416,7 @@ module Cql
         end
 
         it 'connects to each node a configurable number of times' do
-          connection_helper = described_class.new(io_reactor, 9876, nil, connections_per_node = 3, 7, logger)
+          connection_helper = described_class.new(io_reactor, 9876, nil, connections_per_node = 3, 7, nil, logger)
           connection = FakeConnection.new('host3', 9876, 7)
           io_reactor.stub(:connect).with('1.0.0.3', 9876, 7).and_return(Future.resolved(connection))
           peer_request_response { seed_connection_rows + extra_connection_rows.take(1) }

data/spec/cql/client/query_trace_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe QueryTrace do
+      let :trace do
+        described_class.new(session_row, event_rows)
+      end
+
+      let :started_at do
+        Time.now
+      end
+
+      let :session_row do
+        {
+          'session_id' => Uuid.new('a1028490-3f05-11e3-9531-fb72eff05fbb'),
+          'coordinator' => IPAddr.new('127.0.0.1'),
+          'duration' => 1263,
+          'parameters' => {
+            'query' => 'SELECT * FROM something'
+          },
+          'request' => 'Execute CQL3 query',
+          'started_at' => started_at
+        }
+      end
+
+      let :event_rows do
+        [
+          {
+            'session_id' => Uuid.new('a1028490-3f05-11e3-9531-fb72eff05fbb'),
+            'event_id' => TimeUuid.new('a1028491-3f05-11e3-9531-fb72eff05fbb'),
+            'activity' => 'Parsing statement',
+            'source' => IPAddr.new('127.0.0.1'),
+            'source_elapsed' => 52,
+            'thread' => 'Native-Transport-Requests:126'
+          },
+          {
+            'session_id' => Uuid.new('a1028490-3f05-11e3-9531-fb72eff05fbb'),
+            'event_id' => TimeUuid.new('a1028492-3f05-11e3-9531-fb72eff05fbb'),
+            'activity' => 'Peparing statement',
+            'source' => IPAddr.new('127.0.0.1'),
+            'source_elapsed' => 54,
+            'thread' => 'Native-Transport-Requests:126'
+          },
+        ]
+      end
+
+      context 'when the session is nil' do
+        it 'returns nil from all methods' do
+          trace = described_class.new(nil, nil)
+          trace.coordinator.should be_nil
+          trace.cql.should be_nil
+          trace.started_at.should be_nil
+          trace.events.should be_empty
+        end
+      end
+
+      context 'when the duration field of the session is nil' do
+        it 'raises an IncompleteTraceError' do
+          session_row['duration'] = nil
+          expect { described_class.new(session_row, event_rows) }.to raise_error(IncompleteTraceError)
+        end
+      end
+
+      describe '#coordinator' do
+        it 'returns the IP address of the coordinator node' do
+          trace.coordinator.should == IPAddr.new('127.0.0.1')
+        end
+      end
+
+      describe '#cql' do
+        it 'returns the query' do
+          trace.cql.should == 'SELECT * FROM something'
+        end
+      end
+
+      describe '#started_at' do
+        it 'returns the time the request started' do
+          trace.started_at.should eql(started_at)
+        end
+      end
+
+      describe '#duration' do
+        it 'returns the duration in seconds' do
+          trace.duration.should == 0.001263
+        end
+      end
+
+      describe '#events' do
+        it 'returns a list of TraceEvents' do
+          trace.events.should have(2).items
+          trace.events.first.should be_a(TraceEvent)
+        end
+
+        it 'returns an unmodifiable list' do
+          expect { trace.events << :foo }.to raise_error
+        end
+
+        context 'returns a list of trace events whose' do
+          let :events do
+            trace.events
+          end
+
+          let :event do
+            events.first
+          end
+
+          describe '#activity' do
+            it 'returns the event activity' do
+              event.activity.should == 'Parsing statement'
+            end
+          end
+
+          describe '#source' do
+            it 'returns the event source' do
+              event.source.should == IPAddr.new('127.0.0.1')
+            end
+          end
+
+          describe '#source_elapsed' do
+            it 'returns the elapsed time at the source' do
+              event.source_elapsed.should == 0.000052
+            end
+          end
+
+          describe '#time' do
+            it 'returns the time component from the event ID' do
+              event.time.to_i.should == TimeUuid.new('a1028492-3f05-11e3-9531-fb72eff05fbb').to_time.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/request_runner_spec.rb

@@ -35,27 +35,31 @@ module Cql
 
       describe '#execute' do
         let :rows_response do
-          Protocol::RowsResultResponse.new(rows, metadata)
+          Protocol::RowsResultResponse.new(rows, metadata, nil)
         end
 
         let :void_response do
-          Protocol::VoidResultResponse.new
+          Protocol::VoidResultResponse.new(nil)
         end
 
         let :prepared_response do
-          Protocol::PreparedResultResponse.new("\x2a", metadata)
+          Protocol::PreparedResultResponse.new("\x2a", metadata, nil)
         end
 
         let :error_response do
           Protocol::ErrorResponse.new(0xbad, 'Bork')
         end
 
+        let :detailed_error_response do
+          Protocol::DetailedErrorResponse.new(0xbad, 'Bork', {:cl => :quorum, :received => 1, :blockfor => 1, :write_type => 'SINGLE'})
+        end
+
         let :authenticate_response do
           Protocol::AuthenticateResponse.new('TheAuthenticator')
         end
 
         let :set_keyspace_response do
-          Protocol::SetKeyspaceResultResponse.new('some_keyspace')
+          Protocol::SetKeyspaceResultResponse.new('some_keyspace', nil)
         end
 
         def run(response, rq=request)
@@ -75,14 +79,14 @@ module Cql
           connection.should have_received(:send_request).with(request, 7)
         end
 
-        it 'transforms a RowsResultResponse to a query result' do
+        it 'transforms a RowsResultResponse to a QueryResult' do
           result = run(rows_response)
           result.should have(3).items
         end
 
-        it 'transforms a VoidResultResponse to nil' do
+        it 'transforms a VoidResultResponse to a VoidResult' do
           result = run(void_response)
-          result.should be_nil
+          result.should be_a(VoidResult)
         end
 
         it 'transforms a AuthenticateResponse to an authentication required object' do
@@ -111,6 +115,21 @@ module Cql
           end
         end
 
+        it 'sets the #details field of QueryError when the response has details' do
+          begin
+            run(detailed_error_response)
+          rescue QueryError => e
+            e.details.should == detailed_error_response.details
+          else
+            fail('No error was raised')
+          end
+        end
+
+        it 'transforms a SupportedResponse into its hash of supported options' do
+          result = run(Protocol::SupportedResponse.new('CQL_VERSION' => %w[9.9.9], 'COMPRESSION' => %w[fractal quantum]))
+          result.should eql('CQL_VERSION' => %w[9.9.9], 'COMPRESSION' => %w[fractal quantum])
+        end
+
         it 'transforms all other responses to nil' do
           result = run('hibbly hobbly')
           result.should be_nil
@@ -121,6 +140,24 @@ module Cql
           result = runner.execute(connection, request) { |response| response.reverse }.value
           result.should == 'hibbly hobbly'.reverse
         end
+
+        context 'when the response has a trace ID' do
+          let :trace_id do
+            Uuid.new('63a26b40-3f02-11e3-9531-fb72eff05fbb')
+          end
+
+          it 'returns a QueryResult that knows its trace ID' do
+            connection.stub(:send_request).with(request, anything).and_return(Future.resolved(Protocol::RowsResultResponse.new(rows, metadata, trace_id)))
+            response = runner.execute(connection, request).value
+            response.trace_id.should == trace_id
+          end
+
+          it 'returns a VoidResult that knows its trace ID' do
+            connection.stub(:send_request).with(request, anything).and_return(Future.resolved(Protocol::VoidResultResponse.new(trace_id)))
+            response = runner.execute(connection, request).value
+            response.trace_id.should == trace_id
+          end
+        end
       end
     end
   end

data/spec/cql/client/void_result_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe VoidResult do
+      describe '#empty?' do
+        it 'is true' do
+          described_class.new.should be_empty
+        end
+      end
+
+      describe '#trace_id' do
+        it 'is nil' do
+          described_class.new.trace_id.should be_nil
+        end
+
+        it 'is set through the constructor' do
+          uuid = Uuid.new('63a26b40-3f02-11e3-9531-fb72eff05fbb')
+          described_class.new(uuid).trace_id.should == uuid
+        end
+      end
+
+      describe '#metadata' do
+        it 'is empty' do
+          described_class.new.metadata.each.to_a.should be_empty
+        end
+      end
+
+      describe '#each' do
+        it 'returns an enumerable' do
+          described_class.new.each.should be_a(Enumerable)
+        end
+
+        it 'enumerates nothing' do
+          described_class.new.each.to_a.should be_empty
+        end
+      end
+    end
+  end
+end