tenacity 0.5.1 → 0.5.2

data/test/associations/has_one_test.rb

@@ -9,11 +9,11 @@ class HasOneTest < Test::Unit::TestCase
 
         @source_class = class_for_extension(source)
         @source = @source_class.create({})
-        @target_class = class_for_extension(target, :has_one)
+        @target_class = class_for_extension(target, :t_has_one)
         @target = @target_class.create({})
 
-        @foreign_key = foreign_key_for(target, :has_one)
-        @foreign_key_id = foreign_key_id_for(target, :has_one)
+        @foreign_key = foreign_key_for(target, :t_has_one)
+        @foreign_key_id = foreign_key_id_for(target, :t_has_one)
       end
 
       should "be able to set and get the associated object" do
@@ -60,7 +60,7 @@ class HasOneTest < Test::Unit::TestCase
 
         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))
+        assert_nil @target_class._t_find(serialize_id(@target)).send(foreign_key_id_for(target, :t_belongs_to))
       end
 
       context "with a polymorphic association" do

data/test/core/classmethods_test.rb

@@ -58,5 +58,19 @@ class ClassmethodsTest < Test::Unit::TestCase
     should("respond to destroy_all") { assert @targets.respond_to?(:destroy_all) }
   end
 
+  context "A class including Tenacity" do
+    should "be able to override the default object id type" do
+      active_record_object = ActiveRecordObjectWithStringId.new
+      active_record_object.id = 'abc999'
+      active_record_object.save!
+
+      mongo_mapper_object = MongoMapperObject.create
+      mongo_mapper_object.active_record_object_with_string_id = active_record_object
+      mongo_mapper_object.save
+
+      assert_equal active_record_object, MongoMapperObject._t_find(mongo_mapper_object.id).active_record_object_with_string_id
+    end
+  end
+
 end
 

data/test/fixtures/active_record_object_with_string_id.rb

@@ -0,0 +1,5 @@
+class ActiveRecordObjectWithStringId < ActiveRecord::Base
+  include Tenacity
+
+  t_has_one :mongo_mapper_object
+end

data/test/fixtures/couch_rest_object.rb

@@ -2,6 +2,8 @@ class CouchRestObject < CouchRest::Model::Base
   include Tenacity
   use_database COUCH_DB
 
+  property :prop, :type => String
+
   t_has_one :active_record_has_one_target
   t_has_one :couch_rest_has_one_target
   t_has_one :data_mapper_has_one_target

data/test/fixtures/data_mapper_object.rb

@@ -3,6 +3,7 @@ class DataMapperObject
   include Tenacity
 
   property :id, Serial
+  property :prop, String
 
   t_has_one :active_record_has_one_target
   t_has_one :couch_rest_has_one_target

data/test/fixtures/data_mapper_object_with_string_id.rb

@@ -0,0 +1,6 @@
+class DataMapperObjectWithStringId
+  include DataMapper::Resource
+  include Tenacity
+
+  property :id, String, :key => true
+end

data/test/fixtures/mongo_mapper_object.rb

@@ -2,6 +2,8 @@ class MongoMapperObject
   include MongoMapper::Document
   include Tenacity
 
+  key :prop, String
+
   t_has_one :active_record_has_one_target
   t_has_one :couch_rest_has_one_target
   t_has_one :data_mapper_has_one_target
@@ -37,4 +39,6 @@ class MongoMapperObject
   require_ripple { t_has_many :ripple_has_many_targets, :as => :ripple_has_many_target_testable }
   t_has_many :sequel_has_many_targets, :as => :sequel_has_many_target_testable
   require_toystore { t_has_many :toystore_has_many_targets, :as => :toystore_has_many_target_testable }
+
+  t_belongs_to :active_record_object_with_string_id
 end

data/test/fixtures/mongoid_object.rb

@@ -3,6 +3,8 @@ require_mongoid do
     include Mongoid::Document
     include Tenacity
 
+    field :prop, :type => String
+
     t_has_one :active_record_has_one_target
     t_has_one :couch_rest_has_one_target
     t_has_one :data_mapper_has_one_target

data/test/fixtures/ripple_object.rb

@@ -3,6 +3,8 @@ require_ripple do
     include Ripple::Document
     include Tenacity
 
