cassandra_mapper 0.0.1

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'cassandra_mapper'
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+

data/test/unit/callbacks_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class CallbacksTest < Test::Unit::TestCase
+  context 'A CassandraModel::Base-derived instance' do
+    setup do
+      @class = Class.new(CassandraMapper::Base) do
+        before_save   :do_before_save
+        after_save    :do_after_save
+        before_create :do_before_create
+        after_create  :do_after_create
+        before_update :do_before_update
+        after_update  :do_after_update
+        before_destroy :do_before_destroy
+        after_destroy  :do_after_destroy
+      end
+      @instance = @class.new
+      @connection = stub('connection')
+      @instance.stubs(:connection).returns(@connection)
+      @sequence = sequence('invocation_sequence')
+      @simple_representation = {}
+      @instance.stubs(:to_simple).returns(@simple_representation)
+      @instance.stubs(:key).returns(:foo)
+      # intercept freeze invocations to prevent Mocha teardown errors
+      @instance.stubs(:freeze)
+    end
+
+    context 'first save' do
+      setup do
+        @instance.stubs(:new_record?).returns(true)
+      end
+
+      should 'invoke the before_save, before_create, after_create, after_save callbacks' do
+        @instance.expects(:do_before_save).in_sequence(@sequence).returns(true)
+        @instance.expects(:do_before_create).in_sequence(@sequence).returns(true)
+        @connection.expects(:insert).in_sequence(@sequence).returns(@instance)
+        @instance.expects(:do_after_create).in_sequence(@sequence).returns(true)
+        @instance.expects(:do_after_save).in_sequence(@sequence).returns(true)
+        @instance.save
+      end
+    end
+
+    context 'update' do
+      setup do
+        @instance.stubs(:new_record?).returns(false)
+        @instance.stubs(:changed_attributes).returns([:blah])
+        # must provide an actual new value for an insert to take place
+        @simple_representation['blah'] = 'foo'
+      end
+
+      should 'invoke the before_save, before_update, after_update, after_save callbacks' do
+        @instance.expects(:do_before_save).in_sequence(@sequence).returns(true)
+        @instance.expects(:do_before_update).in_sequence(@sequence).returns(true)
+        @connection.expects(:insert).in_sequence(@sequence).returns(@instance)
+        @instance.expects(:do_after_update).in_sequence(@sequence).returns(true)
+        @instance.expects(:do_after_save).in_sequence(@sequence).returns(true)
+        @instance.save
+      end
+    end
+
+    context 'after being retrieved via :find' do
+      setup do
+        @key = 'some_key'
+        @class.maps :some_attr
+        @source_values = {'some_attr' => 'some_value'}
+        @connection = stub('connection', :multi_get => {@key => @source_values})
+        @class.stubs(:connection).returns(@connection)
+        @class.module_eval do
+          after_load :do_after_load
+
+          def do_after_load
+            self.class.after_load_invoked('some_attr' => some_attr)
+          end
+        end
+      end
+
+      should 'invoke the after_load callback' do
+        @class.expects(:after_load_invoked).with(@source_values)
+        @class.find(@key)
+      end
+    end
+
+    context 'destroy' do
+      should 'invoke the before_destroy and after_destroy callbacks on an existing row' do
+        @instance.stubs(:new_record?).returns(false)
+        @instance.expects(:do_before_destroy).once.in_sequence(@sequence).returns(true)
+        @class.expects(:delete).with(@instance.key).once.in_sequence(@sequence)
+        @instance.expects(:do_after_destroy).once.in_sequence(@sequence).returns(true)
+        @instance.destroy
+      end
+
+      should 'not invoke callbacks on a new row' do
+        @instance.stubs(:new_record?).returns(true)
+        @instance.expects(:do_before_destroy).never.in_sequence(@sequence)
+        @class.expects(:delete).with(@instance.key).never.in_sequence(@sequence)
+        @instance.expects(:do_after_destroy).never.in_sequence(@sequence)
+        @instance.destroy
+      end
+    end
+  end
+end

