cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/spec/cql/protocol/responses/schema_change_event_response_spec.rb

@@ -6,10 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe SchemaChangeEventResponse do
-      describe '.decode!' do
+      describe '.decode' do
         let :response do
-          buffer = ByteBuffer.new("\x00\aDROPPED\x00\ncql_rb_609\x00\x05users")
-          described_class.decode!(1, buffer, buffer.length)
+          buffer = CqlByteBuffer.new("\x00\aDROPPED\x00\ncql_rb_609\x00\x05users")
+          described_class.decode(1, buffer, buffer.length)
         end
 
         it 'decodes the change' do

data/spec/cql/protocol/responses/schema_change_result_response_spec.rb

@@ -6,10 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe SchemaChangeResultResponse do
-      describe '.decode!' do
+      describe '.decode' do
         let :response do
-          buffer = ByteBuffer.new("\x00\aUPDATED\x00\ncql_rb_973\x00\x05users")
-          described_class.decode!(1, buffer, buffer.length)
+          buffer = CqlByteBuffer.new("\x00\aUPDATED\x00\ncql_rb_973\x00\x05users")
+          described_class.decode(1, buffer, buffer.length)
         end
 
         it 'decodes the description' do

data/spec/cql/protocol/responses/set_keyspace_result_response_spec.rb

@@ -6,9 +6,9 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe SetKeyspaceResultResponse do
-      describe '.decode!' do
+      describe '.decode' do
         let :response do
-          described_class.decode!(1, ByteBuffer.new("\x00\x06system"), 8)
+          described_class.decode(1, CqlByteBuffer.new("\x00\x06system"), 8)
         end
 
         it 'decodes the keyspace' do

data/spec/cql/protocol/responses/status_change_event_response_spec.rb

@@ -6,10 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe StatusChangeEventResponse do
-      describe '.decode!' do
+      describe '.decode' do
         let :response do
-          buffer = ByteBuffer.new("\x00\x04DOWN\x04\x00\x00\x00\x00\x00\x00#R")
-          described_class.decode!(1, buffer, buffer.length)
+          buffer = CqlByteBuffer.new("\x00\x04DOWN\x04\x00\x00\x00\x00\x00\x00#R")
+          described_class.decode(1, buffer, buffer.length)
         end
 
         it 'decodes the change' do

data/spec/cql/protocol/responses/supported_response_spec.rb

@@ -6,10 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe SupportedResponse do
-      describe '.decode!' do
+      describe '.decode' do
         let :response do
-          buffer = ByteBuffer.new("\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00")
-          described_class.decode!(1, buffer, buffer.length)
+          buffer = CqlByteBuffer.new("\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x00")
+          described_class.decode(1, buffer, buffer.length)
         end
 
         it 'decodes the options' do

data/spec/cql/protocol/responses/topology_change_event_response_spec.rb

@@ -6,10 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe TopologyChangeEventResponse do
-      describe '.decode!' do
+      describe '.decode' do
         let :response do
-          buffer = ByteBuffer.new("\x00\fREMOVED_NODE\x04\x00\x00\x00\x00\x00\x00#R")
-          described_class.decode!(1, buffer, buffer.length)
+          buffer = CqlByteBuffer.new("\x00\fREMOVED_NODE\x04\x00\x00\x00\x00\x00\x00#R")
+          described_class.decode(1, buffer, buffer.length)
         end
 
         it 'decodes the change' do

data/spec/cql/protocol/responses/void_result_response_spec.rb

@@ -6,10 +6,10 @@ require 'spec_helper'
 module Cql
   module Protocol
     describe VoidResultResponse do
-      describe '.decode!' do
+      describe '.decode' do
         it 'returns a new instance' do
           unused_byte_buffer = nil
-          described_class.decode!(1, unused_byte_buffer, 0).should be_a(described_class)
+          described_class.decode(1, unused_byte_buffer, 0).should be_a(described_class)
         end
       end
 

data/spec/cql/protocol/type_converter_spec.rb

@@ -11,55 +11,67 @@ module Cql
       end
 
       let :buffer do
-        ''
+        CqlByteBuffer.new
       end
 
       describe '#to_bytes' do