+    property :prop, String
+
     t_has_one :active_record_has_one_target
     t_has_one :couch_rest_has_one_target
     t_has_one :data_mapper_has_one_target

data/test/fixtures/sequel_object_with_string_id.rb

@@ -0,0 +1,3 @@
+class SequelObjectWithStringId < Sequel::Model
+  include Tenacity
+end

data/test/fixtures/toystore_object.rb

@@ -7,6 +7,8 @@ require_toystore do
 
     include Tenacity
 
+    attribute :prop, String
+
     t_has_one :active_record_has_one_target
     t_has_one :couch_rest_has_one_target
     t_has_one :data_mapper_has_one_target

data/test/helpers/active_record_test_helper.rb

@@ -26,6 +26,10 @@ ActiveRecord::Schema.define :version => 0 do
     t.string :prop
   end
 
+  create_table :active_record_object_with_string_ids, :force => true, :id => false do |t|
+    t.string :id, :limit => 36, :primary => true
+  end
+
   create_table :active_record_has_one_targets, :force => true do |t|
     t.integer :active_record_object_id
     t.string :couch_rest_object_id

data/test/helpers/data_mapper_test_helper.rb

@@ -12,6 +12,7 @@ def migrate_data_mapper_tables
   DataMapperHasManyTarget
   DataMapperHasOneTarget
   DataMapperObject
+  DataMapperObjectWithStringId
 
   DataMapper.auto_migrate!
 end

data/test/helpers/sequel_test_helper.rb

@@ -5,6 +5,11 @@ Sequel::Model.raise_on_save_failure = true
 
 DB.create_table :sequel_objects do
   primary_key :id
+  String :prop
+end
+
+DB.create_table :sequel_object_with_string_ids do
+  String :id, :primary_key => true
 end
 
 DB.create_table :sequel_has_one_targets do

data/test/orm_ext/activerecord_test.rb

@@ -91,6 +91,22 @@ class ActiveRecordTest < Test::Unit::TestCase
       ActiveRecordObject._t_delete([object_1.id, object_2.id, object_3.id], false)
       assert_equal old_count - 3, ActiveRecordObject.count
     end
+
+    should "save the object if it is dirty" do
+      object = ActiveRecordObject.create
+      object.prop = "something"
+      assert object._t_save_if_dirty
+    end
+
+    should "not save the object if it is not dirty" do
+      object = ActiveRecordObject.create
+      assert !object._t_save_if_dirty
+    end
+
+    should "be able to successfully determine the id type" do
+      assert_equal Integer, ActiveRecordObject._t_id_type
+      assert_equal String, ActiveRecordObjectWithStringId._t_id_type
+    end
   end
 
   private

data/test/orm_ext/datamapper_test.rb

@@ -83,6 +83,22 @@ class DataMapperTest < Test::Unit::TestCase
       assert_equal old_count - 3, DataMapperObject.count
     end
 
+    should "save the object if it is dirty" do
+      object = DataMapperObject.create
+      object.prop = "something"
+      assert object._t_save_if_dirty
+    end
+
+    should "not save the object if it is not dirty" do
+      object = DataMapperObject.create
+      assert !object._t_save_if_dirty
+    end
+
+    should "be able to successfully determine the id type" do
+      assert_equal Integer, DataMapperObject._t_id_type
+      assert_equal String, DataMapperObjectWithStringId._t_id_type
+    end
+
     context "that works with t_has_many associations" do
       setup do
         @has_many_target_1 = DataMapperHasManyTarget.create

data/test/orm_ext/mongo_mapper_test.rb

@@ -92,6 +92,17 @@ class MongoMapperTest < Test::Unit::TestCase
       MongoMapperObject._t_delete([object_1.id, object_2.id, object_3.id], false)
       assert_equal old_count - 3, MongoMapperObject.count
     end
+
+    should "save the object if it is dirty" do
+      object = MongoMapperObject.create
+      object.prop = "something"
+      assert object._t_save_if_dirty
+    end
+
+    should "not save the object if it is not dirty" do
+      object = MongoMapperObject.create
+      assert !object._t_save_if_dirty
+    end
   end
 
   def association

data/test/orm_ext/mongoid_test.rb

