activesupport 3.1.0 → 5.0.0

data/lib/active_support/testing/setup_and_teardown.rb

@@ -3,109 +3,48 @@ require 'active_support/callbacks'
 
 module ActiveSupport
   module Testing
+    # Adds support for +setup+ and +teardown+ callbacks.
+    # These callbacks serve as a replacement to overwriting the
+    # <tt>#setup</tt> and <tt>#teardown</tt> methods of your TestCase.
+    #
+    #   class ExampleTest < ActiveSupport::TestCase
+    #     setup do
+    #       # ...
+    #     end
+    #
+    #     teardown do
+    #       # ...
+    #     end
+    #   end
     module SetupAndTeardown
       extend ActiveSupport::Concern
 
       included do
         include ActiveSupport::Callbacks
         define_callbacks :setup, :teardown
-
-        if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
-          include ForMiniTest
-        else
-          include ForClassicTestUnit
-        end
       end
 
       module ClassMethods
+        # Add a callback, which runs before <tt>TestCase#setup</tt>.
         def setup(*args, &block)
           set_callback(:setup, :before, *args, &block)
         end
 
+        # Add a callback, which runs after <tt>TestCase#teardown</tt>.
         def teardown(*args, &block)
           set_callback(:teardown, :after, *args, &block)
         end
       end
 
-      module ForMiniTest
-        def run(runner)
-          result = '.'
-          begin
-            run_callbacks :setup do
-              result = super
-            end
-          rescue Exception => e
-            result = runner.puke(self.class, method_name, e)
-          ensure
-            begin
-              run_callbacks :teardown
-            rescue Exception => e
-              result = runner.puke(self.class, method_name, e)
-            end
-          end
-          result
-        end
+      def before_setup # :nodoc:
+        super
+        run_callbacks :setup
       end
 
