timecop 0.3.1 → 0.3.4

data/{History.txt → History.rdoc}

@@ -1,3 +1,26 @@
+=== 0.3.4 / unreleased (RC2 released 2009-11-28)
+
+* Maintenance
+  * Fix various timezone-related issues.  Notably, when traveling to a DateTime
+    instance specified in a non-local timezone, convert provided DateTime 
+    instance to a local instance and return that from DateTime.now.
+    Code contributed by Michaël Witrant [piglop]
+  * Fix bug that would not allow Timecop to be used when Ruby's 'date'
+    library had not been previously loaded.
+    Code contributed by Tuomas Kareinen [tuomas]
+  * Fix bug when traveling to a DateTime across a DST boundary that
+    resulted in DateTime's being off by an hour.
+  * Migrate argument parsing into Timecop::TimeStackItem to reduce the
+    responsibility of the Timecop class.
+
+=== 0.3.3  2009-10-30
+
+* Revoked due to regression.
+
+=== 0.3.2 / 2009-10-24
+
+* Revoked due to regression.
+    
 === 0.3.1 / 2009-09-30
 
 * Maintenance
@@ -7,7 +30,7 @@
 
 * API
   * Completely remove Timecop#unset_all (deprecated by Timecop#return in 0.2.0)
-  * Return Time.now from #freeze, #travel and #return  -- code contributed by Keith Bennett (keithrbennett)
+  * Return Time.now from #freeze, #travel and #return  -- code contributed by Keith Bennett [keithrbennett]
 
 * Maintenance
   * Fix bug that left Time#mock_time set in some instances

data/README.rdoc

@@ -1,15 +1,21 @@
 = timecop
 
