← Back to branch summary

~michaelforrest/use-case-mapper/trunk

« back to all changes in this revision

Viewing changes to vendor/rails/activerecord/test/cases/lifecycle_test.rb

  • Committer: Richard Lee (Canonical)
  • Date: 2010-10-15 15:17:58 UTC
  • mfrom: (190.1.3 use-case-mapper)
  • Revision ID: richard.lee@canonical.com-20101015151758-wcvmfxrexsongf9d
Merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/rails/activerecord/test/cases/lifecycle_test.rb
1
 
require "cases/helper"
2
 
require 'models/topic'
3
 
require 'models/developer'
4
 
require 'models/reply'
5
 
require 'models/minimalistic'
6
 
 
7
 
class Topic; def after_find() end end
8
 
class Developer; def after_find() end end
9
 
class SpecialDeveloper < Developer; end
10
 
 
11
 
class TopicManualObserver
12
 
  include Singleton
13
 
 
14
 
  attr_reader :action, :object, :callbacks
15
 
 
16
 
  def initialize
17
 
    Topic.add_observer(self)
18
 
    @callbacks = []
19
 
  end
20
 
 
21
 
  def update(callback_method, object)
22
 
    @callbacks << { "callback_method" => callback_method, "object" => object }
23
 
  end
24
 
 
25
 
  def has_been_notified?
26
 
    !@callbacks.empty?
27
 
  end
28
 
end
29
 
 
30
 
class TopicaAuditor < ActiveRecord::Observer
31
 
  observe :topic
32
 
 
33
 
  attr_reader :topic
34
 
 
35
 
  def after_find(topic)
36
 
    @topic = topic
37
 
  end
38
 
end
39
 
 
40
 
class TopicObserver < ActiveRecord::Observer
41
 
  attr_reader :topic
42
 
 
43
 
  def after_find(topic)
44
 
    @topic = topic
45
 
  end
46
 
end
47
 
 
48
 
class MinimalisticObserver < ActiveRecord::Observer
49
 
  attr_reader :minimalistic
50
 
 
51
 
  def after_find(minimalistic)
52
 
    @minimalistic = minimalistic
53
 
  end
54
 
end
55
 
 
56
 
class MultiObserver < ActiveRecord::Observer
57
 
  attr_reader :record
58
 
 
59
 
  def self.observed_class() [ Topic, Developer ] end
60
 
 
61
 
  cattr_reader :last_inherited
62
 
  @@last_inherited = nil
63
 
 
64
 
  def observed_class_inherited_with_testing(subclass)
65
 
    observed_class_inherited_without_testing(subclass)
66
 
    @@last_inherited = subclass
67
 
  end
68
 
 
69
 
  alias_method_chain :observed_class_inherited, :testing
70
 
 
71
 
  def after_find(record)
72
 
    @record = record
73
 
  end
74
 
end
75
 
 
76
 
class LifecycleTest < ActiveRecord::TestCase
77
 
  fixtures :topics, :developers, :minimalistics
78
 
 
79
 
  def test_before_destroy
80
 
    original_count = Topic.count
81
 
    (topic_to_be_destroyed = Topic.find(1)).destroy
82
 
    assert_equal original_count - (1 + topic_to_be_destroyed.replies.size), Topic.count
83
 
  end
84
 
 
85
 
  def test_after_save
86
 
    ActiveRecord::Base.observers = :topic_manual_observer
87
 
    ActiveRecord::Base.instantiate_observers
88
 
 
89
 
    topic = Topic.find(1)
90
 
    topic.title = "hello"
91
 
    topic.save
92
 
 
93
 
    assert TopicManualObserver.instance.has_been_notified?
94
 
    assert_equal :after_save, TopicManualObserver.instance.callbacks.last["callback_method"]
95
 
  end
96
 
 
97
 
  def test_observer_update_on_save
98
 
    ActiveRecord::Base.observers = TopicManualObserver
99
 
    ActiveRecord::Base.instantiate_observers
