tenacity 0.2.0 → 0.3.0

data/test/helpers/data_mapper_test_helper.rb

@@ -0,0 +1,44 @@
+require 'datamapper'
+require 'dm-migrations'
+require 'dm-migrations/migration_runner'
+
+DataMapper.setup(:default, {
+  :adapter  => 'sqlite3',
+  :database => ':memory:'})  
+
+migration 1, :create_join_tables do
+  up do
+    create_table :active_record_has_many_targets_data_mapper_objects do
+      column :data_mapper_object_id, Integer
+      column :active_record_has_many_target_id, String
+    end
+
+    create_table :data_mapper_objects_mongo_mapper_has_many_targets do
+      column :data_mapper_object_id, Integer
+      column :mongo_mapper_has_many_target_id, String
+    end
+
+    create_table :couch_rest_has_many_targets_data_mapper_objects do
+      column :data_mapper_object_id, Integer
+      column :couch_rest_has_many_target_id, String
+    end
+
+    create_table :data_mapper_has_many_targets_data_mapper_objects do
+      column :data_mapper_object_id, Integer
+      column :data_mapper_has_many_target_id, String
+    end
+
+    create_table :data_mapper_objects_mongoid_has_many_targets do
+      column :data_mapper_object_id, Integer
+      column :mongoid_has_many_target_id, String
+    end
+
+    create_table :data_mapper_objects_sequel_has_many_targets do
+      column :data_mapper_object_id, Integer
+      column :sequel_has_many_target_id, String
+    end
+  end
+end
+
+migrate_up!
+

data/test/helpers/mongoid_test_helper.rb

@@ -0,0 +1,21 @@
+def require_mongoid
+  begin
+    require 'mongoid'
+    yield
+  rescue LoadError
+  end
+end
+
+begin
+  require 'mongoid'
+
+  Mongoid.configure do |config|
+    name = "tenacity_test"
+    host = "localhost"
+    config.master = Mongo::Connection.new.db(name)
+    config.persist_in_safe_mode = false
+  end
+rescue LoadError
+  puts "WARNING:  Mongoid could not be loaded.  Skipping tests."
+end
+

data/test/helpers/sequel_test_helper.rb

@@ -0,0 +1,60 @@
+require 'sequel'
+
+DB = Sequel.sqlite
+
+DB.create_table :sequel_objects do
+  primary_key :id
+end
+
+DB.create_table :sequel_has_one_targets do
+  primary_key :id
+
+  String :active_record_object_id
+  String :couch_rest_object_id
+  String :data_mapper_object_id
+  String :mongo_mapper_object_id
+  String :mongoid_object_id
+  String :sequel_object_id
+end
+
+DB.create_table :sequel_has_many_targets do
+  primary_key :id
+
+  String :active_record_object_id
+  String :couch_rest_object_id
+  String :data_mapper_object_id
+  String :mongo_mapper_object_id
+  String :mongoid_object_id
+  String :sequel_object_id
+end
+
+DB.create_table :active_record_has_many_targets_sequel_objects do
+  Integer :sequel_object_id
+  String :active_record_has_many_target_id
+end
+
+DB.create_table :mongo_mapper_has_many_targets_sequel_objects do
+  Integer :sequel_object_id
+  String :mongo_mapper_has_many_target_id
+end
+
+DB.create_table :couch_rest_has_many_targets_sequel_objects do
+  Integer :sequel_object_id
+  String :couch_rest_has_many_target_id
+end
+
+DB.create_table :data_mapper_has_many_targets_sequel_objects do
+  Integer :sequel_object_id
+  String :data_mapper_has_many_target_id
+end
+
+DB.create_table :mongoid_has_many_targets_sequel_objects do
+  Integer :sequel_object_id
+  String :mongoid_has_many_target_id
+end
+
+DB.create_table :sequel_has_many_targets_sequel_objects do
+  Integer :sequel_object_id
+  String :sequel_has_many_target_id
+end
+

data/test/orm_ext/activerecord_test.rb

@@ -8,85 +8,105 @@ class ActiveRecordTest < Test::Unit::TestCase
     end
 
     should "be able to find the object in the database" do
-      car = ActiveRecordCar.create
-      assert_equal car, ActiveRecordCar._t_find(car.id)
+      object = ActiveRecordObject.create
+      assert_equal object, ActiveRecordObject._t_find(object.id)
     end
 
     should "return nil if the specified object cannot be found in the database" do