-* http://github.com/jtrupiano/timecop
+* Source[http://github.com/jtrupiano/timecop]
+* Documentation[http://johntrupiano.rubyforge.org/timecop]
 
 == DESCRIPTION
 
 A gem providing "time travel" and "time freezing" capabilities, making it dead simple to test time-dependent code.  It provides a unified method to mock Time.now, Date.today, and DateTime.now in a single call.
 
+== INSTALL
+
+  gem install timecop
+
 == FEATURES
 
 * Freeze time to a specific point.
 * Travel back to a specific point in time, but allow time to continue moving forward from there.
+* No dependencies, can be used with _any_ ruby project
 * Timecop api allows arguments to be passed into #freeze and #travel as one of the following:
   * Time instance
   * DateTime instance
@@ -54,16 +60,9 @@ in config/environments/test.rb
   sleep(10)
   new_time == Time.now # ==> false
 
-== DEPENDENCIES
-
-* None
-
-== INSTALL
-
-* sudo gem install timecop (latest stable version from rubyforge)
-* sudo gem install jtrupiano-timecop (HEAD of the repo from github)
-
 == REFERENCES
 
-* "0.2.0 release":http://blog.smartlogicsolutions.com/2008/12/24/timecop-2-released-freeze-and-rebase-time-ruby/
-* "0.1.0 release":http://blog.smartlogicsolutions.com/2008/11/19/timecop-freeze-time-in-ruby-for-better-testing/
+* {0.3.4 release}[http://blog.smartlogicsolutions.com/2009/12/07/timecop-0-3-4-released/]
+* {0.3.0 release}[http://blog.smartlogicsolutions.com/2009/09/20/timecop-0-3-0-released/]
+* {0.2.0 release}[http://blog.smartlogicsolutions.com/2008/12/24/timecop-2-released-freeze-and-rebase-time-ruby/]
+* {0.1.0 release}[http://blog.smartlogicsolutions.com/2008/11/19/timecop-freeze-time-in-ruby-for-better-testing/]

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-gem 'jeweler', '~> 1.2.1'
+gem 'jeweler', '~> 1.3.0'
 
 begin
   require 'jeweler'
@@ -16,6 +16,7 @@ begin
     s.authors = ["John Trupiano"]
     s.files =  FileList["[A-Z]*", "{bin,lib,test}/**/*"]
   end
+  Jeweler::GemcutterTasks.new
   Jeweler::RubyforgeTasks.new do |rubyforge|
     rubyforge.doc_task = "rdoc"
     rubyforge.remote_doc_path = "timecop"
@@ -47,7 +48,7 @@ Rake::RDocTask.new do |rdoc|
   rdoc.options << '--line-numbers' << '--inline-source'
   rdoc.title = "timecop #{version}"
   rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('History.txt')
+  rdoc.rdoc_files.include('History.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 3
-:patch: 1
+:patch: 4
 :major: 0
+:minor: 3

data/lib/timecop/time_extensions.rb

@@ -1,40 +1,10 @@
-#--
-# 1. Extensions to the Time, Date, and DateTime objects
-# 2. Allows us to "freeze" time in our Ruby applications.
-# 3. This is very useful when your app's functionality is dependent on time (e.g. 
-# anything that might expire).  This will allow us to alter the return value of
-# Date.today, Time.now, and DateTime.now, such that our application code _never_ has to change.
 
 class Time #:nodoc:
   class << self
-    # Time we might be behaving as
-    #attr_reader :mock_time
-    
-    @@mock_offset = nil
-    @@mock_time = nil
-    
+    # Time we are behaving as
     def mock_time
-      if !@@mock_offset.nil?
-        now_without_mock_time - @@mock_offset
-      else
-        @@mock_time
-      end
-    end
-    
-    # Set new time to pretend we are.
-    def freeze_time(new_now)
-      @@mock_time = new_now
-      @@mock_offset = nil
-    end
-    
-    def move_time(new_now)
-      @@mock_offset = new_now.nil? ? nil : (now_without_mock_time - new_now)
-      @@mock_time = nil
-    end
-    
-    # Restores Time to system clock
-    def unmock!
-      move_time(nil)
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.time
     end
     
     # Alias the original now
@@ -50,15 +20,15 @@ class Time #:nodoc:
   end
 end 
 
-if Object.const_defined?(:Date)
+if Object.const_defined?(:Date) && Date.respond_to?(:today)
   class Date #:nodoc:
     class << self
+      # Date we are behaving as
       def mock_date
-        now = Time.mock_time
-        return nil if now.nil?
-        Date.new(now.year, now.month, now.day)
+        mocked_time_stack_item = Timecop.top_stack_item
+        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date
       end
-        
+      
       # Alias the original today
       alias_method :today_without_mock_date, :today
     
@@ -73,18 +43,23 @@ if Object.const_defined?(:Date)
   end
 end
 
-if Object.const_defined?(:DateTime)
+if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
   class DateTime #:nodoc:
     class << self
+      # Time we are behaving as
       def mock_time
-        t_now = Time.mock_time
-        return nil if t_now.nil?
-        DateTime.new(t_now.year, t_now.month, t_now.day, t_now.hour, t_now.min, t_now.sec)
+        mocked_time_stack_item = Timecop.top_stack_item
+        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime
       end
-
-      # Alias the original now
-      alias_method :now_without_mock_time, :now
-
+      
+      # Fake alias :now_without_mock_time :now
+      # It appears that the DateTime library itself references Time.now
+      # for it's interpretation of now which caused 
+      # DateTime.now_without_mock_time to incorrectly return the frozen time.
+      def now_without_mock_time
+        Time.now_without_mock_time.send :to_datetime
+      end
+      
       # Define now_with_mock_time
       def now_with_mock_time
         mock_time || now_without_mock_time

data/lib/timecop/time_stack_item.rb

@@ -0,0 +1,113 @@
+
+class Timecop
+  # A data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
+  # movements on a simple stack.
+  class TimeStackItem #:nodoc:
+  
+    attr_reader :mock_type
+    def initialize(mock_type, *args)
+      raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel].include?(mock_type)
+      @mock_type      = mock_type
+      @time           = parse_time(*args)
+      @travel_offset  = compute_travel_offset
+      @dst_adjustment = compute_dst_adjustment
+    end
+    
+    def year
+      time.year
+    end
+    
+    def month
+      time.month
+    end
+    
+    def day
+      time.day
+    end
+    
+    def hour
+      time.hour
+    end
+    
+    def min
+      time.min
+    end
+    
+    def sec
+      time.sec
+    end
+    
+    def utc_offset
+      time.utc_offset
+    end
+    
+    def travel_offset
+      @travel_offset
+    end
+    
+    def time #:nodoc:
+      if travel_offset.nil?
+        @time
+      else
+        Time.now_without_mock_time + travel_offset
+      end
+    end
+    
+    def date
+      time.send(:to_date)
+    end
+    
+    def datetime
+      # DateTime doesn't know about DST, so let's remove its presence
+      our_offset = utc_offset + dst_adjustment
+      DateTime.new(year, month, day, hour, min, sec, utc_offset_to_rational(our_offset))
+    end
+    
+    def dst_adjustment
+      @dst_adjustment
+    end
+    
+    private
+      def rational_to_utc_offset(rational)
+        ((24.0 / rational.denominator) * rational.numerator) * (60 * 60)
+      end
+      
+      def utc_offset_to_rational(utc_offset)
+        Rational(utc_offset, 24 * 60 * 60)
+      end
+      
+      def parse_time(*args)
+        arg = args.shift
+        if arg.is_a?(Time)
+          arg.getlocal
+        elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
+          offset_difference = Time.now.utc_offset - rational_to_utc_offset(arg.offset)
+          Time.local(arg.year, arg.month, arg.day, arg.hour, arg.min, arg.sec) + offset_difference
+        elsif Object.const_defined?(:Date) && arg.is_a?(Date)
+          Time.local(arg.year, arg.month, arg.day, 0, 0, 0)
+        elsif args.empty? && arg.kind_of?(Integer)
+          Time.now + arg
+        else # we'll just assume it's a list of y/m/d/h/m/s
+          year   = arg        || 0
+          month  = args.shift || 1
+          day    = args.shift || 1
+          hour   = args.shift || 0
+          minute = args.shift || 0
+          second = args.shift || 0
+          Time.local(year, month, day, hour, minute, second)
+        end
+      end
+      
+      def compute_dst_adjustment
+        return 0 if !(time.dst? ^ Time.now.dst?)
+        return -1 * 60 * 60 if time.dst?
+        return 60 * 60
+      end
+      
+      def compute_travel_offset
+        return nil if mock_type == :freeze
+        @time - Time.now_without_mock_time
+      end
+      
+  end
+end

data/lib/timecop/timecop.rb

@@ -1,6 +1,6 @@
 require 'singleton'
 require File.join(File.dirname(__FILE__), 'time_extensions')
-require File.join(File.dirname(__FILE__), 'stack_item')
+require File.join(File.dirname(__FILE__), 'time_stack_item')
 
 # Timecop
 # * Wrapper class for manipulating the extensions to the Time, Date, and DateTime objects
@@ -58,7 +58,7 @@ class Timecop
   #
   # Returns the 'new' current Time.
   def self.travel(*args, &block)
-    instance().send(:travel, :move, *args, &block)
+    instance().send(:travel, :travel, *args, &block)
     Time.now
   end
   
@@ -69,6 +69,10 @@ class Timecop
     instance().send(:unmock!)
     Time.now
   end
+  
+  def self.top_stack_item #:nodoc:
+    instance().instance_variable_get(:@_stack).last
+  end
 
   protected
   
@@ -77,12 +81,7 @@ class Timecop
     end
     
     def travel(mock_type, *args, &block) #:nodoc:
-      # parse the arguments, build our base time units
-      year, month, day, hour, minute, second = parse_travel_args(*args)
-
-      stack_item = StackItem.new(mock_type, year, month, day, hour, minute, second)
-      # perform our action
-      freeze_or_move(stack_item)
+      stack_item = TimeStackItem.new(mock_type, *args)
       
       # store this time traveling on our stack...
       @_stack << stack_item
@@ -93,61 +92,12 @@ class Timecop
         ensure
           # pull it off the stack...
           @_stack.pop
-          if @_stack.size == 0
-            # completely unmock if there's nothing to revert back to 
-            unmock!
-          else
-            # or reinstantiate the new the top of the stack (could be a :freeze or a :move)
-            new_top = @_stack.last
-            freeze_or_move(new_top)
-          end
         end
       end
     end
   
     def unmock! #:nodoc:
       @_stack = []
-      Time.unmock!
     end
   
-  private
-  
-    def freeze_or_move(stack_item) #:nodoc:
-      if stack_item.mock_type == :freeze
-        Time.freeze_time(time_for_stack_item(stack_item))
-      else
-        Time.move_time(time_for_stack_item(stack_item))
-      end
-    end
-    
-    def time_for_stack_item(stack_item) #:nodoc:
-      if Time.respond_to?(:zone) && !Time.zone.nil?
-        # ActiveSupport loaded
-        time = Time.zone.local(stack_item.year, stack_item.month, stack_item.day, stack_item.hour, stack_item.minute, stack_item.second)
-      else 
-        # ActiveSupport not loaded
-        time = Time.local(stack_item.year, stack_item.month, stack_item.day, stack_item.hour, stack_item.minute, stack_item.second)
-      end      
-    end
-        
-    def parse_travel_args(*args) #:nodoc:
-      arg = args.shift
-      if arg.is_a?(Time) || (Object.const_defined?(:DateTime) && arg.is_a?(DateTime))
-        year, month, day, hour, minute, second = arg.year, arg.month, arg.day, arg.hour, arg.min, arg.sec
-      elsif Object.const_defined?(:Date) && arg.is_a?(Date)
-        year, month, day, hour, minute, second = arg.year, arg.month, arg.day, 0, 0, 0
-        #puts "#{year}-#{month}-#{day} #{hour}:#{minute}:#{second}"
-      elsif args.empty? && arg.kind_of?(Integer)
-        t = Time.now + arg
-        year, month, day, hour, minute, second = t.year, t.month, t.day, t.hour, t.min, t.sec
-      else # we'll just assume it's a list of y/m/h/d/m/s
-        year   = arg        || 0
-        month  = args.shift || 1
-        day    = args.shift || 1
-        hour   = args.shift || 0
-        minute = args.shift || 0
-        second = args.shift || 0
-      end
-      return year, month, day, hour, minute, second
-    end
 end

data/test/run_tests.sh

@@ -1,10 +1,13 @@
 #!/bin/sh
 
-echo "\033[1;81m Running test_timecop_internals...\033[0m"
-ruby test_timecop_internals.rb || (echo "FAILED!!!!!!!!!!!!")
+echo "\033[1;81m Running test_time_stack_item...\033[0m"
+ruby test_time_stack_item.rb || (echo "FAILED!!!!!!!!!!!!")
 
 echo "\033[1;81m Running test_timecop_without_date...\033[0m"
 ruby test_timecop_without_date.rb || (echo "FAILED!!!!!!!!!!!!")
 
+echo "\033[1;81m Running test_timecop_without_date_but_with_time...\033[0m"
+ruby test_timecop_without_date_but_with_time.rb || (echo "FAILED!!!!!!!!!!!!")
+
 echo "\033[1;81m Running test_timecop...\033[0m"
 ruby test_timecop.rb || (echo "FAILED!!!!!!!!!!!!")

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+
+class Test::Unit::TestCase
+  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
+    end
+  
+    TIMEZONES = ["Europe/Paris", "UTC", "EDT"]
+  
+    def each_timezone
+      old_tz = ENV["TZ"]
+    
+      begin
+        TIMEZONES.each do |timezone|
+          ENV["TZ"] = timezone
+          yield
+        end
+      ensure
+        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}"
+    end
+    
+end

data/test/test_time_stack_item.rb

@@ -0,0 +1,167 @@
+require 'date'
+require 'test_helper'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+
+class TestTimeStackItem < Test::Unit::TestCase
+  
+  def teardown
+    Timecop.return
+  end
+  
+  def test_new_with_time
+    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, t)
+    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_datetime_now
+    t = DateTime.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, t)
+    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_datetime_in_different_timezone
+    each_timezone do
+      t = DateTime.parse("2009-10-11 00:38:00 +0200")
+      stack_item = Timecop::TimeStackItem.new(:freeze, t)
+      assert_date_times_equal(t, stack_item.datetime)
+    end
+  end
+  
+  def test_new_with_date
+    date = Date.today
+    y, m, d, h, min, s = date.year, date.month, date.day, 0, 0, 0
+    stack_item = Timecop::TimeStackItem.new(:freeze, date)
+    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
+  
+  # Due to the nature of this test (calling Time.now once in this test and
+  # once in #new), this test may fail when two subsequent calls
+  # to Time.now return a different second.
+  def test_new_with_integer
+    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)
+    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)
+    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_rational_to_utc_offset
+    assert_equal -14400, a_time_stack_item.send(:rational_to_utc_offset, Rational(-1, 6))
+    assert_equal -18000, a_time_stack_item.send(:rational_to_utc_offset, Rational(-5, 24))
+    assert_equal 0,      a_time_stack_item.send(:rational_to_utc_offset, Rational(0, 1))
+    assert_equal 3600,   a_time_stack_item.send(:rational_to_utc_offset, Rational(1, 24))
+  end
+  
+  def test_utc_offset_to_rational
+    assert_equal Rational(-1, 6),  a_time_stack_item.send(:utc_offset_to_rational, -14400)
+    assert_equal Rational(-5, 24), a_time_stack_item.send(:utc_offset_to_rational, -18000)
+    assert_equal Rational(0, 1),   a_time_stack_item.send(:utc_offset_to_rational, 0)
+    assert_equal Rational(1, 24),  a_time_stack_item.send(:utc_offset_to_rational, 3600)
+  end
+  
+  # Ensure DST adjustment is calculated properly for DateTime's
+  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)
+    assert Time.now.dst?, "precondition"
+    assert tsi.time.dst?, "precondition"
+    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)
+    assert !Time.now.dst?, "precondition"
+    assert !tsi.time.dst?, "precondition"
+    assert_equal 0, tsi.send(:dst_adjustment)    
+  end
+  
+  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")
+    tsi = Timecop::TimeStackItem.new(:freeze, t)
+    assert Time.now.dst?, "precondition"
+    assert !tsi.time.dst?, "precondition"
+    assert_equal 60 * 60, tsi.send(:dst_adjustment)
+  end
+  
+  def test_compute_dst_adjustment_for_non_dst_to_dst
+    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0400"))
+    t = DateTime.parse("2009-10-11 00:00:00 -0400")
+    tsi = Timecop::TimeStackItem.new(:freeze, t)
+    assert !Time.now.dst?, "precondition"
+    assert tsi.time.dst?, "precondition"
+    assert_equal -1 * 60 * 60, tsi.send(:dst_adjustment)
+  end
+  
+  # Ensure DateTime's 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)
+    assert_date_times_equal t, tsi.datetime
+    # verify Date also 'moves backward' an hour to change the day
+    assert_equal Date.new(2009, 10, 10), tsi.date
+  end
+  
+  def test_datetime_for_non_dst_to_dst
+    Timecop.freeze(DateTime.parse("2009-10-11 00:00:00 -0400"))
+    t = DateTime.parse("2009-11-30 23:38:00 -0500")
+    tsi = Timecop::TimeStackItem.new(:freeze, t)
+    assert_date_times_equal t, tsi.datetime
+    # verify Date also 'moves forward' an hour to change the day
+    assert_equal Date.new(2009, 12, 1), tsi.date
+  end
+  
+  # Ensure @travel_offset is set properly
+  def test_set_travel_offset_for_travel
+    # Timecop.freeze(2009, 10, 1, 0, 0, 0)
+    t_now = Time.now
+    t = Time.local(2009, 10, 1, 0, 0, 30)
+    expected_offset = t - t_now
+    tsi = Timecop::TimeStackItem.new(:travel, t)
+    assert_times_effectively_equal expected_offset, tsi.send(:travel_offset), 1, "Offset not calculated correctly"
+  end
+  
+  def test_set_travel_offset_for_freeze
+    Timecop.freeze(2009, 10, 1, 0, 0, 0)
+    t = Time.local(2009, 10, 1, 0, 0, 30)
+    tsi = Timecop::TimeStackItem.new(:freeze, t)
+    assert_equal nil, tsi.send(:travel_offset)
+  end
+end

