tenacity 0.2.0 → 0.3.0

data/test/orm_ext/mongo_mapper_test.rb

@@ -8,92 +8,112 @@ class MongoMapperTest < Test::Unit::TestCase
     end
 
     should "be able to find the object in the database" do
-      wheel = MongoMapperWheel.create
-      assert_equal wheel, MongoMapperWheel._t_find(wheel.id)
+      object = MongoMapperObject.create
+      assert_equal object, MongoMapperObject._t_find(object.id)
     end
 
     should "return nil if the specified id could not be found in the database" do
-      assert_nil MongoMapperWheel._t_find('4d0e1224b28cdbfb72000042')
+      assert_nil MongoMapperObject._t_find('4d0e1224b28cdbfb72000042')
     end
 
     should "be able to find multiple objects in the database" do
-      wheel_1 = MongoMapperWheel.create
-      wheel_2 = MongoMapperWheel.create
-      assert_set_equal [wheel_1, wheel_2], MongoMapperWheel._t_find_bulk([wheel_1.id, wheel_2.id, '4d0e1224b28cdbfb72000042'])
+      object_1 = MongoMapperObject.create
+      object_2 = MongoMapperObject.create
+      assert_set_equal [object_1, object_2], MongoMapperObject._t_find_bulk([object_1.id, object_2.id, '4d0e1224b28cdbfb72000042'])
     end
 
     should "return an empty array if none of the specified object ids could be found in the database" do
-      assert_equal [], MongoMapperWheel._t_find_bulk(['4d0e1224b28cdbfb72000042', '4d0e1224b28cdbfb72000043', '4d0e1224b28cdbfb72000044'])
+      assert_equal [], MongoMapperObject._t_find_bulk(['4d0e1224b28cdbfb72000042', '4d0e1224b28cdbfb72000043', '4d0e1224b28cdbfb72000044'])
     end
 
     should "be able to find the first associate of an object" do
-      car = ActiveRecordCar.create
-      wheel = MongoMapperWheel.create(:active_record_car_id => car.id.to_s)
-      assert_equal wheel, MongoMapperWheel._t_find_first_by_associate(:active_record_car_id, car.id)
+      object = MongoMapperObject.create
+      target = MongoMapperHasOneTarget.create(:mongo_mapper_object_id => object.id.to_s)
+      assert_equal target, MongoMapperHasOneTarget._t_find_first_by_associate(:mongo_mapper_object_id, object.id)
     end
 
     should "return nil if the first associate of an object could not be found" do
-      assert_nil MongoMapperWheel._t_find_first_by_associate(:active_record_car_id, 12345)
+      assert_nil MongoMapperHasOneTarget._t_find_first_by_associate(:mongo_mapper_object_id, 12345)
     end
 
     should "be able to find the associates of an object" do
-      wheel_1 = MongoMapperWheel.create(:active_record_car_id => '101')
-      wheel_2 = MongoMapperWheel.create(:active_record_car_id => '101')
-      wheel_3 = MongoMapperWheel.create(:active_record_car_id => '102')
-      assert_set_equal [wheel_1, wheel_2], MongoMapperWheel._t_find_all_by_associate(:active_record_car_id, '101')
+      target_1 = MongoMapperHasOneTarget.create(:mongo_mapper_object_id => '101')
+      target_2 = MongoMapperHasOneTarget.create(:mongo_mapper_object_id => '101')
+      target_3 = MongoMapperHasOneTarget.create(:mongo_mapper_object_id => '102')
+      assert_set_equal [target_1, target_2], MongoMapperHasOneTarget._t_find_all_by_associate(:mongo_mapper_object_id, '101')
     end
 
     should "return an empty array if the object has no associates" do
-      assert_equal [], MongoMapperWheel._t_find_all_by_associate(:active_record_car_id, 1234)
+      assert_equal [], MongoMapperHasOneTarget._t_find_all_by_associate(:mongo_mapper_object_id, '1234')
     end
 
     should "be able to reload an object from the database" do
-      wheel = MongoMapperWheel.create
-      wheel.active_record_car_id = 101
-      assert_equal 101, wheel.active_record_car_id.to_i
-      wheel.reload
-      assert_equal '', wheel.active_record_car_id
+      target = MongoMapperHasOneTarget.create
+      target.mongo_mapper_object_id = 101
+      assert_equal '101', target.mongo_mapper_object_id
+      target.reload
+      assert_equal '', target.mongo_mapper_object_id
     end
 
     should "be able to associate many objects with the given object" do