-      assert_nil ActiveRecordCar._t_find(989782)
+      assert_nil ActiveRecordObject._t_find(989782)
     end
 
     should "be able to find multiple objects in the database" do
-      car = ActiveRecordCar.create
-      car_2 = ActiveRecordCar.create
-      assert_set_equal [car, car_2], ActiveRecordCar._t_find_bulk([car.id, car_2.id, 989823])
+      object = ActiveRecordObject.create
+      object_2 = ActiveRecordObject.create
+      assert_set_equal [object, object_2], ActiveRecordObject._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 [], ActiveRecordNut._t_find_bulk([989823, 992111, 989771])
+      assert_set_equal [], ActiveRecordObject._t_find_bulk([989823, 992111, 989771])
     end
 
     should "be able to find the first associate of an object" do
-      mongo_mapper_dashboard = MongoMapperDashboard.create
-      climate_control_unit = ActiveRecordClimateControlUnit.create(:mongo_mapper_dashboard_id => mongo_mapper_dashboard.id)
-      assert_equal climate_control_unit, ActiveRecordClimateControlUnit._t_find_first_by_associate(:mongo_mapper_dashboard_id, mongo_mapper_dashboard.id)
+      object = ActiveRecordObject.create
+      has_one_target = ActiveRecordHasOneTarget.create(:active_record_object_id => object.id)
+      assert_equal has_one_target, ActiveRecordHasOneTarget._t_find_first_by_associate(:active_record_object_id, object.id)
     end
 
     should "return nil if unable to find the first associate of an object" do
-      assert_nil ActiveRecordClimateControlUnit._t_find_first_by_associate(:mongo_mapper_dashboard_id, 'abc123')
+      assert_nil ActiveRecordHasOneTarget._t_find_first_by_associate(:active_record_object_id, '9999999')
     end
 
     should "be able to find all associates of an object" do
-      nut_1 = ActiveRecordNut.create(:mongo_mapper_wheel_id => 'abc123')
-      nut_2 = ActiveRecordNut.create(:mongo_mapper_wheel_id => 'abc123')
-      nut_3 = ActiveRecordNut.create(:mongo_mapper_wheel_id => 'xyz456')
-      assert_set_equal [nut_1, nut_2], ActiveRecordNut._t_find_all_by_associate(:mongo_mapper_wheel_id, 'abc123')
+      object = ActiveRecordObject.create
+      has_many_target_1 = ActiveRecordHasManyTarget.create(:active_record_object_id => object.id)
+      has_many_target_2 = ActiveRecordHasManyTarget.create(:active_record_object_id => object.id)
+      has_many_target_3 = ActiveRecordHasManyTarget.create(:active_record_object_id => '9999999')
+      assert_set_equal [has_many_target_1, has_many_target_2], ActiveRecordHasManyTarget._t_find_all_by_associate(:active_record_object_id, object.id)
     end
 
     should "return an empty array able to find the associates of an object" do
-      assert_set_equal [], ActiveRecordNut._t_find_all_by_associate(:mongo_mapper_wheel_id, 'abc123')
+      assert_set_equal [], ActiveRecordHasManyTarget._t_find_all_by_associate(:active_record_object_id, '9999999999')
     end
 
     should "be able to reload an object from the database" do
-      nut = ActiveRecordNut.create
-      nut.mongo_mapper_wheel_id = 'abc123'
-      nut.reload
-      assert_equal '', nut.mongo_mapper_wheel_id
+      object = ActiveRecordHasOneTarget.create
+      object.mongo_mapper_object_id = 'abc123'
+      object.reload
+      assert_equal '', object.mongo_mapper_object_id
     end
 
     should "be able to clear the associates of a given object" do
-      nut = ActiveRecordNut.create
-      nut._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
-      nut.save
-      nut._t_clear_associates(association)
-      assert_set_equal [], nut._t_get_associate_ids(association)
+      object = ActiveRecordObject.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
-      nut = ActiveRecordNut.create
-      nut._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
-      rows = ActiveRecordNut.connection.execute("select mongo_mapper_wheel_id from nuts_and_wheels where nut_id = #{nut.id}")
+      object = ActiveRecordObject.create
+      object._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
+      rows = ActiveRecordObject.connection.execute("select mongo_mapper_has_many_target_id from active_record_objects_mongo_mapper_has_many_targets where active_record_object_id = #{object.id}")
       ids = []; rows.each { |r| ids << r[0] }; ids
       assert_set_equal ['abc123', 'def456', 'ghi789'], ids
     end
 
     should "be able to get the ids of the objects associated with the given object" do
