cql-rb 1.2.2 → 2.0.0.pre0

data/spec/cql/client/execute_options_decoder_spec.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe ExecuteOptionsDecoder do
+      let :decoder do
+        described_class.new(:two)
+      end
+
+      describe '#decode_options' do
+        it 'returns the default consistency' do
+          options = decoder.decode_options({})
+          options.should include(consistency: :two)
+        end
+
+        it 'returns the default consistency when given no options' do
+          options = decoder.decode_options
+          options.should include(consistency: :two)
+        end
+
+        it 'returns the default consistency when given nil' do
+          options = decoder.decode_options(nil)
+          options.should include(consistency: :two)
+        end
+
+        it 'uses the consistency given in the options' do
+          options = decoder.decode_options(consistency: :three)
+          options.should include(consistency: :three)
+        end
+
+        it 'uses the consistency given as a symbol' do
+          options = decoder.decode_options(:three)
+          options.should include(consistency: :three)
+        end
+
+        it 'defaults to no serial consistency' do
+          options = decoder.decode_options({})
+          options.should_not have_key(:serial_consistency)
+        end
+
+        it 'uses the serial consistency given in the options' do
+          options = decoder.decode_options(serial_consistency: :local_serial)
+          options.should include(serial_consistency: :local_serial)
+        end
+
+        it 'defaults to no tracing' do
+          options = decoder.decode_options({})
+          options.should_not have_key(:trace)
+        end
+
+        it 'uses the tracing value given in the options' do
+          options = decoder.decode_options(trace: true)
+          options.should include(trace: true)
+          options = decoder.decode_options(trace: false)
+          options.should include(trace: false)
+        end
+
+        it 'defaults to no timeout' do
+          options = decoder.decode_options({})
+          options.should_not have_key(:timeout)
+        end
+
+        it 'uses the timeout value given in the options' do
+          options = decoder.decode_options(timeout: 3)
+          options.should include(timeout: 3)
+        end
+
+        context 'when called with multiple options' do
+          it 'merges the options' do
+            options = decoder.decode_options({:tracing => true, :timeout => 3}, {:consistency => :quorum, :timeout => 4})
+            options.should eql(tracing: true, timeout: 4, consistency: :quorum)
+          end
+
+          it 'uses the default consistency' do
+            options = decoder.decode_options({tracing: true, timeout: 3}, {:timeout => 4})
+            options.should eql(tracing: true, timeout: 4, consistency: :two)
+          end
+
+          it 'accepts nil' do
+            options = decoder.decode_options(nil, {tracing: true, timeout: 3}, nil, {:timeout => 4})
+            options.should eql(tracing: true, timeout: 4, consistency: :two)
+          end
+
+          it 'accepts consistencies given as symbols' do
+            options = decoder.decode_options({tracing: true, timeout: 3}, :quorum)
+            options.should eql(tracing: true, timeout: 3, consistency: :quorum)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/keyspace_changer_spec.rb

@@ -16,31 +16,31 @@ module Cql
 
       describe '#use_keyspace' do
         it 'sends a query request with a USE statement' do
-          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one), nil).and_return(Future.resolved)
-          f = keyspace_changer.use_keyspace('important_stuff', connection)
+          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', nil, nil, :one), nil).and_return(Future.resolved)
+          f = keyspace_changer.use_keyspace(connection, 'important_stuff')
           connection.should have_received(:send_request)
         end
 
         it 'accepts quoted keyspace names' do
-          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE "ImportantStuff"', :one), nil).and_return(Future.resolved)
-          f = keyspace_changer.use_keyspace('"ImportantStuff"', connection)
+          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE "ImportantStuff"', nil, nil, :one), nil).and_return(Future.resolved)
+          f = keyspace_changer.use_keyspace(connection, '"ImportantStuff"')
           connection.should have_received(:send_request)
         end
 
         context 'returns a future that' do
           it 'immediately resolves to the given connection when the keyspace is nil' do
-            f = keyspace_changer.use_keyspace(nil, connection)
+            f = keyspace_changer.use_keyspace(connection, nil)
             f.value.should equal(connection)
           end
 
           it 'fails with an InvalidKeyspaceNameError when the keyspace name is invalid' do
-            f = keyspace_changer.use_keyspace('TRUNCATE important_stuff', connection)
+            f = keyspace_changer.use_keyspace(connection, 'TRUNCATE important_stuff')
             expect { f.value }.to raise_error(InvalidKeyspaceNameError)
           end
 
           it 'resolves to the given connection' do
-            connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one), nil).and_return(Future.resolved)
-            f = keyspace_changer.use_keyspace('important_stuff', connection)
+            connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', nil, nil, :one), nil).and_return(Future.resolved)
+            f = keyspace_changer.use_keyspace(connection, 'important_stuff')
             f.value.should equal(connection)
           end
         end

