timecop 0.6.1 → 0.9.6

data/lib/timecop/timecop.rb

@@ -1,5 +1,4 @@
 require 'singleton'
-require File.join(File.dirname(__FILE__), "time_extensions")
 require File.join(File.dirname(__FILE__), "time_stack_item")
 
 # Timecop
@@ -14,7 +13,7 @@ class Timecop
   include Singleton
 
   class << self
-    attr_accessor :active_support
+    private :instance
 
     # Allows you to run a block of code and "fake" a time throughout the execution of that block.
     # This is particularly useful for writing test methods where the passage of time is critical to the business
@@ -33,6 +32,7 @@ class Timecop
     # 3. Timecop.freeze(date_inst)
     # 4. Timecop.freeze(offset_in_seconds)
     # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
+    # 6. Timecop.freeze() # Defaults to Time.now
     #
     # When a block is also passed, Time.now, DateTime.now and Date.today are all reset to their
     # previous values after the block has finished executing.  This allows us to nest multiple
@@ -76,11 +76,11 @@ class Timecop
     end
 
     def baseline
-      instance.send(:baseline)
+      instance.baseline
     end
 
     def baseline=(baseline)
-      instance.send(:baseline=, baseline)
+      instance.baseline = baseline
     end
 
     # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists) permamently when
@@ -88,73 +88,153 @@ class Timecop
     # the given block.
     def return(&block)
       if block_given?
-        instance.send(:return, &block)
+        instance.return(&block)
       else
-        instance.send(:unmock!)
+        instance.unmock!
         nil
       end
     end
+    alias :unfreeze :return
 
     def return_to_baseline
-      instance.send(:return_to_baseline)
+      instance.return_to_baseline
       Time.now
     end
 
     def top_stack_item #:nodoc:
-      instance.instance_variable_get(:@_stack).last
+      instance.stack.last
+    end
+
+    def safe_mode=(safe)
+      @safe_mode = safe
+    end
+
+    def safe_mode?
+      @safe_mode ||= false
+    end
+
+    def thread_safe=(t)
+      instance.thread_safe = t
+    end
+
+    def thread_safe
+      instance.thread_safe
+    end
+
+    # Returns whether or not Timecop is currently frozen/travelled
+    def frozen?
+      !instance.stack.empty?
     end
 
     private
     def send_travel(mock_type, *args, &block)
-      val = instance.send(:travel, mock_type, *args, &block)
+      val = instance.travel(mock_type, *args, &block)
       block_given? ? val : Time.now
     end
   end
 
-  private
+  def baseline=(b)
+    set_baseline(b)
+    stack << TimeStackItem.new(:travel, b)
+  end
+
+  def baseline
+    if @thread_safe
+      Thread.current[:timecop_baseline]
+    else
+      @baseline
+    end
+  end
+
+  def set_baseline(b)
+    if @thread_safe
+      Thread.current[:timecop_baseline] = b
+    else
+      @baseline = b
+    end
+  end
+
+  def stack
+    if @thread_safe
+      Thread.current[:timecop_stack] ||= []
+      Thread.current[:timecop_stack]
+    else
+      @stack
+    end
+  end
 
-  def baseline=(baseline)
-    @baseline = baseline
-    @_stack << TimeStackItem.new(:travel, baseline)
+  def set_stack(s)
+    if @thread_safe
+      Thread.current[:timecop_stack] = s
+    else
+      @stack = s
+    end
   end
 
   def initialize #:nodoc:
-    @_stack = []
+    @stack = []
+    @safe = nil
+    @thread_safe = false
+  end
+
+  def thread_safe=(t)
+    initialize
+    @thread_safe = t
+  end
+
+  def thread_safe
+    @thread_safe
   end
 
   def travel(mock_type, *args, &block) #:nodoc:
+    raise SafeModeException if Timecop.safe_mode? && !block_given? && !@safe
+
     stack_item = TimeStackItem.new(mock_type, *args)
 
-    @_stack << stack_item
+    stack_backup = stack.dup
+    stack << stack_item
 
     if block_given?
+      safe_backup = @safe
+      @safe = true
       begin
         yield stack_item.time
       ensure
-        @_stack.pop
+        stack.replace stack_backup
+        @safe = safe_backup
       end
     end
   end
 
   def return(&block)