-      nut_1 = ActiveRecordNut.create
-      nut_2 = ActiveRecordNut.create
-      nut_3 = ActiveRecordNut.create
-      wheel = MongoMapperWheel.create
-      wheel._t_associate_many(association, [nut_1.id, nut_2.id, nut_3.id])
-      assert_set_equal [nut_1.id.to_s, nut_2.id.to_s, nut_3.id.to_s], wheel.t_active_record_nut_ids
+      target_1 = MongoMapperHasManyTarget.create
+      target_2 = MongoMapperHasManyTarget.create
+      target_3 = MongoMapperHasManyTarget.create
+      object = MongoMapperObject.create
+      object._t_associate_many(association, [target_1.id, target_2.id, target_3.id])
+      assert_set_equal [target_1.id.to_s, target_2.id.to_s, target_3.id.to_s], object.t_mongo_mapper_has_many_target_ids
     end
 
     should "be able to get the ids of the objects associated with the given object" do
-      nut_1 = ActiveRecordNut.create
-      nut_2 = ActiveRecordNut.create
-      nut_3 = ActiveRecordNut.create
-      wheel = MongoMapperWheel.create
+      target_1 = MongoMapperHasManyTarget.create
+      target_2 = MongoMapperHasManyTarget.create
+      target_3 = MongoMapperHasManyTarget.create
+      object = MongoMapperObject.create
 
-      wheel._t_associate_many(association, [nut_1.id, nut_2.id, nut_3.id])
-      assert_set_equal [nut_1.id.to_s, nut_2.id.to_s, nut_3.id.to_s], wheel._t_get_associate_ids(association)
+      object._t_associate_many(association, [target_1.id, target_2.id, target_3.id])
+      assert_set_equal [target_1.id.to_s, target_2.id.to_s, target_3.id.to_s], object._t_get_associate_ids(association)
     end
 
     should "return an empty array when trying to fetch associate ids for an object with no associates" do
-      wheel = MongoMapperWheel.create
-      assert_equal [], wheel._t_get_associate_ids(association)
+      object = MongoMapperObject.create
+      assert_equal [], object._t_get_associate_ids(association)
     end
 
     should "be able to clear the associates of an object" do
-      nut_1 = ActiveRecordNut.create
-      nut_2 = ActiveRecordNut.create
-      nut_3 = ActiveRecordNut.create
-      wheel = MongoMapperWheel.create
+      target_1 = MongoMapperHasManyTarget.create
+      target_2 = MongoMapperHasManyTarget.create
+      target_3 = MongoMapperHasManyTarget.create
+      object = MongoMapperObject.create
+
+      object._t_associate_many(association, [target_1.id, target_2.id, target_3.id])
+      assert_set_equal [target_1.id.to_s, target_2.id.to_s, target_3.id.to_s], object._t_get_associate_ids(association)
+      object._t_clear_associates(association)
+      assert_equal [], object._t_get_associate_ids(association)
+    end
+
+    should "be able to delete a set of objects, issuing their callbacks" do
+      object_1 = MongoMapperObject.create
+      object_2 = MongoMapperObject.create
+      object_3 = MongoMapperObject.create
+
+      old_count = MongoMapperObject.count
+      MongoMapperObject._t_delete([object_1.id, object_2.id, object_3.id])
+      assert_equal old_count - 3, MongoMapperObject.count
+    end
+
+    should "be able to delete a setup of objects, without issuing their callbacks" do
+      object_1 = MongoMapperObject.create
+      object_2 = MongoMapperObject.create
+      object_3 = MongoMapperObject.create
 
-      wheel._t_associate_many(association, [nut_1.id, nut_2.id, nut_3.id])
-      assert_set_equal [nut_1.id.to_s, nut_2.id.to_s, nut_3.id.to_s], wheel._t_get_associate_ids(association)
-      wheel._t_clear_associates(association)
-      assert_equal [], wheel._t_get_associate_ids(association)
+      old_count = MongoMapperObject.count
+      MongoMapperObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+      assert_equal old_count - 3, MongoMapperObject.count
     end
   end
 
   def association
-    Tenacity::Association.new(:t_has_many, :active_record_nuts, MongoMapperWheel)
+    Tenacity::Association.new(:t_has_many, :mongo_mapper_has_many_targets, MongoMapperObject)
   end
 
 end