-      module ForClassicTestUnit
-        # For compatibility with Ruby < 1.8.6
-        PASSTHROUGH_EXCEPTIONS = Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
-
-        # This redefinition is unfortunate but test/unit shows us no alternative.
-        # Doubly unfortunate: hax to support Mocha's hax.
-        def run(result)
-          return if @method_name.to_s == "default_test"
-
-          mocha_counter = retrieve_mocha_counter(result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-
-          begin
-            begin
-              run_callbacks :setup do
-                setup
-                __send__(@method_name)
-                mocha_verify(mocha_counter) if mocha_counter
-              end
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue Exception => e
-              raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
-              add_error(e)
-            ensure
-              begin
-                teardown
-                run_callbacks :teardown
-              rescue Test::Unit::AssertionFailedError => e
-                add_failure(e.message, e.backtrace)
-              rescue Exception => e
-                raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
-                add_error(e)
-              end
-            end
-          ensure
-            mocha_teardown if mocha_counter
-          end
-
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
-        end
-
-        protected
-
-        def retrieve_mocha_counter(result) #:nodoc:
-          if respond_to?(:mocha_verify) # using mocha
-            if defined?(Mocha::TestCaseAdapter::AssertionCounter)
-              Mocha::TestCaseAdapter::AssertionCounter.new(result)
-            else
-              Mocha::Integration::TestUnit::AssertionCounter.new(result)
-            end
-          end
-        end
+      def after_teardown # :nodoc:
+        run_callbacks :teardown
+        super
       end
-
     end
   end
 end

data/lib/active_support/testing/stream.rb

@@ -0,0 +1,42 @@
+module ActiveSupport
+  module Testing
+    module Stream #:nodoc:
+      private
+
+      def silence_stream(stream)
+        old_stream = stream.dup
+        stream.reopen(IO::NULL)
+        stream.sync = true
+        yield
+      ensure
+        stream.reopen(old_stream)
+        old_stream.close
+      end
+
+      def quietly
+        silence_stream(STDOUT) do
+          silence_stream(STDERR) do
+            yield
+          end
+        end
+      end
+
+      def capture(stream)
+        stream = stream.to_s
+        captured_stream = Tempfile.new(stream)
+        stream_io = eval("$#{stream}")
+        origin_stream = stream_io.dup
+        stream_io.reopen(captured_stream)
+
+        yield
+
+        stream_io.rewind
+        return captured_stream.read
+      ensure
+        captured_stream.close
+        captured_stream.unlink
+        stream_io.reopen(origin_stream)
+      end
+    end
+  end
+end

data/lib/active_support/testing/tagged_logging.rb

@@ -0,0 +1,25 @@
+module ActiveSupport
+  module Testing
+    # Logs a "PostsControllerTest: test name" heading before each test to
+    # make test.log easier to search and follow along with.
+    module TaggedLogging #:nodoc:
+      attr_writer :tagged_logger
+
+      def before_setup
+        if tagged_logger && tagged_logger.info?
+          heading = "#{self.class}: #{name}"
+          divider = '-' * heading.size
+          tagged_logger.info divider
+          tagged_logger.info heading
+          tagged_logger.info divider
+        end
+        super
+      end
+
+      private
+        def tagged_logger
+          @tagged_logger ||= (defined?(Rails.logger) && Rails.logger)
+        end
+    end
+  end
+end

data/lib/active_support/testing/time_helpers.rb

@@ -0,0 +1,134 @@
+module ActiveSupport
+  module Testing
+    class SimpleStubs # :nodoc:
+      Stub = Struct.new(:object, :method_name, :original_method)
+
+      def initialize
+        @stubs = {}
+      end
+
+      def stub_object(object, method_name, return_value)
+        key = [object.object_id, method_name]
+
+        if stub = @stubs[key]
+          unstub_object(stub)
+        end
+
+        new_name = "__simple_stub__#{method_name}"
+
+        @stubs[key] = Stub.new(object, method_name, new_name)
+
+        object.singleton_class.send :alias_method, new_name, method_name
+        object.define_singleton_method(method_name) { return_value }
+      end
+
+      def unstub_all!
+        @stubs.each_value do |stub|
+          unstub_object(stub)
+        end
+        @stubs = {}
+      end
+
+      private
+
+        def unstub_object(stub)
+          singleton_class = stub.object.singleton_class
+          singleton_class.send :undef_method, stub.method_name
+          singleton_class.send :alias_method, stub.method_name, stub.original_method
+          singleton_class.send :undef_method, stub.original_method
+        end
+    end
+
+    # Contains helpers that help you test passage of time.
+    module TimeHelpers
+      # Changes current time to the time in the future or in the past by a given time difference by
+      # stubbing +Time.now+, +Date.today+, and +DateTime.now+.
+      #
+      #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel 1.day
+      #   Time.current     # => Sun, 10 Nov 2013 15:34:49 EST -05:00
+      #   Date.current     # => Sun, 10 Nov 2013
+      #   DateTime.current # => Sun, 10 Nov 2013 15:34:49 -0500
+      #
+      # This method also accepts a block, which will return the current time back to its original
+      # state at the end of the block:
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel 1.day do
+      #     User.create.created_at # => Sun, 10 Nov 2013 15:34:49 EST -05:00
+      #   end
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel(duration, &block)
+        travel_to Time.now + duration, &block
+      end
+
+      # Changes current time to the given time by stubbing +Time.now+,
+      # +Date.today+, and +DateTime.now+ to return the time or date passed into this method.
+      #
+      #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
+      #   Time.current     # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #   Date.current     # => Wed, 24 Nov 2004
+      #   DateTime.current # => Wed, 24 Nov 2004 01:04:44 -0500
+      #
+      # Dates are taken as their timestamp at the beginning of the day in the
+      # application time zone. <tt>Time.current</tt> returns said timestamp,
+      # and <tt>Time.now</tt> its equivalent in the system time zone. Similarly,
+      # <tt>Date.current</tt> returns a date equal to the argument, and
+      # <tt>Date.today</tt> the date according to <tt>Time.now</tt>, which may
+      # be different. (Note that you rarely want to deal with <tt>Time.now</tt>,
+      # or <tt>Date.today</tt>, in order to honor the application time zone
+      # please always use <tt>Time.current</tt> and <tt>Date.current</tt>.)
+      #
+      # Note that the usec for the time passed will be set to 0 to prevent rounding
+      # errors with external services, like MySQL (which will round instead of floor,
+      # leading to off-by-one-second errors).
+      #
+      # This method also accepts a block, which will return the current time back to its original
+      # state at the end of the block:
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.new(2004, 11, 24, 01, 04, 44) do
+      #     Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #   end
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel_to(date_or_time)
+        if date_or_time.is_a?(Date) && !date_or_time.is_a?(DateTime)
+          now = date_or_time.midnight.to_time
+        else
+          now = date_or_time.to_time.change(usec: 0)
+        end
+
+        simple_stubs.stub_object(Time, :now, now)
+        simple_stubs.stub_object(Date, :today, now.to_date)
+        simple_stubs.stub_object(DateTime, :now, now.to_datetime)
+
+        if block_given?
+          begin
+            yield
+          ensure
+            travel_back
+          end
+        end
+      end
+
+      # Returns the current time back to its original state, by removing the stubs added by
+      # `travel` and `travel_to`.
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #   travel_back
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel_back
+        simple_stubs.unstub_all!
+      end
+
+      private
+
+        def simple_stubs
+          @simple_stubs ||= SimpleStubs.new
+        end
+    end
+  end
+end

data/lib/active_support/time.rb

@@ -1,35 +1,18 @@
-require 'active_support'
-
 module ActiveSupport
   autoload :Duration, 'active_support/duration'
   autoload :TimeWithZone, 'active_support/time_with_zone'
   autoload :TimeZone, 'active_support/values/time_zone'
-
-  on_load_all do
-    [Duration, TimeWithZone, TimeZone]
-  end
 end
 
 require 'date'
 require 'time'
 
-require 'active_support/core_ext/time/publicize_conversion_methods'
-require 'active_support/core_ext/time/marshal'
-require 'active_support/core_ext/time/acts_like'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/time/zones'
-
-require 'active_support/core_ext/date/acts_like'
-require 'active_support/core_ext/date/freeze'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date/conversions'
-require 'active_support/core_ext/date/zones'
-
-require 'active_support/core_ext/date_time/acts_like'
-require 'active_support/core_ext/date_time/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/date_time/zones'
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/date'
+require 'active_support/core_ext/date_time'
 
 require 'active_support/core_ext/integer/time'
 require 'active_support/core_ext/numeric/time'
+
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/string/zones'