From 2036d3ba75da1a0f3061bf5a33c89e2b2eaff420 Mon Sep 17 00:00:00 2001 From: Carl Lerche & Yehuda Katz Date: Thu, 9 Apr 2009 12:33:39 -0700 Subject: Revert rspec-runner change. TODO: Add back support for the rspec T::U runner. --- .../active_support/testing/setup_and_teardown.rb | 16 +- activesupport/test/new_callbacks_test.rb | 600 +++++++++++---------- 2 files changed, 306 insertions(+), 310 deletions(-) diff --git a/activesupport/lib/active_support/testing/setup_and_teardown.rb b/activesupport/lib/active_support/testing/setup_and_teardown.rb index 780c1309f4..6248bf1921 100644 --- a/activesupport/lib/active_support/testing/setup_and_teardown.rb +++ b/activesupport/lib/active_support/testing/setup_and_teardown.rb @@ -10,6 +10,8 @@ module ActiveSupport if defined? MiniTest include ForMiniTest + elsif defined? Spec + include ForRspec else include ForClassicTestUnit end @@ -34,19 +36,11 @@ module ActiveSupport result end end - + module ForClassicTestUnit # For compatibility with Ruby < 1.8.6 PASSTHROUGH_EXCEPTIONS = Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit] - def setup - run_callbacks :setup - end - - def teardown - run_callbacks :teardown, :enumerator => :reverse_each - end - # This redefinition is unfortunate but test/unit shows us no alternative. # Doubly unfortunate: hax to support Mocha's hax. def run(result) @@ -60,7 +54,7 @@ module ActiveSupport @_result = result begin begin - # run_callbacks :setup + run_callbacks :setup setup __send__(@method_name) mocha_verify(assertion_counter) if using_mocha @@ -74,7 +68,7 @@ module ActiveSupport ensure begin teardown - # run_callbacks :teardown, :enumerator => :reverse_each + run_callbacks :teardown, :enumerator => :reverse_each rescue Test::Unit::AssertionFailedError => e add_failure(e.message, e.backtrace) rescue Exception => e diff --git a/activesupport/test/new_callbacks_test.rb b/activesupport/test/new_callbacks_test.rb index 6948ad23dc..5cde078b65 100644 --- a/activesupport/test/new_callbacks_test.rb +++ b/activesupport/test/new_callbacks_test.rb @@ -3,380 +3,382 @@ require 'test/unit' $:.unshift "#{File.dirname(__FILE__)}/../lib" require 'active_support' -class Record - include ActiveSupport::NewCallbacks +module NewCallbacksTest + class Record + include ActiveSupport::NewCallbacks - define_callbacks :save + define_callbacks :save - def self.before_save(*filters, &blk) - save_callback(:before, *filters, &blk) - end + def self.before_save(*filters, &blk) + save_callback(:before, *filters, &blk) + end - def self.after_save(*filters, &blk) - save_callback(:after, *filters, &blk) - end + def self.after_save(*filters, &blk) + save_callback(:after, *filters, &blk) + end - class << self - def callback_symbol(callback_method) - returning(:"#{callback_method}_method") do |method_name| - define_method(method_name) do - history << [callback_method, :symbol] + class << self + def callback_symbol(callback_method) + returning(:"#{callback_method}_method") do |method_name| + define_method(method_name) do + history << [callback_method, :symbol] + end end end - end - def callback_string(callback_method) - "history << [#{callback_method.to_sym.inspect}, :string]" - end + def callback_string(callback_method) + "history << [#{callback_method.to_sym.inspect}, :string]" + end - def callback_proc(callback_method) - Proc.new { |model| model.history << [callback_method, :proc] } - end + def callback_proc(callback_method) + Proc.new { |model| model.history << [callback_method, :proc] } + end - def callback_object(callback_method) - klass = Class.new - klass.send(:define_method, callback_method) do |model| - model.history << [callback_method, :object] + def callback_object(callback_method) + klass = Class.new + klass.send(:define_method, callback_method) do |model| + model.history << [callback_method, :object] + end + klass.new end - klass.new end - end - def history - @history ||= [] + def history + @history ||= [] + end end -end -class Person < Record - [:before_save, :after_save].each do |callback_method| - callback_method_sym = callback_method.to_sym - send(callback_method, callback_symbol(callback_method_sym)) - send(callback_method, callback_string(callback_method_sym)) - send(callback_method, callback_proc(callback_method_sym)) - send(callback_method, callback_object(callback_method_sym)) - send(callback_method) { |model| model.history << [callback_method_sym, :block] } - end + class Person < Record + [:before_save, :after_save].each do |callback_method| + callback_method_sym = callback_method.to_sym + send(callback_method, callback_symbol(callback_method_sym)) + send(callback_method, callback_string(callback_method_sym)) + send(callback_method, callback_proc(callback_method_sym)) + send(callback_method, callback_object(callback_method_sym)) + send(callback_method) { |model| model.history << [callback_method_sym, :block] } + end - def save - _run_save_callbacks {} + def save + _run_save_callbacks {} + end end -end -class PersonSkipper < Person - skip_save_callback :before, :before_save_method, :if => :yes - skip_save_callback :after, :before_save_method, :unless => :yes - skip_save_callback :after, :before_save_method, :if => :no - skip_save_callback :before, :before_save_method, :unless => :no - def yes; true; end - def no; false; end -end + class PersonSkipper < Person + skip_save_callback :before, :before_save_method, :if => :yes + skip_save_callback :after, :before_save_method, :unless => :yes + skip_save_callback :after, :before_save_method, :if => :no + skip_save_callback :before, :before_save_method, :unless => :no + def yes; true; end + def no; false; end + end -class ParentController - include ActiveSupport::NewCallbacks + class ParentController + include ActiveSupport::NewCallbacks - define_callbacks :dispatch + define_callbacks :dispatch - dispatch_callback :before, :log, :per_key => {:unless => proc {|c| c.action_name == :index || c.action_name == :show }} - dispatch_callback :after, :log2 + dispatch_callback :before, :log, :per_key => {:unless => proc {|c| c.action_name == :index || c.action_name == :show }} + dispatch_callback :after, :log2 - attr_reader :action_name, :logger - def initialize(action_name) - @action_name, @logger = action_name, [] - end + attr_reader :action_name, :logger + def initialize(action_name) + @action_name, @logger = action_name, [] + end - def log - @logger << action_name - end + def log + @logger << action_name + end - def log2 - @logger << action_name - end + def log2 + @logger << action_name + end - def dispatch - _run_dispatch_callbacks(action_name) { - @logger << "Done" - } - self + def dispatch + _run_dispatch_callbacks(action_name) { + @logger << "Done" + } + self + end end -end -class Child < ParentController - skip_dispatch_callback :before, :log, :per_key => {:if => proc {|c| c.action_name == :update} } - skip_dispatch_callback :after, :log2 -end + class Child < ParentController + skip_dispatch_callback :before, :log, :per_key => {:if => proc {|c| c.action_name == :update} } + skip_dispatch_callback :after, :log2 + end -class OneTimeCompile < Record - @@starts_true, @@starts_false = true, false + class OneTimeCompile < Record + @@starts_true, @@starts_false = true, false - def initialize - super - end + def initialize + super + end - before_save Proc.new {|r| r.history << [:before_save, :starts_true, :if] }, :per_key => {:if => :starts_true} - before_save Proc.new {|r| r.history << [:before_save, :starts_false, :if] }, :per_key => {:if => :starts_false} - before_save Proc.new {|r| r.history << [:before_save, :starts_true, :unless] }, :per_key => {:unless => :starts_true} - before_save Proc.new {|r| r.history << [:before_save, :starts_false, :unless] }, :per_key => {:unless => :starts_false} + before_save Proc.new {|r| r.history << [:before_save, :starts_true, :if] }, :per_key => {:if => :starts_true} + before_save Proc.new {|r| r.history << [:before_save, :starts_false, :if] }, :per_key => {:if => :starts_false} + before_save Proc.new {|r| r.history << [:before_save, :starts_true, :unless] }, :per_key => {:unless => :starts_true} + before_save Proc.new {|r| r.history << [:before_save, :starts_false, :unless] }, :per_key => {:unless => :starts_false} - def starts_true - if @@starts_true - @@starts_true = false - return true + def starts_true + if @@starts_true + @@starts_true = false + return true + end + @@starts_true end - @@starts_true - end - def starts_false - unless @@starts_false - @@starts_false = true - return false + def starts_false + unless @@starts_false + @@starts_false = true + return false + end + @@starts_false end - @@starts_false - end - def save - _run_save_callbacks(:action) {} + def save + _run_save_callbacks(:action) {} + end end -end -class OneTimeCompileTest < Test::Unit::TestCase - def test_optimized_first_compile - around = OneTimeCompile.new - around.save - assert_equal [ - [:before_save, :starts_true, :if], - [:before_save, :starts_true, :unless] - ], around.history + class OneTimeCompileTest < Test::Unit::TestCase + def test_optimized_first_compile + around = OneTimeCompile.new + around.save + assert_equal [ + [:before_save, :starts_true, :if], + [:before_save, :starts_true, :unless] + ], around.history + end end -end -class ConditionalPerson < Record - # proc - before_save Proc.new { |r| r.history << [:before_save, :proc] }, :if => Proc.new { |r| true } - before_save Proc.new { |r| r.history << "b00m" }, :if => Proc.new { |r| false } - before_save Proc.new { |r| r.history << [:before_save, :proc] }, :unless => Proc.new { |r| false } - before_save Proc.new { |r| r.history << "b00m" }, :unless => Proc.new { |r| true } - # symbol - before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :if => :yes - before_save Proc.new { |r| r.history << "b00m" }, :if => :no - before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :unless => :no - before_save Proc.new { |r| r.history << "b00m" }, :unless => :yes - # string - before_save Proc.new { |r| r.history << [:before_save, :string] }, :if => 'yes' - before_save Proc.new { |r| r.history << "b00m" }, :if => 'no' - before_save Proc.new { |r| r.history << [:before_save, :string] }, :unless => 'no' - before_save Proc.new { |r| r.history << "b00m" }, :unless => 'yes' - # Combined if and unless - before_save Proc.new { |r| r.history << [:before_save, :combined_symbol] }, :if => :yes, :unless => :no - before_save Proc.new { |r| r.history << "b00m" }, :if => :yes, :unless => :yes + class ConditionalPerson < Record + # proc + before_save Proc.new { |r| r.history << [:before_save, :proc] }, :if => Proc.new { |r| true } + before_save Proc.new { |r| r.history << "b00m" }, :if => Proc.new { |r| false } + before_save Proc.new { |r| r.history << [:before_save, :proc] }, :unless => Proc.new { |r| false } + before_save Proc.new { |r| r.history << "b00m" }, :unless => Proc.new { |r| true } + # symbol + before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :if => :yes + before_save Proc.new { |r| r.history << "b00m" }, :if => :no + before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :unless => :no + before_save Proc.new { |r| r.history << "b00m" }, :unless => :yes + # string + before_save Proc.new { |r| r.history << [:before_save, :string] }, :if => 'yes' + before_save Proc.new { |r| r.history << "b00m" }, :if => 'no' + before_save Proc.new { |r| r.history << [:before_save, :string] }, :unless => 'no' + before_save Proc.new { |r| r.history << "b00m" }, :unless => 'yes' + # Combined if and unless + before_save Proc.new { |r| r.history << [:before_save, :combined_symbol] }, :if => :yes, :unless => :no + before_save Proc.new { |r| r.history << "b00m" }, :if => :yes, :unless => :yes - def yes; true; end - def other_yes; true; end - def no; false; end - def other_no; false; end + def yes; true; end + def other_yes; true; end + def no; false; end + def other_no; false; end - def save - _run_save_callbacks {} + def save + _run_save_callbacks {} + end end -end -class MySuper - include ActiveSupport::NewCallbacks - define_callbacks :save -end + class MySuper + include ActiveSupport::NewCallbacks + define_callbacks :save + end -class AroundPerson < MySuper - attr_reader :history + class AroundPerson < MySuper + attr_reader :history - save_callback :before, :nope, :if => :no - save_callback :before, :nope, :unless => :yes - save_callback :after, :tweedle - save_callback :before, "tweedle_dee" - save_callback :before, proc {|m| m.history << "yup" } - save_callback :before, :nope, :if => proc { false } - save_callback :before, :nope, :unless => proc { true } - save_callback :before, :yup, :if => proc { true } - save_callback :before, :yup, :unless => proc { false } - save_callback :around, :tweedle_dum - save_callback :around, :w0tyes, :if => :yes - save_callback :around, :w0tno, :if => :no - save_callback :around, :tweedle_deedle + save_callback :before, :nope, :if => :no + save_callback :before, :nope, :unless => :yes + save_callback :after, :tweedle + save_callback :before, "tweedle_dee" + save_callback :before, proc {|m| m.history << "yup" } + save_callback :before, :nope, :if => proc { false } + save_callback :before, :nope, :unless => proc { true } + save_callback :before, :yup, :if => proc { true } + save_callback :before, :yup, :unless => proc { false } + save_callback :around, :tweedle_dum + save_callback :around, :w0tyes, :if => :yes + save_callback :around, :w0tno, :if => :no + save_callback :around, :tweedle_deedle - def no; false; end - def yes; true; end + def no; false; end + def yes; true; end - def nope - @history << "boom" - end + def nope + @history << "boom" + end - def yup - @history << "yup" - end + def yup + @history << "yup" + end - def w0tyes - @history << "w0tyes before" - yield - @history << "w0tyes after" - end + def w0tyes + @history << "w0tyes before" + yield + @history << "w0tyes after" + end - def w0tno - @history << "boom" - yield - end + def w0tno + @history << "boom" + yield + end - def tweedle_dee - @history << "tweedle dee" - end + def tweedle_dee + @history << "tweedle dee" + end - def tweedle_dum - @history << "tweedle dum pre" - yield - @history << "tweedle dum post" - end + def tweedle_dum + @history << "tweedle dum pre" + yield + @history << "tweedle dum post" + end - def tweedle - @history << "tweedle" - end + def tweedle + @history << "tweedle" + end - def tweedle_deedle - @history << "tweedle deedle pre" - yield - @history << "tweedle deedle post" - end + def tweedle_deedle + @history << "tweedle deedle pre" + yield + @history << "tweedle deedle post" + end - def initialize - @history = [] - end + def initialize + @history = [] + end - def save - _run_save_callbacks do - @history << "running" + def save + _run_save_callbacks do + @history << "running" + end end end -end -class AroundCallbacksTest < Test::Unit::TestCase - def test_save_around - around = AroundPerson.new - around.save - assert_equal [ - "tweedle dee", - "yup", "yup", "yup", - "tweedle dum pre", - "w0tyes before", - "tweedle deedle pre", - "running", - "tweedle deedle post", - "w0tyes after", - "tweedle dum post", - "tweedle" - ], around.history + class AroundCallbacksTest < Test::Unit::TestCase + def test_save_around + around = AroundPerson.new + around.save + assert_equal [ + "tweedle dee", + "yup", "yup", + "tweedle dum pre", + "w0tyes before", + "tweedle deedle pre", + "running", + "tweedle deedle post", + "w0tyes after", + "tweedle dum post", + "tweedle" + ], around.history + end end -end -class SkipCallbacksTest < Test::Unit::TestCase - def test_skip_person - person = PersonSkipper.new - assert_equal [], person.history - person.save - assert_equal [ - [:before_save, :string], - [:before_save, :proc], - [:before_save, :object], - [:before_save, :block], - [:after_save, :block], - [:after_save, :object], - [:after_save, :proc], - [:after_save, :string], - [:after_save, :symbol] - ], person.history + class SkipCallbacksTest < Test::Unit::TestCase + def test_skip_person + person = PersonSkipper.new + assert_equal [], person.history + person.save + assert_equal [ + [:before_save, :string], + [:before_save, :proc], + [:before_save, :object], + [:before_save, :block], + [:after_save, :block], + [:after_save, :object], + [:after_save, :proc], + [:after_save, :string], + [:after_save, :symbol] + ], person.history + end end -end -class CallbacksTest < Test::Unit::TestCase - def test_save_person - person = Person.new - assert_equal [], person.history - person.save - assert_equal [ - [:before_save, :symbol], - [:before_save, :string], - [:before_save, :proc], - [:before_save, :object], - [:before_save, :block], - [:after_save, :block], - [:after_save, :object], - [:after_save, :proc], - [:after_save, :string], - [:after_save, :symbol] - ], person.history + class CallbacksTest < Test::Unit::TestCase + def test_save_person + person = Person.new + assert_equal [], person.history + person.save + assert_equal [ + [:before_save, :symbol], + [:before_save, :string], + [:before_save, :proc], + [:before_save, :object], + [:before_save, :block], + [:after_save, :block], + [:after_save, :object], + [:after_save, :proc], + [:after_save, :string], + [:after_save, :symbol] + ], person.history + end end -end -class ConditionalCallbackTest < Test::Unit::TestCase - def test_save_conditional_person - person = ConditionalPerson.new - person.save - assert_equal [ - [:before_save, :proc], - [:before_save, :proc], - [:before_save, :symbol], - [:before_save, :symbol], - [:before_save, :string], - [:before_save, :string], - [:before_save, :combined_symbol], - ], person.history + class ConditionalCallbackTest < Test::Unit::TestCase + def test_save_conditional_person + person = ConditionalPerson.new + person.save + assert_equal [ + [:before_save, :proc], + [:before_save, :proc], + [:before_save, :symbol], + [:before_save, :symbol], + [:before_save, :string], + [:before_save, :string], + [:before_save, :combined_symbol], + ], person.history + end end -end -class CallbackTerminator - include ActiveSupport::NewCallbacks + class CallbackTerminator + include ActiveSupport::NewCallbacks - define_callbacks :save, "result == :halt" + define_callbacks :save, "result == :halt" - save_callback :before, :first - save_callback :before, :second - save_callback :around, :around_it - save_callback :before, :third - save_callback :after, :first - save_callback :around, :around_it - save_callback :after, :second - save_callback :around, :around_it - save_callback :after, :third + save_callback :before, :first + save_callback :before, :second + save_callback :around, :around_it + save_callback :before, :third + save_callback :after, :first + save_callback :around, :around_it + save_callback :after, :second + save_callback :around, :around_it + save_callback :after, :third - attr_reader :history - def initialize - @history = [] - end + attr_reader :history + def initialize + @history = [] + end - def around_it - @history << "around1" - yield - @history << "around2" - end + def around_it + @history << "around1" + yield + @history << "around2" + end - def first - @history << "first" - end + def first + @history << "first" + end - def second - @history << "second" - :halt - end + def second + @history << "second" + :halt + end - def third - @history << "third" - end + def third + @history << "third" + end - def save - _run_save_callbacks + def save + _run_save_callbacks + end end -end -class CallbackTerminatorTest < Test::Unit::TestCase - def test_termination - terminator = CallbackTerminator.new - terminator.save - assert_equal ["first", "second", "third", "second", "first"], terminator.history + class CallbackTerminatorTest < Test::Unit::TestCase + def test_termination + terminator = CallbackTerminator.new + terminator.save + assert_equal ["first", "second", "third", "second", "first"], terminator.history + end end -end +end \ No newline at end of file -- cgit v1.2.3