data/test/unit/identity_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class IdentityTest < Test::Unit::TestCase
+  context 'CassandraWrapper::Base' do
+    setup do
+      @class = Class.new(CassandraMapper::Base)
+      @values = {:a => 'Aa', :b => 'Bb', :c => 'Cc'}
+      @values.keys.each {|key| @class.maps key}
+      @instance = @class.new(@values)
+    end
+
+    context 'key attribute declaration' do
+      should 'be possible with the :key class method' do
+        @class.key :a
+        assert_equal :a, @class.key
+      end
+
+      should 'determine the :key value on an instance' do
+        @class.key :a
+        assert_equal @values[:a], @instance.key
+        @class.key :b
+        assert_equal @values[:b], @instance.key
+      end
+
+      should 'be overriddable with an instance method' do
+        @class.key :a
+        @class.module_eval do
+          def key
+            "#{a}-#{b}"
+          end
+        end
+        assert_equal "#{@values[:a]}-#{@values[:b]}", @instance.key 
+      end
+
+      should 'result in default of :key if left undeclared' do
+        assert_equal :key, @class.key
+      end
+    end
+
+    should 'default new_record? to true' do
+      assert_equal true, @instance.new_record?
+    end
+
+    should 'allow specification of new_record flag via assignment' do
+      @instance.new_record = false
+      assert_equal false, @instance.new_record?
+      @instance.new_record = true
+      assert_equal true, @instance.new_record?
+    end
+  end
+end

data/test/unit/indexing_test.rb

