cql-rb 1.0.0.pre7 → 1.0.0.pre8

data/spec/cql/client/client_shared.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+shared_context 'client setup' do
+  let :connection_options do
+    {:host => 'example.com', :port => 12321, :io_reactor => io_reactor}
+  end
+
+  let :io_reactor do
+    FakeIoReactor.new
+  end
+
+  def connections
+    io_reactor.connections
+  end
+
+  def connection
+    connections.first
+  end
+
+  def requests
+    connection[:requests]
+  end
+
+  def last_request
+    requests.last
+  end
+end

data/spec/cql/client/synchronous_client_spec.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'cql/client/client_shared'
+
+
+module Cql
+  module Client
+    describe SynchronousClient do
+      let :client do
+        described_class.new(async_client)
+      end
+
+      let :async_client do
+        stub(:async_client)
+      end
+
+      let :future do
+        stub(:future, get: nil)
+      end
+
+      describe '#connect' do
+        it 'calls #connect on the async client and waits for the result' do
+          async_client.should_receive(:connect).and_return(future)
+          future.should_receive(:get)
+          client.connect
+        end
+
+        it 'returns self' do
+          async_client.stub(:connect).and_return(future)
+          client.connect.should equal(client)
+        end
+      end
+
+      describe '#close' do
+        it 'calls #close on the async client and waits for the result' do
+          async_client.should_receive(:close).and_return(future)
+          future.should_receive(:get)
+          client.close
+        end
+
+        it 'returns self' do
+          async_client.stub(:close).and_return(future)
+          client.close.should equal(client)
+        end
+      end
+
+      describe '#connected?' do
+        it 'delegates to the async client' do
+          async_client.stub(:connected?).and_return(true)
+          client.connected?.should be_true
+          async_client.stub(:connected?).and_return(false)
+          client.connected?.should be_false
+        end
+      end
+
+      describe '#keyspace' do
+        it 'delegates to the async client' do
+          async_client.stub(:keyspace).and_return('foo')
+          client.keyspace.should == 'foo'
+        end
+      end
+
+      describe '#use' do
+        it 'calls #use on the async client and waits for the result' do
+          async_client.should_receive(:use).with('foo').and_return(future)
+          future.should_receive(:get)
+          client.use('foo')
+        end
+      end
+
+      describe '#execute' do
+        it 'calls #execute on the async client and waits for, and returns the result' do
+          result = stub(:result)
+          async_client.stub(:execute).with('SELECT * FROM something', :one).and_return(future)
+          future.stub(:get).and_return(result)
+          client.execute('SELECT * FROM something', :one).should equal(result)
+        end
+      end
+
+      describe '#prepare' do
+        it 'calls #prepare on the async client, waits for the result and returns a SynchronousFuture' do
+          result = stub(:result)
+          metadata = stub(:metadata)
+          async_statement = stub(:async_statement, metadata: metadata)
+          another_future = stub(:another_future)
+          async_client.stub(:prepare).with('SELECT * FROM something').and_return(future)
+          future.stub(:get).and_return(async_statement)
+          statement = client.prepare('SELECT * FROM something')
+          async_statement.should_receive(:execute).and_return(another_future)
+          another_future.stub(:get).and_return(result)
+          statement.execute.should equal(result)
+          statement.metadata.should equal(metadata)
+        end
+      end
+
+      describe '#async' do
+        it 'returns an asynchronous client' do
+          client.async.should equal(async_client)
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/synchronous_prepared_statement_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe SynchronousPreparedStatement do
+      let :statement do
+        described_class.new(async_statement)
+      end
+
+      let :async_statement do
+        stub(:async_statement, metadata: metadata)
+      end
+
+      let :metadata do
+        stub(:metadata)
+      end
+
+      let :future do
+        Future.new
+      end
+
+      describe '#metadata' do
+        it 'returns the async statement\'s metadata' do
+          statement.metadata.should equal(async_statement.metadata)
+        end
+      end
+
+      describe '#execute' do
+        it 'it calls #execute on the async statement and waits for the result' do
+          result = stub(:result)
+          async_statement.should_receive(:execute).with('one', 'two', :three).and_return(future)
+          future.complete!(result)
+          statement.execute('one', 'two', :three).should equal(result)
+        end
+      end
+
+      describe '#pipeline' do
+        it 'executes the statement multiple times and waits for all the results' do
+          result1 = stub(:result1)
+          result2 = stub(:result2)
+          async_statement.stub(:execute).with('one', 'two', :three).and_return(Future.completed(result1))
+          async_statement.stub(:execute).with('four', 'file', :all).and_return(Future.completed(result2))
+          results = statement.pipeline do |p|
+            p.execute('one', 'two', :three)
+            p.execute('four', 'file', :all)
+          end
+          results.should eql([result1, result2])
+        end
+
+        it 'does nothing when statements are executed' do
+          statement.pipeline { |p| }.should == []
+        end
+      end
+
+      describe '#async' do
+        it 'returns an asynchronous statement' do
+          statement.async.should equal(async_statement)
+        end
+      end
+    end
+  end
+end