data/test/test_timecop.rb

@@ -1,6 +1,5 @@
-
 require 'date'
-require 'test/unit'
+require 'test_helper'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 
 class TestTimecop < Test::Unit::TestCase
@@ -67,24 +66,62 @@ class TestTimecop < Test::Unit::TestCase
     t = Time.local(2008, 10, 10, 10, 10, 10)
     Timecop.freeze(t) do 
       assert_equal t, Time.now
-      assert_equal DateTime.new(2008, 10, 10, 10, 10, 10), DateTime.now
+      assert_date_times_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
       assert_equal Date.new(2008, 10, 10), Date.today
     end
     assert_not_equal t, Time.now
-    assert_not_equal DateTime.new(2008, 10, 10, 10, 10, 10), DateTime.now
+    assert_not_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
     assert_not_equal Date.new(2008, 10, 10), Date.today
   end
   
-  def test_freeze_with_datetime_instance_works_as_expected
-    t = DateTime.new(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do 
-      assert_equal t, DateTime.now
-      assert_equal Time.local(2008, 10, 10, 10, 10, 10), Time.now
-      assert_equal Date.new(2008, 10, 10), Date.today
+  def test_freeze_with_datetime_on_specific_timezone_during_dst
+    each_timezone do
+      # Start from a time that is subject to DST
+      Timecop.freeze(2009, 9, 1)
+      # Travel to a DateTime that is also in DST
+      t = DateTime.parse("2009-10-11 00:38:00 +0200")
+      Timecop.freeze(t) do
+        assert_date_times_equal t, DateTime.now
+      end
+      # Undo the original freeze
+      Timecop.return
     end
-    assert_not_equal t, DateTime.now
-    assert_not_equal Time.local(2008, 10, 10, 10, 10, 10), Time.now
-    assert_not_equal Date.new(2008, 10, 10), Date.today
+  end
+  
+  def test_freeze_with_datetime_on_specific_timezone_not_during_dst
+    each_timezone do
+      # Start from a time that is not subject to DST
+      Timecop.freeze(2009, 12, 1)
+      # Travel to a time that is also not in DST
+      t = DateTime.parse("2009-12-11 00:38:00 +0100")
+      Timecop.freeze(t) do
+        assert_date_times_equal t, DateTime.now
+      end
+    end
+  end
+  
+  def test_freeze_with_datetime_from_a_non_dst_time_to_a_dst_time
+    each_timezone do
+      # Start from a time that is not subject to DST
+      Timecop.freeze(DateTime.parse("2009-12-1 00:00:00 +0100"))
+      # Travel back to a time in DST
+      t = DateTime.parse("2009-10-11 00:38:00 +0200")
+      Timecop.freeze(t) do
+        assert_date_times_equal t, DateTime.now
+      end
+    end    
+  end
+
+  def test_freeze_with_datetime_from_a_dst_time_to_a_non_dst_time
+    each_timezone do
+      # Start from a time that is not subject to DST
+      Timecop.freeze(DateTime.parse("2009-10-11 00:00:00 +0200"))
+      # Travel back to a time in DST
+      t = DateTime.parse("2009-12-1 00:38:00 +0100")
+      Timecop.freeze(t) do
+        assert_date_times_equal t, DateTime.now
+      end
+    end    
   end
   
   def test_freeze_with_date_instance_works_as_expected
@@ -92,18 +129,18 @@ class TestTimecop < Test::Unit::TestCase
     Timecop.freeze(d) do
       assert_equal d, Date.today
       assert_equal Time.local(2008, 10, 10, 0, 0, 0), Time.now
-      assert_equal DateTime.new(2008, 10, 10, 0, 0, 0), DateTime.now
+      assert_date_times_equal DateTime.new(2008, 10, 10, 0, 0, 0, local_offset), DateTime.now
     end
     assert_not_equal d, Date.today
     assert_not_equal Time.local(2008, 10, 10, 0, 0, 0), Time.now
-    assert_not_equal DateTime.new(2008, 10, 10, 0, 0, 0), DateTime.now    
+    assert_not_equal DateTime.new(2008, 10, 10, 0, 0, 0, local_offset), DateTime.now    
   end
   
   def test_freeze_with_integer_instance_works_as_expected
     t = Time.local(2008, 10, 10, 10, 10, 10)
     Timecop.freeze(t) do
       assert_equal t, Time.now
-      assert_equal DateTime.new(2008, 10, 10, 10, 10, 10), DateTime.now
+      assert_date_times_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
       assert_equal Date.new(2008, 10, 10), Date.today
       Timecop.freeze(10) do
         assert_equal t + 10, Time.now
@@ -147,25 +184,44 @@ class TestTimecop < Test::Unit::TestCase
     t = Time.local(2008, 10, 10, 10, 10, 10)
     now = Time.now
     Timecop.travel(t) do
-      #assert Time.now < now, "If we had failed to freeze, time would have proceeded, which is what appears to have happened."
-      assert Time.now - t < 2000, "Looks like we failed to actually travel time" # 2 seconds
-      new_t = Time.now
-      #sleep(10)
-      assert_not_equal new_t, Time.now
+      new_now = Time.now
+      assert_times_effectively_equal(new_now, t, 1, "Looks like we failed to actually travel time")
+      sleep(0.25)
+      assert_times_effectively_not_equal new_now, Time.now, 0.25, "Looks like time is not moving"
+    end
+  end
+  
+  def test_mocked_date_time_now_is_local
+    each_timezone do
+      t = DateTime.parse("2009-10-11 00:38:00 +0200")
+      Timecop.freeze(t) do
+        assert_equal local_offset, DateTime.now.offset, "Failed for timezone: #{ENV['TZ']}"
+      end
     end
   end
   
-  def test_recursive_rebasing_maintains_each_context
+  def test_freeze_with_utc_time
+    each_timezone do
+      t = Time.utc(2008, 10, 10, 10, 10, 10)
+      local = t.getlocal
+      Timecop.freeze(t) do
+        assert_equal local, Time.now, "Failed for timezone: #{ENV['TZ']}"
+      end
+    end
+  end
+  
+  def test_recursive_travel_maintains_each_context
     t = Time.local(2008, 10, 10, 10, 10, 10)
     Timecop.travel(2008, 10, 10, 10, 10, 10) do 
       assert((t - Time.now).abs < 50, "Failed to travel time.")
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(2008, 9, 9, 9, 9, 9) do
-        assert((t2 - Time.now) < 50, "Failed to travel time.")
-        assert((t - Time.now) > 1000, "Failed to travel time.")
+        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
+        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
       end
-      assert((t - Time.now).abs < 2000, "Failed to restore previously-traveled time.")
+      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
     end
+    assert_nil Time.send(:mock_time)
   end
   
   def test_recursive_travel_then_freeze
@@ -176,8 +232,9 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.freeze(2008, 9, 9, 9, 9, 9) do
         assert_equal t2, Time.now
       end
-      assert((t - Time.now).abs < 2000, "Failed to restore previously-traveled time.")
+      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
     end
+    assert_nil Time.send(:mock_time)
   end
   
   def test_recursive_freeze_then_travel
@@ -186,11 +243,12 @@ class TestTimecop < Test::Unit::TestCase
       assert_equal t, Time.now
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(t2) do
-        assert((t2 - Time.now) < 50, "Failed to travel time.")
-        assert((t - Time.now) > 1000, "Failed to travel time.")
+        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
+        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
       end
       assert_equal t, Time.now
     end
+    assert_nil Time.send(:mock_time)    
   end
   
   def test_return_values_are_Time_instances
@@ -218,13 +276,4 @@ class TestTimecop < Test::Unit::TestCase
     assert times_effectively_equal(t_real, t_return)
   end
 
-
-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.to_i - time2.to_i).abs <= seconds_interval
-  end
-    
 end

