tenacity 0.3.0 → 0.4.0

data/test/association_features/has_one_test.rb

@@ -4,7 +4,7 @@ class HasOneTest < Test::Unit::TestCase
 
   context "A class with a has_one association to another class" do
     setup do
-      setup_fixtures
+      setup_all_fixtures
       @climate_control_unit = ActiveRecordClimateControlUnit.create
       @dashboard = MongoMapperDashboard.create(:active_record_climate_control_unit => @climate_control_unit)
     end
@@ -15,7 +15,7 @@ class HasOneTest < Test::Unit::TestCase
       other_climate_control_unit = ActiveRecordClimateControlUnit.create
       assert_equal @climate_control_unit, MongoMapperDashboard.find(@dashboard.id).active_record_climate_control_unit
       ActiveRecordClimateControlUnit.update(@climate_control_unit.id, :mongo_mapper_dashboard_id => nil)
-      ActiveRecordClimateControlUnit.update(other_climate_control_unit.id, :mongo_mapper_dashboard_id => @dashboard.id)
+      ActiveRecordClimateControlUnit.update(other_climate_control_unit.id, :mongo_mapper_dashboard_id => serialize_id(@dashboard))
       assert_equal other_climate_control_unit, MongoMapperDashboard.find(@dashboard.id).active_record_climate_control_unit
 
       assert_equal @climate_control_unit, @dashboard.active_record_climate_control_unit
@@ -36,6 +36,61 @@ class HasOneTest < Test::Unit::TestCase
       engine = ActiveRecordEngine.create(:active_record_car => car)
       assert_equal engine, car.active_record_engine
     end
+
+    should "not be able to modify the associated object if the readonly option is set" do
+      car = ActiveRecordCar.create
+      dashboard = MongoMapperDashboard.create(:active_record_car => car)
+      dashboard = car.mongo_mapper_dashboard
+      dashboard.prop = "value"
+      assert_raises(Tenacity::ReadOnlyError) { dashboard.save }
+    end
+
+    should "save the associated object if autosave is true" do
+      source = ActiveRecordObject.create
+      target = MongoMapperAutosaveTrueHasOneTarget.new(:prop => 'abc')
+      source.mongo_mapper_autosave_true_has_one_target = target
+      source.save
+      assert_equal 'abc', source.mongo_mapper_autosave_true_has_one_target.prop
+
+      source.mongo_mapper_autosave_true_has_one_target.prop = 'xyz'
+      source.save
+      source.reload && source.mongo_mapper_autosave_true_has_one_target(true)
+      assert_equal 'xyz', source.mongo_mapper_autosave_true_has_one_target.prop
+    end
+
+    should "not save the associated object upon assignment if autosave is false" do
+      source = ActiveRecordObject.create
+      target = MongoMapperAutosaveFalseHasOneTarget.new
+      source.mongo_mapper_autosave_false_has_one_target = target
+
+      source.save
+      assert_nil MongoMapperAutosaveFalseHasOneTarget.first(:active_record_object_id => source.id)
+    end
+
+    should "destroy the associated object if autosave is true and object is marked for destruction" do
+      source = ActiveRecordObject.create
+      target = MongoMapperAutosaveTrueHasOneTarget.new
+      source.mongo_mapper_autosave_true_has_one_target = target
+      source.save
+      assert_not_nil source.mongo_mapper_autosave_true_has_one_target(true)
+
+      source.mongo_mapper_autosave_true_has_one_target.mark_for_destruction
+      assert source.mongo_mapper_autosave_true_has_one_target.marked_for_destruction?
+      source.save
+      source.reload
+      assert_nil source.mongo_mapper_autosave_true_has_one_target(true)
+    end
+
+    should "be able to store an object via its polymorphic interface" do
+      circuit_board = MongoMapperCircuitBoard.create
+      alternator = MongoMapperAlternator.create
+      alternator.diagnosable = circuit_board
+      alternator.save
+
+      component = MongoMapperAlternator.find(alternator.id).diagnosable
+      assert_equal circuit_board, component
+      assert_equal 'MongoMapperAlternator', component.diagnosable_type
+    end
   end
 
 end

