jamesgolick-cassandra 0.8.2

data/lib/cassandra/ordered_hash.rb

@@ -0,0 +1,141 @@
+# OrderedHash is namespaced to prevent conflicts with other implementations
+class Cassandra
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION >= '1.9'
+    OrderedHash = ::Hash
+  else
+    class OrderedHash < Hash #:nodoc:
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def self.[](*args)
+        ordered_hash = new
+
+        if (args.length == 1 && args.first.is_a?(Array))
+          args.first.each do |key_value_pair|
+            next unless (key_value_pair.is_a?(Array))
+            ordered_hash[key_value_pair[0]] = key_value_pair[1]
+          end
+
+          return ordered_hash
+        end
+
+        unless (args.size % 2 == 0)
+          raise ArgumentError.new("odd number of arguments for Hash")
+        end
+
+        args.each_with_index do |val, ind|
+          next if (ind % 2 != 0)
+          ordered_hash[val] = args[ind + 1]
+        end
+
+        ordered_hash
+      end
+
+      def initialize_copy(other)
+        super
+        # make a deep copy of keys
+        @keys = other.keys
+      end
+
+      def []=(key, value)
+        @keys << key if !has_key?(key)
+        super
+      end
+
+      def delete(key)
+        if has_key? key
+          index = @keys.index(key)
+          @keys.delete_at index
+        end
+        super
+      end
+      
+      def delete_if
+        super
+        sync_keys!
+        self
+      end
+
+      def reject!
+        super
+        sync_keys!
+        self
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def keys
+        @keys.dup
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+
+      def to_hash
+        self
+      end
+
+      def to_a
+        @keys.map { |key| [ key, self[key] ] }
+      end
+
+      def each_key
+        @keys.each { |key| yield key }
+      end
+
+      def each_value
+        @keys.each { |key| yield self[key]}
+      end
+
+      def each
+        @keys.each {|key| yield [key, self[key]]}
+      end
+
+      alias_method :each_pair, :each
+
+      def clear
+        super
+        @keys.clear
+        self
+      end
+
+      def shift
+        k = @keys.first
+        v = delete(k)
+        [k, v]
+      end
+
+      def merge!(other_hash)
+        other_hash.each {|k,v| self[k] = v }
+        self
+      end
+
+      def merge(other_hash)
+        dup.merge!(other_hash)
+      end
+
+      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+      def replace(other)
+        super
+        @keys = other.keys
+        self
+      end
+
+      def inspect
+        "#<OrderedHash #{super}>"
+      end
+
+    private
+
+      def sync_keys!
+        @keys.delete_if {|k| !has_key?(k)}
+      end
+    end
+  end
+end

data/lib/cassandra/protocol.rb