-      nut = ActiveRecordNut.create
-      nut._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
-      assert_set_equal ['abc123', 'def456', 'ghi789'], nut._t_get_associate_ids(association)
+      object = ActiveRecordObject.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
-      nut = ActiveRecordNut.create
-      assert_set_equal [], nut._t_get_associate_ids(association)
+      object = ActiveRecordObject.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 = ActiveRecordObject.create
+      object_2 = ActiveRecordObject.create
+      object_3 = ActiveRecordObject.create
+
+      old_count = ActiveRecordObject.count
+      ActiveRecordObject._t_delete([object_1.id, object_2.id, object_3.id])
+      assert_equal old_count - 3, ActiveRecordObject.count
+    end
+
+    should "be able to delete a setup of objects, without issuing their callbacks" do
+      object_1 = ActiveRecordObject.create
+      object_2 = ActiveRecordObject.create
+      object_3 = ActiveRecordObject.create
+
+      old_count = ActiveRecordObject.count
+      ActiveRecordObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+      assert_equal old_count - 3, ActiveRecordObject.count
     end
   end
 
   private
 
   def association
-    Tenacity::Association.new(:t_has_many, :mongo_mapper_wheels, ActiveRecordNut, :join_table => :nuts_and_wheels,
-                              :association_key => :nut_id)
+    Tenacity::Association.new(:t_has_many, :mongo_mapper_has_many_targets, ActiveRecordObject)
   end
 
 end

data/test/orm_ext/couchrest_test.rb

@@ -8,95 +8,115 @@ class CouchRestTest < Test::Unit::TestCase
     end
 
     should "be able to find the object in the database" do
-      radio = CouchRestRadio.create({})
-      assert_equal radio, CouchRestRadio._t_find(radio.id)
+      object = CouchRestObject.create({})
+      assert_equal object, CouchRestObject._t_find(object.id)
     end
 
     should "return nil if the specified id could not be found in the database" do
-      assert_nil CouchRestRadio._t_find("abc123")
+      assert_nil CouchRestObject._t_find("abc123")
     end
 
     should "be able to find multiple objects in the database" do
-      radio_1 = CouchRestRadio.create({})
-      radio_2 = CouchRestRadio.create({})
-      assert_set_equal [radio_1, radio_2], CouchRestRadio._t_find_bulk([radio_1.id, radio_2.id, "abc123"])
+      object_1 = CouchRestObject.create({})
+      object_2 = CouchRestObject.create({})
+      assert_set_equal [object_1, object_2], CouchRestObject._t_find_bulk([object_1.id, object_2.id, "abc123"])
     end
 
     should "return an empty array if unable to find the specified objects in the database" do
-      assert_equal [], CouchRestRadio._t_find_bulk(["abc123", "abc456", "abc789"])
+      assert_equal [], CouchRestObject._t_find_bulk(["abc123", "abc456", "abc789"])
     end
 
     should "be able to find the first associate of an object" do
-      dashboard = MongoMapperDashboard.create
-      radio = CouchRestRadio.create(:mongo_mapper_dashboard_id => dashboard.id)
-      assert_equal radio, CouchRestRadio._t_find_first_by_associate(:mongo_mapper_dashboard_id, dashboard.id)
+      object = CouchRestObject.create({})
+      target = CouchRestHasOneTarget.create(:couch_rest_object_id => object.id)
+      assert_equal target, CouchRestHasOneTarget._t_find_first_by_associate(:couch_rest_object_id, object.id)
     end
 
     should "return nil if the first associate of an object could not be found" do
-      assert_nil CouchRestRadio._t_find_first_by_associate(:mongo_mapper_dashboard_id, 12345)
+      assert_nil CouchRestHasOneTarget._t_find_first_by_associate(:couch_rest_object_id, 12345)
     end
 
     should "be able to find all associates of an object" do
