cql-rb 1.2.2 → 2.0.0.pre0

data/spec/cql/client/request_runner_spec.rb

@@ -35,7 +35,11 @@ module Cql
 
       describe '#execute' do
         let :rows_response do
-          Protocol::RowsResultResponse.new(rows, metadata, nil)
+          Protocol::RowsResultResponse.new(rows, metadata, nil, nil)
+        end
+
+        let :raw_rows_response do
+          Protocol::RawRowsResultResponse.new(2, ByteBuffer.new("\x00\x00\x00\x02\x00\x00\x00\x01a\x00\x00\x00\x01b"), nil, nil)
         end
 
         let :void_response do
@@ -43,7 +47,7 @@ module Cql
         end
 
         let :prepared_response do
-          Protocol::PreparedResultResponse.new("\x2a", metadata, nil)
+          Protocol::PreparedResultResponse.new("\x2a", metadata, nil, nil)
         end
 
         let :error_response do
@@ -84,12 +88,19 @@ module Cql
           result.should have(3).items
         end
 
+        it 'transforms a RawRowsResultResponse to a LazyQueryResult, and mixes in the specified metadata' do
+          metadata = [['ks', 'tbl', 'col', :varchar]]
+          connection.stub(:send_request).and_return(Future.resolved(raw_rows_response))
+          result = runner.execute(connection, request, nil, metadata).value
+          result.to_a.should == [{'col' => 'a'}, {'col' => 'b'}]
+        end
+
         it 'transforms a VoidResultResponse to a VoidResult' do
           result = run(void_response)
           result.should be_a(VoidResult)
         end
 
-        it 'transforms a AuthenticateResponse to an authentication required object' do
+        it 'transforms an AuthenticateResponse to an authentication required object' do
           result = run(authenticate_response)
           result.should be_a(AuthenticationRequired)
           result.authentication_class.should == 'TheAuthenticator'
@@ -107,7 +118,7 @@ module Cql
 
         it 'sets the #cql field of QueryError when the request is a query request' do
           begin
-            run(error_response, Protocol::QueryRequest.new('SELECT * FROM everything', :all))
+            run(error_response, Protocol::QueryRequest.new('SELECT * FROM everything', nil, nil, :all))
           rescue QueryError => e
             e.cql.should == 'SELECT * FROM everything'
           else
@@ -147,7 +158,7 @@ module Cql
           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)))
+            connection.stub(:send_request).with(request, anything).and_return(Future.resolved(Protocol::RowsResultResponse.new(rows, metadata, nil, trace_id)))
             response = runner.execute(connection, request).value
             response.trace_id.should == trace_id
           end
@@ -158,6 +169,21 @@ module Cql
             response.trace_id.should == trace_id
           end
         end
+
+        context 'when the response has a paging state' do
+          it 'returns a QueryResult that knows its paging state' do
+            connection.stub(:send_request).with(request, anything).and_return(Future.resolved(Protocol::RowsResultResponse.new(rows, metadata, 'foobaz', nil)))
+            response = runner.execute(connection, request).value
+            response.paging_state.should == 'foobaz'
+          end
+
+          it 'returns a LazyQueryResult that knows its paging state' do
+            metadata = [['ks', 'tbl', 'col', :varchar]]
+            connection.stub(:send_request).with(request, anything).and_return(Future.resolved(Protocol::RawRowsResultResponse.new(2, ByteBuffer.new("\x00\x00\x00\x02\x00\x00\x00\x01a\x00\x00\x00\x01b"), 'bazbuzz', nil)))
+            response = runner.execute(connection, request, nil, metadata).value
+            response.paging_state.should == 'bazbuzz'
+          end
+        end
       end
     end
   end

data/spec/cql/client/synchronous_client_spec.rb

@@ -75,13 +75,26 @@ module Cql
           future.stub(:value).and_return(result)
           client.execute('SELECT * FROM something', :one).should equal(result)
         end
