cql-rb 1.2.2 → 2.0.0.pre0

data/spec/cql/client/asynchronous_prepared_statement_spec.rb

@@ -21,14 +21,34 @@ module Cql
         ]
       end
 
+      let :raw_result_metadata do
+        raw_metadata + [
+          ['my_keyspace', 'my_table', 'a_third_column', :double],
+        ]
+      end
+
       let :rows do
         [
-          {'my_column' => 11, 'my_other_column' => 'hello'},
-          {'my_column' => 22, 'my_other_column' => 'foo'},
-          {'my_column' => 33, 'my_other_column' => 'bar'},
+          {'my_column' => 11, 'my_other_column' => 'hello', 'a_third_column' => 0.0},
+          {'my_column' => 22, 'my_other_column' => 'foo', 'a_third_column' => 0.0},
+          {'my_column' => 33, 'my_other_column' => 'bar', 'a_third_column' => 0.0},
         ]
       end
 
+      let :raw_rows do
+        buffer = ByteBuffer.new("\x00\x00\x00\x03")
+        buffer << "\x00\x00\x00\x04\x00\x00\x00\x0b"
+        buffer << "\x00\x00\x00\x05hello"
+        buffer << "\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00"
+        buffer << "\x00\x00\x00\x04\x00\x00\x00\x18"
+        buffer << "\x00\x00\x00\x03foo"
+        buffer << "\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00"
+        buffer << "\x00\x00\x00\x04\x00\x00\x00\x21"
+        buffer << "\x00\x00\x00\x03bar"
+        buffer << "\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00"
+        buffer
+      end
+
       let :cql do
         'SELECT * FROM my_table'
       end
@@ -41,14 +61,24 @@ module Cql
         ]
       end
 
+      let :protocol_version do
+        'v2'
+      end
+
       def handle_request(connection, request, timeout)
         case request
         when Protocol::PrepareRequest
           statement_id = Array.new(16) { [rand(255)].pack('c') }.join('')
           connection[:last_prepared_statement_id] = statement_id
-          Protocol::PreparedResultResponse.new(statement_id, raw_metadata, nil)
+          Protocol::PreparedResultResponse.new(statement_id, raw_metadata, protocol_version == 'v1' ? nil : raw_result_metadata, nil)
         when Protocol::ExecuteRequest