@@ -0,0 +1,92 @@
+
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+    private
+
+    def _mutate(mutation_map, consistency_level)
+      client.batch_mutate(@keyspace, mutation_map, consistency_level)
+    end
+
+    def _remove(key, column_path, timestamp, consistency_level)
+      client.remove(@keyspace, key, column_path, timestamp, consistency_level)
+    end
+
+    def _count_columns(column_family, key, super_column, consistency)
+      client.get_count(@keyspace, key,
+        CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+        consistency
+      )
+    end
+
+    def _get_columns(column_family, key, columns, sub_columns, consistency)
+      result = if is_super(column_family)
+        if sub_columns
+          columns_to_hash(column_family, client.get_slice(@keyspace, key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => columns),
+            CassandraThrift::SlicePredicate.new(:column_names => sub_columns),
+            consistency))
+        else
+          columns_to_hash(column_family, client.get_slice(@keyspace, key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family),
+            CassandraThrift::SlicePredicate.new(:column_names => columns),
+            consistency))
+        end
+      else
+        columns_to_hash(column_family, client.get_slice(@keyspace, key,
+          CassandraThrift::ColumnParent.new(:column_family => column_family),
+          CassandraThrift::SlicePredicate.new(:column_names => columns),
+          consistency))
+      end
+
+      klass = column_name_class(column_family)
+      (sub_columns || columns).map { |name| result[klass.new(name)] }
+    end
+
+    def _multiget(column_family, keys, column, sub_column, count, start, finish, reversed, consistency)
+      # Single values; count and range parameters have no effect
+      if is_super(column_family) and sub_column
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column)
+        multi_column_to_hash!(client.multiget(@keyspace, keys, column_path, consistency))
+      elsif !is_super(column_family) and column
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column)
+        multi_column_to_hash!(client.multiget(@keyspace, keys, column_path, consistency))
+
+      # Slices
+      else
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range => 
+          CassandraThrift::SliceRange.new(
+            :reversed => reversed, 
+            :count => count, 
+            :start => start, 
+            :finish => finish))
+        
+        if is_super(column_family) and column
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+          multi_sub_columns_to_hash!(column_family, client.multiget_slice(@keyspace, keys, column_parent, predicate, consistency))
+        else
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+          multi_columns_to_hash!(column_family, client.multiget_slice(@keyspace, keys, column_parent, predicate, consistency))
+        end
+      end
+    end
+
+    def _get_range(column_family, start, finish, count, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
+      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
+      client.get_range_slices(@keyspace, column_parent, predicate, range, 1)
+    end
+    
+    def _get_range_keys(column_family, start, finish, count, consistency)
+      _get_range(column_family, start, finish, count, consistency).collect{|i| i.key }
+    end
+
+    def each_key(column_family)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family.to_s)
+      predicate = CassandraThrift::SlicePredicate.new(:column_names => [])
+      range = CassandraThrift::KeyRange.new(:start_key => '', :end_key => '')
+      client.get_range_slices(@keyspace, column_parent, predicate, range, 1).each{|i| yield i.key }
+    end
+  end
+end

data/lib/cassandra/time.rb

@@ -0,0 +1,11 @@
+
+class Time
+  def self.stamp
+    Time.now.stamp
+  end
+  
+  def stamp
+    to_i * 1_000_000 + usec
+  end
+end
+        