data/test/orm_ext/mongoid_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+require_mongoid do
+  class MongoidTest < Test::Unit::TestCase
+
+    context "The Mongoid extension" do
+      setup do
+        setup_fixtures
+      end
+
+      should "be able to find the object in the database" do
+        object = MongoidObject.create
+        assert_equal object, MongoidObject._t_find(object.id)
+      end
+
+      should "return nil if the specified id could not be found in the database" do
+        assert_nil MongoidObject._t_find('4d0e1224b28cdbfb72000042')
+      end
+
+      should "be able to find multiple objects in the database" do
+        object_1 = MongoidObject.create
+        object_2 = MongoidObject.create
+        assert_set_equal [object_1, object_2], MongoidObject._t_find_bulk([object_1.id, object_2.id, '4d0e1224b28cdbfb72000042'])
+      end
+
+      should "return an empty array if none of the specified object ids could be found in the database" do
+        assert_equal [], MongoidObject._t_find_bulk(['4d0e1224b28cdbfb72000042', '4d0e1224b28cdbfb72000043', '4d0e1224b28cdbfb72000044'])
+      end
+
+      should "be able to find the first associate of an object" do
+        object = MongoidObject.create
+        target = MongoidHasOneTarget.create(:mongoid_object_id => object.id.to_s)
+        assert_equal target, MongoidHasOneTarget._t_find_first_by_associate(:mongoid_object_id, object.id)
+      end
+
+      should "return nil if the first associate of an object could not be found" do
+        assert_nil MongoidHasOneTarget._t_find_first_by_associate(:mongoid_object_id, 12345)
+      end
+
+      should "be able to find the associates of an object" do
+        target_1 = MongoidHasOneTarget.create(:mongoid_object_id => '101')
+        target_2 = MongoidHasOneTarget.create(:mongoid_object_id => '101')
+        target_3 = MongoidHasOneTarget.create(:mongoid_object_id => '102')
+        assert_set_equal [target_1, target_2], MongoidHasOneTarget._t_find_all_by_associate(:mongoid_object_id, '101')
+      end
+
+      should "return an empty array if the object has no associates" do
+        assert_equal [], MongoidHasOneTarget._t_find_all_by_associate(:mongoid_object_id, '1234')
+      end
+
+      should "be able to reload an object from the database" do
+        target = MongoidHasOneTarget.create
+        target.mongoid_object_id = 101
+        assert_equal '101', target.mongoid_object_id
+        target.reload
+        assert_equal '', target.mongoid_object_id
+      end
+
+      should "be able to associate many objects with the given object" do
+        target_1 = MongoidHasManyTarget.create
+        target_2 = MongoidHasManyTarget.create
+        target_3 = MongoidHasManyTarget.create
+        object = MongoidObject.create
+        object._t_associate_many(association, [target_1.id, target_2.id, target_3.id])
+        assert_set_equal [target_1.id.to_s, target_2.id.to_s, target_3.id.to_s], object.t_mongoid_has_many_target_ids
+      end
+
+      should "be able to get the ids of the objects associated with the given object" do
+        target_1 = MongoidHasManyTarget.create
+        target_2 = MongoidHasManyTarget.create
+        target_3 = MongoidHasManyTarget.create
+        object = MongoidObject.create
+
+        object._t_associate_many(association, [target_1.id, target_2.id, target_3.id])
+        assert_set_equal [target_1.id.to_s, target_2.id.to_s, target_3.id.to_s], object._t_get_associate_ids(association)
+      end
+
+      should "return an empty array when trying to fetch associate ids for an object with no associates" do
+        object = MongoidObject.create
+        assert_equal [], object._t_get_associate_ids(association)
+      end
+
+      should "be able to clear the associates of an object" do
+        target_1 = MongoidHasManyTarget.create
+        target_2 = MongoidHasManyTarget.create
+        target_3 = MongoidHasManyTarget.create
+        object = MongoidObject.create
+
+        object._t_associate_many(association, [target_1.id, target_2.id, target_3.id])
+        assert_set_equal [target_1.id.to_s, target_2.id.to_s, target_3.id.to_s], object._t_get_associate_ids(association)
+        object._t_clear_associates(association)
+        assert_equal [], object._t_get_associate_ids(association)
+      end
+
+      should "be able to delete a set of objects, issuing their callbacks" do
+        object_1 = MongoidObject.create
+        object_2 = MongoidObject.create
+        object_3 = MongoidObject.create
+
+        old_count = MongoidObject.count
+        MongoidObject._t_delete([object_1.id, object_2.id, object_3.id])
+        assert_equal old_count - 3, MongoidObject.count
+      end
+
+      should "be able to delete a setup of objects, without issuing their callbacks" do
+        object_1 = MongoidObject.create
+        object_2 = MongoidObject.create
+        object_3 = MongoidObject.create
+
+        old_count = MongoidObject.count
+        MongoidObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+        assert_equal old_count - 3, MongoidObject.count
+      end
+    end
+
+    def association
+      Tenacity::Association.new(:t_has_many, :mongoid_has_many_targets, MongoidObject)
+    end
+
+  end
+end