+
+        it 'wraps AsynchronousPagedQueryResult in a synchronous wrapper' do
+          cql = 'SELECT * FROM something'
+          request = double(:request, cql: cql, values: [])
+          async_result = double(:result, paging_state: 'somepagingstate')
+          options = {:page_size => 10}
+          async_client.stub(:execute).and_return(Future.resolved(AsynchronousQueryPagedQueryResult.new(async_client, request, async_result, options)))
+          result1 = client.execute(cql, options)
+          result2 = result1.next_page
+          async_client.should have_received(:execute).with('SELECT * FROM something', page_size: 10, paging_state: 'somepagingstate')
+          result2.should be_a(SynchronousPagedQueryResult)
+        end
       end
 
       describe '#prepare' do
         it 'calls #prepare on the async client, waits for the result and returns a SynchronousFuture' do
           result = double(:result)
           metadata = double(:metadata)
-          async_statement = double(:async_statement, metadata: metadata)
+          result_metadata = double(:result_metadata)
+          async_statement = double(:async_statement, metadata: metadata, result_metadata: result_metadata)
           another_future = double(:another_future)
           async_client.stub(:prepare).with('SELECT * FROM something').and_return(future)
           future.stub(:value).and_return(async_statement)
@@ -93,6 +106,36 @@ module Cql
         end
       end
 
+      describe '#batch' do
+        let :batch do
+          double(:batch)
+        end
+
+        context 'when called without a block' do
+          it 'delegates to the asynchronous client and wraps the returned object in a synchronous wrapper' do
+            async_client.stub(:batch).with(:unlogged, trace: true).and_return(batch)
+            batch.stub(:execute).and_return(Cql::Future.resolved(VoidResult.new))
+            b = client.batch(:unlogged, trace: true)
+            b.execute.should be_a(VoidResult)
+          end
+        end
+
+        context 'when called with a block' do
+          it 'delegates to the asynchronous client' do
+            async_client.stub(:batch).with(:counter, trace: true).and_yield(batch).and_return(Cql::Future.resolved(VoidResult.new))
+            yielded_batch = nil
+            client.batch(:counter, trace: true) { |b| yielded_batch = b }
+            yielded_batch.should equal(batch)
+          end
+
+          it 'waits for the operation to complete' do
+            async_client.stub(:batch).with(:counter, {}).and_yield(batch).and_return(Cql::Future.resolved(VoidResult.new))
+            result = client.batch(:counter) { |b| }
+            result.should be_a(VoidResult)
+          end
+        end
+      end
+
       describe '#async' do
         it 'returns an asynchronous client' do
           client.async.should equal(async_client)

data/spec/cql/client/synchronous_prepared_statement_spec.rb

@@ -11,13 +11,17 @@ module Cql
       end
 
       let :async_statement do
-        double(:async_statement, metadata: metadata)
+        double(:async_statement, metadata: metadata, result_metadata: result_metadata)
       end
 
       let :metadata do
         double(:metadata)
       end
 
+      let :result_metadata do
+        double(:result_metadata)
+      end
+
       let :promise do
         Promise.new
       end
@@ -32,6 +36,12 @@ module Cql
         end
       end
 
+      describe '#result_metadata' do
+        it 'returns the async statement\'s result metadata' do
+          statement.result_metadata.should equal(async_statement.result_metadata)
+        end
+      end
+
       describe '#execute' do
         it 'it calls #execute on the async statement and waits for the result' do
           result = double(:result)
@@ -39,6 +49,58 @@ module Cql
           promise.fulfill(result)
           statement.execute('one', 'two', :three).should equal(result)
         end