data/test/cassandra_client_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class CassandraClientTest < Test::Unit::TestCase
+  include Cassandra::Constants
+  
+  def setup
+    @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :exception_classes => [])
+  end
+  
+  def test_client_method_is_called
+    assert_nil @twitter.instance_variable_get(:@client)
+    @twitter.insert(:Statuses, key, {'1' => 'v', '2' => 'v', '3' => 'v'})
+    assert_not_nil @twitter.instance_variable_get(:@client)
+  end
+  
+  def key
+    caller.first[/`(.*?)'/, 1]
+  end
+  
+end

data/test/cassandra_mock_test.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require 'cassandra_test'
+require 'cassandra/mock'
+
+class CassandraMockTest < CassandraTest
+  include Cassandra::Constants
+
+  def setup
+    storage_xml_path = File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'conf', 'storage-conf.xml'))
+    @twitter = Cassandra::Mock.new('Twitter', storage_xml_path)
+    @twitter.clear_keyspace!
+
+    @blogs = Cassandra::Mock.new('Multiblog', storage_xml_path)
+    @blogs.clear_keyspace!
+
+    @blogs_long = Cassandra::Mock.new('MultiblogLong', storage_xml_path)
+    @blogs_long.clear_keyspace!
+
+    @uuids = (0..6).map {|i| SimpleUUID::UUID.new(Time.at(2**(24+i))) }
+    @longs = (0..6).map {|i| Long.new(Time.at(2**(24+i))) }
+  end
+
+  def test_setup
+    assert @twitter
+    assert @blogs
+    assert @blogs_long
+  end
+  
+  def test_schema_for_keyspace
+    data = {
+      "StatusRelationships"=>{
+          "CompareSubcolumnsWith"=>"org.apache.cassandra.db.marshal.TimeUUIDType", 
+          "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
+          "Type"=>"Super"},
+      "StatusAudits"=>{
+        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
+        "Type"=>"Standard"}, 
+      "Statuses"=>{
+        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
+        "Type"=>"Standard"}, 
+      "UserRelationships"=>{
+        "CompareSubcolumnsWith"=>"org.apache.cassandra.db.marshal.TimeUUIDType", 
+        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
+        "Type"=>"Super"}, 
+      "UserAudits"=>{
+        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type", 
+        "Type"=>"Standard"},
+      "Users"=>{"CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type", "Type"=>"Standard"},
+      "TimelinishThings"=>
+        {"CompareWith"=>"org.apache.cassandra.db.marshal.BytesType", "Type"=>"Standard"}
+    }
+    stuff = @twitter.send(:schema_for_keyspace, 'Twitter')
+    data.keys.each do |k|
+      assert_equal data[k], stuff[k], k
+    end
+  end
+
+  def test_sorting_row_keys
+    @twitter.insert(:Statuses, 'b', {:text => 'foo'})
+    @twitter.insert(:Statuses, 'a', {:text => 'foo'})
+    assert_equal ['a'], @twitter.get_range(:Statuses, :count => 1)
+  end
+
+  def test_inserting_array_for_indices
+    @twitter.insert(:TimelinishThings, 'a', ['1','2'])
+    row = @twitter.get(:TimelinishThings, 'a')
+    assert_equal({'1' => nil, '2' => nil}, row)
+
+    assert_raises(ArgumentError) {
+      @twitter.insert(:UserRelationships, 'a', ['u1','u2'])
+    }
+  end
+end

data/test/cassandra_test.rb

@@ -0,0 +1,370 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class CassandraTest < Test::Unit::TestCase
+  include Cassandra::Constants
+
+  def setup
+    @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :exception_classes => [])
+    @twitter.clear_keyspace!
+
+    @blogs = Cassandra.new('Multiblog')
+    @blogs.clear_keyspace!
+
+    @blogs_long = Cassandra.new('MultiblogLong')
+    @blogs_long.clear_keyspace!
+
+    @uuids = (0..6).map {|i| SimpleUUID::UUID.new(Time.at(2**(24+i))) }
+    @longs = (0..6).map {|i| Long.new(Time.at(2**(24+i))) }
+  end
+
+  def test_inspect
+    assert_nothing_raised do
+      @blogs.inspect
+      @twitter.inspect
+    end
+  end
+
+  def test_get_key
+    @twitter.insert(:Users, key, {'body' => 'v', 'user' => 'v'})
+    assert_equal({'body' => 'v', 'user' => 'v'}, @twitter.get(:Users, key))
+    assert_equal({}, @twitter.get(:Users, 'bogus'))
+  end
+
+  def test_get_key_preserving_order
+    # In-order hash is preserved
+    hash = OrderedHash['a', '', 'b', '', 'c', '', 'd', '',]
+    @twitter.insert(:Users, key, hash)
+    assert_equal(hash.keys, @twitter.get(:Users, key).keys)
+
+    @twitter.remove(:Users, key)
+
+    # Out-of-order hash is returned sorted
+    hash = OrderedHash['b', '', 'c', '', 'd', '', 'a', '']
+    @twitter.insert(:Users, key, hash)
+    assert_equal(hash.keys.sort, @twitter.get(:Users, key).keys)
+    assert_not_equal(hash.keys, @twitter.get(:Users, key).keys)
+  end
+
+  def test_get_first_time_uuid_column
+    @blogs.insert(:Blogs, key, 
+      {@uuids[0] => 'I like this cat', @uuids[1] => 'Buttons is cuter', @uuids[2] => 'I disagree'})
+    
+    assert_equal({@uuids[0] => 'I like this cat'}, @blogs.get(:Blogs, key, :count => 1))
+    assert_equal({@uuids[2] => 'I disagree'}, @blogs.get(:Blogs, key, :count => 1, :reversed => true))
+    assert_equal({}, @blogs.get(:Blogs, 'bogus'))
+  end
+
+  def test_get_multiple_time_uuid_columns
+    @blogs.insert(:Blogs, key,
+      {@uuids[0] => 'I like this cat', @uuids[1] => 'Buttons is cuter', @uuids[2] => 'I disagree'})
+
+    assert_equal(['I like this cat', 'Buttons is cuter'], @blogs.get_columns(:Blogs, key, @uuids[0..1]))
+  end
+
+  def test_get_first_long_column
+    @blogs_long.insert(:Blogs, key, 
+      {@longs[0] => 'I like this cat', @longs[1] => 'Buttons is cuter', @longs[2] => 'I disagree'})
+
+    assert_equal({@longs[0] => 'I like this cat'}, @blogs_long.get(:Blogs, key, :count => 1))
+    assert_equal({@longs[2] => 'I disagree'}, @blogs_long.get(:Blogs, key, :count => 1, :reversed => true))
+    assert_equal({}, @blogs_long.get(:Blogs, 'bogus'))
+  end
+
+  def test_long_remove_bug
+    @blogs_long.insert(:Blogs, key, {@longs[0] => 'I like this cat'})
+    @blogs_long.remove(:Blogs, key)
+    assert_equal({}, @blogs_long.get(:Blogs, key, :count => 1))
+
+    @blogs_long.insert(:Blogs, key, {@longs[0] => 'I really like this cat'})
+    assert_equal({@longs[0] => 'I really like this cat'}, @blogs_long.get(:Blogs, key, :count => 1))
+  end
+
+  def test_get_with_count
+    @twitter.insert(:Statuses, key, {'1' => 'v', '2' => 'v', '3' => 'v'})
+    assert_equal 1, @twitter.get(:Statuses, key, :count => 1).size
+    assert_equal 2, @twitter.get(:Statuses, key, :count => 2).size
+  end
+
+  def test_get_value
+    @twitter.insert(:Statuses, key, {'body' => 'v'})
+    assert_equal 'v', @twitter.get(:Statuses, key, 'body')
+    assert_nil @twitter.get(:Statuses, 'bogus', 'body')
+
+    assert @twitter.exists?(:Statuses, key, 'body')
+    assert !@twitter.exists?(:Statuses, 'bogus', 'body')
+  end
+
+  def test_exists_with_only_key
+    @twitter.insert(:Statuses, key, {'body' => 'v'})
+    assert @twitter.exists?(:Statuses, key)
+  end
+
+  def test_get_super_key
+    columns = {'user_timelines' => {@uuids[4] => '4', @uuids[5] => '5'}}
+    @twitter.insert(:StatusRelationships, key, columns)
+    assert_equal(columns, @twitter.get(:StatusRelationships, key))
+    assert_equal({}, @twitter.get(:StatusRelationships, 'bogus'))
+  end
+
+  def test_get_several_super_keys
+    columns = {
+      'user_timelines' => {@uuids[1]  => 'v1'},
+      'mentions_timelines' => {@uuids[2]  => 'v2'}}
+    @twitter.insert(:StatusRelationships, key, columns)
+
+    assert_equal(columns, @twitter.get(:StatusRelationships, key))
+    assert_equal({}, @twitter.get(:StatusRelationships, 'bogus'))
+  end
+
+  def test_get_super_sub_keys_with_count
+    @twitter.insert(:StatusRelationships, key,
+      {'user_timelines' => {@uuids[1]  => 'v1', @uuids[2]  => 'v2', @uuids[3]  => 'v3'}})
+    assert_equal({@uuids[1]  => 'v1'},
+      @twitter.get(:StatusRelationships, key, "user_timelines", :count => 1))
+    assert_equal({@uuids[3]  => 'v3'},
+      @twitter.get(:StatusRelationships, key, "user_timelines", :count => 1, :reversed => true))
+  end
+
+  def test_get_super_sub_keys_with_ranges
+    @twitter.insert(:StatusRelationships, key,
+      {'user_timelines' => {
+        @uuids[1] => 'v1',
+        @uuids[2] => 'v2',
+        @uuids[3] => 'v3',
+        @uuids[4] => 'v4',
+        @uuids[5] => 'v5'}})
+
+    keys = @twitter.get(:StatusRelationships, key, "user_timelines").keys
+    assert_equal keys.sort, keys
+    assert_equal({@uuids[1] => 'v1'}, @twitter.get(:StatusRelationships, key, "user_timelines", :finish => @uuids[2], :count => 1))
+    assert_equal({@uuids[2] => 'v2'}, @twitter.get(:StatusRelationships, key, "user_timelines", :start => @uuids[2], :count => 1))
+    assert_equal 4, @twitter.get(:StatusRelationships, key, "user_timelines", :start => @uuids[2], :finish => @uuids[5]).size
+  end
+
+  def test_get_super_sub_key
+    columns = {@uuids[1] => 'v1', @uuids[2] => 'v2'}
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
+    assert_equal(columns, @twitter.get(:StatusRelationships, key, 'user_timelines'))
+    assert_equal({}, @twitter.get(:StatusRelationships, 'bogus', 'user_timelines'))
+    # FIXME Not sure if this is valid
+    # assert_nil @twitter.exists?(:StatusRelationships, 'bogus', 'user_timelines')
+  end
+
+  def test_get_super_value
+    columns = {@uuids[1] => 'v1'}
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
+    assert_equal('v1', @twitter.get(:StatusRelationships, key, 'user_timelines', columns.keys.first))
+    assert_nil @twitter.get(:StatusRelationships, 'bogus', 'user_timelines', columns.keys.first)
+  end
+
+
+  #TODO: add a OPP keyspace for this
+  # def test_get_range
+  #   @twitter.insert(:Statuses, '2', {'body' => '1'})
+  #   @twitter.insert(:Statuses, '3', {'body' => '1'})
+  #   @twitter.insert(:Statuses, '4', {'body' => '1'})
+  #   @twitter.insert(:Statuses, '5', {'body' => '1'})
+  #   @twitter.insert(:Statuses, '6', {'body' => '1'})
+  #   assert_equal(['3', '4', '5'], @twitter.get_range(:Statuses, :start => '3', :finish => '5'))
+  # end
+  
+  def test_get_range_count
+     @twitter.insert(:Statuses, '2', {'body' => '1'})
+     @twitter.insert(:Statuses, '3', {'body' => '1'})
+     @twitter.insert(:Statuses, '4', {'body' => '1'})
+     @twitter.insert(:Statuses, '5', {'body' => '1'})
+     @twitter.insert(:Statuses, '6', {'body' => '1'})
+     assert_equal(3, @twitter.get_range(:Statuses, :count => 3).size)
+  end
+
+  def test_multi_get
+    @twitter.insert(:Users, key + '1', {'body' => 'v1', 'user' => 'v1'})
+    @twitter.insert(:Users, key + '2', {'body' => 'v2', 'user' => 'v2'})
+
+    expected = OrderedHash[key + '1', {'body' => 'v1', 'user' => 'v1'}, key + '2', {'body' => 'v2', 'user' => 'v2'}, 'bogus', {}]
+    result = @twitter.multi_get(:Users, [key + '1', key + '2', 'bogus'])
+    assert_equal expected, result
+    assert_equal expected.keys, result.keys
+
+    expected = OrderedHash[key + '2', {'body' => 'v2', 'user' => 'v2'}, 'bogus', {}, key + '1', {'body' => 'v1', 'user' => 'v1'}]
+    result = @twitter.multi_get(:Users, [key + '2', 'bogus', key + '1'])
+    assert_equal expected, result
+    assert_equal expected.keys, result.keys
+  end
+
+  def test_remove_key
+    @twitter.insert(:Statuses, key, {'body' => 'v'})
+    assert_equal({'body' => 'v'}, @twitter.get(:Statuses, key))
+
+    @twitter.remove(:Statuses, key)
+    assert_equal({}, @twitter.get(:Statuses, key))
+  end
+
+  def test_remove_value
+    @twitter.insert(:Statuses, key, {'body' => 'v'})
+    @twitter.remove(:Statuses, key, 'body')
+    assert_nil @twitter.get(:Statuses, key, 'body')
+  end
+
+  def test_remove_super_key
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {@uuids[1] => 'v1'}})
+    @twitter.remove(:StatusRelationships, key)
+    assert_equal({}, @twitter.get(:StatusRelationships, key))
+  end
+
+  def test_remove_super_sub_key
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {@uuids[1] => 'v1'}})
+    @twitter.remove(:StatusRelationships, key, 'user_timelines')
+    assert_equal({}, @twitter.get(:StatusRelationships, key, 'user_timelines'))
+  end
+
+  def test_remove_super_value
+    columns = {@uuids[1] => 'v1'}
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
+    @twitter.remove(:StatusRelationships, key, 'user_timelines', columns.keys.first)
+    assert_nil @twitter.get(:StatusRelationships, key, 'user_timelines', columns.keys.first)
+  end
+
+  def test_clear_column_family
+    @twitter.insert(:Statuses, key + "1", {'body' => '1'})
+    @twitter.insert(:Statuses, key + "2", {'body' => '2'})
+    @twitter.insert(:Statuses, key + "3", {'body' => '3'})
+    @twitter.clear_column_family!(:Statuses)
+    assert_equal 0, @twitter.count_range(:Statuses)
+  end
+
+  def test_insert_key
+    @twitter.insert(:Statuses, key, {'body' => 'v', 'user' => 'v'})
+    assert_equal({'body' => 'v', 'user' => 'v'}, @twitter.get(:Statuses, key))
+  end
+
+  def test_insert_super_key
+    columns = {@uuids[1] => 'v1', @uuids[2] => 'v2'}
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
+    assert_equal(columns, @twitter.get(:StatusRelationships, key, 'user_timelines'))
+  end
+
+  def test_get_columns
+    @twitter.insert(:Statuses, key, {'body' => 'v1', 'user' => 'v2'})
+    assert_equal(['v1' , 'v2'], @twitter.get_columns(:Statuses, key, ['body', 'user']))
+  end
+
+  def test_get_column_values_super
+    user_columns, mentions_columns = {@uuids[1] => 'v1'}, {@uuids[2] => 'v2'}
+    @twitter.insert(:StatusRelationships, key,
+      {'user_timelines' => user_columns, 'mentions_timelines' => mentions_columns})
+    assert_equal [user_columns, mentions_columns],
+      @twitter.get_columns(:StatusRelationships, key, ['user_timelines', 'mentions_timelines'])
+  end
+
+  def test_get_sub_column_values_super
+    user_columns = {@uuids[1] => 'v1', @uuids[2] => 'v2'}
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => user_columns})
+    assert_equal ['v1', 'v2'],
+      @twitter.get_columns(:StatusRelationships, key, 'user_timelines', @uuids[1..2])
+  end
+
+  def test_multi_get_columns
+    @twitter.insert(:Users, key + '1', {'body' => 'v1', 'user' => 'v1'})
+    @twitter.insert(:Users, key + '2', {'body' => 'v2', 'user' => 'v2'})
+    assert_equal(
+      OrderedHash[key + '1', ['v1', 'v1'], key + '2', ['v2', 'v2'], 'bogus', [nil, nil]],
+      @twitter.multi_get_columns(:Users, [key + '1', key + '2', 'bogus'], ['body', 'user']))
+    assert_equal(
+      OrderedHash[key + '2', ['v2', 'v2'], 'bogus', [nil, nil], key + '1', ['v1', 'v1']],
+      @twitter.multi_get_columns(:Users, [key + '2', 'bogus', key + '1'], ['body', 'user']))
+  end
+
+  def test_count_keys
+    @twitter.insert(:Statuses, key + "1", {'body' => '1'})
+    @twitter.insert(:Statuses, key + "2", {'body' => '2'})
+    @twitter.insert(:Statuses, key + "3", {'body' => '3'})
+    assert_equal 3, @twitter.count_range(:Statuses)
+  end
+
+  def test_count_columns
+    @twitter.insert(:Statuses, key, {'body' => 'v1', 'user' => 'v2'})
+    assert_equal 2, @twitter.count_columns(:Statuses, key)
+  end
+
+  def test_count_super_columns
+    @twitter.insert(:StatusRelationships, key, {
+      'user_timelines' => {@uuids[1] => 'v1'},
+      'mentions_timelines' => {@uuids[2] => 'v2'}})
+    assert_equal 2, @twitter.count_columns(:StatusRelationships, key)
+  end
+
+  def test_count_super_sub_columns
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {@uuids[1] => 'v1', @uuids[2] => 'v2'}})
+    assert_equal 2, @twitter.count_columns(:StatusRelationships, key, 'user_timelines')
+  end
+
+  def test_multi_count_columns
+    @twitter.insert(:Users, key + '1', {'body' => 'v1', 'user' => 'v1'})
+    @twitter.insert(:Users, key + '2', {'body' => 'v2', 'user' => 'v2'})
+    assert_equal(
+      OrderedHash[key + '1', 2, key + '2', 2, 'bogus', 0],
+      @twitter.multi_count_columns(:Users, [key + '1', key + '2', 'bogus']))
+    assert_equal(
+      OrderedHash[key + '2', 2, 'bogus', 0, key + '1', 2],
+      @twitter.multi_count_columns(:Users, [key + '2', 'bogus', key + '1']))
+  end
+
+  def test_batch_mutate
+    k = key
+
+    @twitter.insert(:Users, k + '1', {'body' => 'v1', 'user' => 'v1'})
+
+    @twitter.batch do
+      @twitter.insert(:Users, k + '2', {'body' => 'v2', 'user' => 'v2'})
+      @twitter.insert(:Users, k + '3', {'body' => 'bogus', 'user' => 'v3'})
+      @twitter.insert(:Users, k + '3', {'body' => 'v3', 'location' => 'v3'})
+      @twitter.insert(:Statuses, k + '3', {'body' => 'v'})
+
+      assert_equal({'body' => 'v1', 'user' => 'v1'}, @twitter.get(:Users, k + '1')) # Written
+      assert_equal({}, @twitter.get(:Users, k + '2')) # Not yet written
+      assert_equal({}, @twitter.get(:Statuses, k + '3')) # Not yet written
+
+      @twitter.remove(:Users, k + '1')
+      assert_equal({'body' => 'v1', 'user' => 'v1'}, @twitter.get(:Users, k + '1')) # Not yet removed
+
+      @twitter.remove(:Users, k + '4')
+      @twitter.insert(:Users, k + '4', {'body' => 'v4', 'user' => 'v4'})
+      assert_equal({}, @twitter.get(:Users, k + '4')) # Not yet written
+    end
+
+    assert_equal({'body' => 'v2', 'user' => 'v2'}, @twitter.get(:Users, k + '2')) # Written
+    assert_equal({'body' => 'v3', 'user' => 'v3', 'location' => 'v3'}, @twitter.get(:Users, k + '3')) # Written and compacted
+    assert_equal({'body' => 'v4', 'user' => 'v4'}, @twitter.get(:Users, k + '4')) # Written
+    assert_equal({'body' => 'v'}, @twitter.get(:Statuses, k + '3')) # Written
+    assert_equal({}, @twitter.get(:Users, k + '1')) # Removed
+  end
+
+  def test_complain_about_nil_key
+    assert_raises(ArgumentError) do
+      @twitter.insert(:Statuses, nil, {'text' => 'crap'})
+    end
+  end
+
+  def test_raise_access_error_on_nonexistent_keyspace
+    nonexistent = Cassandra.new('Nonexistent')
+    assert_raises(Cassandra::AccessError) do
+      nonexistent.get "foo", "bar"
+    end
+  end
+
+  def test_nil_sub_column_value
+    @twitter.insert(:Index, 'asdf', {"thing" => {'jkl' => nil} })
+  end
+
+  def test_disconnect!
+    @twitter.disconnect!
+    assert_nil @twitter.instance_variable_get(:@client)
+  end
+
+  private
+
+  def key
+    caller.first[/`(.*?)'/, 1]
+  end
+end