cassandra-mavericks 0.21.1

data/test/comparable_types_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class ComparableTypesTest < Test::Unit::TestCase
+  include Cassandra::Constants
+
+  def test_long_sort
+    ary = []
+    10.times { ary << Long.new }
+    assert_equal ary.sort, ary
+  end
+
+  def test_long_equality
+    long = Long.new
+    assert_equal long, Long.new(long)
+    assert_equal long, Long.new(long.to_s)
+    assert_equal long, Long.new(long.to_i)
+    assert_equal long, Long.new(long.to_guid)
+  end
+
+  def test_long_error
+    assert_raises(Cassandra::Comparable::TypeError) do
+      Long.new("bogus")
+    end
+  end
+
+  def test_types_behave_well
+    assert !(Long.new() == false)
+  end
+
+  def test_casting_unknown_class
+    assert_raises(Cassandra::Comparable::TypeError) do
+      Cassandra::Long.new({})
+    end
+  end
+
+  def test_long_inspect
+    obj = Long.new("\000\000\000\000\000\000\000\000")
+    if RUBY_VERSION < '1.9'
+      assert_equal "<Cassandra::Long##{obj.object_id} time: Thu Jan 01 00:00:00 UTC 1970, usecs: 0, jitter: 0, guid: 00000000-0000-0000>", obj.inspect
+    else
+      assert_equal "<Cassandra::Long##{obj.object_id} time: 1970-01-01 00:00:00 UTC, usecs: 0, jitter: 0, guid: 00000000-0000-0000>", obj.inspect
+    end
+  end
+
+end

data/test/composite_type_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class CompositeTypesTest < Test::Unit::TestCase
+  include Cassandra::Constants
+
+  def setup
+    @col_parts = [[363].pack('N'), 'extradites-mulling', SimpleUUID::UUID.new().bytes]
+    @col = Cassandra::Composite.new(*@col_parts)
+
+    @part0_length = 2 + 4 + 1 # size + int + end_term
+    @part1_length = 2 + @col_parts[1].length + 1 # size + string_len + end_term
+    @part2_length = 2 + @col_parts[2].length + 1 # size + uuid_bytes + end_term
+
+    @types = ['IntegerType', 'UTF8Type', 'TimeUUIDType']
+    @type_aliaes = ['i', 's', 't']
+
+    @dycol = Cassandra::DynamicComposite.new(*@types.zip(@col_parts))
+    @dycol_alias = Cassandra::DynamicComposite.new(*@type_aliaes.zip(@col_parts))
+  end
+
+  def test_creation_from_parts
+    (0..2).each do |i|
+      assert_equal(@col_parts[i], @col[i])
+      assert_equal(@col_parts[i], @dycol[i])
+      assert_equal(@col_parts[i], @dycol_alias[i])
+    end
+  end
+
+  def test_packing_and_unpacking
+    assert_equal(@part0_length + @part1_length + @part2_length, @col.pack.length)
+
+    col2 = Cassandra::Composite.new_from_packed(@col.pack)
+    assert_equal(@col_parts[0], col2[0])
+    assert_equal(@col_parts[1], col2[1])
+    assert_equal(@col_parts[2], col2[2])
+    assert_equal(@col, col2)
+    # make sure we set this while we have the packed string handy
+    assert_equal(@col.pack.hash, col2.instance_variable_get(:@hash))
+
+    col2 = Cassandra::Composite.new(@col.pack)
+    assert_equal(@col_parts[0], col2[0])
+    assert_equal(@col_parts[1], col2[1])
+    assert_equal(@col_parts[2], col2[2])
+    assert_equal(@col, col2)
+  end
+
+  def test_packing_and_unpacking_dynamic_columns
+    part0_length = @part0_length + 2 + @types[0].length
+    part1_length = @part1_length + 2 + @types[1].length
+    part2_length = @part2_length + 2 + @types[2].length
+    assert_equal(part0_length + part1_length + part2_length, @dycol.pack.length)
+
+    col2 = Cassandra::DynamicComposite.new_from_packed(@dycol.pack)
+    assert_equal(@col_parts[0], col2[0])
+    assert_equal(@col_parts[1], col2[1])
+    assert_equal(@col_parts[2], col2[2])
+    assert_equal(@dycol, col2)
+    # make sure we set this while we have the packed string handy
+    assert_equal(@dycol.pack.hash, col2.instance_variable_get(:@hash))
+
+    col2 = Cassandra::DynamicComposite.new(@dycol.pack)
+    assert_equal(@col_parts[0], col2[0])
+    assert_equal(@col_parts[1], col2[1])
+    assert_equal(@col_parts[2], col2[2])
+    assert_equal(@dycol, col2)
+  end
+
+  def test_packing_and_unpacking_dynamic_columns_with_aliases
+    part0_length = @part0_length + 2
+    part1_length = @part1_length + 2
+    part2_length = @part2_length + 2
+    assert_equal(part0_length + part1_length + part2_length, @dycol_alias.pack.length)
+
+    col2 = Cassandra::DynamicComposite.new_from_packed(@dycol_alias.pack)
+    assert_equal(@col_parts[0], col2[0])
+    assert_equal(@col_parts[1], col2[1])
+    assert_equal(@col_parts[2], col2[2])
+    assert_equal(@dycol_alias, col2)
+
+    col2 = Cassandra::DynamicComposite.new(@dycol_alias.pack)
+    assert_equal(@col_parts[0], col2[0])
+    assert_equal(@col_parts[1], col2[1])
+    assert_equal(@col_parts[2], col2[2])
+    assert_equal(@dycol_alias, col2)
+  end
+end