-      dashboard = MongoMapperDashboard.create
-      radio_1 = CouchRestRadio.create(:mongo_mapper_dashboard_id => dashboard.id)
-      radio_2 = CouchRestRadio.create(:mongo_mapper_dashboard_id => dashboard.id)
-      radio_3 = CouchRestRadio.create(:mongo_mapper_dashboard_id => 'abc123')
-      assert_set_equal [radio_1, radio_2], CouchRestRadio._t_find_all_by_associate(:mongo_mapper_dashboard_id, dashboard.id)
+      object = CouchRestObject.create({})
+      target_1 = CouchRestHasManyTarget.create(:couch_rest_object_id => object.id)
+      target_2 = CouchRestHasManyTarget.create(:couch_rest_object_id => object.id)
+      target_3 = CouchRestHasManyTarget.create(:couch_rest_object_id => 'abc123')
+      assert_set_equal [target_1, target_2], CouchRestHasManyTarget._t_find_all_by_associate(:couch_rest_object_id, object.id)
     end
 
     should "return an empty array if unable to find the associates of an object" do
-      assert_equal [], CouchRestRadio._t_find_all_by_associate(:mongo_mapper_dashboard_id, 'abc123')
+      assert_set_equal [], CouchRestHasManyTarget._t_find_all_by_associate(:couch_rest_object_id, 'abc123')
     end
 
     should "be able to reload an object from the database" do
-      radio = CouchRestRadio.create({"abc" => "123"})
-      assert_equal "123", radio["abc"]
-      radio["abc"] = "456"
-      assert_equal "456", radio["abc"]
-      radio._t_reload
-      assert_equal "123", radio["abc"]
+      object = CouchRestObject.create({"abc" => "123"})
+      assert_equal "123", object["abc"]
+      object["abc"] = "456"
+      assert_equal "456", object["abc"]
+      object._t_reload
+      assert_equal "123", object["abc"]
     end
 
     should "be able to associate many objects with the given object" do
-      button_1 = MongoMapperButton.create
-      button_2 = MongoMapperButton.create
-      button_3 = MongoMapperButton.create
-      radio = CouchRestRadio.create({})
-      radio._t_associate_many(association, [button_1.id, button_2.id, button_3.id])
-      assert_set_equal [button_1.id.to_s, button_2.id.to_s, button_3.id.to_s], radio.t_mongo_mapper_button_ids
+      target_1 = CouchRestHasManyTarget.create({})
+      target_2 = CouchRestHasManyTarget.create({})
+      target_3 = CouchRestHasManyTarget.create({})
+      object = CouchRestObject.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_couch_rest_has_many_target_ids
     end
 
     should "be able to get the ids of the objects associated with the given object" do
-      button_1 = MongoMapperButton.create
-      button_2 = MongoMapperButton.create
-      button_3 = MongoMapperButton.create
-      radio = CouchRestRadio.create({})
+      target_1 = CouchRestHasManyTarget.create({})
+      target_2 = CouchRestHasManyTarget.create({})
+      target_3 = CouchRestHasManyTarget.create({})
+      object = CouchRestObject.create({})
 
-      radio._t_associate_many(association, [button_1.id, button_2.id, button_3.id])
-      assert_set_equal [button_1.id.to_s, button_2.id.to_s, button_3.id.to_s], radio._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
-      radio = CouchRestRadio.create({})
-      assert_equal [], radio._t_get_associate_ids(association)
+      object = CouchRestObject.create({})
+      assert_equal [], object._t_get_associate_ids(association)
     end
 
     should "be able to clear the associates of an object" do
-      button_1 = MongoMapperButton.create
-      button_2 = MongoMapperButton.create
-      button_3 = MongoMapperButton.create
-      radio = CouchRestRadio.create({})
+      target_1 = CouchRestHasManyTarget.create({})
+      target_2 = CouchRestHasManyTarget.create({})
+      target_3 = CouchRestHasManyTarget.create({})
+      object = CouchRestObject.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 = CouchRestObject.create({})
+      object_2 = CouchRestObject.create({})
+      object_3 = CouchRestObject.create({})
+
+      old_count = CouchRestObject.count
+      CouchRestObject._t_delete([object_1.id, object_2.id, object_3.id])
+      assert_equal old_count - 3, CouchRestObject.count
+    end
+
+    should "be able to delete a setup of objects, without issuing their callbacks" do
+      object_1 = CouchRestObject.create({})
+      object_2 = CouchRestObject.create({})
+      object_3 = CouchRestObject.create({})
 