+
+        it 'wraps AsynchronousPagedQueryResult in a synchronous wrapper' do
+          request = double(:request, values: ['one', 'two'])
+          async_result = double(:result, paging_state: 'somepagingstate')
+          options = {:page_size => 10}
+          async_statement.stub(:execute).and_return(Future.resolved(AsynchronousPreparedPagedQueryResult.new(async_statement, request, async_result, options)))
+          result1 = statement.execute('one', 'two', options)
+          result2 = result1.next_page
+          async_statement.should have_received(:execute).with('one', 'two', page_size: 10, paging_state: 'somepagingstate')
+          result2.should be_a(SynchronousPagedQueryResult)
+        end
+      end
+
+      describe '#batch' do
+        let :batch do
+          double(:batch)
+        end
+
+        context 'when called without a block' do
+          it 'delegates to the asynchronous statement and wraps the returned object in a synchronous wrapper' do
+            async_statement.stub(:batch).with(:unlogged, trace: true).and_return(batch)
+            batch.stub(:execute).and_return(Cql::Future.resolved(VoidResult.new))
+            b = statement.batch(:unlogged, trace: true)
+            b.execute.should be_a(VoidResult)
+          end
+        end
+
+        context 'when called with a block' do
+          it 'delegates to the asynchronous statement' do
+            async_statement.stub(:batch).with(:counter, trace: true).and_yield(batch).and_return(Cql::Future.resolved(VoidResult.new))
+            yielded_batch = nil
+            statement.batch(:counter, trace: true) { |b| yielded_batch = b }
+            yielded_batch.should equal(batch)
+          end
+
+          it 'waits for the operation to complete' do
+            async_statement.stub(:batch).with(:counter, anything).and_yield(batch).and_return(Cql::Future.resolved(VoidResult.new))
+            result = statement.batch(:counter) { |b| }
+            result.should be_a(VoidResult)
+          end
+        end
+      end
+
+      describe '#add_to_batch' do
+        it 'delegates to the async statement' do
+          batch = double(:batch)
+          connection = double(:connection)
+          bound_arguments = [1, 2, 3]
+          async_statement.stub(:add_to_batch)
+          statement.add_to_batch(batch, connection, bound_arguments)
+          async_statement.should have_received(:add_to_batch).with(batch, connection, bound_arguments)
+        end
       end
 
       describe '#pipeline' do

data/spec/cql/future_spec.rb

@@ -393,6 +393,33 @@ module Cql
           mapped_value.should == 3 * 2
         end
 
+        it 'will be fulfilled with the specified value' do
+          mapped_value = nil
+          p = Promise.new
+          f = p.future.map(7)
+          f.on_value { |v| mapped_value = v }
+          p.fulfill(3)
+          mapped_value.should == 7
+        end
+
+        it 'will be fulfilled with the result of the given block, even if a value is specified' do
+          mapped_value = nil
+          p = Promise.new
+          f = p.future.map(7) { |v| v * 2 }
+          f.on_value { |v| mapped_value = v }
+          p.fulfill(3)
+          mapped_value.should == 3 * 2
+        end
+
+        it 'will be fulfilled with nil when neither value nor block is specified' do
+          mapped_value = 3
+          p = Promise.new
+          f = p.future.map
+          f.on_value { |v| mapped_value = v }
+          p.fulfill(3)
+          mapped_value.should be_nil
+        end
+
         it 'fails when the original future fails' do
           failed = false
           p = Promise.new
@@ -432,13 +459,34 @@ module Cql
 
     describe '#recover' do
       context 'returns a new future that' do
-        it 'becomes fulfilled with a value when the source future fails' do
+        it 'becomes fulfilled with a value created by the block when the source future fails' do
           p = Promise.new
           f = p.future.recover { 'foo' }
           p.fail(error)
           f.value.should == 'foo'
         end
 
+        it 'becomes fulfilled with a specfied value when the source future fails' do
+          p = Promise.new
+          f = p.future.recover('bar')
+          p.fail(error)
+          f.value.should == 'bar'
+        end
+
+        it 'becomes fulfilled with a value created by the block even when a value is specified when the source future fails' do
+          p = Promise.new
+          f = p.future.recover('bar') { 'foo' }
+          p.fail(error)
+          f.value.should == 'foo'
+        end
+
+        it 'becomes fulfilled with nil value when no value nor block is specified and the source future fails' do
+          p = Promise.new
+          f = p.future.recover
+          p.fail(error)
+          f.value.should be_nil
+        end
+
         it 'yields the error to the block' do
           p = Promise.new
           f = p.future.recover { |e| e.message }
@@ -644,7 +692,7 @@ module Cql
           described_class.resolved('hello world')
         end
 
-        it 'returns a future which is resolved' do
+        it 'is resolved' do
           future.should be_resolved
         end
 

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -7,7 +7,7 @@ module Cql
   module Protocol
     describe CqlProtocolHandler do
       let :protocol_handler do
