cql-rb 1.0.0.pre0

data/lib/cql/uuid.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module Cql
+  class Uuid
+    def initialize(n)
+      case n
+      when String
+        @n = from_s(n)
+      else
+        @n = n
+      end
+    end
+
+    def to_s
+      @s ||= begin
+        parts = []
+        parts << (@n >> (24 * 4)).to_s(16).rjust(8, '0')
+        parts << ((@n >> (20 * 4)) & 0xffff).to_s(16).rjust(4, '0')
+        parts << ((@n >> (16 * 4)) & 0xffff).to_s(16).rjust(4, '0')
+        parts << ((@n >> (12 * 4)) & 0xffff).to_s(16).rjust(4, '0')
+        parts << (@n & 0xffffffffffff).to_s(16).rjust(12, '0')
+        parts.join('-').force_encoding(::Encoding::ASCII)
+      end
+    end
+
+    def value
+      @n
+    end
+
+    def eql?(other)
+      self.value == other.value
+    end
+    alias_method :==, :eql?
+
+    private
+
+    def from_s(str)
+      str = str.gsub('-', '')
+      n = 0
+      (str.length/2).times do |i|
+        n = (n << 8) | str[i * 2, 2].to_i(16)
+      end
+      n
+    end
+  end
+end

data/lib/cql/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Cql
+  VERSION = '1.0.0.pre0'.freeze
+end

data/spec/cql/client_spec.rb