data/test/test_timecop_without_date.rb

@@ -1,8 +1,8 @@
 
-require 'test/unit'
+require 'test_helper'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 
-class TestTimecopWithouDate < Test::Unit::TestCase
+class TestTimecopWithoutDate < Test::Unit::TestCase
   
   def setup
     assert !Object.const_defined?(:Date)
@@ -56,10 +56,10 @@ class TestTimecopWithouDate < Test::Unit::TestCase
     t = Time.local(2008, 10, 10, 10, 10, 10)
     now = Time.now
     Timecop.freeze(t) do
-      #assert Time.now < now, "If we had failed to freeze, time would have proceeded, which is what appears to have happened."
+      sleep(0.25)
+      assert Time.now < now, "If we had failed to freeze, time would have proceeded, which is what appears to have happened."
       new_t = Time.now
       assert_equal t, new_t, "Failed to change move time." # 2 seconds
-      #sleep(10)
       assert_equal new_t, Time.now
     end
   end
@@ -68,24 +68,23 @@ class TestTimecopWithouDate < Test::Unit::TestCase
     t = Time.local(2008, 10, 10, 10, 10, 10)
     now = Time.now
     Timecop.travel(t) do
-      #assert Time.now < now, "If we had failed to freeze, time would have proceeded, which is what appears to have happened."
-      assert Time.now - t < 2000, "Looks like we failed to actually travel time" # 2 seconds
-      new_t = Time.now
-      #sleep(10)
-      assert_not_equal new_t, Time.now
+      new_now = Time.now
+      assert_times_effectively_equal new_now, t, 1, "Looks like we failed to actually travel time" # 0.1 seconds
+      sleep(0.25)
+      assert_times_effectively_not_equal new_now, Time.now, 0.25, "Looks like time is not moving"
     end
   end
   