data/test/associations/belongs_to_test.rb

@@ -17,26 +17,60 @@ class BelongsToTest < Test::Unit::TestCase
       end
 
       should "be able to fetch the id of the associated object" do
-        @target.send("#{@foreign_key_id}=", @source.id.to_s)
+        @target.send("#{@foreign_key_id}=", serialize_id(@source))
         @target.save
-        assert_equal @source.id.to_s, @target_class._t_find(@target.id.to_s).send(@foreign_key_id)
+        assert_equal serialize_id(@source), @target_class._t_find(serialize_id(@target)).send(@foreign_key_id)
       end
 
       should "be able to load the associated object" do
         @target.send("#{@foreign_key}=", @source)
         @target.save
-        assert_equal @source.id.to_s, @target_class._t_find(@target.id.to_s).send(@foreign_key_id)
-        assert_equal @source, @target_class._t_find(@target.id.to_s).send(@foreign_key)
+        assert_equal serialize_id(@source), @target_class._t_find(serialize_id(@target)).send(@foreign_key_id)
+        assert_equal @source, @target_class._t_find(serialize_id(@target)).send(@foreign_key)
       end
 
       should "be be able to load the associated object if all we have is the id" do
-        @target.send("#{@foreign_key_id}=", @source.id.to_s)
+        @target.send("#{@foreign_key_id}=", serialize_id(@source))
         @target.save
-        assert_equal @source, @target_class._t_find(@target.id.to_s).send(@foreign_key)
+        assert_equal @source, @target_class._t_find(serialize_id(@target)).send(@foreign_key)
       end
 
       should "return nil if no association is set" do
-        assert_nil @target_class._t_find(@target.id.to_s).send(@foreign_key)
+        assert_nil @target_class._t_find(serialize_id(@target)).send(@foreign_key)
+      end
+
+      should "be able to destroy the associated object when the source object is destroyed" do
+        Tenacity::Association.any_instance.stubs(:dependent).returns(:destroy)
+        @target.send("#{@foreign_key}=", @source)
+        @target.save
+        @target_class._t_delete([serialize_id(@target)])
+        assert_nil @source_class._t_find(serialize_id(@source))
+        assert_nil @target_class._t_find(serialize_id(@target))
+      end
+
+      should "be able to delete the associated object when the source object is destroyed" do
+        Tenacity::Association.any_instance.stubs(:dependent).returns(:delete)
+        @target.send("#{@foreign_key}=", @source)
+        @target.save
+        @target_class._t_delete([serialize_id(@target)])
+        assert_nil @source_class._t_find(serialize_id(@source))
+        assert_nil @target_class._t_find(serialize_id(@target))
+      end
+
+      context "with a polymorphic association" do
+        setup do
+          @foreign_key = "#{source}_has_one_target_testable"
+          @polymorphic_type = "#{source}_has_one_target_testable_type"
+        end
+
+        should "be able to create a polymorphic association" do
+          @target.send("#{@foreign_key}=", @source)
+          @target.save
+
+          reloaded_source = @target_class._t_find(serialize_id(@target)).send(@foreign_key)
+          assert_equal @source, reloaded_source
+          assert_equal @source_class.to_s, @target.send(@polymorphic_type)
+        end
       end
     end
   end

data/test/associations/has_many_test.rb

@@ -22,8 +22,8 @@ class HasManyTest < Test::Unit::TestCase
         @source.send("#{@foreign_key_id}=", [@target_1.id, @target_2.id, @target_3.id])
         @source.save
         [@target_1, @target_2, @target_3].each { |t| t._t_reload }