@@ -0,0 +1,406 @@
+require 'test_helper'
+class IndexingTest < Test::Unit::TestCase
+  context 'A CassandraMapper::Index' do
+    setup do
+      @class = CassandraMapper::Index
+    end
+
+    context 'with defaults' do
+      setup do
+        @instance = @class.new
+      end
+
+      should 'have a nil :indexed_class attribute' do
+        assert_equal nil, @instance.indexed_class
+      end
+
+      should 'have a nil :source attribute' do
+        assert_equal nil, @instance.source
+      end
+
+      should 'have a nil :column_family attribute' do
+        assert_equal nil, @instance.column_family
+      end
+
+      should 'have :key for :indexed_identifier' do
+        assert_equal :key, @instance.indexed_identifier
+      end
+
+      should 'have nil for :name attribute' do
+        assert_equal nil, @instance.name
+      end
+    end
+
+    context 'with constructor options' do
+      setup do
+        @options = {:column_family      => :SomeIndex,
+                    :indexed_class      => Class.new,
+                    :source             => :to_be_indexed,
+                    :indexed_identifier => :index_column,
+                    :name               => :some_index_name}
+        @instance = @class.new(@options)
+      end
+
+      should 'get :indexed_class attribute' do
+        assert_equal @options[:indexed_class], @instance.indexed_class
+      end
+
+      should 'get :source attribute' do
+        assert_equal @options[:source], @instance.source
+      end
+
+      should 'get :column_family attribute' do
+        assert_equal @options[:column_family], @instance.column_family
+      end
+
+      should 'get :indexed_identifier attribute' do
+        assert_equal @options[:indexed_identifier], @instance.indexed_identifier
+      end
+
+      should 'get :name attribute' do
+        assert_equal @options[:name], @instance.name
+      end
+    end
+
+    should 'retrieve :source_for(instance) from instance :source' do
+      instance = @class.new(:source => :some_source)
+      object = mock('object to be indexed')
+      object.expects(:some_source).with.returns('my source')
+      assert_equal 'my source', instance.source_for(object)
+    end
+
+    should 'retrieve :indexed_identifier_for(instance) from instance :indexed_identifier' do
+      instance = @class.new(:indexed_identifier => :some_identifier)
+      object = mock('object to be indexed')
+      object.expects(:some_identifier).with.returns('my identifier')
+      assert_equal 'my identifier', instance.indexed_identifier_for(object)
+    end
+
+    context 'indexing method' do
+      setup do
+        @name = :this_index_name
+        @column_family = stub('column_family')
+        @source = :index_source
+        @indexed_class = Class.new(CassandraMapper::Base)
+        @target_object = @indexed_class.new
+        @indexed_identifier = :index_identifier
+        @instance = @class.new(:name               => @name,
+                               :indexed_class      => @indexed_class,
+                               :column_family      => @column_family,
+                               :source             => @source,
+                               :indexed_identifier => @indexed_identifier)
+        @client = stub('cassandra_client')
+        @target_object.stubs(:connection).returns(@client)
+        @target_object.stubs(:key).with.returns(@object_key = 'some_object_identifier')
+        @target_object.stubs(@indexed_identifier).with.returns(@object_identifier = 'some_object_sortable_identifier')
+        @target_object_state = stub('target_object_index_state')
+        @target_object.stubs(@name).returns(@target_object_state)
+      end
+
+      context ':create' do
+        should 'insert the target source as key to the column family, with key as value' do
+          @instance.expects(:source_for).with(@target_object).returns(source_value = 'some_source_value')
+          @client.expects(:insert).with(@column_family, source_value, {@object_identifier => @object_key})
+          @target_object_state.expects(:source_value=).with(source_value)
+          @target_object_state.expects(:identifier_value=).with(@object_identifier)
+          @instance.create(@target_object)
+        end
+
+        should 'do nothing if the current index source is nil' do
+          @instance.expects(:source_for).with(@target_object).returns(nil)
+          @client.expects(:insert).never
+          @instance.create(@target_object)
+        end
+      end
+
+      context ':remove' do
+        should "remove the target object's old identifier value from the row at the old source" do
+          # use sequences to work around naming conflicts
+          @target_object_state.stubs(:source_value).with.returns(source_value = 'some_old_source_value')
+          @target_object_state.stubs(:identifier_value).with.returns(identifier_value = 'some_old_identifier_value')
+          @target_object_state.expects(:source_value=).with(nil)
+          @target_object_state.expects(:identifier_value=).with(nil)
+          @client.expects(:remove).with(@column_family, source_value, identifier_value)
+          @instance.remove(@target_object)
+        end
+
+        should 'do nothing if the old identifier value is nil' do
+          @target_object_state.stubs(:source_value).with.returns('some_old_source_value')
+          @target_object_state.expects(:identifier_value).with.returns(nil)
+          @target_object_state.expects(:source_value=).never
+          @target_object_state.expects(:identifier_value=).never
+          @client.expects(:remove).never
+          @instance.remove(@target_object)
+        end
+
+        should 'do nothing if the old source value is nil' do
+          @target_object_state.expects(:source_value).with.returns(nil)
+          @target_object_state.stubs(:identifier_value).with.returns('some_old_identifier_value')
+          @target_object_state.expects(:source_value=).never
+          @target_object_state.expects(:identifier_value=).never
+          @client.expects(:remove).never
+          @instance.remove(@target_object)
+        end
+      end
+
+      context ':update' do
+        should 'perform a :create and :remove if the source values differ' do
+          @target_object_state.stubs(:source_value).with.returns('some_old_source_value')
+          @instance.expects(:source_for).with(@target_object).returns('some_source_value').at_least_once
+          @target_object_state.stubs(:identifier_value).with.returns(@object_identifier)
+          seq = sequence('operations')
+          @instance.expects(:remove).with(@target_object).in_sequence(seq)
+          @instance.expects(:create).with(@target_object).in_sequence(seq)
+          @instance.update(@target_object)
+        end
+
+        should 'perform a :create and :remove if identifier values differ' do
+          @target_object_state.stubs(:source_value).with.returns('some_source_value')
+          @instance.stubs(:source_for).with(@target_object).returns('some_source_value')
+          @target_object_state.stubs(:identifier_value).with.returns('some_old_identifier_value')
+          @instance.expects(:indexed_identifier_for).with(@target_object).returns('some new identifier value').at_least_once
+          seq = sequence('operations')
+          @instance.expects(:remove).with(@target_object).in_sequence(seq)
+          @instance.expects(:create).with(@target_object).in_sequence(seq)
+          @instance.update(@target_object)
+        end
+
+        should 'do nothing if the values are unchanged' do
+          @target_object_state.expects(:source_value).with.returns('some_source_value')
+          @instance.expects(:source_for).with(@target_object).returns('some_source_value').at_least_once
+          @target_object_state.expects(:identifier_value).with.returns(@object_identifier)
+          @instance.expects(:indexed_identifier_for).with(@target_object).returns(@object_identifier).at_least_once
+          @instance.expects(:remove).never
+          @instance.expects(:create).never
+          @instance.update(@target_object)
+        end
+      end
+    end
+
+    context 'read method' do
+      setup do
+        @indexed_class = Class.new(CassandraMapper::Base) do
+          maps :key
+          maps :some_source_field
+        end
+        @column_family = :MyIndexes
+        @source_attrib = :some_source_field
+        @instance = @class.new(:indexed_class => @indexed_class,
+                              :column_family => @column_family,
+                              :source        => @source_attrib)
+        @connection = stub(:connection)
+        @indexed_class.stubs(:connection).returns(@connection)
+        # the order reflects insert order, so we need to be very explicit here
+        @expected = Cassandra::OrderedHash.new()
+        @expected['0000-id1'] = 'id1'
+        @expected['0001-id2'] = 'id2'
+        @sorted_ids = ['id1', 'id2']
+      end
+
+      context 'get' do
+        context 'for single indexed value' do
+          setup do
+            @key = 'this indexed value'
+          end
+
+          should 'perform Cassandra get for the given index value and return raw result' do
+            @connection.expects(:get).with(@column_family, @key, {}).returns(@expected)
+            result = @instance.get(@key)
+            assert_equal @expected, result
+          end
+
+          should 'pass any options along to the Cassandra.get invocation' do
+            options = {:count => 2, :start => 'foo'}
+            @connection.expects(:get).with(@column_family, @key, options).returns(@expected)
+            @instance.get(@key, options)
+          end
+        end
+
+        context 'for multiple indexed values' do
+          setup do
+            @keys = ['this indexed value', 'that indexed value', 'mine', 'yours']
+            @client_result = Cassandra::OrderedHash.new()
+            # the order reflects insert order, so we need to be explicit
+            @client_result['this indexed value'] = {'0000-id1' => 'id1'}
+            @client_result['that indexed value'] = {'0001-id2' => 'id2'}
+            @client_result['mine']               = {'aaaa-id1' => 'id1'}
+            @client_result['yours']              = {'bbbb-id2' => 'id2'}
+            @expected.merge!(@client_result['mine'])
+            @expected.merge!(@client_result['yours'])
+          end
+
+          should 'perform Cassandra.multi_get for multiple index values and return merged result' do
+            @connection.expects(:multi_get).with(@column_family, @keys, {}).returns(@client_result)
+            result = @instance.get(@keys)
+            assert_equal @expected, result
+          end
+
+          should 'pass any options along to underlying Cassandra.multi_get' do
+            options = {:count => 4, :finish => 'zzzzzyyyyzzzz'}
+            @connection.expects(:multi_get).with(@column_family, @keys, options).returns(@client_result)
+            @instance.get(@keys, options)
+          end
+        end
+      end
+
+      context 'keys' do
+        should 'retrieve data from :get and return identifiers based on result indexed id order' do
+          value = 'some value'
+          @instance.expects(:get).with(value, {}).returns(@expected)
+          result = @instance.keys(value)
+          assert_equal @sorted_ids, result
+        end
+
+        should 'collapse redundant identifiers down and preserve earliest order' do
+          value = 'some value'
+          @expected["aaaa-#{@sorted_ids[0]}"] = @sorted_ids[0]
+          @expected["bbbb-#{@sorted_ids[1]}"] = @sorted_ids[1]
+          @instance.expects(:get).with(value, {}).returns(@expected)
+          result = @instance.keys(value)
+          assert_equal @sorted_ids, result
+        end
+
+        should 'pass options through to :get' do
+          options = {:this => :that, :mine => :not_yours}
+          value = 'foo'
+          @instance.expects(:get).with(value, options).returns(@expected)
+          @instance.keys(value, options)
+        end
+      end
+
+      context 'objects' do
+        setup do
+          @expected_objects = @sorted_ids.collect {|id| @indexed_class.new(:key => id)}
+        end
+
+        should 'return results of a model class :find call with :keys as its arguments' do
+          @indexed_class.expects(:find).with(@sorted_ids, {:allow_missing => true}).returns(@expected_objects)
+          @instance.expects(:keys).with(value = 'foo', {}).returns(@sorted_ids)
+          result = @instance.objects(value)
+          assert_equal @expected_objects, result
+        end
+
+        should 'not call :find if :keys is empty, and return an empty array' do
+          @indexed_class.expects(:find).never
+          @instance.expects(:keys).with(value = 'foo', {}).returns([])
+          result = @instance.objects(value)
+          assert_equal [], result
+        end
+
+        should 'pass options through to :keys' do
+          @instance.expects(:keys).with(value = 'foo', options = {:this => :and, :that => :dude}).returns(@sorted_ids)
+          @indexed_class.expects(:find).with(@sorted_ids, {:allow_missing => true}).returns(@expected_objects)
+          @instance.objects(value, options)
+        end
+      end
+    end
+  end
+
+  context 'A Cassandra::Base-derived class' do
+    setup do
+      @class = Class.new(CassandraMapper::Base)
+    end
+    
+    context 'has_index method' do
+      should 'create a class accessor for the named index' do
+        assert_equal true, ! @class.respond_to?(:this_index)
+        @class.has_index :this_index
+        assert_equal true, @class.respond_to?(:this_index)
+      end
+
+      should 'set the :name attribute on the resulting index object' do
+        @class.has_index :this_index
+        assert_equal :this_index, @class.this_index.name
+      end
+
+      should 'determine class of index from the :class option' do
+        subclass = Class.new(CassandraMapper::Index)
+        @class.has_index :this_index, :class => subclass
+        assert_equal true, subclass === @class.this_index
+      end
+
+      should 'default class of index to CassandraMapper::Index' do
+        @class.has_index :this_index
+        assert_equal true, CassandraMapper::Index === @class.this_index
+      end
+
+      should 'pass all options, with :indexed_class mapped to indexed class, to the constructor' do
+        options = {:a => 'a', :b => 'b', :c => 'c'}
+        subclass = Class.new(CassandraMapper::Index)
+        subclass.expects(:new).with(options.merge(:indexed_class => @class,
+                                                  :name => :this_index)).returns(CassandraMapper::Index.new(options.merge(:indexed_class => @class)))
+        @class.has_index :this_index, options.merge(:class => subclass)
+      end
+
+      context 'given a block' do
+        should 'evaluate the block in the context of the new index object' do
+          received = []
+          @class.has_index :this_index do
+            received << self
+          end
+          assert_equal [@class.this_index], received
+        end
+      end
+    end
+
+    context 'instance' do
+      setup do
+        @instance = @class.new
+      end
+
+      context 'with class that has_index :foo' do
+        setup do
+          @class.has_index :foo
+          @class.maps :some_attr
+          @class.maps :id
+          @class.key :id
+        end
+
+        should 'have an attribute :foo of type CassandraMapper::Index::State' do
+          assert_equal CassandraMapper::Index::State, @instance.foo.class
+        end
+
+        should 'have nil index state values for :foo state object' do
+          assert_equal nil, @instance.foo.source_value
+          assert_equal nil, @instance.foo.identifier_value
+        end
+
+        should 'receive proper state_value and identifier_value values after :loaded' do
+          @class.foo.expects(:source_for).with(@instance).returns(source = 'some_source_value')
+          @class.foo.expects(:indexed_identifier_for).with(@instance).returns(key = 'some_key')
+          @instance.loaded!
+          assert_equal source, @instance.foo.source_value
+          assert_equal key, @instance.foo.identifier_value
+        end
+
+        should 'create the index upon saving a new instance' do
+          @instance.stubs(:new_record?).returns(true)
+          @instance.some_attr = 'blah'
+          @instance.id = 'foo'
+          @class.foo.expects(:create).with(@instance)
+          @instance.connection.expects(:insert)
+          @instance.save
+        end
+
+        should 'update the index upon saving an existing instance' do
+          @instance.stubs(:new_record?).returns(false)
+          @instance.some_attr = 'blah'
+          @instance.id = 'foo'
+          @class.foo.expects(:update).with(@instance)
+          @instance.connection.expects(:insert)
+          @instance.save
+        end
+
+        should 'remove from the index upon destroying an existing instance' do
+          @instance.stubs(:new_record?).returns(false)
+          @instance.stubs(:freeze)
+          @instance.some_attr = 'blah'
+          @instance.id = 'foo'
+          @class.foo.expects(:remove).with(@instance)
+          @instance.connection.expects(:remove)
+          @instance.destroy
+        end
+      end
+    end
+  end
+end