cql-rb 1.1.3 → 1.2.0.pre0

data/spec/cql/compression/compression_common.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+shared_examples 'compressor' do |algorithm|
+  describe '#algorithm' do
+    it %(returns "#{algorithm}") do
+      described_class.new.algorithm.should == algorithm
+    end
+  end
+
+  describe '#compress?' do
+    it 'returns true for arguments larger than 64 bytes' do
+      described_class.new.compress?('x' * 65).should be_true
+    end
+
+    it 'returns false for arguments smaller than 64 bytes' do
+      described_class.new.compress?('x' * 64).should be_false
+    end
+
+    it 'is customizable via a constructor argument' do
+      described_class.new(89).compress?('x' * 90).should be_true
+      described_class.new(89).compress?('x' * 89).should be_false
+    end
+  end
+
+  describe '#compress/#decompress' do
+    let :compressor do
+      described_class.new
+    end
+
+    it 'compresses strings' do
+      input = 'hello' * 100
+      compressed = compressor.compress(input)
+      compressed.bytesize.should be < input.bytesize
+    end
+
+    it 'decompresses compressed strings' do
+      input = "\x19\x10helloN\x05\x00"
+      decompressed = compressor.decompress(input)
+      decompressed.should == 'hellohellohellohellohello'
+    end
+
+    it 'decompresses its own compressed output' do
+      input = 'Ķ' * 100
+      output = compressor.decompress(compressor.compress(input))
+      output.force_encoding(::Encoding::UTF_8)
+      output.should == input
+    end
+
+    it 'returns binary strings' do
+      compressed = compressor.compress('hello' * 100)
+      decompressed = compressor.decompress(compressed)
+      compressed.encoding.should == ::Encoding::BINARY
+      decompressed.encoding.should == ::Encoding::BINARY
+    end
+  end
+end

data/spec/cql/compression/snappy_compressor_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'cql/compression/compression_common'
+
+
+module Cql
+  module Compression
+    begin
+      require 'cql/compression/snappy_compressor'
+    
+      describe SnappyCompressor do
+        include_examples 'compressor', 'snappy'
+      end
+    rescue LoadError => e
+      describe 'SnappyCompressor' do
+        it 'supports Snappy' do
+          pending e.message
+        end
+      end
+    end
+  end
+end

data/spec/cql/io/io_reactor_spec.rb

@@ -141,7 +141,7 @@ module Cql
         end
 
         before do
-          protocol_handler_factory.stub(:new) do |connection, _|
+          protocol_handler_factory.stub(:call) do |connection, _|
             connection.to_io.stub(:connect_nonblock)
             protocol_handler.stub(:connection).and_return(connection)
             protocol_handler
@@ -165,7 +165,14 @@ module Cql
           reactor.stop if reactor.running?
         end
 
+        it 'calls #call on the protocol handler factory with the connection and the reactor itself' do
+          reactor.start.value
+          reactor.connect('example.com', 9999, 5).value
+          protocol_handler_factory.should have_received(:call).with(an_instance_of(Connection), reactor)
+        end
+
         it 'calls #new on the protocol handler factory with the connection and the reactor itself' do
+          protocol_handler_factory.stub(:new)
           reactor.start.value
           reactor.connect('example.com', 9999, 5).value
           protocol_handler_factory.should have_received(:new).with(an_instance_of(Connection), reactor)

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -112,6 +112,46 @@ module Cql
           futures[128].should be_resolved
         end
 
+        context 'when a compressor is specified' do
+          let :protocol_handler do
+            described_class.new(connection, scheduler, compressor)
+          end
+
+          let :compressor do
+            double(:compressor)
+          end
+
+          let :request do
+            Protocol::PrepareRequest.new('SELECT * FROM things')
+          end
+
+          before do
+            compressor.stub(:compress?).and_return(true)
+            compressor.stub(:compress).and_return('FAKECOMPRESSEDBODY')
+          end
+
+          it 'compresses request frames' do
+            protocol_handler.send_request(request)
+            buffer.to_s.should == [1, 1, 0, 9, 18].pack('C4N') + 'FAKECOMPRESSEDBODY'
+          end
+
+          it 'compresses queued request frames' do
+            130.times { protocol_handler.send_request(request) }
+            compressor.should have_received(:compress).exactly(130).times
+          end
+
+          it 'decompresses response frames' do
+            id = "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/".force_encoding(::Encoding::BINARY)
+            compressor.stub(:decompress).with('FAKECOMPRESSEDBODY').and_return("\x00\x00\x00\x04" + "\x00\x10" + id + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\ncql_rb_911\x00\x05users\x00\tuser_name\x00\r")
+            f1 = protocol_handler.send_request(request)
+            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)
+          end
+        end
+
         context 'when the protocol handler closes' do
           it 'fails all requests waiting for a reply' do
             futures = Array.new(5) { protocol_handler.send_request(request) }

data/spec/cql/protocol/frame_decoder_spec.rb