-        types = [
-          :ascii,
+        numeric_types = [
           :bigint,
-          :blob,
-          :boolean,
           :counter,
           :decimal,
           :double,
           :float,
-          :inet,
           :int,
+          :varint,
+        ]
+
+        types = numeric_types + [
+          :ascii,
+          :blob,
+          :boolean,
+          :inet,
           :text,
           :varchar,
           :timestamp,
           :timeuuid,
           :uuid,
-          :varint
         ]
 
         context 'when encoding normal value' do
           types.each do |type|
             it "encodes a null #{type.upcase}" do
-              converter.to_bytes(buffer, type, nil, 4).should == "\xff\xff\xff\xff"
+              converter.to_bytes(buffer, type, nil, 4).should eql_bytes("\xff\xff\xff\xff")
             end
           end
 
           it 'encodes a null LIST' do
-            converter.to_bytes(buffer, [:list, :int], nil, 4).should == "\xff\xff\xff\xff"
+            converter.to_bytes(buffer, [:list, :int], nil, 4).should eql_bytes("\xff\xff\xff\xff")
           end
 
           it 'encodes a null MAP' do
-            converter.to_bytes(buffer, [:map, :text, :text], nil, 4).should == "\xff\xff\xff\xff"
+            converter.to_bytes(buffer, [:map, :text, :text], nil, 4).should eql_bytes("\xff\xff\xff\xff")
 
           end
 
           it 'encodes a null SET' do
-            converter.to_bytes(buffer, [:set, :uuid], nil, 4).should == "\xff\xff\xff\xff"
-
+            converter.to_bytes(buffer, [:set, :uuid], nil, 4).should eql_bytes("\xff\xff\xff\xff")
           end
         end
 
         context 'when encoding collection values' do
           types.each do |type|
             it "encodes a null #{type.upcase}" do
-              converter.to_bytes(buffer, type, nil, 2).should == "\xff\xff"
+              converter.to_bytes(buffer, type, nil, 2).should eql_bytes("\xff\xff")
+            end
+          end
+        end
+
+        context 'when encoding and decoding negative numbers' do
+          numeric_types.each do |type|
+            it "encodes and decodes a -1 #{type.upcase}" do
+              value = type == :decimal ? BigDecimal.new('-1') : -1
+              encoded = converter.to_bytes(buffer, type, value, 4)
+              converter.from_bytes(encoded, type, 4).should == value
             end
           end
         end

data/spec/cql/time_uuid_spec.rb

@@ -5,10 +5,6 @@ require 'spec_helper'
 
 module Cql
   describe TimeUuid do
-    let :time do
-      Time.utc(2013, 6, 7, 8, 9, 10)
-    end
-
     describe '#to_time' do
       it 'returns a Time' do
         x = TimeUuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66')
@@ -16,6 +12,23 @@ module Cql
         x.to_time.should be < Time.utc(2013, 6, 9, 8, 45, 58)
       end
     end
+
+    describe '#<=>' do
+      let :uuids do
+        [
+          TimeUuid.new(175821750227570343682790694234162314858),
+          TimeUuid.new(179047849699804924671695969702288932458),
+          TimeUuid.new(179548637446269962124687370109891231338),
+          TimeUuid.new(180030188594876536196511058046351949418),
+          TimeUuid.new(180518394909134308472692603674640891498),
+          TimeUuid.new(183319310901264713895398493985212841578),
+        ]
+      end
+
+      it 'sorts by the time component' do
+        uuids.shuffle.sort.should == uuids
+      end
+    end
   end
 
   describe TimeUuid::Generator do

data/spec/cql/uuid_spec.rb

@@ -60,7 +60,7 @@ module Cql
 
     describe '#hash' do
       it 'calculates a 64 bit hash of the UUID' do
-        h = Uuid.new(276263553384940695775376958868900023510).hash
+        h = Uuid.new(162917432198567078063626261009205865234).hash
         h.should be < 2**63
         h.should be > -2**63
       end
@@ -82,6 +82,10 @@ module Cql
       it 'returns the numeric value' do
         Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6').value.should == 276263553384940695775376958868900023510
       end
+
+      it 'is aliased as #to_i' do
+        Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6').to_i.should == 276263553384940695775376958868900023510
+      end
     end
   end
 end

data/spec/integration/protocol_spec.rb

@@ -8,21 +8,41 @@ describe 'Protocol parsing and communication' do
     2
   end
 
-  let! :io_reactor do
-    ir = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version) })
-    ir.start
-    connections << ir.connect(ENV['CASSANDRA_HOST'], 9042, 5).value
-    ir
+  let :io_reactor do
+    Cql::Io::IoReactor.new.start.value
   end
 