data/spec/cql/future_spec.rb

@@ -190,6 +190,10 @@ module Cql
           f = Future.combine(Future.new, Future.new)
           expect { f.fail!(StandardError.new('Blurgh')) }.to raise_error(FutureError)
         end
+
+        it 'completes with an empty list when no futures are given' do
+          Future.combine.get.should == []
+        end
       end
     end
 

data/spec/cql/io/io_reactor_spec.rb

@@ -213,37 +213,56 @@ module Cql
             expect { f.get }.to raise_error(ConnectionNotFoundError)
           end
 
-          it 'fails if the connection is busy' do
-            f = io_reactor.start.flat_map do
-              io_reactor.add_connection(host, port).flat_map do
-                io_reactor.add_connection(host, port).flat_map do |connection_id|
-                  200.times do
-                    io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
-                  end
-                  io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
-                end
-              end
+          it 'queues requests when the connection is busy' do
+            request = Cql::Protocol::QueryRequest.new('UPDATE x SET y = 1 WHERE z = 2', :one)
+
+            io_reactor.start
+            connection_id = io_reactor.add_connection(host, port).get
+
+            futures = 200.times.map do
+              io_reactor.queue_request(request, connection_id)
+            end
+
+            128.times do |i|
+              server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
+            end
+
+            Future.combine(*futures.shift(128)).get
+
+            128.times do |i|
+              server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
             end
-            expect { f.get }.to raise_error(ConnectionBusyError)
+
+            Future.combine(*futures).get
           end
 
-          it 'fails if the connection is busy, when there is only one connection' do
-            f = io_reactor.start.flat_map do
-              io_reactor.add_connection(host, port).flat_map do |connection_id|
-                200.times do
-                  io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
-                end
-                io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
+          it 'fails queued requests when the connection closes' do
+            request = Cql::Protocol::QueryRequest.new('UPDATE x SET y = 1 WHERE z = 2', :one)
+
+            io_reactor.start
+            connection_id = io_reactor.add_connection(host, port).get
+
+            failures = 0
+
+            200.times do
+              f = io_reactor.queue_request(request, connection_id)
+              f.on_failure do
+                failures += 1
               end
             end
-            expect { f.get }.to raise_error(ConnectionBusyError)
+
+            server.broadcast!("\x01\x00\x00\x02\x00\x00\x00\x16")
+
+            await { failures == 200 }
           end
         end
 
         it 'fails if there is an error when encoding the request' do
+          request = stub(:request)
+          request.stub(:encode_frame).and_raise(Cql::ProtocolError.new('Boork!'))
           io_reactor.start
           io_reactor.add_connection(host, port).get
-          f = io_reactor.queue_request(Cql::Protocol::QueryRequest.new('USE test', :foobar))
+          f = io_reactor.queue_request(request)
           expect { f.get }.to raise_error(Cql::ProtocolError)
         end
 

data/spec/cql/protocol/request_spec.rb