@@ -0,0 +1,132 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe FrameDecoder do
+      let :decoder do
+        described_class.new
+      end
+
+      describe '#decode_frame' do
+        context 'with an uncompressed frame' do
+          it 'returns a partial frame when not all the frame\'s bytes are in the buffer' do
+            frame = decoder.decode_frame(ByteBuffer.new)
+            frame.should_not be_complete
+            frame = decoder.decode_frame(ByteBuffer.new("\x81\x00\x00\x02\x00\x00\x00\x16"))
+            frame.should_not be_complete
+            frame = decoder.decode_frame(ByteBuffer.new("\x81\x00\x00\x02\x00\x00\x00\x16\x01\x23\x45"))
+            frame.should_not be_complete
+          end
+
+          it 'returns a complete frame when all bytes are in the buffer' do
+            buffer = ByteBuffer.new
+            buffer << "\x81\x00\x00\x06\x00\x00\x00\x27"
+            buffer << "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00"
+            frame = decoder.decode_frame(buffer)
+            frame.should be_complete
+            frame.body.should be_a(Response)
+          end
+
+          it 'returns the stream ID' do
+            buffer = ByteBuffer.new("\x81\x00\x03\x02\x00\x00\x00\x00")
+            frame = decoder.decode_frame(buffer)
+            frame.stream_id.should == 3
+          end
+
+          it 'returns the stream ID when it is negative' do
+            buffer = ByteBuffer.new("\x81\x00\xff\x02\x00\x00\x00\x00")
+            frame = decoder.decode_frame(buffer)
+            frame.stream_id.should == -1
+          end
+
+          it 'first returns a partial frame, then a complete frame' do
+            buffer = ByteBuffer.new
+            buffer << "\x81\x00\x00\x06\x00\x00\x00\x27"
+            frame = decoder.decode_frame(buffer)
+            buffer << "\x00\x02\x00\x0bCQL_VERSION"
+            frame = decoder.decode_frame(buffer, frame)
+            buffer << "\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00"
+            frame = decoder.decode_frame(buffer, frame)
+            frame.should be_complete
+          end
+
+          it 'leaves extra bytes in the buffer' do
+            buffer = ByteBuffer.new
+            buffer << "\x81\x00\x00\x06\x00\x00\x00\x27"
+            buffer << "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00\xca\xfe"
+            frame = decoder.decode_frame(buffer)
+            frame.should be_complete
+            buffer.to_s.should == "\xca\xfe"
+          end
+
+          it 'consumes the number of bytes specified in the frame header' do
+            buffer = ByteBuffer.new
+            buffer << "\x81\x00\x00\x06\x00\x00\x00\x29"
+            buffer << "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00\xca\xfe"
+            frame = decoder.decode_frame(buffer)
+            frame.should be_complete
+            buffer.to_s.should be_empty
+          end
+
+          it 'extracts a trace ID' do
+            buffer = ByteBuffer.new
+            buffer << "\x81\x02\x00\x08\x00\x00\x00\x14\a\xE4\xBE\x10?\x03\x11\xE3\x951\xFBr\xEF\xF0_\xBB\x00\x00\x00\x01"
+            frame = decoder.decode_frame(buffer)
+            frame.body.trace_id.should == Uuid.new('07e4be10-3f03-11e3-9531-fb72eff05fbb')
+          end
+
+          it 'complains when the frame is a request frame' do
+            expect { decoder.decode_frame(ByteBuffer.new("\x01\x00\x00\x05\x00\x00\x00\x00")) }.to raise_error(UnsupportedFrameTypeError)
+          end
+
+          it 'complains when the opcode is unknown' do
+            expect { decoder.decode_frame(ByteBuffer.new("\x81\x00\x00\xff\x00\x00\x00\x00")) }.to raise_error(UnsupportedOperationError)
+          end
+        end
+
+        context 'with a compressed frame' do
+          let :decoder do
+            described_class.new(compressor)
+          end
+
+          let :compressor do
+            double(:compressor)
+          end
+
+          let :buffer do
+            ByteBuffer.new("\x81\x01\x00\x06\x00\x00\x00\x12FAKECOMPRESSEDBODY")
+          end
+
+          before do
+            compressor.stub(:decompress).with('FAKECOMPRESSEDBODY').and_return("\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00")
+          end
+
+          it 'decompresses the body bytes' do
+            frame = decoder.decode_frame(buffer)
+            frame.body.should be_a(Response)
+          end
+
+          it 'leaves extra bytes in the buffer' do
+            buffer << 'EXTRABYTES'
+            frame = decoder.decode_frame(buffer)
+            buffer.to_s.should == 'EXTRABYTES'
+          end
+
+          it 'extracts a trace ID' do
+            buffer.update(1, "\x03\x00\x08")
+            compressor.stub(:decompress).with('FAKECOMPRESSEDBODY').and_return("\a\xE4\xBE\x10?\x03\x11\xE3\x951\xFBr\xEF\xF0_\xBB\x00\x00\x00\x01")
+            frame = decoder.decode_frame(buffer)
+            frame.body.trace_id.should == Uuid.new('07e4be10-3f03-11e3-9531-fb72eff05fbb')
+          end
+
+          it 'complains when there is no compressor' do
+            expect { described_class.new.decode_frame(buffer) }.to raise_error(UnexpectedCompressionError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cql/protocol/frame_encoder_spec.rb

@@ -0,0 +1,105 @@
+# encoding: ascii-8bit
+
+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"
+        end
+
+        it 'appends a rendered request frame to 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)
+          buffer.to_s.should == "hello\x01\x00\x03\x09\x00\x00\x00\x18\x00\x00\x00\x14SELECT * FROM things"
+        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)
+        end
+
+        context 'with a compressor' do
+          let :encoder do
+            described_class.new(compressor)
+          end
+
+          let :compressor do
+            double(:compressor)
+          end
+
+          let :request do
+            PrepareRequest.new('SELECT * FROM things')
+          end
+
+          let :compressed_frame do
+            encoder.encode_frame(request, 3).to_s
+          end
+
+          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')
+          end
+
+          it 'sets the compression flag' do
+            compressed_frame[1].should == "\x01"
+          end
+
+          it 'sets the size to the compressed size' do
+            compressed_frame[4, 4].unpack('N').first.should == 18
+          end
+
+          it 'compresses the frame body' do
+            compressed_frame[8, 18].should == 'FAKECOMPRESSEDBODY'
+            compressed_frame.bytesize.should == 26
+          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"
+          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
+          end
+        end
+      end
+
+      describe '#change_stream_id' do
+        it 'changes the stream ID byte' do
+          buffer = ByteBuffer.new("\x01\x00\x03\x02\x00\x00\x00\x00")
+          encoder.change_stream_id(99, buffer)
+          buffer.discard(2)
+          buffer.read_byte.should == 99
+        end
+
+        it 'changes the stream ID byte of the frame starting at the specified offset' do
+          buffer = ByteBuffer.new("hello foo\x01\x00\x03\x02\x00\x00\x00\x00")
+          encoder.change_stream_id(99, buffer, 9)
+          buffer.discard(11)
+          buffer.read_byte.should == 99
+        end
+      end
+    end
+  end
+end

