2008-01-21 12:20:51 -05:00
|
|
|
require "cases/helper"
|
2008-01-18 02:31:37 -05:00
|
|
|
require 'models/topic'
|
|
|
|
require 'models/developer'
|
|
|
|
require 'models/reply'
|
2008-06-08 23:45:57 -04:00
|
|
|
require 'models/minimalistic'
|
2004-11-23 20:04:44 -05:00
|
|
|
|
|
|
|
class Topic; def after_find() end end
|
|
|
|
class Developer; def after_find() end end
|
2005-09-19 12:34:34 -04:00
|
|
|
class SpecialDeveloper < Developer; end
|
2004-11-23 20:04:44 -05:00
|
|
|
|
|
|
|
class TopicManualObserver
|
|
|
|
include Singleton
|
|
|
|
|
|
|
|
attr_reader :action, :object, :callbacks
|
|
|
|
|
|
|
|
def initialize
|
|
|
|
Topic.add_observer(self)
|
|
|
|
@callbacks = []
|
|
|
|
end
|
|
|
|
|
|
|
|
def update(callback_method, object)
|
|
|
|
@callbacks << { "callback_method" => callback_method, "object" => object }
|
|
|
|
end
|
|
|
|
|
|
|
|
def has_been_notified?
|
|
|
|
!@callbacks.empty?
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-02-17 17:52:55 -05:00
|
|
|
class TopicaAuditor < ActiveRecord::Observer
|
2007-10-14 01:20:24 -04:00
|
|
|
observe :topic
|
2008-01-18 02:30:42 -05:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
attr_reader :topic
|
2008-01-18 02:30:42 -05:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def after_find(topic)
|
|
|
|
@topic = topic
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
class TopicObserver < ActiveRecord::Observer
|
|
|
|
attr_reader :topic
|
2008-01-18 02:30:42 -05:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def after_find(topic)
|
|
|
|
@topic = topic
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-06-08 23:45:57 -04:00
|
|
|
class MinimalisticObserver < ActiveRecord::Observer
|
|
|
|
attr_reader :minimalistic
|
|
|
|
|
|
|
|
def after_find(minimalistic)
|
|
|
|
@minimalistic = minimalistic
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
class MultiObserver < ActiveRecord::Observer
|
|
|
|
attr_reader :record
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def self.observed_class() [ Topic, Developer ] end
|
|
|
|
|
2006-06-30 00:38:24 -04:00
|
|
|
cattr_reader :last_inherited
|
|
|
|
@@last_inherited = nil
|
|
|
|
|
|
|
|
def observed_class_inherited_with_testing(subclass)
|
|
|
|
observed_class_inherited_without_testing(subclass)
|
|
|
|
@@last_inherited = subclass
|
|
|
|
end
|
|
|
|
|
|
|
|
alias_method_chain :observed_class_inherited, :testing
|
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def after_find(record)
|
|
|
|
@record = record
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-01-21 12:20:51 -05:00
|
|
|
class LifecycleTest < ActiveRecord::TestCase
|
2008-07-31 16:59:53 -04:00
|
|
|
fixtures :topics, :developers, :minimalistics
|
2004-11-23 20:04:44 -05:00
|
|
|
|
|
|
|
def test_before_destroy
|
2008-03-23 22:50:02 -04:00
|
|
|
original_count = Topic.count
|
|
|
|
(topic_to_be_destroyed = Topic.find(1)).destroy
|
|
|
|
assert_equal original_count - (1 + topic_to_be_destroyed.replies.size), Topic.count
|
2004-11-23 20:04:44 -05:00
|
|
|
end
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def test_after_save
|
2005-09-25 04:48:30 -04:00
|
|
|
ActiveRecord::Base.observers = :topic_manual_observer
|
2006-08-05 22:40:24 -04:00
|
|
|
ActiveRecord::Base.instantiate_observers
|
2004-11-23 20:04:44 -05:00
|
|
|
|
|
|
|
topic = Topic.find(1)
|
|
|
|
topic.title = "hello"
|
|
|
|
topic.save
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2005-09-25 04:48:30 -04:00
|
|
|
assert TopicManualObserver.instance.has_been_notified?
|
|
|
|
assert_equal :after_save, TopicManualObserver.instance.callbacks.last["callback_method"]
|
2004-11-23 20:04:44 -05:00
|
|
|
end
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def test_observer_update_on_save
|
2005-09-25 04:48:30 -04:00
|
|
|
ActiveRecord::Base.observers = TopicManualObserver
|
2006-08-05 22:40:24 -04:00
|
|
|
ActiveRecord::Base.instantiate_observers
|
2004-11-23 20:04:44 -05:00
|
|
|
|
2006-06-30 00:38:24 -04:00
|
|
|
topic = Topic.find(1)
|
2005-09-25 04:48:30 -04:00
|
|
|
assert TopicManualObserver.instance.has_been_notified?
|
|
|
|
assert_equal :after_find, TopicManualObserver.instance.callbacks.first["callback_method"]
|
2004-11-23 20:04:44 -05:00
|
|
|
end
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def test_auto_observer
|
2008-02-17 17:52:55 -05:00
|
|
|
topic_observer = TopicaAuditor.instance
|
|
|
|
assert_nil TopicaAuditor.observed_class
|
|
|
|
assert_equal [Topic], TopicaAuditor.instance.observed_classes.to_a
|
2004-11-23 20:04:44 -05:00
|
|
|
|
2006-06-30 00:38:24 -04:00
|
|
|
topic = Topic.find(1)
|
|
|
|
assert_equal topic.title, topic_observer.topic.title
|
2004-11-23 20:04:44 -05:00
|
|
|
end
|
2006-06-30 00:38:24 -04:00
|
|
|
|
|
|
|
def test_inferred_auto_observer
|
2004-11-23 20:04:44 -05:00
|
|
|
topic_observer = TopicObserver.instance
|
2008-02-17 17:52:55 -05:00
|
|
|
assert_equal Topic, TopicObserver.observed_class
|
2004-11-23 20:04:44 -05:00
|
|
|
|
2006-06-30 00:38:24 -04:00
|
|
|
topic = Topic.find(1)
|
|
|
|
assert_equal topic.title, topic_observer.topic.title
|
2004-11-23 20:04:44 -05:00
|
|
|
end
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2004-11-23 20:04:44 -05:00
|
|
|
def test_observing_two_classes
|
|
|
|
multi_observer = MultiObserver.instance
|
|
|
|
|
|
|
|
topic = Topic.find(1)
|
2006-06-30 00:38:24 -04:00
|
|
|
assert_equal topic.title, multi_observer.record.title
|
2004-11-23 20:04:44 -05:00
|
|
|
|
2006-06-30 00:38:24 -04:00
|
|
|
developer = Developer.find(1)
|
|
|
|
assert_equal developer.name, multi_observer.record.name
|
2004-11-23 20:04:44 -05:00
|
|
|
end
|
2006-06-30 00:38:24 -04:00
|
|
|
|
2005-09-19 12:34:34 -04:00
|
|
|
def test_observing_subclasses
|
|
|
|
multi_observer = MultiObserver.instance
|
|
|
|
|
|
|
|
developer = SpecialDeveloper.find(1)
|
2006-06-30 00:38:24 -04:00
|
|
|
assert_equal developer.name, multi_observer.record.name
|
|
|
|
|
|
|
|
klass = Class.new(Developer)
|
|
|
|
assert_equal klass, multi_observer.last_inherited
|
|
|
|
|
|
|
|
developer = klass.find(1)
|
|
|
|
assert_equal developer.name, multi_observer.record.name
|
|
|
|
end
|
|
|
|
|
2008-07-22 16:38:26 -04:00
|
|
|
def test_after_find_can_be_observed_when_its_not_defined_on_the_model
|
2008-06-08 23:45:57 -04:00
|
|
|
observer = MinimalisticObserver.instance
|
|
|
|
assert_equal Minimalistic, MinimalisticObserver.observed_class
|
|
|
|
|
|
|
|
minimalistic = Minimalistic.find(1)
|
2008-07-22 16:38:26 -04:00
|
|
|
assert_equal minimalistic, observer.minimalistic
|
2008-07-15 14:55:14 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_after_find_can_be_observed_when_its_defined_on_the_model
|
|
|
|
observer = TopicObserver.instance
|
|
|
|
assert_equal Topic, TopicObserver.observed_class
|
|
|
|
|
|
|
|
topic = Topic.find(1)
|
|
|
|
assert_equal topic, observer.topic
|
2008-06-08 23:45:57 -04:00
|
|
|
end
|
|
|
|
|
2008-07-22 16:38:26 -04:00
|
|
|
def test_after_find_is_not_created_if_its_not_used
|
|
|
|
# use a fresh class so an observer can't have defined an
|
|
|
|
# after_find on it
|
|
|
|
model_class = Class.new(ActiveRecord::Base)
|
|
|
|
observer_class = Class.new(ActiveRecord::Observer)
|
|
|
|
observer_class.observe(model_class)
|
|
|
|
|
|
|
|
observer = observer_class.instance
|
|
|
|
|
|
|
|
assert !model_class.method_defined?(:after_find)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_after_find_is_not_clobbered_if_it_already_exists
|
|
|
|
# use a fresh observer class so we can instantiate it (Observer is
|
|
|
|
# a Singleton)
|
|
|
|
model_class = Class.new(ActiveRecord::Base) do
|
|
|
|
def after_find; end
|
|
|
|
end
|
|
|
|
original_method = model_class.instance_method(:after_find)
|
|
|
|
observer_class = Class.new(ActiveRecord::Observer) do
|
|
|
|
def after_find; end
|
|
|
|
end
|
|
|
|
observer_class.observe(model_class)
|
|
|
|
|
|
|
|
observer = observer_class.instance
|
|
|
|
assert_equal original_method, model_class.instance_method(:after_find)
|
|
|
|
end
|
|
|
|
|
2006-06-30 00:38:24 -04:00
|
|
|
def test_invalid_observer
|
2006-08-05 22:40:24 -04:00
|
|
|
assert_raise(ArgumentError) { Topic.observers = Object.new; Topic.instantiate_observers }
|
2005-09-19 12:34:34 -04:00
|
|
|
end
|
2005-06-10 10:58:02 -04:00
|
|
|
end
|