-  let :connections do
-    []
+  let :connection do
+    io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 5, &protocol_handler_factory).value
+  end
+
+  let :protocol_handler_factory do
+    lambda { |connection| Cql::Protocol::CqlProtocolHandler.new(connection, io_reactor, protocol_version) }
   end
 
   let :keyspace_name do
     "cql_rb_#{rand(1000)}"
   end
 
+  before :all do
+    ir = Cql::Io::IoReactor.new
+    protocol_handler_factory = lambda { |connection| Cql::Protocol::CqlProtocolHandler.new(connection, ir, 2) }
+    f = ir.start
+    f = f.flat_map do |reactor|
+      reactor.connect(ENV['CASSANDRA_HOST'], 9042, 5, &protocol_handler_factory)
+    end
+    f = f.flat_map do |connection|
+      connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0'))
+    end
+    f = f.map do |response|
+      response.is_a?(Cql::Protocol::AuthenticateResponse)
+    end
+    f = f.flat_map do |authentication_required|
+      ir.stop.map(authentication_required)
+    end
+    @authentication_enabled = f.value
+  end
+
   after do
     if io_reactor.running?
       drop_keyspace! rescue nil
@@ -30,22 +50,7 @@ describe 'Protocol parsing and communication' do
     end
   end
 
-  def authentication_enabled?
-    ir = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version) })
-    ir.start
-    connected = ir.connect(ENV['CASSANDRA_HOST'], 9042, 5)
-    started = connected.flat_map do |connection|
-      connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0'))
-    end
-    response = started.value
-    required = response.is_a?(Cql::Protocol::AuthenticateResponse)
-    ir.stop.value
-    required
-  end
-
-
   def raw_execute_request(request)
-    connection = connections.first
     connection.send_request(request).value
   end
 
@@ -133,7 +138,7 @@ describe 'Protocol parsing and communication' do
 
     context 'when authentication is not required' do
       it 'sends STARTUP and receives READY' do
-        pending('authentication required', if: authentication_enabled?) do
+        pending('authentication required', if: @authentication_enabled) do
           response = execute_request(Cql::Protocol::StartupRequest.new('3.1.0'), false)
           response.should be_a(Cql::Protocol::ReadyResponse)
         end
@@ -147,14 +152,14 @@ describe 'Protocol parsing and communication' do
         end
 
         it 'sends STARTUP and receives AUTHENTICATE' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             response = raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response.should be_a(Cql::Protocol::AuthenticateResponse)
           end
         end
 
         it 'ignores the AUTHENTICATE response and receives ERROR' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response = raw_execute_request(Cql::Protocol::RegisterRequest.new('TOPOLOGY_CHANGE'))
             response.code.should == 10