data/spec/cql/protocol/requests/credentials_request_spec.rb

@@ -6,12 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe CredentialsRequest do
-      describe '#encode_frame' do
+      describe '#write' do
         it 'encodes a CREDENTIALS request frame' do
-          bytes = CredentialsRequest.new('username' => 'cassandra', 'password' => 'ardnassac').encode_frame(3)
+          bytes = CredentialsRequest.new('username' => 'cassandra', 'password' => 'ardnassac').write('')
           bytes.should == (
-            "\x01\x00\x03\04" +
-            "\x00\x00\x00\x2c" +
             "\x00\x02" +
             "\x00\x08username" +
             "\x00\x09cassandra" +

data/spec/cql/protocol/requests/execute_request_spec.rb

@@ -47,10 +47,10 @@ module Cql
         end
       end
 
-      describe '#encode_frame' do
+      describe '#write' do
         it 'encodes an EXECUTE request frame' do
-          bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum).encode_frame(3)
-          bytes.should == "\x01\x00\x03\x0a\x00\x00\x00\x2e\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/\x00\x03\x00\x00\x00\x05hello\x00\x00\x00\x04\x00\x00\x00\x2a\x00\x00\x00\x03foo\x00\x07"
+          bytes = ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum).write('')
+          bytes.should == "\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/\x00\x03\x00\x00\x00\x05hello\x00\x00\x00\x04\x00\x00\x00\x2a\x00\x00\x00\x03foo\x00\x07"
         end
 
         specs = [
@@ -84,8 +84,8 @@ module Cql
         specs.each do |type, value, expected_bytes|
           it "encodes #{type} values" do
             metadata = [['ks', 'tbl', 'id_column', type]]
-            buffer = ExecuteRequest.new(id, metadata, [value], :one).encode_frame(3)
-            buffer.discard(8 + 2 + 16 + 2)
+            buffer = ExecuteRequest.new(id, metadata, [value], :one).write(ByteBuffer.new)
+            buffer.discard(2 + 16 + 2)
             length = buffer.read_int
             result_bytes = buffer.read(length)
             result_bytes.should eql_bytes(expected_bytes)

data/spec/cql/protocol/requests/options_request_spec.rb

@@ -6,10 +6,16 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe OptionsRequest do
-      describe '#encode_frame' do
-        it 'encodes an OPTIONS request frame' do
-          bytes = OptionsRequest.new.encode_frame(3)
-          bytes.should == "\x01\x00\x03\x05\x00\x00\x00\x00"
+      describe '#compressable?' do
+        it 'is not compressable' do
+          described_class.new.should_not be_compressable
+        end
+      end
+
+      describe '#write' do
+        it 'encodes an OPTIONS request frame (i.e. an empty body)' do
+          bytes = OptionsRequest.new.write('')
+          bytes.should be_empty
         end
       end