data/spec/cql/client/peer_discovery_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe PeerDiscovery do
+      let :peer_discovery do
+        described_class.new(seed_connections)
+      end
+
+      describe '#new_hosts' do
+        let :seed_connections do
+          [
+            FakeConnection.new('host0', 9042, 5, {:data_center => 'dc0', :host_id => Uuid.new('00000000-0000-0000-0000-000000000000')}),
+            FakeConnection.new('host1', 9042, 5, {:data_center => 'dc0', :host_id => Uuid.new('11111111-1111-1111-1111-111111111111')}),
+            FakeConnection.new('host2', 9042, 5, {:data_center => 'dc0', :host_id => Uuid.new('22222222-2222-2222-2222-222222222222')}),
+          ]
+        end
+
+        let :peer_metadata do
+          [
+            ['system', 'peers', 'peer', :inet],
+            ['system', 'peers', 'data_center', :varchar],
+            ['system', 'peers', 'host_id', :uuid],
+            ['system', 'peers', 'rpc_address', :inet],
+          ]
+        end
+
+        let :peer_rows do
+          [
+            {'peer' => IPAddr.new('2.0.0.0'), 'rpc_address' => IPAddr.new('1.0.0.0'), 'data_center' => 'dc0', 'host_id' => Uuid.new('00000000-0000-0000-0000-000000000000')},
+            {'peer' => IPAddr.new('2.0.0.1'), 'rpc_address' => IPAddr.new('1.0.0.1'), 'data_center' => 'dc0', 'host_id' => Uuid.new('11111111-1111-1111-1111-111111111111')},
+            {'peer' => IPAddr.new('2.0.0.2'), 'rpc_address' => IPAddr.new('1.0.0.2'), 'data_center' => 'dc0', 'host_id' => Uuid.new('22222222-2222-2222-2222-222222222222')},
+            {'peer' => IPAddr.new('2.0.0.3'), 'rpc_address' => IPAddr.new('1.0.0.3'), 'data_center' => 'dc0', 'host_id' => Uuid.new('33333333-3333-3333-3333-333333333333')},
+            {'peer' => IPAddr.new('2.0.0.4'), 'rpc_address' => IPAddr.new('1.0.0.4'), 'data_center' => 'dc0', 'host_id' => Uuid.new('44444444-4444-4444-4444-444444444444')},
+          ]
+        end
+
+        let :peer_rows_response do
+          Protocol::RowsResultResponse.new(peer_rows, peer_metadata, nil, nil)
+        end
+
+        before do
+          seed_connections.each do |connection|
+            connection.handle_request do |request|
+              peer_rows_response
+            end
+          end
+        end
+
+        it 'selects all rows from the "peers" system table' do
+          peer_discovery.new_hosts.value
+          selected_connection = seed_connections.find { |c| c.requests.any? }
+          request = selected_connection.requests.first
+          columns, table = request.cql.scan(/SELECT (.*) FROM (\S+)/).flatten
+          table.should == 'system.peers'
+          columns.should include('peer')
+          columns.should include('data_center')
+          columns.should include('host_id')
+          columns.should include('rpc_address')
+        end
+
+        it 'returns a future that resolves to the addresses of all peers that were not already in the set of seed nodes' do
+          new_hosts = peer_discovery.new_hosts
+          new_hosts.value.should == %w[1.0.0.3 1.0.0.4]
+        end
+
+        it 'returns an empty list of addresses when there are no peers that are not in the set of seed nodes' do
+          peer_rows.pop(2)
+          new_hosts = peer_discovery.new_hosts
+          new_hosts.value.should be_empty
+        end
+
+        it 'returns the value of the "peer" column when the "rpc_address" column contains "0.0.0.0"' do
+          peer_rows.each do |row|
+            row['rpc_address'] = IPAddr.new('0.0.0.0')
+          end
+          new_hosts = peer_discovery.new_hosts
+          new_hosts.value.should == %w[2.0.0.3 2.0.0.4]
+        end
+
+        it 'only returns addresses to nodes that are in the same data centers as the seed nodes' do
+          peer_rows[3]['data_center'] = 'dc1'
+          new_hosts = peer_discovery.new_hosts
+          new_hosts.value.should == %w[1.0.0.4]
+        end
+      end
+    end
+  end
+end

data/spec/cql/client/query_result_spec.rb