@@ -0,0 +1,368 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  describe Client do
+    let :connection_options do
+      {:host => 'example.com', :port => 12321, :io_reactor => io_reactor}
+    end
+
+    let :io_reactor do
+      FakeIoReactor.new
+    end
+
+    let :client do
+      described_class.new(connection_options)
+    end
+
+    def connections
+      io_reactor.connections
+    end
+
+    def connection
+      connections.first
+    end
+
+    def requests
+      connection[:requests]
+    end
+
+    def last_request
+      requests.last
+    end
+
+    describe '#start!' do
+      it 'connects' do
+        client.start!
+        connections.should have(1).item
+      end
+
+      it 'connects only once' do
+        client.start!
+        client.start!
+        connections.should have(1).item
+      end
+
+      it 'connects to all hosts' do
+        client.shutdown!
+        io_reactor.stop.get
+        io_reactor.start.get
+
+        c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+        c.start!
+        connections.should have(3).items
+      end
+
+      it 'returns itself' do
+        client.start!.should equal(client)
+      end
+
+      it 'forwards the host and port' do
+        client.start!
+        connection[:host].should == 'example.com'
+        connection[:port].should == 12321
+      end
+
+      it 'sends a startup request' do
+        client.start!
+        last_request.should be_a(Protocol::StartupRequest)
+      end
+
+      it 'sends a startup request to each connection' do
+        client.shutdown!
+        io_reactor.stop.get
+        io_reactor.start.get
+
+        c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+        c.start!
+        connections.each do |cc|
+          cc[:requests].last.should be_a(Protocol::StartupRequest)
+        end
+      end
+
+      it 'is not in a keyspace' do
+        client.start!
+        client.keyspace.should be_nil
+      end
+
+      it 'changes to the keyspace given as an option' do
+        c = described_class.new(connection_options.merge(:keyspace => 'hello_world'))
+        c.start!
+        last_request.should == Protocol::QueryRequest.new('USE hello_world', :one)
+      end
+
+      it 'validates the keyspace name before sending the USE command' do
+        c = described_class.new(connection_options.merge(:keyspace => 'system; DROP KEYSPACE system'))
+        expect { c.start! }.to raise_error(InvalidKeyspaceNameError)
+        requests.should_not include(Protocol::QueryRequest.new('USE system; DROP KEYSPACE system', :one))
+      end
+    end
+
+    describe '#shutdown!' do
+      it 'closes the connection' do
+        client.start!
+        client.shutdown!
+        io_reactor.should_not be_running
+      end
+
+      it 'accepts multiple calls to #shutdown!' do
+        client.start!
+        client.shutdown!
+        client.shutdown!
+      end
+
+      it 'returns itself' do
+        client.start!.shutdown!.should equal(client)
+      end
+    end
+
+    describe '#use' do
+      before do
+        client.start!
+      end
+
+      it 'executes a USE query' do
+        io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+        client.use('system')
+        last_request.should == Protocol::QueryRequest.new('USE system', :one)
+      end
+
+      it 'executes a USE query for each connection' do
+        client.shutdown!
+        io_reactor.stop.get
+        io_reactor.start.get
+
+        c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+        c.start!
+
+        c.use('system')
+        last_requests = connections.select { |c| c[:host] =~ /^h\d\.example\.com$/ }.sort_by { |c| c[:host] }.map { |c| c[:requests].last }
+        last_requests.should == [
+          Protocol::QueryRequest.new('USE system', :one),
+          Protocol::QueryRequest.new('USE system', :one),
+          Protocol::QueryRequest.new('USE system', :one)
+        ]
+      end
+
+      it 'knows which keyspace it changed to' do
+        io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+        client.use('system')
+        client.keyspace.should == 'system'
+      end
+
+      it 'raises an error if the keyspace name is not valid' do
+        expect { client.use('system; DROP KEYSPACE system') }.to raise_error(InvalidKeyspaceNameError)
+      end
+    end
+
+    describe '#execute' do
+      before do
+        client.start!
+      end
+
+      it 'asks the connection to execute the query' do
+        client.execute('UPDATE stuff SET thing = 1 WHERE id = 3')
+        last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :quorum)
+      end
+
+      it 'uses the specified consistency' do
+        client.execute('UPDATE stuff SET thing = 1 WHERE id = 3', :three)
+        last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :three)
+      end
+
+      context 'with a void CQL query' do
+        it 'returns nil' do
+          io_reactor.queue_response(Protocol::VoidResultResponse.new)
+          result = client.execute('UPDATE stuff SET thing = 1 WHERE id = 3')
+          result.should be_nil
+        end
+      end
+
+      context 'with a USE query' do
+        it 'returns nil' do
+          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          result = client.execute('USE system')
+          result.should be_nil
+        end
+
+        it 'knows which keyspace it changed to' do
+          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          client.execute('USE system')
+          client.keyspace.should == 'system'
+        end
+
+        it 'detects that one connection changed to a keyspace and changes the others too' do
+          client.shutdown!
+          io_reactor.stop.get
+          io_reactor.start.get
+
+          c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+          c.start!
+
+          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h1.example.com' }[:host])
+          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h2.example.com' }[:host])
+          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h3.example.com' }[:host])
+
+          c.execute('USE system', :one)
+          c.keyspace.should == 'system'
+
+          last_requests = connections.select { |c| c[:host] =~ /^h\d\.example\.com$/ }.sort_by { |c| c[:host] }.map { |c| c[:requests].last }
+          last_requests.should == [
+            Protocol::QueryRequest.new('USE system', :one),
+            Protocol::QueryRequest.new('USE system', :one),
+            Protocol::QueryRequest.new('USE system', :one)
+          ]
+        end
+      end
+
+      context 'with an SELECT query' do
+        let :rows do
+          [['xyz', 'abc'], ['abc', 'xyz'], ['123', 'xyz']]
+        end
+
+        let :metadata do
+          [['thingies', 'things', 'thing', :text], ['thingies', 'things', 'item', :text]]
+        end
+
+        let :result do
+          io_reactor.queue_response(Protocol::RowsResultResponse.new(rows, metadata))
+          client.execute('SELECT * FROM things')
+        end
+
+        it 'returns an Enumerable of rows' do
+          row_count = 0
+          result.each do |row|
+            row_count += 1
+          end
+          row_count.should == 3
+        end
+
+        context 'with metadata that' do
+          it 'has keyspace, table and type information' do
+            result.metadata['item'].keyspace.should == 'thingies'
+            result.metadata['item'].table.should == 'things'
+            result.metadata['item'].column_name.should == 'item'
+            result.metadata['item'].type.should == :text
+          end
+
+          it 'is an Enumerable' do
+            result.metadata.map(&:type).should == [:text, :text]
+          end
+
+          it 'is splattable' do
+            ks, table, col, type = result.metadata['thing']
+            ks.should == 'thingies'
+            table.should == 'things'
+            col.should == 'thing'
+            type.should == :text
+          end
+        end
+      end
+
+      context 'when the response is an error' do
+        it 'raises an error' do
+          io_reactor.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
+          expect { client.execute('SELECT * FROM things') }.to raise_error(QueryError, 'Blurgh')
+        end
+      end
+    end
+
+    describe '#prepare' do
+      before do
+        client.start!
+      end
+
+      it 'sends a prepare request' do
+        client.prepare('SELECT * FROM system.peers')
+        last_request.should == Protocol::PrepareRequest.new('SELECT * FROM system.peers')
+      end
+
+      it 'returns a prepared statement' do
+        io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, [['stuff', 'things', 'item', :varchar]]))
+        statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?')
+        statement.should_not be_nil
+      end
+
+      it 'executes a prepared statement' do
+        id = 'A' * 32
+        metadata = [['stuff', 'things', 'item', :varchar]]
+        io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
+        statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?')
+        statement.execute('foo')
+        last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :quorum)
+      end
+
+      it 'executes a prepared statement using the right connection' do
+        client.shutdown!
+        io_reactor.stop.get
+        io_reactor.start.get
+
+        metadata = [['stuff', 'things', 'item', :varchar]]
+        
+        c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+        c.start!
+
+        io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, metadata))
+        io_reactor.queue_response(Protocol::PreparedResultResponse.new('B' * 32, metadata))
+        io_reactor.queue_response(Protocol::PreparedResultResponse.new('C' * 32, metadata))
+
+        statement1 = c.prepare('SELECT * FROM stuff.things WHERE item = ?')
+        statement1_connection = io_reactor.last_used_connection
+        statement2 = c.prepare('SELECT * FROM stuff.things WHERE item = ?')
+        statement2_connection = io_reactor.last_used_connection
+        statement3 = c.prepare('SELECT * FROM stuff.things WHERE item = ?')
+        statement3_connection = io_reactor.last_used_connection
+
+        io_reactor.queue_response(Protocol::RowsResultResponse.new([{'thing' => 'foo1'}], metadata), statement1_connection[:host])
+        io_reactor.queue_response(Protocol::RowsResultResponse.new([{'thing' => 'foo2'}], metadata), statement2_connection[:host])
+        io_reactor.queue_response(Protocol::RowsResultResponse.new([{'thing' => 'foo3'}], metadata), statement3_connection[:host])
+
+        statement1.execute('foo').first.should == {'thing' => 'foo1'}
+        statement2.execute('foo').first.should == {'thing' => 'foo2'}
+        statement3.execute('foo').first.should == {'thing' => 'foo3'}
+      end
+    end
+
+    context 'when not connected' do
+      it 'complains when #use is called before #start!' do
+        expect { client.use('system') }.to raise_error(NotConnectedError)
+      end
+
+      it 'complains when #use is called after #shutdown!' do
+        client.start!
+        client.shutdown!
+        expect { client.use('system') }.to raise_error(NotConnectedError)
+      end
+
+      it 'complains when #execute is called before #start!' do
+        expect { client.execute('DELETE FROM stuff WHERE id = 3') }.to raise_error(NotConnectedError)
+      end
+
+      it 'complains when #execute is called after #shutdown!' do
+        client.start!
+        client.shutdown!
+        expect { client.execute('DELETE FROM stuff WHERE id = 3') }.to raise_error(NotConnectedError)
+      end
+
+      it 'complains when #prepare is called before #start!' do
+        expect { client.prepare('DELETE FROM stuff WHERE id = 3') }.to raise_error(NotConnectedError)
+      end
+
+      it 'complains when #prepare is called after #shutdown!' do
+        client.start!
+        client.shutdown!
+        expect { client.prepare('DELETE FROM stuff WHERE id = 3') }.to raise_error(NotConnectedError)
+      end
+
+      it 'complains when #execute of a prepared statement is called after #shutdown!' do
+        client.start!
+        io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, []))
+        statement = client.prepare('DELETE FROM stuff WHERE id = 3')
+        client.shutdown!
+        expect { statement.execute }.to raise_error(NotConnectedError)
+      end
+    end
+  end
+end