-  def test_recursive_rebasing_maintains_each_context
+  def test_recursive_travel_maintains_each_context
     t = Time.local(2008, 10, 10, 10, 10, 10)
     Timecop.travel(2008, 10, 10, 10, 10, 10) do 
       assert((t - Time.now).abs < 50, "Failed to travel time.")
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(2008, 9, 9, 9, 9, 9) do
-        assert((t2 - Time.now) < 50, "Failed to travel time.")
-        assert((t - Time.now) > 1000, "Failed to travel time.")
+        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
+        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
       end
-      assert((t - Time.now).abs < 2000, "Failed to restore previously-traveled time.")
+      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
     end
     assert_nil Time.send(:mock_time)
   end
@@ -98,7 +97,7 @@ class TestTimecopWithouDate < Test::Unit::TestCase
       Timecop.freeze(2008, 9, 9, 9, 9, 9) do
         assert_equal t2, Time.now
       end
-      assert((t - Time.now).abs < 2000, "Failed to restore previously-traveled time.")
+      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
     end
     assert_nil Time.send(:mock_time)
   end
@@ -109,8 +108,8 @@ class TestTimecopWithouDate < Test::Unit::TestCase
       assert_equal t, Time.now
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(t2) do
-        assert((t2 - Time.now) < 50, "Failed to travel time.")
-        assert((t - Time.now) > 1000, "Failed to travel time.")
+        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
+        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
       end
       assert_equal t, Time.now
     end