-        assert_set_equal [@target_1, @target_2, @target_3], @source_class._t_find(@source.id.to_s).send(@foreign_key)
-        assert_set_equal [@target_1.id.to_s, @target_2.id.to_s, @target_3.id.to_s], @source_class._t_find(@source.id.to_s).send(@foreign_key_id)
+        assert_set_equal [@target_1, @target_2, @target_3], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+        assert_set_equal [serialize_id(@target_1), serialize_id(@target_2), serialize_id(@target_3)], @source_class._t_find(serialize_id(@source)).send(@foreign_key_id)
       end
 
       context "that works with associated objects" do
@@ -34,7 +34,7 @@ class HasManyTest < Test::Unit::TestCase
 
         should "be able to set the associated objects" do
           [@target_1, @target_2, @target_3].each { |t| t._t_reload }
-          assert_set_equal [@target_1, @target_2, @target_3], @source_class._t_find(@source.id.to_s).send(@foreign_key)
+          assert_set_equal [@target_1, @target_2, @target_3], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
         end
 
         should "be able to add an associated object using the << operator" do
@@ -42,7 +42,7 @@ class HasManyTest < Test::Unit::TestCase
           @source.send(@foreign_key) << target_4
           @source.save
           [@target_1, @target_2, @target_3, target_4].each { |t| t._t_reload }
-          assert_set_equal [@target_1, @target_2, @target_3, target_4], @source_class._t_find(@source.id.to_s).send(@foreign_key)
+          assert_set_equal [@target_1, @target_2, @target_3, target_4], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
         end
 
         should "be able to add an associated object using the push method" do
@@ -51,7 +51,7 @@ class HasManyTest < Test::Unit::TestCase
           @source.send(@foreign_key).push(target_4, target_5)
           @source.save
           [@target_1, @target_2, @target_3, target_4, target_5].each { |t| t._t_reload }
-          assert_set_equal [@target_1, @target_2, @target_3, target_4, target_5], @source_class._t_find(@source.id.to_s).send(@foreign_key)
+          assert_set_equal [@target_1, @target_2, @target_3, target_4, target_5], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
         end
 
         should "be able to add an associated object using the concat method" do
@@ -60,25 +60,74 @@ class HasManyTest < Test::Unit::TestCase
           @source.send(@foreign_key).concat([target_4, target_5])
           @source.save
           [@target_1, @target_2, @target_3, target_4, target_5].each { |t| t._t_reload }
-          assert_set_equal [@target_1, @target_2, @target_3, target_4, target_5], @source_class._t_find(@source.id.to_s).send(@foreign_key)
+          assert_set_equal [@target_1, @target_2, @target_3, target_4, target_5], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
         end
 
         should "be able to remove an associated object using the delete method" do
           @source.send(@foreign_key).delete(@target_3)
           @source.save
           [@target_1, @target_2].each { |t| t._t_reload }
-          assert_set_equal [@target_1, @target_2], @source_class._t_find(@source.id.to_s).send(@foreign_key)
+          assert_set_equal [@target_1, @target_2], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
         end
 
         should "be able to clear all associated objects using the clear method" do
           @source.send(@foreign_key).clear
           @source.save
-          assert_set_equal [], @source_class._t_find(@source.id.to_s).send(@foreign_key)
+          assert_set_equal [], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
         end
 
         should "return an empty array if the association is not set" do