-        described_class.new(connection, scheduler)
+        described_class.new(connection, scheduler, 1)
       end
 
       let :connection do
@@ -114,7 +114,7 @@ module Cql
 
         context 'when a compressor is specified' do
           let :protocol_handler do
-            described_class.new(connection, scheduler, compressor)
+            described_class.new(connection, scheduler, 1, compressor)
           end
 
           let :compressor do
@@ -147,8 +147,19 @@ module Cql
             f2 = protocol_handler.send_request(request)
             connection.data_listener.call("\x81\x01\x00\x08\x00\x00\x00\x12FAKECOMPRESSEDBODY")
             connection.data_listener.call("\x81\x01\x01\x08\x00\x00\x00\x12FAKECOMPRESSEDBODY")
-            f1.value.should == Protocol::PreparedResultResponse.new(id, [["cql_rb_911", "users", "user_name", :varchar]], nil)
-            f2.value.should == Protocol::PreparedResultResponse.new(id, [["cql_rb_911", "users", "user_name", :varchar]], nil)
+            f1.value.should == Protocol::PreparedResultResponse.new(id, [["cql_rb_911", "users", "user_name", :varchar]], nil, nil)
+            f2.value.should == Protocol::PreparedResultResponse.new(id, [["cql_rb_911", "users", "user_name", :varchar]], nil, nil)
+          end
+        end
+
+        context 'when a protocol version is specified' do
+          let :protocol_handler do
+            described_class.new(connection, scheduler, 7)
+          end
+
+          it 'sets the protocol version in the header' do
+            protocol_handler.send_request(request)
+            buffer.to_s[0].should == "\x07"
           end
         end
 
@@ -266,7 +277,7 @@ module Cql
         end
 
         it 'registers the keyspace it has changed to' do
-          f = protocol_handler.send_request(Protocol::QueryRequest.new('USE hello', :one))
+          f = protocol_handler.send_request(Protocol::QueryRequest.new('USE hello', nil, nil, :one))
           connection.data_listener.call([0x81, 0, 0, 8, 4 + 2 + 5, 3, 5].pack('C4N2n') + 'hello')
           f.value
           protocol_handler.keyspace.should == 'hello'

data/spec/cql/protocol/decoding_spec.rb

@@ -100,8 +100,8 @@ module Cql
         end
 
         it 'decodes a negative long' do
-          buffer = ByteBuffer.new("\xff\xff\xff\xff\xff\xff\xff\xff")
-          Decoding.read_long!(buffer).should == -1
+          buffer = ByteBuffer.new("\xff\xee\xdd\xcc\xbb\xaa\x99\x88")
+          Decoding.read_long!(buffer).should == 0xffeeddccbbaa9988 - 0x10000000000000000
         end
 
         it 'consumes the bytes' do
@@ -162,8 +162,8 @@ module Cql
         end
 
         it 'decodes a negative int' do
-          buffer = ByteBuffer.new("\xff\xff\xff\xff")
-          Decoding.read_int!(buffer).should == -1
+          buffer = ByteBuffer.new("\xff\xee\xdd\xcc")
+          Decoding.read_int!(buffer).should == 0xffeeddcc - 0x100000000
         end
 
         it 'consumes the bytes' do
@@ -470,14 +470,24 @@ module Cql
           Decoding.read_consistency!(buffer).should == :each_quorum
         end
 
+        it 'decodes SERIAL' do
+          buffer = ByteBuffer.new("\x00\x08")
+          Decoding.read_consistency!(buffer).should == :serial
+        end
+
+        it 'decodes LOCAL_SERIAL' do
+          buffer = ByteBuffer.new("\x00\x09")
+          Decoding.read_consistency!(buffer).should == :local_serial
+        end
+
         it 'decodes LOCAL_ONE' do
-          buffer = ByteBuffer.new("\x00\x10")
+          buffer = ByteBuffer.new("\x00\x0a")
           Decoding.read_consistency!(buffer).should == :local_one
         end
 
         it 'raises an exception for an unknown consistency' do
           expect { Decoding.read_consistency!(ByteBuffer.new("\xff\xff")) }.to raise_error(DecodingError)