-          Protocol::RowsResultResponse.new(rows, raw_metadata, nil)
+          if request.request_metadata
+            Protocol::RowsResultResponse.new(rows, raw_metadata, request.paging_state ? 'page2' : nil, nil)
+          else
+            Protocol::RawRowsResultResponse.new(protocol_version[1].to_i, raw_rows, request.paging_state ? 'page2' : nil, nil)
+          end
+        when Protocol::BatchRequest
+          Protocol::VoidResultResponse.new(nil)
         else
           raise %(Unexpected request: #{request})
         end
@@ -101,13 +131,29 @@ module Cql
         end
       end
 
+      describe '#result_metadata' do
+        let :statement do
+          described_class.prepare(cql, ExecuteOptionsDecoder.new(:all), connection_manager, logger).value
+        end
+
+        it 'returns the interpreted result metadata' do
+          statement.result_metadata.should be_a(ResultMetadata)
+          statement.result_metadata['a_third_column'].should be_a(ColumnMetadata)
+        end
+
+        it 'is nil when there is no result metadata' do
+          protocol_version.replace('v1')
+          statement.result_metadata.should be_nil
+        end
+      end
+
       describe '#execute' do
         let :statement do
           described_class.prepare(cql, ExecuteOptionsDecoder.new(:local_quorum), connection_manager, logger).value
         end
 
         it 'executes itself on one of the connections' do
-          statement.execute(11, 'hello')
+          statement.execute(11, 'hello').value
           requests = connections.flat_map(&:requests).select { |r| r.is_a?(Protocol::ExecuteRequest) }
           requests.should have(1).item
           requests.first.metadata.should == raw_metadata
@@ -115,29 +161,46 @@ module Cql
         end
 
         it 'uses the right statement ID for the connection' do
-          statement.execute(11, 'hello')
+          statement.execute(11, 'hello').value
           connection, request = connections.map { |c| [c, c.requests.find { |r| r.is_a?(Protocol::ExecuteRequest) }] }.find { |c, r| r }
           request.id.should == connection[:last_prepared_statement_id]
         end
 
         it 'sends the default consistency level' do
-          statement.execute(11, 'hello')
+          statement.execute(11, 'hello').value
           request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
           request.consistency.should == :local_quorum
         end
 
         it 'sends the consistency given as last argument' do
-          statement.execute(11, 'hello', :two)
+          statement.execute(11, 'hello', :two).value
           request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
           request.consistency.should == :two
         end
 
         it 'sends the consistency given as an option' do
-          statement.execute(11, 'hello', consistency: :two)
+          statement.execute(11, 'hello', consistency: :two).value
           request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
           request.consistency.should == :two
         end
 
+        it 'sends the serial consistency given as an option' do
+          statement.execute(11, 'hello', serial_consistency: :local_serial).value
+          request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
+          request.serial_consistency.should == :local_serial
+        end
+
+        it 'asks the server not to send metadata' do
+          statement.execute(11, 'hello', consistency: :two).value
+          request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
+          request.request_metadata.should be_false
+        end
+
+        it 'passes the metadata to the request runner' do
+          response = statement.execute(11, 'hello', consistency: :two).value
+          response.count.should == 3
+        end
+
         it 'uses the specified timeout' do
           sent_timeout = nil
           connections.each do |c|
@@ -146,10 +209,38 @@ module Cql
               handle_request(c, r, t)
             end
           end
-          statement.execute(11, 'hello', timeout: 3)
+          statement.execute(11, 'hello', timeout: 3).value
           sent_timeout.should == 3
         end
 
+        context 'when paging' do
+          it 'sends the page size given as an option' do
+            statement.execute(11, 'hello', page_size: 10).value
+            request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
+            request.page_size.should == 10
+          end
+
+          it 'sends the page size and paging state given as options' do
+            statement.execute(11, 'hello', page_size: 10, paging_state: 'foo').value
+            request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
+            request.page_size.should == 10
+            request.paging_state.should == 'foo'
+          end
+
+          it 'returns a result which can load the next page' do
+            result = statement.execute(11, 'foo', page_size: 2).value
+            result.next_page.value
+            request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
+            request.paging_state.should == result.paging_state
+          end
+
+          it 'returns a result which knows when there are no more pages' do
+            result = statement.execute(11, 'foo', page_size: 2).value
+            result = result.next_page.value
+            result.should be_last_page
+          end
+        end
+
         context 'when it receives a new connection from the connection manager' do
           let :new_connection do
             FakeConnection.new('h3.example.com', 1234, 5)
@@ -206,6 +297,97 @@ module Cql
           tracing.should be_true
         end
       end
+
+      describe '#batch' do
+        let :statement do
+          described_class.prepare('UPDATE x SET y = ? WHERE z = ?', ExecuteOptionsDecoder.new(:one), connection_manager, logger).value
+        end
+
+        def requests
+          connections.flat_map(&:requests).select { |r| r.is_a?(Protocol::BatchRequest) }
+        end
+
+        context 'when called witout a block' do
+          it 'returns a batch' do
+            batch = statement.batch
+            batch.add(1, 'foo')
+            batch.execute.value
+            requests.first.should be_a(Protocol::BatchRequest)
+          end
+
+          it 'creates a batch of the right type' do
+            batch = statement.batch(:unlogged)
+            batch.add(1, 'foo')
+            batch.execute.value
+            requests.first.type.should == Protocol::BatchRequest::UNLOGGED_TYPE
+          end
+
+          it 'passes the options to the batch' do
+            batch = statement.batch(trace: true)
+            batch.add(1, 'foo')
+            batch.execute.value
+            requests.first.trace.should be_true
+          end
+        end
+
+        context 'when called with a block' do
+          it 'yields and executes a batch' do
+            f = statement.batch do |batch|
+              batch.add(5, 'foo')
+              batch.add(6, 'bar')
+            end
+            f.value
+            requests.first.should be_a(Protocol::BatchRequest)
+          end
+
+          it 'passes the options to the batch\'s #execute' do
+            f = statement.batch(:unlogged, trace: true) do |batch|
+              batch.add(4, 'baz')
+            end
+            f.value
+            requests.first.trace.should be_true
+          end
+        end
+      end
+
+      describe '#add_to_batch' do
+        let :statement do
+          described_class.prepare('UPDATE x SET y = ? WHERE z = ?', ExecuteOptionsDecoder.new(:one), connection_manager, logger).value
+        end
+
+        let :batch do
+          double(:batch)
+        end
+
+        let :additions do
+          []
+        end
+
+        before do
+          connections.pop(2)
+          batch.stub(:add_prepared) do |*args|
+            additions << args
+          end
+        end
+
+        it 'calls #add_prepared with the statement ID, metadata and bound variables' do
+          statement.add_to_batch(batch, connections.first, [11, 'foo'])
+          statement_id, metadata, bound_args = additions.first
+          statement_id.should == connections.first[:last_prepared_statement_id]
+          metadata.should == raw_metadata
+          bound_args.should == [11, 'foo']
+        end
+
+        it 'raises an error when the number of bound arguments is not right' do
+          expect { statement.add_to_batch(batch, connections.first, [11, 'foo', 22]) }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an error when the statement has not been prepared on the specified connection' do
+          connection = double(:connection)
+          connection.stub(:[]).with(statement).and_return(nil)
+          expect { statement.add_to_batch(batch, connection, [11, 'foo']) }.to raise_error(NotPreparedError)
+        end
+      end
     end
   end
 end

data/spec/cql/client/authenticators_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe PlainTextAuthProvider do
+      let :auth_provider do
+        described_class.new('foo', 'bar')
+      end
+
+      let :standard_authentication_class do
+        'org.apache.cassandra.auth.PasswordAuthenticator'
+      end
+
+      describe '#create_authenticator' do
+        it 'creates a PlainTextAuthenticator' do
+          authenticator = auth_provider.create_authenticator(standard_authentication_class)
+          authenticator.initial_response.should == "\x00foo\x00bar"
+        end
+
+        it 'returns nil when the authentication class is not o.a.c.a.PasswordAuthenticator' do
+          authenticator = auth_provider.create_authenticator('org.acme.Foo')
+          authenticator.should be_nil
+        end
+      end
+    end
+
+    describe PlainTextAuthenticator do
+      describe '#initial_response' do
+        it 'encodes the username and password' do
+          response = described_class.new('user', 'pass').initial_response
+          response.should == "\x00user\x00pass"
+        end
+      end
+
+      describe '#challenge_response' do
+        it 'returns nil' do
+          authenticator = described_class.new('user', 'pass')
+          authenticator.initial_response
+          authenticator.challenge_response('?').should be_nil
+        end
+      end
+
+      describe '#authentication_successful' do
+        it 'does nothing' do
+          authenticator = described_class.new('user', 'pass')
+          authenticator.initial_response
+          authenticator.challenge_response('?')
+          authenticator.authentication_successful('ok')
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/batch_spec.rb

@@ -0,0 +1,277 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe AsynchronousBatch do
+      let :batch do
+        described_class.new(:unlogged, execute_options_decoder, connection_manager)
+      end
+
+      let :execute_options_decoder do
+        ExecuteOptionsDecoder.new(:two)
+      end
+
+      let :connection_manager do
+        double(:connection_manager)
+      end
+
+      let :connection do
+        double(:connection)
+      end
+
+      describe '#initialize' do
+        it 'raises an error when the type is not :logged, :unlogged or :counter' do
+          expect { described_class.new(:foobar, execute_options_decoder, connection_manager) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#add' do
+        it 'returns nil' do
+          result = batch.add('UPDATE x SET y = 1 WHER z = 2')
+          result.should be_nil
+        end
+      end
+
+      describe '#execute' do
+        let :requests do
+          []
+        end
+
+        def last_request
+          requests.last[0]
+        end
+
+        def last_timeout
+          requests.last[1]
+        end
+
+        let :prepared_statement do
+          double(:prepared_statement)
+        end
+
+        let :metadata do
+          [['ks', 'tbl', 'col1', :bigint], ['ks', 'tbl', 'col2', :text]]
+        end
+
+        before do
+          connection_manager.stub(:random_connection).and_return(connection)
+          connection.stub(:send_request) do |request, timeout|
+            requests << [request, timeout]
+            Future.resolved(Protocol::VoidResultResponse.new(nil))
+          end
+        end
+
+        it 'creates a BATCH request and executes it on a random connection' do
+          batch.execute.value
+          connection.should have_received(:send_request).with(an_instance_of(Protocol::BatchRequest), nil)
+        end
+
+        it 'creates a BATCH request from the added parts' do
+          prepared_statement.stub(:add_to_batch) do |batch_request, connection, bound_args|
+            batch_request.add_prepared('XXXXXXXXXXXXXXXX', metadata, bound_args)
+          end
+          prepared_statement.stub(:metadata).and_return(metadata)
+          batch.add('UPDATE x SET y = 1 WHERE z = 2')
+          batch.add('UPDATE x SET y = 2 WHERE z = ?', 3)
+          batch.add(prepared_statement, 3, 'foo')
+          batch.execute.value
+          encoded_frame = last_request.write(1, '')
+          encoded_frame.should include('UPDATE x SET y = 1 WHERE z = 2')
+          encoded_frame.should include('UPDATE x SET y = 2 WHERE z = ?')
+          encoded_frame.should include(Protocol::QueryRequest.encode_values('', [3], nil))
+          encoded_frame.should include('XXXXXXXXXXXXXXXX')
+          encoded_frame.should include(Protocol::ExecuteRequest.encode_values('', metadata, [3, 'foo']))
+        end
+
+        it 'uses the provided type hints' do
+          batch.add('UPDATE x SET y = 2 WHERE z = ?', 3, type_hints: [:int])
+          batch.execute.value
+          encoded_frame = last_request.write(1, '')
+          encoded_frame.should include(Protocol::QueryRequest.encode_values('', [3], [:int]))
+        end
+
+        it 'tries again when a prepared statement raises NotPreparedError' do
+          connection1 = double(:connection1)
+          connection2 = double(:connection2)
+          connection2.stub(:send_request).and_return(Cql::Future.resolved(Protocol::VoidResultResponse.new(nil)))
+          connection_manager.stub(:random_connection).and_return(connection1, connection2)
+          prepared_statement.stub(:add_to_batch).with(anything, connection1, anything).and_raise(NotPreparedError)
+          prepared_statement.stub(:add_to_batch).with(anything, connection2, anything)
+          batch.add(prepared_statement, 3, 'foo')
+          expect { batch.execute.value }.to_not raise_error
+        end
+
+        it 'gives up when the prepared statement has raised NotPreparedError three times' do
+          prepared_statement.stub(:add_to_batch).with(anything, connection, anything).and_raise(NotPreparedError)
+          batch.add(prepared_statement, 3, 'foo')
+          expect { batch.execute.value }.to raise_error(NotPreparedError)
+          prepared_statement.should have_received(:add_to_batch).exactly(3).times
+        end
+
+        it 'returns a future that resolves to the response' do
+          f = batch.execute
+          f.value.should equal(VoidResult::INSTANCE)
+        end
+
+        it 'accepts a timeout' do
+          batch.execute(timeout: 10).value
+          last_timeout.should == 10
+        end
+
+        it 'accepts a consistency' do
+          batch.execute(consistency: :three).value
+          last_request.consistency.should == :three
+        end
+
+        it 'accepts consistency as a symbol' do
+          batch.execute(:three).value
+          last_request.consistency.should == :three
+        end
+
+        it 'uses the default consistency' do
+          batch.execute.value
+          last_request.consistency.should == :two
+        end
+
+        it 'enables tracing' do
+          batch.execute(trace: true).value
+          last_request.trace.should be_true
+        end
+
+        it 'creates a batch of the right type' do
+          b1 = described_class.new(:logged, execute_options_decoder, connection_manager)
+          b2 = described_class.new(:unlogged, execute_options_decoder, connection_manager)
+          b3 = described_class.new(:counter, execute_options_decoder, connection_manager)
+          b1.execute.value
+          last_request.type.should == Protocol::BatchRequest::LOGGED_TYPE
+          b2.execute.value
+          last_request.type.should == Protocol::BatchRequest::UNLOGGED_TYPE
+          b3.execute.value
+          last_request.type.should == Protocol::BatchRequest::COUNTER_TYPE
+        end
+
+        it 'uses the options given in the constructor' do
+          b = described_class.new(:unlogged, execute_options_decoder, connection_manager, timeout: 4)
+          b.execute.value
+          last_timeout.should == 4
+        end
+
+        it 'merges the options with the options given in the constructor' do
+          b = described_class.new(:unlogged, execute_options_decoder, connection_manager, timeout: 4, trace: true)
+          b.execute(trace: false).value
+          last_timeout.should == 4
+          last_request.trace.should be_false
+        end
+      end
+    end
+
+    describe SynchronousBatch do
+      let :batch do
+        described_class.new(asynchronous_batch)
+      end
+
+      let :asynchronous_batch do
+        double(:asynchronous_batch)
+      end
+
+      before do
+        asynchronous_batch.stub(:add)
+        asynchronous_batch.stub(:execute).and_return(Cql::Future.resolved(VoidResult::INSTANCE))
+      end
+
+      describe '#async' do
+        it 'returns the asynchronous batch' do
+          batch.async.should equal(asynchronous_batch)
+        end
+      end
+
+      describe '#add' do
+        it 'delegates to the asynchronous batch' do
+          batch.add('UPDATE x SET y = ? WHERE z = ?', 3, 4)
+          asynchronous_batch.should have_received(:add).with('UPDATE x SET y = ? WHERE z = ?', 3, 4)
+        end
+      end
+
+      describe '#execute' do
+        it 'delegates to the asynchronous batch' do
+          batch.execute(trace: true)
+          asynchronous_batch.should have_received(:execute).with(trace: true)
+        end
+
+        it 'waits for the response' do
+          batch.execute.should == VoidResult::INSTANCE
+        end
+      end
+    end
+
+    describe AsynchronousPreparedStatementBatch do
+      let :prepared_statement_batch do
+        described_class.new(prepared_statement, batch)
+      end
+
+      let :prepared_statement do
+        double(:prepared_statement)
+      end
+
+      let :batch do
+        double(:batch)
+      end
+
+      before do
+        batch.stub(:add)
+        batch.stub(:execute).and_return(Cql::Future.resolved(VoidResult::INSTANCE))
+      end
+
+      describe '#add' do
+        it 'passes the statement and the given arguments to the batch' do
+          prepared_statement_batch.add('foo', 3)
+          batch.should have_received(:add).with(prepared_statement, 'foo', 3)
+        end
+      end
+
+      describe '#execute' do
+        it 'delegates to the batch' do
+          result = prepared_statement_batch.execute(trace: true)
+          batch.should have_received(:execute).with(trace: true)
+          result.value.should == VoidResult::INSTANCE
+        end
+      end
+    end
+
+    describe SynchronousPreparedStatementBatch do
+      let :batch do
+        described_class.new(asynchronous_batch)
+      end
+
+      let :asynchronous_batch do
+        double(:asynchronous_batch)
+      end
+
+      before do
+        asynchronous_batch.stub(:add)
+        asynchronous_batch.stub(:execute).and_return(Cql::Future.resolved(VoidResult::INSTANCE))
+      end
+
+      describe '#add' do
+        it 'delegates to the async batch' do
+          batch.add(3, 'foo', 9)
+          asynchronous_batch.should have_received(:add).with(3, 'foo', 9)
+        end
+      end
+
+      describe '#execute' do
+        it 'delegates to the async batch' do
+          batch.execute(trace: true)
+          asynchronous_batch.should have_received(:execute).with(trace: true)
+        end
+
+        it 'waits for the response' do
+          batch.execute.should == VoidResult::INSTANCE
+        end
+      end
+    end
+  end
+end