-          source = @source_class.create({})
-          assert_set_equal [], @source_class._t_find(source.id.to_s).send(@foreign_key)
+          s = @source_class.create({})
+          assert_set_equal [], @source_class._t_find(serialize_id(s)).send(@foreign_key)
+        end
+
+        should "be able to destroy the associated object when an object is destroyed" do
+          Tenacity::Association.any_instance.stubs(:dependent).returns(:destroy, nil)
+          @source.destroy
+
+          assert_nil @source_class._t_find(serialize_id(@source))
+          assert_nil @target_class._t_find(serialize_id(@target_1))
+          assert_nil @target_class._t_find(serialize_id(@target_2))
+          assert_nil @target_class._t_find(serialize_id(@target_3))
+        end
+
+        should "be able to delete the associated object when an object is destroyed" do
+          Tenacity::Association.any_instance.stubs(:dependent).returns(:delete_all)
+          @source.destroy
+
+          assert_nil @source_class._t_find(serialize_id(@source))
+          assert_nil @target_class._t_find(serialize_id(@target_1))
+          assert_nil @target_class._t_find(serialize_id(@target_2))
+          assert_nil @target_class._t_find(serialize_id(@target_3))
+        end
+
+        should "be able to nullify the foreign key of the associated object when an object is destroyed" do
+          Tenacity::Association.any_instance.stubs(:dependent).returns(:nullify)
+          @source.destroy
+
+          assert_nil @source_class._t_find(serialize_id(@source))
+          assert_not_nil @target_class._t_find(serialize_id(@target_1))
+          assert_not_nil @target_class._t_find(serialize_id(@target_2))
+          assert_not_nil @target_class._t_find(serialize_id(@target_3))
+          assert_nil @target_class._t_find(serialize_id(@target_1)).send(foreign_key_id_for(target, :belongs_to))
+          assert_nil @target_class._t_find(serialize_id(@target_2)).send(foreign_key_id_for(target, :belongs_to))
+          assert_nil @target_class._t_find(serialize_id(@target_3)).send(foreign_key_id_for(target, :belongs_to))
+        end
+      end
+
+      context "with polymorphic associations" do
+        setup do
+          @foreign_key = "#{target}_has_many_target_testable"
+          @polymorphic_type = "#{target}_has_many_target_testable_type"
+        end
+
+        should "be able to store an object via its polymorphic interface" do
+          @source.send("#{@foreign_key}=", [@target_1, @target_2, @target_3])
+          @source.save
+
+          [@target_1, @target_2, @target_3].each { |t| t._t_reload }
+          assert_set_equal [@target_1, @target_2, @target_3], @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+          [@target_1, @target_2, @target_3].each { |t| assert_equal @source_class.to_s, t.send(@polymorphic_type) }
         end
       end
     end

data/test/associations/has_one_test.rb

@@ -18,11 +18,66 @@ class HasOneTest < Test::Unit::TestCase
 
       should "be able to set and get the associated object" do
         @source.send("#{@foreign_key}=", @target)
-        assert_equal @target, @source_class._t_find(@source.id.to_s).send(@foreign_key)
+        assert_equal @target, @source_class._t_find(serialize_id(@source)).send(@foreign_key)
       end
 
       should "return nil if no association is set" do
-        assert_nil @source_class._t_find(@source.id.to_s).send(@foreign_key)
+        assert_nil @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+      end
+
+      should "be able to invoke the post delete callback" do
+        @source.send("#{@foreign_key}=", @target)
+        @source_class._t_delete([serialize_id(@source)])
+      end
+
+      should "be able to destroy the associated object when an object is destroyed" do
+        Tenacity::Association.any_instance.stubs(:dependent).returns(:destroy, nil)
+
+        @source.send("#{@foreign_key}=", @target)
+        assert_equal @target, @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+        @source.destroy
+
+        assert_nil @source_class._t_find(serialize_id(@source))
+        assert_nil @target_class._t_find(serialize_id(@target))
+      end
+
+      should "be able to delete the associated object when an object is destroyed" do
+        Tenacity::Association.any_instance.stubs(:dependent).returns(:delete)
+
+        @source.send("#{@foreign_key}=", @target)
+        assert_equal @target, @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+        @source.destroy
+
+        assert_nil @source_class._t_find(serialize_id(@source))
+        assert_nil @target_class._t_find(serialize_id(@target))
+      end
+
+      should "be able to nullify the foreign key of the associated object when an object is destroyed" do
+        Tenacity::Association.any_instance.stubs(:dependent).returns(:nullify)
+
+        @source.send("#{@foreign_key}=", @target)
+        assert_equal @target, @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+        @source.destroy
+
+        assert_nil @source_class._t_find(serialize_id(@source))
+        assert_not_nil @target_class._t_find(serialize_id(@target))
+        assert_nil @target_class._t_find(serialize_id(@target)).send(foreign_key_id_for(target, :belongs_to))
+      end
+
+      context "with a polymorphic association" do
+        setup do
+          @foreign_key = "#{target}_has_one_target_testable"
+          @polymorphic_type = "#{target}_has_one_target_testable_type"
+        end
+
+        should "be able to store an object via its polymorphic interface" do
+          @source.send("#{@foreign_key}=", @target)
+          @source.save
+
+          reloaded_target = @source_class._t_find(serialize_id(@source)).send(@foreign_key)
+          assert_equal @target, reloaded_target
+          assert_equal @source_class.to_s, reloaded_target.send(@polymorphic_type)
+        end
       end
     end
   end