-    current_stack = @_stack
-    current_baseline = @baseline
+    current_stack = stack
+    current_baseline = baseline
     unmock!
     yield
-    @_stack = current_stack
-    @baseline = current_baseline
+  ensure
+    set_stack current_stack
+    set_baseline current_baseline
   end
 
   def unmock! #:nodoc:
-    @baseline = nil
-    @_stack = []
+    set_baseline nil
+    set_stack []
   end
 
   def return_to_baseline
-    if @baseline
-      @_stack = [@_stack.shift]
+    if baseline
+      set_stack [stack.shift]
     else
       unmock!
     end
   end
+
+  class SafeModeException < StandardError
+    def initialize
+      super "Safe mode is enabled, only calls passing a block are allowed."
+    end
+  end
 end
+
+# This must be done after TimeCop is available
+require File.join(File.dirname(__FILE__), "time_extensions")

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.6.1"
+  VERSION = "0.9.6"
 end

data/test/test_helper.rb

@@ -1,38 +1,39 @@
-require 'rubygems'
 require 'bundler/setup'
-require 'test/unit'
-begin
-  require 'mocha/setup'
-rescue LoadError
-  require 'mocha'
-end
+require 'minitest/autorun'
+require 'minitest/rg'
+require 'pry'
+
+$VERBOSE = true # enable ruby warnings
 
-class Test::Unit::TestCase
+require 'mocha/minitest'
 
+class Minitest::Test
   private
     # Tests to see that two times are within the given distance,
     # in seconds, from each other.
     def times_effectively_equal(time1, time2, seconds_interval = 1)
       (time1 - time2).abs <= seconds_interval
     end
-    
+
     def assert_times_effectively_equal(time1, time2, seconds_interval = 1, msg = nil)
       assert times_effectively_equal(time1, time2, seconds_interval), "#{msg}: time1 = #{time1.to_s}, time2 = #{time2.to_s}"
     end
-    
+
     def assert_times_effectively_not_equal(time1, time2, seconds_interval = 1, msg = nil)
       assert !times_effectively_equal(time1, time2, seconds_interval), "#{msg}: time1 = #{time1.to_s}, time2 = #{time2.to_s}"
     end
-    
-    def local_offset
-      DateTime.now_without_mock_time.offset
+
+    # Gets the local offset (supplied by ENV['TZ'] or your computer's clock)
+    # At the given timestamp, or Time.now if not time is given.
+    def local_offset(time = Time.now)
+      Time.at(time.to_i).to_datetime.offset
     end
-  
-    TIMEZONES = ["Europe/Paris", "UTC", "EDT"]
-  
+
+    TIMEZONES = ["Pacific/Midway", "Europe/Paris", "UTC", "America/Chicago"]
+
     def each_timezone
       old_tz = ENV["TZ"]
-    
+
       begin
         TIMEZONES.each do |timezone|
           ENV["TZ"] = timezone
@@ -42,13 +43,17 @@ class Test::Unit::TestCase
         ENV["TZ"] = old_tz
       end
     end
-    
+
     def a_time_stack_item
       Timecop::TimeStackItem.new(:freeze, 2008, 1, 1, 0, 0, 0)
     end
-  
+
     def assert_date_times_equal(dt1, dt2)
-      assert_equal dt1, dt2, "Failed for timezone: #{ENV['TZ']}: #{dt1.to_s} not equal to #{dt2.to_s}"
+      assert_in_delta dt1.to_time.to_f, dt2.to_time.to_f, 0.01, "Failed for timezone: #{ENV['TZ']}: #{dt1.to_s} not equal to #{dt2.to_s}"
     end
-    
+
+    def jruby?
+      RUBY_PLATFORM == "java"
+    end
+
 end

data/test/time_stack_item_test.rb

@@ -1,11 +1,13 @@
 require 'date'
-require File.join(File.dirname(__FILE__), "test_helper")
-require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+require_relative "test_helper"
+require 'timecop'
 
-class TestTimeStackItem < Test::Unit::TestCase
+require 'active_support/all'
+
+class TestTimeStackItem < Minitest::Test
   def teardown
-    Timecop.active_support = nil
     Timecop.return
+    Time.zone = nil
   end
 
   def test_new_with_time
@@ -85,6 +87,19 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal s,   stack_item.sec
   end
 