data/test/test_timecop_without_date_but_with_time.rb

@@ -0,0 +1,12 @@
+require "test/unit"
+
+class TestTimecopWithoutDateButWithTime < Test::Unit::TestCase
+  TIMECOP_LIB = File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+
+  def test_loads_properly_when_time_is_required_instead_of_date
+    assert_nothing_raised do
+      require "time"
+      require TIMECOP_LIB
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timecop
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.4
 platform: ruby
 authors: 
 - John Trupiano
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-30 00:00:00 -04:00
+date: 2009-12-07 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -23,19 +23,21 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- History.txt
+- History.rdoc
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION.yml
 - lib/timecop.rb
-- lib/timecop/stack_item.rb
 - lib/timecop/time_extensions.rb
+- lib/timecop/time_stack_item.rb
 - lib/timecop/timecop.rb
 - test/run_tests.sh
+- test/test_helper.rb
+- test/test_time_stack_item.rb
 - test/test_timecop.rb
-- test/test_timecop_internals.rb
 - test/test_timecop_without_date.rb
+- test/test_timecop_without_date_but_with_time.rb
 has_rdoc: true
 homepage: http://github.com/jtrupiano/timecop
 licenses: []
@@ -65,6 +67,8 @@ signing_key:
 specification_version: 3
 summary: A gem providing "time travel" and "time freezing" capabilities, making it dead simple to test time-dependent code.  It provides a unified method to mock Time.now, Date.today, and DateTime.now in a single call.
 test_files: 