data/spec/cql/future_spec.rb

@@ -0,0 +1,297 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  describe Future do
+    let :future do
+      described_class.new
+    end
+
+    context 'when completed' do
+      it 'is complete' do
+        future.complete!('foo')
+        future.should be_complete
+      end
+
+      it 'has a value' do
+        future.complete!('foo')
+        future.value.should == 'foo'
+      end
+
+      it 'is complete even when the value is falsy' do
+        future.complete!(nil)
+        future.should be_complete
+      end
+
+      it 'returns the value from #get, too' do
+        future.complete!('foo')
+        future.get.should == 'foo'
+      end
+
+      it 'has the value nil by default' do
+        future.complete!
+        future.value.should be_nil
+      end
+
+      it 'notifies all completion listeners' do
+        v1, v2 = nil, nil
+        future.on_complete { |v| v1 = v }
+        future.on_complete { |v| v2 = v }
+        future.complete!('bar')
+        v1.should == 'bar'
+        v2.should == 'bar'
+      end
+
+      it 'notifies new listeners even when already completed' do
+        v1, v2 = nil, nil
+        future.complete!('bar')
+        future.on_complete { |v| v1 = v }
+        future.on_complete { |v| v2 = v }
+        v1.should == 'bar'
+        v2.should == 'bar'
+      end
+
+      it 'blocks on #value until completed' do
+        Thread.start(future) do |f|
+          sleep 0.1
+          future.complete!('bar')
+        end
+        future.value.should == 'bar'
+      end
+
+      it 'blocks on #value until completed, when value is nil' do
+        Thread.start(future) do |f|
+          sleep 0.1
+          future.complete!
+        end
+        future.value.should be_nil
+        future.value.should be_nil
+      end
+
+      it 'blocks on #value until failed' do
+        Thread.start(future) do |f|
+          sleep 0.1
+          future.fail!(StandardError.new('FAIL!'))
+        end
+        expect { future.value }.to raise_error('FAIL!')
+      end
+
+      it 'cannot be completed again' do
+        future.complete!('bar')
+        expect { future.complete!('foo') }.to raise_error(FutureError)
+      end
+
+      it 'cannot be failed again' do
+        future.complete!('bar')
+        expect { future.fail!(StandardError.new('FAIL!')) }.to raise_error(FutureError)
+      end
+    end
+
+    context 'when failed' do
+      it 'is failed' do
+        future.fail!(StandardError.new('FAIL!'))
+        future.should be_failed
+      end
+
+      it 'raises the error from #value' do
+        future.fail!(StandardError.new('FAIL!'))
+        expect { future.value }.to raise_error('FAIL!')
+      end
+
+      it 'notifies all failure listeners' do
+        e1, e2 = nil, nil
+        future.on_failure { |e| e1 = e }
+        future.on_failure { |e| e2 = e }
+        future.fail!(StandardError.new('FAIL!'))
+        e1.message.should == 'FAIL!'
+        e2.message.should == 'FAIL!'
+      end
+
+      it 'notifies new listeners even when already failed' do
+        e1, e2 = nil, nil
+        future.fail!(StandardError.new('FAIL!'))
+        future.on_failure { |e| e1 = e }
+        future.on_failure { |e| e2 = e }
+        e1.message.should == 'FAIL!'
+        e2.message.should == 'FAIL!'
+      end
+
+      it 'cannot be failed again' do
+        future.fail!(StandardError.new('FAIL!'))
+        expect { future.fail!(StandardError.new('FAIL!')) }.to raise_error(FutureError)
+      end
+
+      it 'cannot be completed' do
+        future.fail!(StandardError.new('FAIL!'))
+        expect { future.complete!('hurgh') }.to raise_error(FutureError)
+      end
+    end
+
+    describe '.combine' do
+      context 'returns a new future which' do
+        it 'is complete when the source futures are complete' do
+          f1 = Future.new
+          f2 = Future.new
+          f3 = Future.combine(f1, f2)
+          f1.complete!
+          f3.should_not be_complete
+          f2.complete!
+          f3.should be_complete
+        end
+
+        it 'completes when the source futures have completed' do
+          sequence = []
+          f1 = Future.new
+          f2 = Future.new
+          f3 = Future.new
+          f4 = Future.combine(f1, f2, f3)
+          f1.on_complete { sequence << 1 } 
+          f2.on_complete { sequence << 2 } 
+          f3.on_complete { sequence << 3 }
+          f2.complete!
+          f1.complete!
+          f3.complete!
+          sequence.should == [2, 1, 3]
+        end
+
+        it 'returns an array of the values of the source futures, in order' do
+          f1 = Future.new
+          f2 = Future.new
+          f3 = Future.new
+          f4 = Future.combine(f1, f2, f3)
+          f2.complete!(2)
+          f1.complete!(1)
+          f3.complete!(3)
+          f4.get.should == [1, 2, 3]
+        end
+
+        it 'fails if any of the source futures fail' do
+          f1 = Future.new
+          f2 = Future.new
+          f3 = Future.new
+          f4 = Future.new
+          f5 = Future.combine(f1, f2, f3, f4)
+          f2.complete!
+          f1.fail!(StandardError.new('hurgh'))
+          f3.fail!(StandardError.new('murgasd'))
+          f4.complete!
+          expect { f5.get }.to raise_error('hurgh')
+          f5.should be_failed
+        end
+
+        it 'raises an error when #complete! is called' do
+          f = Future.combine(Future.new, Future.new)
+          expect { f.complete! }.to raise_error(FutureError)
+        end
+
+        it 'raises an error when #fail! is called' do
+          f = Future.combine(Future.new, Future.new)
+          expect { f.fail!(StandardError.new('Blurgh')) }.to raise_error(FutureError)
+        end
+      end
+    end
+
+    describe '#map' do
+      context 'returns a new future that' do
+        it 'will complete with the result of the given block' do
+          mapped_value = nil
+          f1 = Future.new
+          f2 = f1.map { |v| v * 2 }
+          f2.on_complete { |v| mapped_value = v }
+          f1.complete!(3)
+          mapped_value.should == 3 * 2
+        end
+
+        it 'fails when the original future fails' do
+          failed = false
+          f1 = Future.new
+          f2 = f1.map { |v| v * 2 }
+          f2.on_failure { failed = true }
+          f1.fail!(StandardError.new('Blurgh'))
+          failed.should be_true
+        end
+
+        it 'fails when the block raises an error' do
+          f1 = Future.new
+          f2 = f1.map { |v| raise 'Blurgh' }
+          Thread.start do
+            sleep(0.01)
+            f1.complete!
+          end
+          expect { f2.get }.to raise_error('Blurgh')
+        end
+      end
+    end
+
+    describe '#flat_map' do
+      it 'works like #map, but expects that the block returns a future' do
+        f1 = Future.new
+        f2 = f1.flat_map { |v| Future.completed(v * 2) }
+        f1.complete!(3)
+        f2.value.should == 3 * 2
+      end
+
+      it 'fails when the block raises an error' do
+        f1 = Future.new
+        f2 = f1.flat_map { |v| raise 'Hurgh' }
+        f1.complete!(3)
+        expect { f2.get }.to raise_error('Hurgh')
+      end
+    end
+
+    describe '.completed' do
+      let :future do
+        described_class.completed('hello world')
+      end
+
+      it 'is complete when created' do
+        future.should be_complete
+      end
+
+      it 'calls callbacks immediately' do
+        value = nil
+        future.on_complete { |v| value = v }
+        value.should == 'hello world'
+      end
+
+      it 'does not block on #value' do
+        future.value.should == 'hello world'
+      end
+
+      it 'defaults to the value nil' do
+        described_class.completed.value.should be_nil
+      end
+
+      it 'handles #map' do
+        described_class.completed('foo').map(&:upcase).value.should == 'FOO'
+      end
+
+      it 'handles #map' do
+        f = described_class.completed('foo').map { |v| raise 'Blurgh' }
+        f.should be_failed
+      end
+    end
+
+    describe '.failed' do
+      let :future do
+        described_class.failed(StandardError.new('Blurgh'))
+      end
+
+      it 'is failed when created' do
+        future.should be_failed
+      end
+
+      it 'calls callbacks immediately' do
+        error = nil
+        future.on_failure { |e| error = e }
+        error.message.should == 'Blurgh'
+      end
+
+      it 'does not block on #value' do
+        expect { future.value }.to raise_error('Blurgh')
+      end
+    end
+  end
+end