data/test/orm_ext/sequel_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class SequelTest < Test::Unit::TestCase
+
+  context "The Sequel extension" do
+    setup do
+      setup_fixtures
+    end
+
+    should "be able to find the object in the database" do
+      object = SequelObject.create
+      assert_equal object, SequelObject._t_find(object.id)
+    end
+
+    should "return nil if the specified object cannot be found in the database" do
+      assert_nil SequelObject._t_find(989782)
+    end
+
+    should "be able to find multiple objects in the database" do
+      object = SequelObject.create
+      object_2 = SequelObject.create
+      assert_set_equal [object, object_2], SequelObject._t_find_bulk([object.id, object_2.id, 989823])
+    end
+
+    should "return an empty array if none of the specified ids could be found in the database" do
+      assert_set_equal [], SequelObject._t_find_bulk([989823, 992111, 989771])
+    end
+
+    should "be able to find the first associate of an object" do
+      object = SequelObject.create
+      has_one_target = SequelHasOneTarget.create(:sequel_object_id => object.id)
+      assert_equal has_one_target, SequelHasOneTarget._t_find_first_by_associate(:sequel_object_id, object.id)
+    end
+
+    should "return nil if unable to find the first associate of an object" do
+      assert_nil SequelHasOneTarget._t_find_first_by_associate(:sequel_object_id, '9999999')
+    end
+
+    should "be able to find all associates of an object" do
+      object = SequelObject.create
+      has_many_target_1 = SequelHasManyTarget.create(:sequel_object_id => object.id)
+      has_many_target_2 = SequelHasManyTarget.create(:sequel_object_id => object.id)
+      has_many_target_3 = SequelHasManyTarget.create(:sequel_object_id => '9999999')
+      assert_set_equal [has_many_target_1, has_many_target_2], SequelHasManyTarget._t_find_all_by_associate(:sequel_object_id, object.id)
+    end
+
+    should "return an empty array able to find the associates of an object" do
+      assert_set_equal [], SequelHasManyTarget._t_find_all_by_associate(:sequel_object_id, '9999999999')
+    end
+
+    should "be able to reload an object from the database" do
+      object = SequelHasOneTarget.create
+      object.mongo_mapper_object_id = 'abc123'
+      assert_equal 'abc123', object.mongo_mapper_object_id
+      object.reload
+      assert_equal '', object.mongo_mapper_object_id
+    end
+
+    should "be able to clear the associates of a given object" do
+      object = SequelObject.create
+      object._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
+      object.save
+      object._t_clear_associates(association)
+      assert_set_equal [], object._t_get_associate_ids(association)
+    end
+
+    should "be able to associate many objects with the given object" do
+      object = SequelObject.create
+      object._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
+
+      rows = DB["select mongo_mapper_has_many_target_id from mongo_mapper_has_many_targets_sequel_objects where sequel_object_id = #{object.id}"].all
+      ids = rows.map { |row| row[:mongo_mapper_has_many_target_id] }
+      assert_set_equal ['abc123', 'def456', 'ghi789'], ids
+    end
+
+    should "be able to get the ids of the objects associated with the given object" do
+      object = SequelObject.create
+      object._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
+      assert_set_equal ['abc123', 'def456', 'ghi789'], object._t_get_associate_ids(association)
+    end
+
+    should "return an empty array if there are no objects associated with the given object ids" do
+      object = SequelObject.create
+      assert_set_equal [], object._t_get_associate_ids(association)
+    end
+
+    should "be able to delete a set of objects, issuing their callbacks" do
+      object_1 = SequelObject.create
+      object_2 = SequelObject.create
+      object_3 = SequelObject.create
+
+      old_count = SequelObject.count
+      SequelObject._t_delete([object_1.id, object_2.id, object_3.id])
+      assert_equal old_count - 3, SequelObject.count
+    end
+
+    should "be able to delete a setup of objects, without issuing their callbacks" do
+      object_1 = SequelObject.create
+      object_2 = SequelObject.create
+      object_3 = SequelObject.create
+
+      old_count = SequelObject.count
+      SequelObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+      assert_equal old_count - 3, SequelObject.count
+    end
+  end
+
+  private
+
+  def association
+    Tenacity::Association.new(:t_has_many, :mongo_mapper_has_many_targets, SequelObject)
+  end
+end

data/test/test_helper.rb

@@ -12,8 +12,11 @@ require 'test/unit'
 require 'shoulda'
 
 require File.join(File.dirname(__FILE__), 'helpers', 'active_record_test_helper')