@@ -93,6 +93,17 @@ require_mongoid do
         MongoidObject._t_delete([object_1.id, object_2.id, object_3.id], false)
         assert_equal old_count - 3, MongoidObject.count
       end
+
+      should "save the object if it is dirty" do
+        object = MongoidObject.create
+        object.prop = "something"
+        assert object._t_save_if_dirty
+      end
+
+      should "not save the object if it is not dirty" do
+        object = MongoidObject.create
+        assert !object._t_save_if_dirty
+      end
     end
 
     def association

data/test/orm_ext/ripple_test.rb

@@ -1,140 +1,153 @@
 require 'test_helper'
 
-require_ripple do
-  class RippleTest < Test::Unit::TestCase
-
-    context "The Ripple extension" do
-      setup do
-        setup_ripple_fixtures
-      end
-
-      should "be able to find the object in the database" do
-        object = RippleObject.create
-        assert_equal object, RippleObject._t_find(object.id)
-      end
-
-      should "return nil if the specified id could not be found in the database" do
-        assert_nil RippleObject._t_find('something')
-      end
-
-      should "be able to find multiple objects in the database" do
-        object_1 = RippleObject.create
-        object_2 = RippleObject.create
-        assert_set_equal [object_1, object_2], RippleObject._t_find_bulk([object_1.id, object_2.id, 'bogus_key'])
-      end
-
-      should "return an empty array if none of the specified object ids could be found in the database" do
-        assert_equal [], RippleObject._t_find_bulk(['bogus_key_1', 'bogus_key_2', 'bogus_key_3'])
+if ENV['LONG'] == 'true'
+  require_ripple do
+    class RippleTest < Test::Unit::TestCase
+
+      context "The Ripple extension" do
+        setup do
+          setup_ripple_fixtures
+        end
+
+        should "be able to find the object in the database" do
+          object = RippleObject.create
+          assert_equal object, RippleObject._t_find(object.id)
+        end
+
+        should "return nil if the specified id could not be found in the database" do
+          assert_nil RippleObject._t_find('something')
+        end
+
+        should "be able to find multiple objects in the database" do
+          object_1 = RippleObject.create
+          object_2 = RippleObject.create
+          assert_set_equal [object_1, object_2], RippleObject._t_find_bulk([object_1.id, object_2.id, 'bogus_key'])
+        end
+
+        should "return an empty array if none of the specified object ids could be found in the database" do
+          assert_equal [], RippleObject._t_find_bulk(['bogus_key_1', 'bogus_key_2', 'bogus_key_3'])
+        end
+
+        should "be able to find the first associate of an object" do
+          object = RippleObject.create
+          target = RippleHasOneTarget.create(:ripple_object_id => object.id)
+          assert_equal target, RippleHasOneTarget._t_find_first_by_associate(:ripple_object_id, object.id)
+        end
+
+        should "return nil if the first associate of an object could not be found" do
+          assert_nil RippleHasOneTarget._t_find_first_by_associate(:ripple_object_id, 12345)
+        end
+
+        should "be able to find the associates of an object" do
+          object_1 = RippleObject.create
+          object_2 = RippleObject.create
+          target_1 = RippleHasOneTarget.create(:ripple_object => object_1)
+          target_2 = RippleHasOneTarget.create(:ripple_object => object_1)
+          target_3 = RippleHasOneTarget.create(:ripple_object => object_2)
+          assert_set_equal [target_1, target_2], RippleHasOneTarget._t_find_all_by_associate(:ripple_object_id, object_1.id)
+        end
+
+        should "return an empty array if the object has no associates" do
+          assert_equal [], RippleHasOneTarget._t_find_all_by_associate(:ripple_object_id, '1234')
+        end
+
+        should "be able to reload an object from the database" do
+          target = RippleHasOneTarget.create
+          target.ripple_object_id = '101'
+          assert_equal '101', target.ripple_object_id
+          target._t_reload
+          assert_nil target.ripple_object_id
+        end
+
+        should "be able to get the ids of the objects associated with the given object" do
+          target_1 = RippleHasManyTarget.create
+          target_2 = RippleHasManyTarget.create
+          target_3 = RippleHasManyTarget.create
+          object = RippleObject.create
+          object.ripple_has_many_targets = [target_1, target_2, target_3]
+          object.save
+
+          assert_set_equal [target_1.id, target_2.id, target_3.id], RippleHasManyTarget._t_find_all_ids_by_associate("ripple_object_id", object.id)
+        end
+
+        should "return an empty array when trying to fetch associate ids for an object with no associates" do
+          object = RippleObject.create
+          assert_equal [], RippleHasManyTarget._t_find_all_ids_by_associate("ripple_object_id", object.id)
+        end
+
+        should "be able to delete a set of objects, issuing their callbacks" do
+          object_1 = RippleObject.create
+          object_2 = RippleObject.create
+          object_3 = RippleObject.create
+
+          assert RippleObject.bucket.exist?(object_1.id)
+          assert RippleObject.bucket.exist?(object_2.id)
+          assert RippleObject.bucket.exist?(object_3.id)
+          RippleObject._t_delete([object_1.id, object_2.id, object_3.id])
+          assert !RippleObject.bucket.exist?(object_1.id)
+          assert !RippleObject.bucket.exist?(object_2.id)
+          assert !RippleObject.bucket.exist?(object_3.id)
+        end
+
+        should "be able to delete a setup of objects, without issuing their callbacks" do
+          object_1 = RippleObject.create
+          object_2 = RippleObject.create
+          object_3 = RippleObject.create
+
+          assert RippleObject.bucket.exist?(object_1.id)
+          assert RippleObject.bucket.exist?(object_2.id)
+          assert RippleObject.bucket.exist?(object_3.id)
+          RippleObject._t_delete([object_1.id, object_2.id, object_3.id], false)
+          assert !RippleObject.bucket.exist?(object_1.id)
+          assert !RippleObject.bucket.exist?(object_2.id)
+          assert !RippleObject.bucket.exist?(object_3.id)
+        end
+
+        should "create associate indexes when source object is saved" do
+          target_1 = RippleHasManyTarget.create
+          target_2 = RippleHasManyTarget.create
+          target_3 = RippleHasManyTarget.create
+          object = RippleObject.create
+          object.ripple_has_many_targets = [target_1, target_2, target_3]
+          object.save
+
+          bucket = ::Ripple.client.bucket('tenacity_test_ripple_has_many_target_ripple_object_id')
+          assert_set_equal [target_1.id, target_2.id, target_3.id], bucket.get(object.id).data
+        end
+
+        should "destroy associate indexes when source object is saved" do
+          target_1 = RippleHasManyTarget.create
+          target_2 = RippleHasManyTarget.create
+          target_3 = RippleHasManyTarget.create
+          object = RippleObject.create
+          object.ripple_has_many_targets = [target_1, target_2, target_3]
+          object.save
+
+          bucket = ::Ripple.client.bucket('tenacity_test_ripple_has_many_target_ripple_object_id')
+          assert_set_equal [target_1.id, target_2.id, target_3.id], bucket.get(object.id).data
+          target_2.destroy
+          assert_set_equal [target_1.id, target_3.id], bucket.get(object.id).data
+
+          target_1.destroy
+          target_3.destroy
+          assert_set_equal [], bucket.get(object.id).data
+        end
+
+        should "save the object if it is dirty" do
+          object = RippleObject.create
+          object.prop = "something"
+          assert object._t_save_if_dirty
+        end
+
+        should "not save the object if it is not dirty" do
+          object = RippleObject.create
+          assert !object._t_save_if_dirty
+        end
+      end
+
+      def association
+        Tenacity::Association.new(:t_has_many, :ripple_has_many_targets, RippleObject)
       end