-          expect { Decoding.read_consistency!(ByteBuffer.new("\x00\x0a")) }.to raise_error(DecodingError)
+          expect { Decoding.read_consistency!(ByteBuffer.new("\x00\x0f")) }.to raise_error(DecodingError)
         end
       end
 

data/spec/cql/protocol/encoding_spec.rb

@@ -238,7 +238,9 @@ module Cql
           :all => "\x00\x05",
           :local_quorum => "\x00\x06",
           :each_quorum => "\x00\x07",
-          :local_one => "\x00\x10",
+          :serial => "\x00\x08",
+          :local_serial => "\x00\x09",
+          :local_one => "\x00\x0a",
         }.each do |consistency, expected_encoding|
           it "encodes #{consistency}" do
             Encoding.write_consistency(buffer, consistency)

data/spec/cql/protocol/frame_encoder_spec.rb

@@ -6,86 +6,135 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe FrameEncoder do
-      let :encoder do
-        described_class.new
-      end
-
       describe '#encode_frame' do
-        it 'returns a rendered request frame for the specified channel' do
-          request = PrepareRequest.new('SELECT * FROM things')
-          stream_id = 3
-          encoded_frame = encoder.encode_frame(request, stream_id)
-          encoded_frame.to_s.should == "\x01\x00\x03\x09\x00\x00\x00\x18\x00\x00\x00\x14SELECT * FROM things"
+        let :request do
+          double(:request)
+        end
+
+        let :compressor do
+          double(:compressor)
         end
 
-        it 'appends a rendered request frame to the specified buffer' do
+        before do
+          request.stub(:opcode).and_return(0x77)
+          request.stub(:trace?).and_return(false)
+          request.stub(:write) { |pv, bb| bb }
+        end
+
+        it 'asks the request to write itself to a buffer' do
+          encoder = described_class.new(1)
+          encoder.encode_frame(request)
+          request.should have_received(:write).with(anything, an_instance_of(ByteBuffer))
+        end
+
+        it 'appends what the request wrote to the specified buffer, after a header' do
           buffer = ByteBuffer.new('hello')
-          request = PrepareRequest.new('SELECT * FROM things')
-          stream_id = 3
-          encoded_frame = encoder.encode_frame(request, stream_id, buffer)
-          buffer.to_s.should == "hello\x01\x00\x03\x09\x00\x00\x00\x18\x00\x00\x00\x14SELECT * FROM things"
+          request.stub(:write) { |pv, bb| bb << "\x01\x02\x03" }
+          encoder = described_class.new(1)
+          encoder.encode_frame(request, 0, buffer)
+          buffer.to_s[ 0, 5].should == 'hello'
+          buffer.to_s[13, 3].should == "\x01\x02\x03"
         end
 
         it 'returns the specified buffer' do
           buffer = ByteBuffer.new('hello')
-          request = PrepareRequest.new('SELECT * FROM things')
-          stream_id = 3
-          encoded_frame = encoder.encode_frame(request, stream_id, buffer)
-          encoded_frame.should equal(buffer)
+          encoder = described_class.new(1)
+          returned_buffer = encoder.encode_frame(request, 0, buffer)
+          returned_buffer.should equal(buffer)
         end
 
-        context 'with a compressor' do
-          let :encoder do
-            described_class.new(compressor)
-          end
+        it 'passes the protocol version to the request' do
+          encoder = described_class.new(7)
+          encoder.encode_frame(request)
+          request.should have_received(:write).with(7, anything)
+        end
 
-          let :compressor do
-            double(:compressor)
-          end
+        it 'encodes a header with the specified protocol version' do
+          encoder = described_class.new(7)
+          buffer = encoder.encode_frame(request)
+          buffer.to_s[0].should == "\x07"
+        end
 
-          let :request do
-            PrepareRequest.new('SELECT * FROM things')
-          end
+        it 'encodes a header with the tracing flag set' do
+          request.stub(:trace?).and_return(true)
+          encoder = described_class.new(1)
+          buffer = encoder.encode_frame(request)
+          buffer.to_s[1].should == "\x02"
+        end
 