data/test/eventmachine_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+if RUBY_VERSION < '1.9' || CASSANDRA_VERSION == '0.6'
+  puts "Skipping EventMachine test"
+else
+
+  require 'thrift_client/event_machine'
+
+  class EventmachineTest < Test::Unit::TestCase
+
+    def test_twitter
+      @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :exception_classes => [], :transport => Thrift::EventMachineTransport, :transport_wrapper => nil)
+      @twitter.clear_keyspace!
+    end
+
+    private
+
+    def em_test(name)
+      EM.run do
+        Fiber.new do
+          begin
+            send("raw_#{name}".to_sym)
+          ensure
+            EM.stop
+          end
+        end.resume
+      end
+    end
+
+    def self.wrap_tests
+      self.public_instance_methods.select { |m| m =~ /^test_/ }.each do |meth|
+        alias_method :"raw_#{meth}", meth
+        define_method(meth) do
+          em_test(meth)
+        end
+      end
+    end
+
+    wrap_tests
+
+  end
+end

data/test/ordered_hash_test.rb

@@ -0,0 +1,386 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class OrderedHashTestInt < Test::Unit::TestCase
+  def setup
+    @keys =   %w( blue   green  red    pink   orange )
+    @values = %w( 000099 009900 aa0000 cc0066 cc6633 )
+    @hash = Hash.new
+    @ordered_hash = Cassandra::OrderedHash.new
+
+    @keys.each_with_index do |key, index|
+      @hash[key] = @values[index]
+      @ordered_hash[key] = @values[index]
+    end
+  end
+
+  def test_order
+    assert_equal @keys,   @ordered_hash.keys
+    assert_equal @values, @ordered_hash.values
+  end
+
+  def test_access
+    assert @hash.all? { |k, v| @ordered_hash[k] == v }
+  end
+
+  def test_assignment
+    key, value = 'purple', '5422a8'
+
+    @ordered_hash[key] = value
+    assert_equal @keys.length + 1, @ordered_hash.length
+    assert_equal key, @ordered_hash.keys.last
+    assert_equal value, @ordered_hash.values.last
+    assert_equal value, @ordered_hash[key]
+  end
+
+  def test_delete
+    key, value = 'white', 'ffffff'
+    bad_key = 'black'
+
+    @ordered_hash[key] = value
+    assert_equal @keys.length + 1, @ordered_hash.length
+    assert_equal @ordered_hash.keys.length, @ordered_hash.length
+
+    assert_equal value, @ordered_hash.delete(key)
+    assert_equal @keys.length, @ordered_hash.length
+    assert_equal @ordered_hash.keys.length, @ordered_hash.length
+
+    assert_nil @ordered_hash.delete(bad_key)
+  end
+
+  def test_to_hash
+    assert_same @ordered_hash, @ordered_hash.to_hash
+  end
+
+  def test_to_a
+    assert_equal @keys.zip(@values), @ordered_hash.to_a
+  end
+
+  def test_has_key
+    assert_equal true, @ordered_hash.has_key?('blue')
+    assert_equal true, @ordered_hash.key?('blue')
+    assert_equal true, @ordered_hash.include?('blue')
+    assert_equal true, @ordered_hash.member?('blue')
+
+    assert_equal false, @ordered_hash.has_key?('indigo')
+    assert_equal false, @ordered_hash.key?('indigo')
+    assert_equal false, @ordered_hash.include?('indigo')
+    assert_equal false, @ordered_hash.member?('indigo')
+  end
+
+  def test_has_value
+    assert_equal true, @ordered_hash.has_value?('000099')
+    assert_equal true, @ordered_hash.value?('000099')
+    assert_equal false, @ordered_hash.has_value?('ABCABC')
+    assert_equal false, @ordered_hash.value?('ABCABC')
+  end
+
+  def test_each_key
+    keys = []
+    @ordered_hash.each_key { |k| keys << k }
+    assert_equal @keys, keys
+  end
+
+  def test_each_value
+    values = []
+    @ordered_hash.each_value { |v| values << v }
+    assert_equal @values, values
+  end
+
+  def test_each
+    values = []
+    @ordered_hash.each {|key, value| values << value}
+    assert_equal @values, values
+  end
+
+  def test_each_with_index
+    @ordered_hash.each_with_index { |pair, index| assert_equal [@keys[index], @values[index]], pair}
+  end
+
+  def test_each_pair
+    values = []
+    keys = []
+    @ordered_hash.each_pair do |key, value|
+      keys << key
+      values << value
+    end
+    assert_equal @values, values
+    assert_equal @keys, keys
+  end
+
+  def test_delete_if
+    copy = @ordered_hash.dup
+    copy.delete('pink')
+    assert_equal copy, @ordered_hash.delete_if { |k, _| k == 'pink' }
+    assert !@ordered_hash.keys.include?('pink')
+  end
+
+  def test_reject!
+    (copy = @ordered_hash.dup).delete('pink')
+    @ordered_hash.reject! { |k, _| k == 'pink' }
+    assert_equal copy, @ordered_hash
+    assert !@ordered_hash.keys.include?('pink')
+  end
+
+  def test_reject
+    copy = @ordered_hash.dup
+    new_ordered_hash = @ordered_hash.reject { |k, _| k == 'pink' }
+    assert_equal copy, @ordered_hash
+    assert !new_ordered_hash.keys.include?('pink')
+    assert @ordered_hash.keys.include?('pink')
+  end
+
+  def test_clear
+    @ordered_hash.clear
+    assert_equal [], @ordered_hash.keys
+  end
+
+  def test_merge
+    other_hash =  Cassandra::OrderedHash.new
+    other_hash['purple'] = '800080'
+    other_hash['violet'] = 'ee82ee'
+    merged = @ordered_hash.merge other_hash
+    assert_equal merged.length, @ordered_hash.length + other_hash.length
+    assert_equal @keys + ['purple', 'violet'], merged.keys
+
+    @ordered_hash.merge! other_hash
+    assert_equal @ordered_hash, merged
+    assert_equal @ordered_hash.keys, merged.keys
+  end
+
+  def test_shift
+    pair = @ordered_hash.shift
+    assert_equal [@keys.first, @values.first], pair
+    assert !@ordered_hash.keys.include?(pair.first)
+  end
+
+  def test_keys
+    original = @ordered_hash.keys.dup
+    @ordered_hash.keys.pop
+    assert_equal original, @ordered_hash.keys
+  end
+
+  def test_inspect
+    assert @ordered_hash.inspect.include?(@hash.inspect)
+  end
+
+  def test_alternate_initialization_with_splat
+    alternate = Cassandra::OrderedHash[1,2,3,4]
+    assert_kind_of Cassandra::OrderedHash, alternate
+    assert_equal [1, 3], alternate.keys
+  end
+
+  def test_alternate_initialization_with_array
+    alternate = Cassandra::OrderedHash[ [
+      [1, 2],
+      [3, 4],
+      "bad key value pair",
+      [ 'missing value' ]
+    ]]
+
+    assert_kind_of Cassandra::OrderedHash, alternate
+    assert_equal [1, 3, 'missing value'], alternate.keys
+    assert_equal [2, 4, nil ], alternate.values
+  end
+
+  def test_alternate_initialization_raises_exception_on_odd_length_args
+    begin
+      alternate = Cassandra::OrderedHash[1,2,3,4,5]
+      flunk "Hash::[] should have raised an exception on initialization " +
+          "with an odd number of parameters"
+    rescue
+      assert_equal "odd number of arguments for Hash", $!.message
+    end
+  end
+
+  def test_replace_updates_keys
+    @other_ordered_hash = Cassandra::OrderedHash[:black, '000000', :white, '000000']
+    original = @ordered_hash.replace(@other_ordered_hash)
+    assert_same original, @ordered_hash
+    assert_equal @other_ordered_hash.keys, @ordered_hash.keys
+  end
+  
+  def test_reverse
+    assert_equal @keys.reverse, @ordered_hash.reverse.keys
+    assert_equal @values.reverse, @ordered_hash.reverse.values
+  end
+end
+
+class OrderedHashTest < Test::Unit::TestCase
+  def setup
+    @keys =   %w( blue   green  red    pink   orange )
+    @values = %w( 000099 009900 aa0000 cc0066 cc6633 )
+    @timestamps = %w( 12 34 56 78 90 )
+    @hash = Hash.new
+    @timestamps_hash = Hash.new
+    @ordered_hash = Cassandra::OrderedHash.new
+
+    @keys.each_with_index do |key, index|
+      @hash[key] = @values[index]
+      @timestamps_hash[key] = @timestamps[index]
+      @ordered_hash.[]=(key, @values[index], @timestamps[index])
+    end
+  end
+
+  def test_order
+    assert_equal @keys,   @ordered_hash.keys
+    assert_equal @values, @ordered_hash.values
+    assert_equal @timestamps_hash, @ordered_hash.timestamps
+  end
+
+  def test_access
+    assert @hash.all? { |k, v| @ordered_hash[k] == v }
+    assert @timestamps_hash.all? { |k, v| @ordered_hash.timestamps[k] == v }
+  end
+
+  def test_assignment
+    key, value, timestamp = 'purple', '5422a8', '1234'
+
+    @ordered_hash.[]=(key, value, timestamp)
+
+    assert_equal @keys.length + 1, @ordered_hash.length
+    assert_equal key, @ordered_hash.keys.last
+    assert_equal value, @ordered_hash.values.last
+    assert_equal value, @ordered_hash[key]
+
+    assert_equal @keys.length + 1, @ordered_hash.timestamps.length
+    assert_equal key, @ordered_hash.timestamps.keys.last
+    assert_equal timestamp, @ordered_hash.timestamps.values.last
+    assert_equal timestamp, @ordered_hash.timestamps[key]
+  end
+
+  def test_delete
+    key, value, timestamp = 'white', 'ffffff', '999'
+    bad_key = 'black'
+
+    @ordered_hash.[]=(key, value, timestamp)
+    assert_equal @keys.length + 1, @ordered_hash.length
+    assert_equal @ordered_hash.keys.length, @ordered_hash.length
+
+    assert_equal value, @ordered_hash.delete(key)
+    assert_equal @keys.length, @ordered_hash.length
+    assert_equal @ordered_hash.keys.length, @ordered_hash.length
+
+    assert_nil @ordered_hash.delete(bad_key)
+
+    @ordered_hash.[]=(key, value, timestamp)
+    assert_equal @keys.length + 1, @ordered_hash.timestamps.length
+    assert_equal @ordered_hash.keys.length, @ordered_hash.timestamps.length
+
+    assert_equal value, @ordered_hash.delete(key)
+    assert_equal @keys.length, @ordered_hash.timestamps.length
+    assert_equal @ordered_hash.keys.length, @ordered_hash.timestamps.length
+
+    assert_nil @ordered_hash.delete(bad_key)
+  end
+
+  def test_to_a
+    assert_equal @keys.zip(@timestamps).sort, @ordered_hash.timestamps.sort.to_a
+  end
+
+  def test_has_key
+    assert_equal true, @ordered_hash.timestamps.has_key?('blue')
+    assert_equal true, @ordered_hash.timestamps.key?('blue')
+    assert_equal true, @ordered_hash.timestamps.include?('blue')
+    assert_equal true, @ordered_hash.timestamps.member?('blue')
+
+    assert_equal false, @ordered_hash.timestamps.has_key?('indigo')
+    assert_equal false, @ordered_hash.timestamps.key?('indigo')
+    assert_equal false, @ordered_hash.timestamps.include?('indigo')
+    assert_equal false, @ordered_hash.timestamps.member?('indigo')
+  end
+
+  def test_has_value
+    assert_equal true, @ordered_hash.timestamps.has_value?('12')
+    assert_equal true, @ordered_hash.timestamps.value?('12')
+    assert_equal false, @ordered_hash.timestamps.has_value?('99')
+    assert_equal false, @ordered_hash.timestamps.value?('99')
+  end
+
+  def test_each_key
+    keys = []
+    @ordered_hash.timestamps.each_key { |k| keys << k }
+    assert_equal @keys.sort, keys.sort
+  end
+
+  def test_each_value
+    values = []
+    @ordered_hash.timestamps.each_value { |v| values << v }
+    assert_equal @timestamps.sort, values.sort
+  end
+
+  def test_each
+    values = []
+    @ordered_hash.timestamps.each {|key, value| values << value}
+    assert_equal @timestamps.sort, values.sort
+  end
+
+  def test_delete_if
+    copy = @ordered_hash.dup
+    copy.delete('pink')
+    assert_equal copy, @ordered_hash.delete_if { |k, _| k == 'pink' }
+    assert !@ordered_hash.timestamps.keys.include?('pink')
+  end
+
+  def test_reject!
+    (copy = @ordered_hash.dup).delete('pink')
+    @ordered_hash.reject! { |k, _| k == 'pink' }
+    assert_equal copy, @ordered_hash
+    assert !@ordered_hash.keys.include?('pink')
+    assert !@ordered_hash.timestamps.keys.include?('pink')
+  end
+
+  def test_reject
+    copy = @ordered_hash.dup
+    new_ordered_hash = @ordered_hash.reject { |k, _| k == 'pink' }
+    assert_equal copy, @ordered_hash
+    assert !new_ordered_hash.timestamps.keys.include?('pink')
+    assert @ordered_hash.timestamps.keys.include?('pink')
+  end
+
+  def test_clear
+    @ordered_hash.clear
+    assert_equal [], @ordered_hash.timestamps.keys
+  end
+
+  def test_merge
+    other_hash =  Cassandra::OrderedHash.new
+    other_hash['purple'] = '800080'
+    other_hash['violet'] = 'ee82ee'
+    merged = @ordered_hash.merge other_hash
+    assert_equal merged.timestamps.length, @ordered_hash.timestamps.length + other_hash.timestamps.length
+    assert_equal (@keys + ['purple', 'violet']).sort, merged.timestamps.keys.sort
+
+    @ordered_hash.merge! other_hash
+    assert_equal @ordered_hash.timestamps, merged.timestamps
+    assert_equal @ordered_hash.timestamps.keys.sort, merged.timestamps.keys.sort
+  end
+
+  def test_shift
+    pair = @ordered_hash.shift
+    assert_equal [@keys.first, @values.first], pair
+    assert !@ordered_hash.timestamps.keys.include?(pair.first)
+  end
+
+  def test_keys
+    original = @ordered_hash.keys.dup
+    @ordered_hash.keys.pop
+    assert_equal original.sort, @ordered_hash.timestamps.keys.sort
+  end
+
+  def test_inspect
+    assert @ordered_hash.timestamps.sort.inspect.include?(@timestamps_hash.sort.inspect)
+  end
+
+  def test_alternate_initialization_with_splat
+    alternate = Cassandra::OrderedHash[1,2,3,4]
+    assert_kind_of Cassandra::OrderedHash, alternate
+    assert_equal [1, 3], alternate.timestamps.keys
+  end
+
+  def test_replace_updates_keys
+    @other_ordered_hash = Cassandra::OrderedHash[:black, '000000', :white, '000000']
+    original = @ordered_hash.replace(@other_ordered_hash)
+    assert_equal original.timestamps, @ordered_hash.timestamps
+    assert_equal @other_ordered_hash.timestamps.keys, @ordered_hash.timestamps.keys
+  end
+end