@@ -0,0 +1,352 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    shared_context 'query_result_setup' do
+      let :metadata do
+        [
+          ['ks', 'tbl', 'col1', :varchar],
+          ['ks', 'tbl', 'col2', :double],
+        ]
+      end
+
+      let :trace_id do
+        double(:trace_id)
+      end
+
+      let :rows do
+        [double(:row1), double(:row2), double(:row3)]
+      end
+    end
+
+    shared_examples 'query_result_shared' do
+      describe '#metadata' do
+        it 'wraps the raw metadata in a ResultMetadata' do
+          result.metadata['col1'].should == ColumnMetadata.new('ks', 'tbl', 'col1', :varchar)
+        end
+      end
+
+      describe '#each' do
+        it 'yields each row' do
+          yielded_rows = []
+          result.each { |r| yielded_rows << r }
+          yielded_rows.should == rows
+        end
+
+        it 'can be iterated multiple times' do
+          yielded_rows = []
+          result.each { |r| yielded_rows << r }
+          result.each { |r| yielded_rows << r }
+          yielded_rows.should == rows + rows
+        end
+
+        it 'is aliased as #each_row' do
+          result.each_row { }
+        end
+
+        it 'returns an Enumerable when no block is given' do
+          result.each.to_a.should == rows
+        end
+      end
+
+      context 'when used as an Enumerable' do
+        before do
+          rows.each_with_index { |r, i| r.stub(:[]).with('col2').and_return(i.to_f) }
+        end
+
+        it 'transforms the rows' do
+          result.map { |r| r['col2'] * 2 }.should == [0.0, 2.0, 4.0]
+        end
+
+        it 'filters the rows' do
+          result.select { |r| r['col2'] > 0 }.should == rows.drop(1)
+        end
+      end
+    end
+
+    describe QueryResult do
+      let :result do
+        described_class.new(metadata, rows, trace_id, nil)
+      end
+
+      include_context 'query_result_setup'
+      include_examples 'query_result_shared'
+
+      describe '#empty?' do
+        it 'returns true when there are no rows' do
+          described_class.new(metadata, [], nil, nil).should be_empty
+        end
+
+        it 'returns false when there are rows' do
+          result.should_not be_empty
+        end
+      end
+    end
+
+    describe LazyQueryResult do
+      let :result do
+        described_class.new(metadata, lazy_rows, trace_id, nil)
+      end
+
+      let :lazy_rows do
+        double(:lazy_rows)
+      end
+
+      include_context 'query_result_setup'
+
+      before do
+        lazy_rows.stub(:rows).and_return(nil)
+        lazy_rows.stub(:materialize) do |md|
+          raise '#materialize called twice' if lazy_rows.rows
+          md.should == metadata
+          lazy_rows.stub(:rows).and_return(rows)
+          rows
+        end
+      end
+
+      include_examples 'query_result_shared'
+
+      describe '#empty?' do
+        it 'returns true when there are no rows' do
+          lazy_rows.stub(:materialize) do
+            lazy_rows.stub(:rows).and_return([])
+            []
+          end
+          result.should be_empty
+        end
+
+        it 'returns false when there are rows' do
+          result.should_not be_empty
+        end
+      end
+    end
+
+    shared_examples 'paged_query_result' do
+      let :metadata do
+        ResultMetadata.new([['ks', 'tbl', 'col1', :varchar], ['ks', 'tbl', 'col2', :double]])
+      end
+
+      describe '#metadata' do
+        it 'delegates to the wrapped result' do
+          query_result.stub(:metadata).and_return(metadata)
+          paged_query_result.metadata.should == metadata
+        end
+      end
+
+      describe '#trace_id' do
+        it 'delegates to the wrapped result' do
+          query_result.stub(:trace_id).and_return('foobaz')
+          paged_query_result.trace_id.should == 'foobaz'
+        end
+      end
+
+      describe '#paging_state' do
+        it 'delegates to the wrapped result' do
+          query_result.stub(:paging_state).and_return('foobaz')
+          paged_query_result.paging_state.should == 'foobaz'
+        end
+      end
+
+      describe '#empty?' do
+        it 'delegates to the wrapped result' do
+          query_result.stub(:empty?).and_return(true)
+          paged_query_result.should be_empty
+        end
+      end
+
+      describe '#each' do
+        it 'delegates to the wrapped result' do
+          query_result.stub(:each).and_yield(:row1).and_yield(:row2)
+          rows = paged_query_result.each_with_object([]) { |row, rows| rows << row }
+          rows.should == [:row1, :row2]
+        end
+      end
+    end
+
+    shared_examples 'asynchronous_paged_query_result' do
+      include_examples 'paged_query_result'
+
+      describe '#last_page?' do
+        it 'returns true when the result has no paging state' do
+          query_result.stub(:paging_state).and_return(nil)
+          paged_query_result.should be_last_page
+        end
+
+        it 'returns false when the result has a paging state' do
+          paged_query_result.should_not be_last_page
+        end
+      end
+    end
+
+    describe AsynchronousQueryPagedQueryResult do
+      let :paged_query_result do
+        described_class.new(client, request, query_result, options)
+      end
+
+      let :client do
+        double(:client)
+      end
+
+      let :request do
+        double(:request, cql: 'SELECT * FROM something WHERE id = ?', values: ['foo'])
+      end
+
+      let :query_result do
+        double(:query_result, paging_state: 'thepagingstate')
+      end
+
+      let :options do
+        {:trace => true, :timeout => 3}
+      end
+
+      include_examples 'asynchronous_paged_query_result'
+
+      describe '#next_page' do
+        let :next_query_result do
+          double(:next_query_result, paging_state: 'thenextpagingstate')
+        end
+
+        before do
+          client.stub(:execute).and_return(Future.resolved(next_query_result))
+        end
+
+        it 'calls the client and passes the paging state' do
+          paged_query_result.next_page.value
+          client.should have_received(:execute).with(anything, anything, hash_including(paging_state: 'thepagingstate'))
+        end
+
+        it 'calls the client and passes the options' do
+          paged_query_result.next_page.value
+          client.should have_received(:execute).with(anything, anything, hash_including(options))
+        end
+
+        it 'calls the client and passes the CQL' do
+          paged_query_result.next_page.value
+          client.should have_received(:execute).with(request.cql, anything, anything)
+        end
+
+        it 'calls the client and passes the bound values' do
+          paged_query_result.next_page.value
+          client.should have_received(:execute).with(anything, 'foo', anything)
+        end
+
+        it 'handles the case when there are multiple bound values' do
+          request.stub(:values).and_return(['foo', 3, 'bar', 4])
+          paged_query_result.next_page.value
+          client.should have_received(:execute).with(anything, 'foo', 3, 'bar', 4, anything)
+        end
+
+        it 'handles the case when there are no bound values' do
+          request.stub(:values).and_return(nil)
+          paged_query_result.next_page.value
+          client.should have_received(:execute).with(request.cql, an_instance_of(Hash))
+        end
+
+        it 'returns the result of the call' do
+          f = paged_query_result.next_page
+          f.value.should equal(next_query_result)
+        end
+      end
+    end
+
+    describe AsynchronousPreparedPagedQueryResult do
+      let :paged_query_result do
+        described_class.new(statement, request, query_result, options)
+      end
+
+      let :statement do
+        double(:statement)
+      end
+
+      let :request do
+        double(:request, values: ['foo', 3])
+      end
+
+      let :query_result do
+        double(:query_result, paging_state: 'thepagingstate')
+      end
+
+      let :options do
+        {:trace => true, :timeout => 3}
+      end
+
+      include_examples 'asynchronous_paged_query_result'
+
+      describe '#next_page' do
+        let :next_query_result do
+          double(:next_query_result, paging_state: 'thenextpagingstate')
+        end
+
+        before do
+          statement.stub(:execute).and_return(Future.resolved(next_query_result))
+        end
+
+        it 'calls the statement and passes the paging state' do
+          paged_query_result.next_page.value
+          statement.should have_received(:execute).with(anything, anything, hash_including(paging_state: 'thepagingstate'))
+        end
+
+        it 'calls the statement and passes the options' do
+          paged_query_result.next_page.value
+          statement.should have_received(:execute).with(anything, anything, hash_including(options))
+        end
+
+        it 'calls the statement and passes the bound values' do
+          paged_query_result.next_page.value
+          statement.should have_received(:execute).with('foo', 3, anything)
+        end
+
+        it 'handles the case when there are no bound values' do
+          request.stub(:values).and_return(nil)
+          paged_query_result.next_page.value
+          statement.should have_received(:execute).with(an_instance_of(Hash))
+        end
+
+        it 'returns the result of the call' do
+          f = paged_query_result.next_page
+          f.value.should equal(next_query_result)
+        end
+      end
+    end
+
+    describe SynchronousPagedQueryResult do
+      let :paged_query_result do
+        described_class.new(asynchronous_paged_query_result)
+      end
+
+      let :asynchronous_paged_query_result do
+        double(:asynchronous_paged_query_result)
+      end
+
+      describe '#next_page' do
+        let :next_query_result do
+          double(:next_query_result)
+        end
+
+        it 'delegates to the wrapped query result and wraps the result in an instance of itself' do
+          next_query_result.stub(:next_page).and_return(Future.resolved(next_query_result))
+          asynchronous_paged_query_result.stub(:next_page).and_return(Future.resolved(next_query_result))
+          second_page = paged_query_result.next_page
+          second_page.next_page
+          next_query_result.should have_received(:next_page)
+        end
+      end
+
+      describe '#last_page?' do
+        it 'delegates to the wrapped query result' do
+          asynchronous_paged_query_result.stub(:last_page?).and_return(true)
+          paged_query_result.should be_last_page
+        end
+      end
+
+      describe '#async' do
+        it 'returns the asynchronous results' do
+          paged_query_result.async.should equal(asynchronous_paged_query_result)
+        end
+      end
+    end
+  end
+end