+  def test_new_with_float
+    t = Time.now
+    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
+    stack_item = Timecop::TimeStackItem.new(:freeze, 0.0)
+
+    assert_equal y,   stack_item.year
+    assert_equal m,   stack_item.month
+    assert_equal d,   stack_item.day
+    assert_equal h,   stack_item.hour
+    assert_equal min, stack_item.min
+    assert_equal s,   stack_item.sec
+  end
+
   def test_new_with_individual_arguments
     y, m, d, h, min, s = 2008, 10, 10, 10, 10, 10
     stack_item = Timecop::TimeStackItem.new(:freeze, y, m, d, h, min, s)
@@ -111,49 +126,35 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal Rational(1, 24),  a_time_stack_item.send(:utc_offset_to_rational, 3600)
   end
 
-  def test_compute_dst_adjustment_for_dst_to_dst
-    Timecop.freeze(DateTime.parse("2009-10-1 00:38:00 -0400"))
-    t = DateTime.parse("2009-10-11 00:00:00 -0400")
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-    return if !(Time.now.dst? && tsi.time.dst?)
-
-    assert_equal 0, tsi.send(:dst_adjustment)
-  end
-
-  def test_compute_dst_adjustment_for_non_dst_to_non_dst
-    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0400"))
-    t = DateTime.parse("2009-12-11 00:00:00 -0400")
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-    return if Time.now.dst? || tsi.time.dst?
-
-    assert_equal 0, tsi.send(:dst_adjustment)
-  end
+  def test_datetime_in_presence_of_activesupport_timezone
+    skip('requires ActiveSupport') unless Time.respond_to? :zone
+    backed_up_zone, backed_up_tzvar = Time.zone, ENV['TZ']
 
-  def test_compute_dst_adjustment_for_dst_to_non_dst
-    Timecop.freeze(DateTime.parse("2009-10-1 00:38:00 -0400"))
-    t = DateTime.parse("2009-12-11 00:00:00 -0400")
+    Time.zone = ENV['TZ'] = 'America/Los_Angeles'
+    t = DateTime.new(2001, 2, 28, 23, 59, 59.5)
     tsi = Timecop::TimeStackItem.new(:freeze, t)
-    return if !Time.now.dst? || tsi.time.dst?
 
-    assert_equal 60 * 60, tsi.send(:dst_adjustment)
+    assert_date_times_equal t, tsi.datetime
+  ensure
+    Time.zone, ENV['TZ'] = backed_up_zone, backed_up_tzvar
   end
 