@@ -168,7 +173,7 @@ describe 'Protocol parsing and communication' do
         end
 
         it 'sends bad username and password in CREDENTIALS and receives ERROR' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response = raw_execute_request(Cql::Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar'))
             response.code.should == 0x100
@@ -178,14 +183,14 @@ describe 'Protocol parsing and communication' do
 
       context 'and the protocol version is 2' do
         it 'sends STARTUP and receives AUTHENTICATE' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             response = raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response.should be_a(Cql::Protocol::AuthenticateResponse)
           end
         end
 
         it 'ignores the AUTHENTICATE response and receives ERROR' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response = raw_execute_request(Cql::Protocol::RegisterRequest.new('TOPOLOGY_CHANGE'))
             response.code.should == 10
@@ -193,7 +198,7 @@ describe 'Protocol parsing and communication' do
         end
 
         it 'sends STARTUP followed by AUTH_RESPONSE and receives AUTH_SUCCESS' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response = raw_execute_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00cassandra"))
             response.should be_a(Cql::Protocol::AuthSuccessResponse)
@@ -201,7 +206,7 @@ describe 'Protocol parsing and communication' do
         end
 
         it 'sends bad username and password in AUTH_RESPONSE and receives ERROR' do
-          pending('authentication not configured', unless: authentication_enabled?) do
+          pending('authentication not configured', unless: @authentication_enabled) do
             raw_execute_request(Cql::Protocol::StartupRequest.new('3.1.0'))
             response = raw_execute_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00ardnassac"))
             response.code.should == 0x100
@@ -227,7 +232,7 @@ describe 'Protocol parsing and communication' do
         semaphore = Queue.new
         event = nil
         execute_request(Cql::Protocol::RegisterRequest.new('SCHEMA_CHANGE'))
-        connections.first.on_event do |event_response|
+        connection.on_event do |event_response|
           event = event_response
           semaphore << :ping
         end
@@ -524,13 +529,17 @@ describe 'Protocol parsing and communication' do
           Cql::Compression::SnappyCompressor.new(0)
         end
 
+        let :protocol_handler_factory do
+          lambda { |connection| Cql::Protocol::CqlProtocolHandler.new(connection, io_reactor, protocol_version, compressor) }
+        end
+
         it 'sends a compressed request and receives a compressed response' do
           compressor.stub(:compress).and_call_original
           compressor.stub(:decompress).and_call_original
-          io_reactor = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version, compressor) })
+          io_reactor = Cql::Io::IoReactor.new
           io_reactor.start.value
           begin
-            connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).value
+            connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1, &protocol_handler_factory).value
             connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0', 'snappy')).value
             connection.send_request(Cql::Protocol::PrepareRequest.new('SELECT * FROM system.peers')).value
             compressor.should have_received(:compress).at_least(1).times
@@ -542,10 +551,6 @@ describe 'Protocol parsing and communication' do
       end
 
       context 'with pipelining' do
-        let :connection do
-          connections.first
-        end
-
         it 'handles multiple concurrent requests' do
           in_keyspace_with_table do
             futures = 10.times.map do
@@ -577,17 +582,18 @@ describe 'Protocol parsing and communication' do
 
   context 'in special circumstances' do
     it 'raises an exception when it cannot connect to Cassandra' do
-      io_reactor = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, protocol_version) })
+      io_reactor = Cql::Io::IoReactor.new
       io_reactor.start.value
-      expect { io_reactor.connect('example.com', 9042, 0.1).value }.to raise_error(Cql::Io::ConnectionError)
-      expect { io_reactor.connect('blackhole', 9042, 0.1).value }.to raise_error(Cql::Io::ConnectionError)
+      expect { io_reactor.connect('example.com', 9042, 0.1, &protocol_handler_factory).value }.to raise_error(Cql::Io::ConnectionError)
+      expect { io_reactor.connect('blackhole', 9042, 0.1, &protocol_handler_factory).value }.to raise_error(Cql::Io::ConnectionError)
       io_reactor.stop.value
     end
 
     it 'does nothing the second time #start is called' do
-      io_reactor = Cql::Io::IoReactor.new(lambda { |*args| Cql::Protocol::CqlProtocolHandler.new(*args, 2) })
+      protocol_handler_factory = lambda { |connection| Cql::Protocol::CqlProtocolHandler.new(connection, io_reactor, 2) }
+      io_reactor = Cql::Io::IoReactor.new
       io_reactor.start.value
-      connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1).value
+      connection = io_reactor.connect(ENV['CASSANDRA_HOST'], 9042, 0.1, &protocol_handler_factory).value
       response = connection.send_request(Cql::Protocol::StartupRequest.new('3.1.0')).value
       if response.is_a?(Cql::Protocol::AuthenticateResponse)
         response = connection.send_request(Cql::Protocol::AuthResponseRequest.new("\x00cassandra\x00cassandra")).value

data/spec/spec_helper.rb

@@ -6,7 +6,6 @@ require 'bundler/setup'
 
 require 'support/bytes_helper'
 require 'support/await_helper'
-require 'support/fake_server'
 require 'support/fake_io_reactor'
 
 unless ENV['COVERAGE'] == 'no' || RUBY_ENGINE == 'rbx'