-      radio._t_associate_many(association, [button_1.id, button_2.id, button_3.id])
-      assert_set_equal [button_1.id.to_s, button_2.id.to_s, button_3.id.to_s], radio._t_get_associate_ids(association)
-      radio._t_clear_associates(association)
-      assert_equal [], radio._t_get_associate_ids(association)
+      old_count = CouchRestObject.count
+      CouchRestObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+      assert_equal old_count - 3, CouchRestObject.count
     end
   end
 
   private
 
   def association
-    Tenacity::Association.new(:t_has_many, :mongo_mapper_buttons, CouchRestRadio)
+    Tenacity::Association.new(:t_has_many, :couch_rest_has_many_targets, CouchRestObject)
   end
 end

data/test/orm_ext/datamapper_test.rb

@@ -0,0 +1,112 @@
+require 'test_helper'
+
+class DataMapperTest < Test::Unit::TestCase
+
+  context "The DataMapper extension" do
+    setup do
+      setup_fixtures
+    end
+
+    should "be able to find the object in the database" do
+      object = DataMapperObject.create
+      assert_equal object, DataMapperObject._t_find(object.id)
+    end
+
+    should "return nil if the specified object cannot be found in the database" do
+      assert_nil DataMapperObject._t_find(989782)
+    end
+
+    should "be able to find multiple objects in the database" do
+      object = DataMapperObject.create
+      object_2 = DataMapperObject.create
+      assert_set_equal [object, object_2], DataMapperObject._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 [], DataMapperObject._t_find_bulk([989823, 992111, 989771])
+    end
+
+    should "be able to find the first associate of an object" do
+      object = DataMapperObject.create
+      has_one_target = DataMapperHasOneTarget.create(:data_mapper_object_id => object.id)
+      assert_equal has_one_target, DataMapperHasOneTarget._t_find_first_by_associate(:data_mapper_object_id, object.id)
+    end
+
+    should "return nil if unable to find the first associate of an object" do
+      assert_nil DataMapperHasOneTarget._t_find_first_by_associate(:data_mapper_object_id, '9999999')
+    end
+
+    should "be able to find all associates of an object" do
+      object = DataMapperObject.create
+      has_many_target_1 = DataMapperHasManyTarget.create(:data_mapper_object_id => object.id)
+      has_many_target_2 = DataMapperHasManyTarget.create(:data_mapper_object_id => object.id)
+      has_many_target_3 = DataMapperHasManyTarget.create(:data_mapper_object_id => '9999999')
+      assert_set_equal [has_many_target_1, has_many_target_2], DataMapperHasManyTarget._t_find_all_by_associate(:data_mapper_object_id, object.id)
+    end
+
+    should "return an empty array able to find the associates of an object" do
+      assert_set_equal [], DataMapperHasManyTarget._t_find_all_by_associate(:data_mapper_object_id, '9999999999')
+    end
+
+    should "be able to reload an object from the database" do
+      object = DataMapperHasOneTarget.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 = DataMapperObject.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 = DataMapperObject.create
+      object._t_associate_many(association, ['abc123', 'def456', 'ghi789'])
+      rows = DataMapperObject.repository.adapter.select("select mongo_mapper_has_many_target_id from data_mapper_objects_mongo_mapper_has_many_targets where data_mapper_object_id = #{object.id}")
+      assert_set_equal ['abc123', 'def456', 'ghi789'], rows
+    end
+
+    should "be able to get the ids of the objects associated with the given object" do
+      object = DataMapperObject.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 = DataMapperObject.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 = DataMapperObject.create
+      object_2 = DataMapperObject.create
+      object_3 = DataMapperObject.create
+
+      old_count = DataMapperObject.count
+      DataMapperObject._t_delete([object_1.id, object_2.id, object_3.id])
+      assert_equal old_count - 3, DataMapperObject.count
+    end
+
+    should "be able to delete a setup of objects, without issuing their callbacks" do
+      object_1 = DataMapperObject.create
+      object_2 = DataMapperObject.create
+      object_3 = DataMapperObject.create
+
+      old_count = DataMapperObject.count
+      DataMapperObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+      assert_equal old_count - 3, DataMapperObject.count
+    end
+  end
+
+  private
+
+  def association
+    Tenacity::Association.new(:t_has_many, :mongo_mapper_has_many_targets, DataMapperObject)
+  end
+
+end