@@ -0,0 +1,17 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe Request do
+      describe '#encode_frame' do
+        it 'returns a rendered request frame for the specified channel' do
+          frame = PrepareRequest.new('SELECT * FROM things').encode_frame(3)
+          frame.to_s.should == "\x01\x00\x03\x09\x00\x00\x00\x18\x00\x00\x00\x14SELECT * FROM things"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe CredentialsRequest do
+      describe '#encode_frame' do
+        it 'encodes a CREDENTIALS request frame' do
+          bytes = CredentialsRequest.new('username' => 'cassandra', 'password' => 'ardnassac').encode_frame(3)
+          bytes.should == (
+            "\x01\x00\x03\04" +
+            "\x00\x00\x00\x2c" +
+            "\x00\x02" +
+            "\x00\x08username" +
+            "\x00\x09cassandra" +
+            "\x00\x08password" +
+            "\x00\x09ardnassac"
+          )
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns a pretty string' do
+          request = CredentialsRequest.new('foo' => 'bar', 'hello' => 'world')
+          request.to_s.should == 'CREDENTIALS {"foo"=>"bar", "hello"=>"world"}'
+        end
+      end
+
+      describe '#eql?' do
+        it 'returns when the credentials are the same' do
+          c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+          c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+          c2.should eql(c2)
+        end
+
+        it 'returns when the credentials are equivalent' do
+          pending 'this would be nice, but is hardly necessary' do
+            c1 = CredentialsRequest.new(:username => 'foo', :password => 'bar')
+            c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c1.should eql(c2)
+          end
+        end
+
+        it 'returns false when the credentials are different' do
+          c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'world')
+          c2 = CredentialsRequest.new('username' => 'foo', 'hello' => 'world')
+          c1.should_not eql(c2)
+        end
+
+        it 'is aliased as ==' do
+          c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+          c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+          c1.should == c2
+        end
+      end
+
+      describe '#hash' do
+        it 'has the same hash code as another identical object' do
+          c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+          c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+          c1.hash.should == c2.hash
+        end
+
+        it 'has the same hash code as another object with equivalent credentials' do
+          pending 'this would be nice, but is hardly necessary' do
+            c1 = CredentialsRequest.new(:username => 'foo', :password => 'bar')
+            c2 = CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            c1.hash.should == c2.hash
+          end
+        end
+
+        it 'does not have the same hash code when the credentials are different' do
+          c1 = CredentialsRequest.new('username' => 'foo', 'password' => 'world')
+          c2 = CredentialsRequest.new('username' => 'foo', 'hello' => 'world')
+          c1.hash.should_not == c2.hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe ExecuteRequest do
+      let :id do
+        "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
+      end
+
+      let :column_metadata do
+        [
+          ['ks', 'tbl', 'col1', :varchar],
+          ['ks', 'tbl', 'col2', :int],
+          ['ks', 'tbl', 'col3', :varchar]
+        ]
+      end
+
+      let :values do
+        ['hello', 42, 'foo']
+      end
+
+      describe '#initialize' do
+        it 'raises an error when the metadata and values don\'t have the same size' do
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 42], :each_quorum) }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an error for unsupported column types' do
+          column_metadata[2][3] = :imaginary
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum) }.to raise_error(UnsupportedColumnTypeError)
+        end
+
+        it 'raises an error for unsupported column collection types' do
+          column_metadata[2][3] = [:imaginary, :varchar]
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 42, ['foo']], :each_quorum) }.to raise_error(UnsupportedColumnTypeError)
+        end
+
+        it 'raises an error when collection values are not enumerable' do
+          column_metadata[2][3] = [:set, :varchar]
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum) }.to raise_error(InvalidValueError)
+        end
+
+        it 'raises an error when it cannot encode the argument' do
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 'not an int', 'foo'], :each_quorum) }.to raise_error(TypeError, /cannot be encoded as INT/)
+        end
+      end
+
+      describe '#encode_frame' 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"
+        end
+
+        specs = [
+          [:ascii, 'test', "test"],
+          [:bigint, 1012312312414123, "\x00\x03\x98\xB1S\xC8\x7F\xAB"],
+          [:blob, "\xab\xcd", "\xab\xcd"],
+          [:boolean, false, "\x00"],
+          [:boolean, true, "\x01"],
+          [:decimal, BigDecimal.new('1042342234234.123423435647768234'), "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"],
+          [:double, 10000.123123123, "@\xC3\x88\x0F\xC2\x7F\x9DU"],
+          [:float, 12.13, "AB\x14{"],
+          [:inet, IPAddr.new('8.8.8.8'), "\x08\x08\x08\x08"],
+          [:inet, IPAddr.new('::1'), "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"],
+          [:int, 12348098, "\x00\xBCj\xC2"],
+          [:text, 'FOOBAR', 'FOOBAR'],
+          [:timestamp, Time.at(1358013521.123), "\x00\x00\x01</\xE9\xDC\xE3"],
+          [:timeuuid, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711'), "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"],
+          [:uuid, Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), "\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6"],
+          [:varchar, 'hello', 'hello'],
+          [:varint, 1231312312331283012830129382342342412123, "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["],
+          [:varint, -234234234234, "\xC9v\x8D:\x86"],
+          [[:list, :timestamp], [Time.at(1358013521.123)], "\x00\x01" + "\x00\x08\x00\x00\x01</\xE9\xDC\xE3"],
+          [[:list, :boolean], [true, false, true, true], "\x00\x04" + "\x00\x01\x01" + "\x00\x01\x00"  + "\x00\x01\x01" + "\x00\x01\x01"],
+          [[:map, :uuid, :int], {Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6') => 45345, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711') => 98765}, "\x00\x02" + "\x00\x10\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6" + "\x00\x04\x00\x00\xb1\x21" + "\x00\x10\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11" + "\x00\x04\x00\x01\x81\xcd"],
+          [[:map, :ascii, :blob], {'hello' => 'world', 'one' => "\x01", 'two' => "\x02"}, "\x00\x03" + "\x00\x05hello" + "\x00\x05world" + "\x00\x03one" + "\x00\x01\x01" + "\x00\x03two" + "\x00\x01\x02"],
+          [[:set, :int], Set.new([13, 3453, 456456, 123, 768678]), "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"],
+          [[:set, :varchar], Set.new(['foo', 'bar', 'baz']), "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"],
+          [[:set, :int], [13, 3453, 456456, 123, 768678], "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"],
+          [[:set, :varchar], ['foo', 'bar', 'baz'], "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"]
+        ]
+        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)
+            length = buffer.read_int
+            result_bytes = buffer.read(length)
+            result_bytes.should eql_bytes(expected_bytes)
+          end
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns a pretty string' do
+          request = ExecuteRequest.new(id, column_metadata, values, :each_quorum)
+          request.to_s.should == 'EXECUTE ca487f1e7a82d23c4e8af3355171a52f ["hello", 42, "foo"] EACH_QUORUM'
+        end
+      end
+
+      describe '#eql?' do
+        it 'returns true when the ID, metadata, values and consistency are the same' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e1.should eql(e2)
+        end
+
+        it 'returns false when the ID is different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id.reverse, column_metadata, values, :one)
+          e1.should_not eql(e2)
+        end
+
+        it 'returns false when the metadata is different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata.reverse, values, :one)
+          e1.should_not eql(e2)
+        end
+
+        it 'returns false when the values are different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values.reverse, :one)
+          e1.should_not eql(e2)
+        end
+
+        it 'returns false when the consistency is different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values, :two)
+          e1.should_not eql(e2)
+        end
+
+        it 'is aliased as ==' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e1.should == e2
+        end
+      end
+
+      describe '#hash' do
+        it 'has the same hash code as another identical object' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e1.hash.should == e2.hash
+        end
+
+        it 'does not have the same hash code when the ID is different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id.reverse, column_metadata, values, :one)
+          e1.hash.should_not == e2.hash
+        end
+
+        it 'does not have the same hash code when the metadata is different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata.reverse, values, :one)
+          e1.hash.should_not == e2.hash
+        end
+
+        it 'does not have the same hash code when the values are different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values.reverse, :one)
+          e1.hash.should_not == e2.hash
+        end
+
+        it 'does not have the same hash code when the consistency is different' do
+          e1 = ExecuteRequest.new(id, column_metadata, values, :one)
+          e2 = ExecuteRequest.new(id, column_metadata, values, :two)
+          e1.hash.should_not == e2.hash
+        end
+      end
+    end
+  end
+end