data/test/fixtures/active_record_car.rb

@@ -1,10 +1,11 @@
 class ActiveRecordCar < ActiveRecord::Base
   include Tenacity
 
-  t_has_many :mongo_mapper_wheels
-  t_has_one :mongo_mapper_dashboard
+  t_has_many :mongo_mapper_wheels, :dependent => :destroy, :readonly => true, :limit => 5
+  t_has_many :mongo_mapper_windows, :limit => 5, :offset => 3
+  t_has_one :mongo_mapper_dashboard, :dependent => :delete, :readonly => true
 
   t_has_one :couch_rest_windshield, :foreign_key => :car_id
-  t_has_one :active_record_engine, :foreign_key => 'car_id'
-  t_has_many :couch_rest_doors, :foreign_key => 'automobile_id'
+  t_has_one :active_record_engine, :foreign_key => 'car_id', :dependent => :nullify
+  t_has_many :couch_rest_doors, :foreign_key => 'automobile_id', :dependent => :delete_all
 end

data/test/fixtures/active_record_climate_control_unit.rb

@@ -2,4 +2,5 @@ class ActiveRecordClimateControlUnit < ActiveRecord::Base
   include Tenacity
 
   t_belongs_to :mongo_mapper_dashboard
+  t_has_one :mongo_mapper_circuit_board, :as => :diagnosable
 end

data/test/fixtures/active_record_engine.rb

@@ -2,4 +2,5 @@ class ActiveRecordEngine < ActiveRecord::Base
   include Tenacity
 
   t_belongs_to :active_record_car, :foreign_key => 'car_id'
+  t_has_many :mongo_mapper_circuit_boards, :as => :diagnosable
 end

data/test/fixtures/active_record_has_many_target.rb

@@ -7,4 +7,11 @@ class ActiveRecordHasManyTarget < ActiveRecord::Base
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
   t_belongs_to :sequel_object
+
+  t_belongs_to :active_record_has_many_target_testable, :polymorphic => true
+  t_belongs_to :couch_rest_has_many_target_testable, :polymorphic => true
+  t_belongs_to :data_mapper_has_many_target_testable, :polymorphic => true
+  t_belongs_to :mongo_mapper_has_many_target_testable, :polymorphic => true
+  require_mongoid { t_belongs_to :mongoid_has_many_target_testable, :polymorphic => true }
+  t_belongs_to :sequel_has_many_target_testable, :polymorphic => true
 end

data/test/fixtures/active_record_has_one_target.rb

@@ -7,4 +7,11 @@ class ActiveRecordHasOneTarget < ActiveRecord::Base
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
   t_belongs_to :sequel_object
+
+  t_belongs_to :active_record_has_one_target_testable, :polymorphic => true
+  t_belongs_to :couch_rest_has_one_target_testable, :polymorphic => true
+  t_belongs_to :data_mapper_has_one_target_testable, :polymorphic => true
+  t_belongs_to :mongo_mapper_has_one_target_testable, :polymorphic => true
+  require_mongoid { t_belongs_to :mongoid_has_one_target_testable, :polymorphic => true }
+  t_belongs_to :sequel_has_one_target_testable, :polymorphic => true
 end