-          let :compressed_frame do
-            encoder.encode_frame(request, 3).to_s
-          end
+        it 'encodes a header with the specified stream ID' do
+          encoder = described_class.new(1)
+          buffer = encoder.encode_frame(request, 9)
+          buffer.to_s[2].should == "\x09"
+        end
+
+        it 'complains when the stream ID is less than 0 or more than 127' do
+          encoder = described_class.new(1)
+          expect { encoder.encode_frame(request, -1) }.to raise_error(InvalidStreamIdError)
+          expect { encoder.encode_frame(request, 128) }.to raise_error(InvalidStreamIdError)
+        end
+
+        it 'encodes a header with the right opcode' do
+          encoder = described_class.new(1)
+          buffer = encoder.encode_frame(request, 9)
+          buffer.to_s[3].should == "\x77"
+        end
 
+        it 'encodes the body size' do
+          request.stub(:write).and_return(ByteBuffer.new('helloworld'))
+          encoder = described_class.new(1)
+          buffer = encoder.encode_frame(request, 9)
+          buffer.to_s[4, 4].should == "\x00\x00\x00\x0a"
+        end
+
+        context 'when a compressor has been specified' do
           before do
-            compressor.stub(:compress?).with("\x00\x00\x00\x14SELECT * FROM things").and_return(true)
-            compressor.stub(:compress).with("\x00\x00\x00\x14SELECT * FROM things").and_return('FAKECOMPRESSEDBODY')
+            request.stub(:compressable?).and_return(true)
+            request.stub(:write).and_return(ByteBuffer.new('helloworld'))
+            compressor.stub(:compress?).and_return(true)
+            compressor.stub(:compress).with('helloworld').and_return('COMPRESSEDFRAME')
           end
 
-          it 'sets the compression flag' do
-            compressed_frame[1].should == "\x01"
+          it 'compresses the request' do
+            encoder = described_class.new(1, compressor)
+            buffer = encoder.encode_frame(request)
+            buffer.to_s[8, 100].should == 'COMPRESSEDFRAME'
           end
 
-          it 'sets the size to the compressed size' do
-            compressed_frame[4, 4].unpack('N').first.should == 18
+          it 'sets the compression flag' do
+            encoder = described_class.new(1, compressor)
+            buffer = encoder.encode_frame(request)
+            buffer.to_s[1, 1].should == "\x01"
           end
 
-          it 'compresses the frame body' do
-            compressed_frame[8, 18].should == 'FAKECOMPRESSEDBODY'
-            compressed_frame.bytesize.should == 26
+          it 'sets both the compression flag and the tracing flag' do
+            request.stub(:trace?).and_return(true)
+            encoder = described_class.new(1, compressor)
+            buffer = encoder.encode_frame(request)
+            buffer.to_s[1, 1].should == "\x03"
           end
 
-          it 'does not clobber the trace flag' do
-            request = PrepareRequest.new('SELECT * FROM things', true)
-            stream_id = 3
-            compressed_frame = encoder.encode_frame(request, stream_id)
-            compressed_frame.to_s[1].should == "\x03"
+          it 'encodes the compressed body size' do
+            encoder = described_class.new(1, compressor)
+            buffer = encoder.encode_frame(request)
+            buffer.to_s[4, 4].should == "\x00\x00\x00\x0f"
           end
 
-          it 'does not compress when the compressor responds to #compress? with false' do
-            compressor.stub(:compress?).and_return(false)
-            compressed_frame[1].should == "\x00"
-            compressed_frame.should include('SELECT * FROM things')
-            compressed_frame.bytesize.should == 32
+          it 'does not compress uncompressable frames' do
+            request.stub(:compressable?).and_return(false)
+            encoder = described_class.new(1, compressor)
+            buffer = encoder.encode_frame(request)
+            compressor.should_not have_received(:compress?)
+            compressor.should_not have_received(:compress)
           end
         end
       end
 
       describe '#change_stream_id' do
+        let :encoder do
+          described_class.new
+        end
+
         it 'changes the stream ID byte' do
           buffer = ByteBuffer.new("\x01\x00\x03\x02\x00\x00\x00\x00")
           encoder.change_stream_id(99, buffer)