+- test/test_helper.rb
+- test/test_time_stack_item.rb
 - test/test_timecop.rb
-- test/test_timecop_internals.rb
 - test/test_timecop_without_date.rb
+- test/test_timecop_without_date_but_with_time.rb

data/lib/timecop/stack_item.rb

@@ -1,12 +0,0 @@
-
-class Timecop
-  # Simply a data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
-  # movements on a simple stack.
-  class StackItem #:nodoc:
-  
-    attr_reader :mock_type, :year, :month, :day, :hour, :minute, :second
-    def initialize(mock_type, year, month, day, hour, minute, second)
-      @mock_type, @year, @month, @day, @hour, @minute, @second = mock_type, year, month, day, hour, minute, second
-    end
-  end
-end

data/test/test_timecop_internals.rb

@@ -1,69 +0,0 @@
-
-require 'date'
-require 'test/unit'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
-
-class TestTimecopInternals < Test::Unit::TestCase
-  
-  def test_parse_travel_args_with_time
-    t = Time.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    ty, tm, td, th, tmin, ts = Timecop.instance().send(:parse_travel_args, t)
-    assert_equal y, ty
-    assert_equal m, tm
-    assert_equal d, td
-    assert_equal h, th
-    assert_equal min, tmin
-    assert_equal s, ts
-  end
-
-  def test_parse_travel_args_with_datetime
-    t = DateTime.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    ty, tm, td, th, tmin, ts = Timecop.instance().send(:parse_travel_args, t)
-    assert_equal y, ty
-    assert_equal m, tm
-    assert_equal d, td
-    assert_equal h, th
-    assert_equal min, tmin
-    assert_equal s, ts
-  end
-
-  def test_parse_travel_args_with_date
-    date = Date.today
-    y, m, d, h, min, s = date.year, date.month, date.day, 0, 0, 0
-    ty, tm, td, th, tmin, ts = Timecop.instance().send(:parse_travel_args, date)
-    assert_equal y, ty
-    assert_equal m, tm
-    assert_equal d, td
-    assert_equal h, th
-    assert_equal min, tmin
-    assert_equal s, ts
-  end
-
-  # Due to the nature of this test (calling Time.now once in this test and
-  # once in #parse_travel_args), this test may fail when two subsequent calls
-  # to Time.now return a different second.
-  def test_parse_travel_args_with_integer
-    t = Time.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    ty, tm, td, th, tmin, ts = Timecop.instance().send(:parse_travel_args, 0)
-    assert_equal y, ty
-    assert_equal m, tm
-    assert_equal d, td
-    assert_equal h, th
-    assert_equal min, tmin
-    assert_equal s, ts
-  end
-
-  def test_parse_travel_args_with_individual_arguments
-    y, m, d, h, min, s = 2008, 10, 10, 10, 10, 10
-    ty, tm, td, th, tmin, ts = Timecop.instance().send(:parse_travel_args, y, m, d, h, min, s)
-    assert_equal y, ty
-    assert_equal m, tm
-    assert_equal d, td
-    assert_equal h, th
-    assert_equal min, tmin
-    assert_equal s, ts
-  end
-end