100
 
 
101
 
    topic = Topic.find(1)
102
 
    assert TopicManualObserver.instance.has_been_notified?
103
 
    assert_equal :after_find, TopicManualObserver.instance.callbacks.first["callback_method"]
104
 
  end
105
 
 
106
 
  def test_auto_observer
107
 
    topic_observer = TopicaAuditor.instance
108
 
    assert_nil TopicaAuditor.observed_class
109
 
    assert_equal [Topic], TopicaAuditor.instance.observed_classes.to_a
110
 
 
111
 
    topic = Topic.find(1)
112
 
    assert_equal topic.title, topic_observer.topic.title
113
 
  end
114
 
 
115
 
  def test_inferred_auto_observer
116
 
    topic_observer = TopicObserver.instance
117
 
    assert_equal Topic, TopicObserver.observed_class
118
 
 
119
 
    topic = Topic.find(1)
120
 
    assert_equal topic.title, topic_observer.topic.title
121
 
  end
122
 
 
123
 
  def test_observing_two_classes
124
 
    multi_observer = MultiObserver.instance
125
 
 
126
 
    topic = Topic.find(1)
127
 
    assert_equal topic.title, multi_observer.record.title
128
 
 
129
 
    developer = Developer.find(1)
130
 
    assert_equal developer.name, multi_observer.record.name
131
 
  end
132
 
 
133
 
  def test_observing_subclasses
134
 
    multi_observer = MultiObserver.instance
135
 
 
136
 
    developer = SpecialDeveloper.find(1)
137
 
    assert_equal developer.name, multi_observer.record.name
138
 
 
139
 
    klass = Class.new(Developer)
140
 
    assert_equal klass, multi_observer.last_inherited
141
 
 
142
 
    developer = klass.find(1)
143
 
    assert_equal developer.name, multi_observer.record.name
144
 
  end
145
 
 
146
 
  def test_after_find_can_be_observed_when_its_not_defined_on_the_model
147
 
    observer = MinimalisticObserver.instance
148
 
    assert_equal Minimalistic, MinimalisticObserver.observed_class
149
 
 
150
 
    minimalistic = Minimalistic.find(1)
151
 
    assert_equal minimalistic, observer.minimalistic
152
 
  end
153
 
 
154
 
  def test_after_find_can_be_observed_when_its_defined_on_the_model
155
 
    observer = TopicObserver.instance
156
 
    assert_equal Topic, TopicObserver.observed_class
157
 
 
158
 
    topic = Topic.find(1)
159
 
    assert_equal topic, observer.topic
160
 
  end
161
 
 
162
 
  def test_after_find_is_not_created_if_its_not_used
163
 
    # use a fresh class so an observer can't have defined an
164
 
    # after_find on it
165
 
    model_class = Class.new(ActiveRecord::Base)
166
 
    observer_class = Class.new(ActiveRecord::Observer)
167
 
    observer_class.observe(model_class)
168
 
 
169
 
    observer = observer_class.instance
170
 
 
171
 
    assert !model_class.method_defined?(:after_find)
172
 
  end
173
 
 
174
 
  def test_after_find_is_not_clobbered_if_it_already_exists
175
 
    # use a fresh observer class so we can instantiate it (Observer is
176
 
    # a Singleton)
177
 
    model_class = Class.new(ActiveRecord::Base) do
178
 
      def after_find; end
179
 
    end
180
 
    original_method = model_class.instance_method(:after_find)
181
 
    observer_class = Class.new(ActiveRecord::Observer) do
182
 
      def after_find; end
183
 
    end
184
 
    observer_class.observe(model_class)
185
 
 
186
 
    observer = observer_class.instance
187
 
    assert_equal original_method, model_class.instance_method(:after_find)
188
 
  end
189
 
 
190
 
  def test_invalid_observer
191
 
    assert_raise(ArgumentError) { Topic.observers = Object.new; Topic.instantiate_observers }
192
 
  end
193
 
end