-require File.join(File.dirname(__FILE__), 'helpers', 'mongo_mapper_test_helper')
 require File.join(File.dirname(__FILE__), 'helpers', 'couch_rest_test_helper')
+require File.join(File.dirname(__FILE__), 'helpers', 'data_mapper_test_helper')
+require File.join(File.dirname(__FILE__), 'helpers', 'mongo_mapper_test_helper')
+require File.join(File.dirname(__FILE__), 'helpers', 'mongoid_test_helper')
+require File.join(File.dirname(__FILE__), 'helpers', 'sequel_test_helper')
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
@@ -21,18 +24,38 @@ require 'tenacity'
 
 Dir[File.join(File.dirname(__FILE__), 'fixtures', '*.rb')].each { |file| require file }
 
+DataMapper.auto_migrate!
+
 def setup_fixtures
-  ActiveRecordCar.delete_all
-  ActiveRecordClimateControlUnit.delete_all
-  ActiveRecordEngine.delete_all
-  ActiveRecordClimateControlUnit.delete_all
-  ActiveRecordNut.delete_all
-  MongoMapperDashboard.delete_all
-  MongoMapperWheel.delete_all
+  Dir.glob(File.join(File.dirname(__FILE__), 'fixtures', '*.rb')).each do |filename|
+    begin
+      filename =~ /.*\/(.*)\.rb/
+      clazz = Kernel.const_get($1.camelcase)
+      if clazz.respond_to?(:delete_all)
+        clazz.delete_all
+      elsif clazz.respond_to?(:db)
+        clazz.db["delete from #{clazz.table_name}"].delete
+      elsif clazz.respond_to?(:destroy)
+        clazz.destroy
+      elsif filename =~ /\/couch_rest/
+        # CouchDB fixtures are destroyed with the database
+      else
+        puts "WARN: Don't know how to clear fixtures for #{clazz}"
+      end
+    rescue NameError
+    end
+  end
 
-  ActiveRecordCar.connection.execute("delete from active_record_cars_mongo_mapper_wheels")
-  ActiveRecordCar.connection.execute("delete from active_record_cars_couch_rest_doors")
-  ActiveRecordCar.connection.execute("delete from nuts_and_wheels")
+  join_tables = %w{
+                    active_record_cars_mongo_mapper_wheels
+                    active_record_cars_couch_rest_doors
+                    nuts_and_wheels
+                    active_record_has_many_targets_active_record_objects
+                    active_record_objects_mongo_mapper_has_many_targets
+                    active_record_objects_couch_rest_has_many_targets
+                    active_record_objects_mongoid_has_many_targets
+                  }
+  join_tables.each { |join_table| ActiveRecordCar.connection.execute("delete from #{join_table}") }
 end
 
 def setup_couchdb_fixtures
@@ -44,6 +67,59 @@ def setup_all_fixtures
   setup_couchdb_fixtures
 end
 
+def setup_fixtures_for(source, target)
+  if source == :couch_rest || target == :couch_rest
+    setup_all_fixtures
+  else
+    setup_fixtures
+  end
+end
+
+def orm_extensions
+  extensions = [:active_record, :couch_rest, :data_mapper, :mongo_mapper, :sequel]
+  require_mongoid { extensions << :mongoid }
+  extensions
+end
+
+def for_each_orm_extension_combination
+  orm_extensions.each do |source|
+    orm_extensions.each do |target|
+      yield source, target
+    end
+  end
+end
+
+def class_for_extension(extension, type=nil)
+  if type.nil?
+    class_name = extension.to_s.camelcase + "Object"
+  elsif type == :belongs_to || type == :has_one
+    class_name = extension.to_s.camelcase + "HasOneTarget"
+  elsif type == :has_many
+    class_name = extension.to_s.camelcase + "HasManyTarget"
+  end
+  Kernel.const_get(class_name)
+end
+
+def foreign_key_for(extension, type)
+  if type == :belongs_to
+    "#{extension}_object"
+  elsif type == :has_one
+    "#{extension}_has_one_target"
+  elsif type == :has_many
+    "#{extension}_has_many_targets"
+  end
+end
+
+def foreign_key_id_for(extension, type)
+  if type == :belongs_to
+    "#{extension}_object_id"
+  elsif type == :has_one
+    "#{extension}_has_one_target_id"
+  elsif type == :has_many
+    "#{extension}_has_many_target_ids"
+  end
+end
+
 def assert_set_equal(expecteds, actuals, message = nil)
   assert_equal expecteds && Set.new(expecteds), actuals && Set.new(actuals), message
 end