data/test/fixtures/active_record_object.rb

@@ -8,10 +8,29 @@ class ActiveRecordObject < ActiveRecord::Base
   require_mongoid { t_has_one :mongoid_has_one_target }
   t_has_one :sequel_has_one_target
 
+  t_has_one :active_record_has_one_target, :as => :active_record_has_one_target_testable
+  t_has_one :couch_rest_has_one_target, :as => :couch_rest_has_one_target_testable
+  t_has_one :data_mapper_has_one_target, :as => :data_mapper_has_one_target_testable
+  t_has_one :mongo_mapper_has_one_target, :as => :mongo_mapper_has_one_target_testable
+  require_mongoid { t_has_one :mongoid_has_one_target, :as => :mongoid_has_one_target_testable }
+  t_has_one :sequel_has_one_target, :as => :sequel_has_one_target_testable
+
   t_has_many :active_record_has_many_targets
   t_has_many :couch_rest_has_many_targets
   t_has_many :data_mapper_has_many_targets
   t_has_many :mongo_mapper_has_many_targets
   require_mongoid { t_has_many :mongoid_has_many_targets }
   t_has_many :sequel_has_many_targets
+
+  t_has_many :active_record_has_many_targets, :as => :active_record_has_many_target_testable
+  t_has_many :couch_rest_has_many_targets, :as => :couch_rest_has_many_target_testable
+  t_has_many :data_mapper_has_many_targets, :as => :data_mapper_has_many_target_testable
+  t_has_many :mongo_mapper_has_many_targets, :as => :mongo_mapper_has_many_target_testable
+  require_mongoid { t_has_many :mongoid_has_many_targets, :as => :mongoid_has_many_target_testable }
+  t_has_many :sequel_has_many_targets, :as => :sequel_has_many_target_testable
+
+  t_has_one :mongo_mapper_autosave_true_has_one_target, :autosave => true
+  t_has_one :mongo_mapper_autosave_false_has_one_target, :autosave => false
+  t_has_many :mongo_mapper_autosave_true_has_many_targets, :autosave => true
+  t_has_many :mongo_mapper_autosave_false_has_many_targets, :autosave => false
 end

data/test/fixtures/couch_rest_has_many_target.rb

@@ -8,5 +8,12 @@ class CouchRestHasManyTarget < CouchRest::Model::Base
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
   t_belongs_to :sequel_object
+
+  t_belongs_to :active_record_has_many_target_testable, :polymorphic => true
+  t_belongs_to :couch_rest_has_many_target_testable, :polymorphic => true
+  t_belongs_to :data_mapper_has_many_target_testable, :polymorphic => true
+  t_belongs_to :mongo_mapper_has_many_target_testable, :polymorphic => true
+  require_mongoid { t_belongs_to :mongoid_has_many_target_testable, :polymorphic => true }
+  t_belongs_to :sequel_has_many_target_testable, :polymorphic => true
 end
 

data/test/fixtures/couch_rest_has_one_target.rb

@@ -8,5 +8,12 @@ class CouchRestHasOneTarget < CouchRest::Model::Base
   t_belongs_to :mongo_mapper_object
   require_mongoid { t_belongs_to :mongoid_object }
   t_belongs_to :sequel_object
+
+  t_belongs_to :active_record_has_one_target_testable, :polymorphic => true
+  t_belongs_to :couch_rest_has_one_target_testable, :polymorphic => true
+  t_belongs_to :data_mapper_has_one_target_testable, :polymorphic => true
+  t_belongs_to :mongo_mapper_has_one_target_testable, :polymorphic => true
+  require_mongoid { t_belongs_to :mongoid_has_one_target_testable, :polymorphic => true }
+  t_belongs_to :sequel_has_one_target_testable, :polymorphic => true
 end