-
-      should "be able to find the first associate of an object" do
-        object = RippleObject.create
-        target = RippleHasOneTarget.create(:ripple_object_id => object.id)
-        assert_equal target, RippleHasOneTarget._t_find_first_by_associate(:ripple_object_id, object.id)
-      end
-
-      should "return nil if the first associate of an object could not be found" do
-        assert_nil RippleHasOneTarget._t_find_first_by_associate(:ripple_object_id, 12345)
-      end
-
-      should "be able to find the associates of an object" do
-        object_1 = RippleObject.create
-        object_2 = RippleObject.create
-        target_1 = RippleHasOneTarget.create(:ripple_object => object_1)
-        target_2 = RippleHasOneTarget.create(:ripple_object => object_1)
-        target_3 = RippleHasOneTarget.create(:ripple_object => object_2)
-        assert_set_equal [target_1, target_2], RippleHasOneTarget._t_find_all_by_associate(:ripple_object_id, object_1.id)
-      end
-
-      should "return an empty array if the object has no associates" do
-        assert_equal [], RippleHasOneTarget._t_find_all_by_associate(:ripple_object_id, '1234')
-      end
-
-      should "be able to reload an object from the database" do
-        target = RippleHasOneTarget.create
-        target.ripple_object_id = '101'
-        assert_equal '101', target.ripple_object_id
-        target._t_reload
-        assert_nil target.ripple_object_id
-      end
-
-      should "be able to get the ids of the objects associated with the given object" do
-        target_1 = RippleHasManyTarget.create
-        target_2 = RippleHasManyTarget.create
-        target_3 = RippleHasManyTarget.create
-        object = RippleObject.create
-        object.ripple_has_many_targets = [target_1, target_2, target_3]
-        object.save
-
-        assert_set_equal [target_1.id, target_2.id, target_3.id], RippleHasManyTarget._t_find_all_ids_by_associate("ripple_object_id", object.id)
-      end
-
-      should "return an empty array when trying to fetch associate ids for an object with no associates" do
-        object = RippleObject.create
-        assert_equal [], RippleHasManyTarget._t_find_all_ids_by_associate("ripple_object_id", object.id)
-      end
-
-      should "be able to delete a set of objects, issuing their callbacks" do
-        object_1 = RippleObject.create
-        object_2 = RippleObject.create
-        object_3 = RippleObject.create
-
-        assert RippleObject.bucket.exist?(object_1.id)
-        assert RippleObject.bucket.exist?(object_2.id)
-        assert RippleObject.bucket.exist?(object_3.id)
-        RippleObject._t_delete([object_1.id, object_2.id, object_3.id])
-        assert !RippleObject.bucket.exist?(object_1.id)
-        assert !RippleObject.bucket.exist?(object_2.id)
-        assert !RippleObject.bucket.exist?(object_3.id)
-      end
-
-      should "be able to delete a setup of objects, without issuing their callbacks" do
-        object_1 = RippleObject.create
-        object_2 = RippleObject.create
-        object_3 = RippleObject.create
-
-        assert RippleObject.bucket.exist?(object_1.id)
-        assert RippleObject.bucket.exist?(object_2.id)
-        assert RippleObject.bucket.exist?(object_3.id)
-        RippleObject._t_delete([object_1.id, object_2.id, object_3.id], false)
-        assert !RippleObject.bucket.exist?(object_1.id)
-        assert !RippleObject.bucket.exist?(object_2.id)
-        assert !RippleObject.bucket.exist?(object_3.id)
-      end
-
-      should "create associate indexes when source object is saved" do
-        target_1 = RippleHasManyTarget.create
-        target_2 = RippleHasManyTarget.create
-        target_3 = RippleHasManyTarget.create
-        object = RippleObject.create
-        object.ripple_has_many_targets = [target_1, target_2, target_3]
-        object.save
-
-        bucket = ::Ripple.client.bucket('tenacity_test_ripple_has_many_target_ripple_object_id')
-        assert_set_equal [target_1.id, target_2.id, target_3.id], bucket.get(object.id).data
-      end
-
-      should "destroy associate indexes when source object is saved" do
-        target_1 = RippleHasManyTarget.create
-        target_2 = RippleHasManyTarget.create
-        target_3 = RippleHasManyTarget.create
-        object = RippleObject.create
-        object.ripple_has_many_targets = [target_1, target_2, target_3]
-        object.save
-
-        bucket = ::Ripple.client.bucket('tenacity_test_ripple_has_many_target_ripple_object_id')
-        assert_set_equal [target_1.id, target_2.id, target_3.id], bucket.get(object.id).data
-        target_2.destroy
-        assert_set_equal [target_1.id, target_3.id], bucket.get(object.id).data
-
-        target_1.destroy
-        target_3.destroy
-        assert_set_equal [], bucket.get(object.id).data
-      end
-    end
-
-    def association
-      Tenacity::Association.new(:t_has_many, :ripple_has_many_targets, RippleObject)
     end
   end
 end