-  def test_compute_dst_adjustment_for_non_dst_to_dst
-    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0400"))
+  # Ensure DateTimes handle changing DST properly
+  def test_datetime_for_dst_to_non_dst
+    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0500"))
     t = DateTime.parse("2009-10-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
-    return if Time.now.dst? || !tsi.time.dst?
 
-    assert_equal -1 * 60 * 60, tsi.send(:dst_adjustment)
+    assert_date_times_equal t, tsi.datetime
   end
 
-  # Ensure DateTimes handle changing DST properly
-  def test_datetime_for_dst_to_non_dst
+  # Ensure DateTimes handle changing DST properly when changing from DateTime to Time
+  def test_datetime_for_dst_to_time_for_non_dst
     Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0500"))
     t = DateTime.parse("2009-10-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
 
-    assert_date_times_equal t, tsi.datetime
+    assert_date_times_equal t.to_time, tsi.time
   end
 
   def test_datetime_for_non_dst_to_dst
@@ -180,11 +181,10 @@ class TestTimeStackItem < Test::Unit::TestCase
     t = Time.local(2009, 10, 1, 0, 0, 30)
     tsi = Timecop::TimeStackItem.new(:freeze, t)
 
-    assert_equal nil, tsi.send(:travel_offset)
+    assert_nil tsi.send(:travel_offset)
   end
 
   def test_timezones
-    require 'active_support/all'
     Time.zone = "Europe/Zurich"
     time = Time.zone.parse("2012-12-27T12:12:12+08:00")
     Timecop.freeze(time) do |frozen_time|
@@ -192,13 +192,21 @@ class TestTimeStackItem < Test::Unit::TestCase
     end
   end
 
+  def test_timezones_with_parsed_string
+    Time.zone = "Europe/Zurich"
+    time_string = "2012-12-27 12:12"
+    expected_time = Time.zone.parse(time_string)
+    Timecop.freeze(time_string) do |frozen_time|
+      assert_equal expected_time, frozen_time
+    end
+  end
+
   def test_timezones_apply_dates
-    require 'active_support/all'
-    Time.zone = "Marshall Is."
+    Time.zone = "Central Time (US & Canada)"
     time = Time.zone.local(2013,1,3)
 
     Timecop.freeze(time) do
-      assert_equal time.to_date, Date.today
+      assert_equal time.to_date, Time.zone.now.to_date
     end
   end
 
@@ -212,48 +220,18 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal tsi.send(:scaling_factor), 4, "Scaling factor not set"
   end
 
-  def test_parse_string_date_with_active_support
-    date = '2012-01-02'
-    Time.expects(:parse).with(date).returns(Time.local(2012, 01, 02))
-    Timecop.freeze(date)
-  end
-
   def test_parse_only_string_with_active_support
     Time.expects(:parse).never
     Timecop.freeze(2011, 01, 02, hour=0, minute=0, second=0)
   end
 
-  def test_parse_with_active_support_off
-    date = '2012-01-02'
-    Timecop.active_support = false
-    Time.expects(:parse).never
-    Timecop.freeze(date)
-  end
-
-  def test_uses_active_supports_in_time_zone
-    time = Time.now
-    Time.any_instance.expects(:in_time_zone).returns(time)
-    Timecop::TimeStackItem.new(:freeze, time)
-  end
-
-  def test_configured_off_active_support_in_time_zone_xxx
-    Timecop.active_support = false
-    Time.any_instance.expects(:in_time_zone).never
-    Timecop::TimeStackItem.new(:freeze, Time.now)
-  end
-
   def test_parse_date
-    assert_nothing_raised do
-      Timecop.freeze(Date.new(2012, 6, 9))
-    end
+    Timecop.freeze(Date.new(2012, 6, 9))
   end
 
   def test_time_zone_returns_nil
-    c = class << Time; self end
-    c.send(:define_method, :zone) { nil }
-    assert_nothing_raised do
-      Timecop.freeze
-    end
+    Time.zone = nil
+    Timecop.freeze
   end
 
   def test_nsecs_are_set
@@ -263,13 +241,59 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal time.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
   end
 
-  def test_time_with_different_timezone
-    require 'active_support/all'
+  def test_time_with_different_timezone_keeps_nsec
+    Time.zone = "Tokyo"
+    t = Time.now
+    Timecop.freeze(t) do
+      assert_equal t, Time.now
+      assert_equal t.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
+    end
+  end
+
+  def test_time_now_always_returns_local_time
+    Time.zone = "Tokyo"
+    t = Time.utc(2000, 1, 1)
+    Timecop.freeze(t) do
+      assert_equal t.getlocal.zone, Time.now.zone
+    end
+  end
+
+  def test_time_zone_now_returns_time_in_that_zone
+    Time.zone = "Hawaii"
+    t = Time.utc(2000, 1, 1)
+    Timecop.freeze(t) do
+      assert_equal t, Time.zone.now
+      assert_equal 'HST', Time.zone.now.zone
+    end
+  end
 
+  def test_freezing_a_time_leaves_timezone_intact
     Time.zone = "Tokyo"
     t = Time.now
+    t_dup = t.dup
+    Timecop.freeze(t) {}
+    assert_equal t_dup.zone, t.zone
+  end
+
+  def test_freezing_a_time_with_zone_returns_proper_zones
+    Time.zone = "Hawaii"
+    t = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), ActiveSupport::TimeZone['Tokyo'])
     Timecop.freeze(t) do
-      assert_times_effectively_equal t, Time.now
+      local_now = Time.now
+      assert_equal t, local_now
+      assert_equal t.getlocal.zone, local_now.zone
+
+      zoned_now = Time.zone.now
+      assert_equal t, zoned_now
+      assert_equal 'HST', zoned_now.zone
+    end
+  end
+
+  def test_datetime_timezones
+    dt = DateTime.new(2011,1,3,15,25,0,"-6")
+    Timecop.freeze(dt) do
+      now = DateTime.now
+      assert_equal dt, now, "#{dt.to_f}, #{now.to_f}"
     end
   end
 end