liangzan-timecop 0.3.1

data/History.txt

@@ -0,0 +1,63 @@
+=== 0.3.0 / 2009-09-20
+
+* 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)
+
+* Maintenance
+  * Fix bug that left Time#mock_time set in some instances
+  * Upped build dependency to jeweler ~> 1.2.1
+  * Don't pollute top-level namespace with classes/constants
+
+* Documentation
+  * Clearer examples in the README, better description in the gemspec
+  * Improve RDoc
+
+=== 0.2.1 / 2009-03-06
+* API Changes
+  
+  * Introduced a 5th style of arguments to be passed into #travel and #freeze.  Now, if you pass in a single integer value,
+    it will be interpreted as a relative offset in seconds from the current Time.now.  Previously this was interpreted as
+    only the year, similar to calling Time.local(2008) --> Jan. 1, 2008.  This is no longer the case.
+    
+* Documentation
+
+  * Moved to Textile for the README.
+  
+  * Added documentation for the new feature, and fixed a few typos.
+
+=== 0.2.0 / 2008-12-23
+
+* API Changes
+
+  * Timecop#travel no longer freezes time.  Rather, it computes the current offset between the new "now" and the real "now", and
+    returns times as if Time had continued to move forward
+    
+  * Timecop#freeze now behaves exactly as the old Timecop#travel behaved.  Unless you depended on the actual freezing of time
+    (which I think would be rare), you should be able to continue to use #travel without worry.
+    
+  * Timecop#return is now exposed (previously Timecop#unset_all, but not well advertised).  It will completely unmock time,
+    and will probably be rarely used outside of the actual implementation of this library.
+    
+* More Test Coverage
+
+  * Tests now explicitly cover the cases when the Date and DateTime objects are not loaded, and ensures proper functionality
+    in their absence and existence.
+    
+  * Still haven't done regression testing against anything other than a few version of 1.8.6 (including REE).  We should
+    probably try to get this tested on both 1.8.7 and 1.9.1.
+
+* Documentation
+
+  * Fixed up a lot of the poorly-formatted rdoc syntax.  The public API should now be properly published in the rdoc,
+    and the internals are omitted.
+    
+=== 0.1.0 / 2008-11-09
+
+* Initial Feature Set
+
+  * Temporarily (or permanently if you prefer) change the concept of Time.now, DateTime.now (if defined), and Date.today (if defined)
+  * Timecop#travel api allows an argument to be passed in as one of: 1) Time instance, 2) DateTime instance, 3) Date instance,
+    4) individual arguments (year, month, day, hour, minute, second)
+  * Nested calls to Timecop#travel are supported -- each block will maintain it's interpretation of now.
+

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,76 @@
+= timecop
+
+* http://github.com/jtrupiano/timecop
+
+== WHAT THIS FORK DOES
+
+This is a fork of the Timecop gem. This fork make use of file caches to store the offset and values of the mock time objects. This allows different processes to read and write to the mock objects. The motivation is to enable Culerity to use timecop.
+
+== Cache Files
+
+Two timecop cache files are created in your home directory. They are .timecop-cache.time.cache and .timecop-cache.offset.cache
+
+== 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. 
+
+== FEATURES
+
+* Freeze time to a specific point.
+* Travel back to a specific point in time, but allow time to continue moving forward from there.
+* Timecop api allows arguments to be passed into #freeze and #travel as one of the following:
+  * Time instance
+  * DateTime instance
+  * Date instance
+  * individual arguments (year, month, day, hour, minute, second)
+  * a single integer argument that is interpreted as an offset in seconds from Time.now
+* Nested calls to Timecop#travel and Timecop#freeze are supported -- each block will maintain its interpretation of now.
+
+== USAGE
+
+Run a time-sensitive test
+
+  joe = User.find(1)
+  joe.purchase_home()
+  assert !joe.mortgage_due?
+  # move ahead a month and assert that the mortgage is due
+  Timecop.freeze(Date.today + 30) do
+    assert joe.mortgage_due?
+  end
+
+Set the time for the test environment of a rails app -- this is particularly helpful if your whole application is time-sensitive.  It allows you to build your test data at a single point in time, and to move in/out of that time as appropriate (within your tests)
+  
+in config/environments/test.rb
+
+  config.after_initialize do
+    # Set Time.now to September 1, 2008 10:05:00 AM (at this instant), but allow it to move forward
+    t = Time.local(2008, 9, 1, 10, 5, 0)
+    Timecop.travel(t)
+  end
+
+=== The difference between Timecop.freeze and Timecop.travel
+
+#freeze is used to statically mock the concept of now.  As your program executes, Time.now will not change unless you make subsequent calls into the Timecop API.  #travel, on the other hand, computes an offset between what we currently think Time.now is (recall that we support nested traveling) and the time passed in.  It uses this offset to simulate the passage of time.  To demonstrate, consider the following code snippets:
+
+  new_time = Time.local(2008, 9, 1, 12, 0, 0)
+  Timecop.freeze(new_time)
+  sleep(10)
+  new_time == Time.now # ==> true
+  
+  Timecop.return # "turn off" Timecop
+  Timecop.travel(new_time)
+  sleep(10)
+  new_time == Time.now # ==> false
+
+== DEPENDENCIES
+
+* None
+
+== INSTALL
+
+* sudo gem install timecop-cache
+
+== 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/

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+gem 'jeweler', '~> 1.2.1'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "timecop"
+    s.rubyforge_project = 'johntrupiano' # if different than lowercase project name
+    s.description = %q(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. This fork uses cache files. Different processes can use time cop. It is meant to be used with Culerity.)
+    s.summary = s.description # More details later??
+    s.email = "zan@liangzan.net"
+    s.homepage = "http://github.com/jtrupiano/timecop"
+    s.authors = ["John Trupiano", "Wong Liang Zan"]
+    s.files =  FileList["[A-Z]*", "{bin,lib,test}/**/*"]
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+    rubyforge.remote_doc_path = "timecop"
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Dir['tasks/**/*.rake'].each do |rake|
+  begin
+    load rake
+  rescue LoadError
+  end
+end
+
+
+

data/VERSION.yml

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

data/lib/timecop.rb

@@ -0,0 +1,2 @@
+# Require Timecop 
+require File.join(File.dirname(__FILE__), 'timecop', 'timecop')

data/lib/timecop/stack_item.rb

@@ -0,0 +1,12 @@
+
+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/lib/timecop/time_extensions.rb

@@ -0,0 +1,143 @@
+#--
+# 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
+
+    TIME_CACHE_PATH = File.expand_path('~/.timecop-cache.time.cache')
+    OFFSET_CACHE_PATH = File.expand_path('~/.timecop-cache.offset.cache')
+
+    def clear_mock_cache
+      clear_mock_time_cache
+      clear_mock_offset_cache
+    end
+
+    def mock_time_cache
+      if File.exist?(TIME_CACHE_PATH)
+        File.open(TIME_CACHE_PATH,'r') do |f|
+          Marshal.load(f)
+        end
+      else
+        nil
+      end
+    end
+
+    def set_mock_time_cache(new_now)
+      File.open(TIME_CACHE_PATH,'w') do |f|
+        Marshal.dump(new_now, f)
+      end
+    end
+
+    def clear_mock_time_cache
+      File.delete(TIME_CACHE_PATH) if File.exist?(TIME_CACHE_PATH)
+    end
+
+    def mock_offset_cache
+      if File.exist?(OFFSET_CACHE_PATH)
+        File.open(OFFSET_CACHE_PATH,'r') do |f|
+          Marshal.load(f)
+        end
+      else
+        nil
+      end
+    end
+
+    def set_mock_offset_cache(new_offset)
+      File.open(OFFSET_CACHE_PATH,'w') do |f|
+        Marshal.dump(new_offset, f)
+      end
+    end
+
+    def clear_mock_offset_cache
+      File.delete(OFFSET_CACHE_PATH) if File.exist?(OFFSET_CACHE_PATH)
+    end
+
+    def mock_time
+      unless mock_offset_cache.nil?
+        now_without_mock_time - mock_offset_cache
+      else
+        mock_time_cache
+      end
+    end
+
+    # Set new time to pretend we are.
+    def freeze_time(new_now)
+      set_mock_time_cache(new_now)
+      clear_mock_offset_cache
+    end
+
+    def move_time(new_now)
+      mock_offset = new_now.nil? ? nil : (now_without_mock_time - new_now)
+      set_mock_offset_cache(mock_offset)
+      clear_mock_time_cache
+    end
+
+    # Restores Time to system clock
+    def unmock!
+      move_time(nil)
+    end
+
+    # Alias the original now
+    alias_method :now_without_mock_time, :now
+
+    # Define now_with_mock_time
+    def now_with_mock_time
+      mock_time || now_without_mock_time
+    end
+
+    # Alias now to now_with_mock_time
+    alias_method :now, :now_with_mock_time
+  end
+end
+
+if Object.const_defined?(:Date)
+  class Date #:nodoc:
+    class << self
+      def mock_date
+        now = Time.mock_time
+        return nil if now.nil?
+        Date.new(now.year, now.month, now.day)
+      end
+
+      # Alias the original today
+      alias_method :today_without_mock_date, :today
+
+      # Define today_with_mock_date
+      def today_with_mock_date
+        mock_date || today_without_mock_date
+      end
+
+      # Alias today to today_with_mock_date
+      alias_method :today, :today_with_mock_date
+    end
+  end
+end
+
+if Object.const_defined?(:DateTime)
+  class DateTime #:nodoc:
+    class << self
+      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)
+      end
+
+      # Alias the original now
+      alias_method :now_without_mock_time, :now
+
+      # Define now_with_mock_time
+      def now_with_mock_time
+        mock_time || now_without_mock_time
+      end
+
+      # Alias now to now_with_mock_time
+      alias_method :now, :now_with_mock_time
+    end
+  end
+end

data/lib/timecop/timecop.rb

@@ -0,0 +1,179 @@
+require 'singleton'
+require File.join(File.dirname(__FILE__), 'time_extensions')
+require File.join(File.dirname(__FILE__), 'stack_item')
+
+# Timecop
+# * Wrapper class for manipulating the extensions to the Time, Date, and DateTime objects
+# * Allows us to "freeze" time in our Ruby applications.
+# * Optionally allows time travel to simulate a running clock, such time is not technically frozen.
+#
+# 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 Timecop
+  include Singleton
+
+  # 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
+  # logic being tested.  For example:
+  #
+  #   joe = User.find(1)
+  #   joe.purchase_home()
+  #   assert !joe.mortgage_due?
+  #   Timecop.freeze(2008, 10, 5) do
+  #     assert joe.mortgage_due?
+  #   end
+  #
+  # freeze and travel will respond to several different arguments:
+  # 1. Timecop.freeze(time_inst)
+  # 2. Timecop.freeze(datetime_inst)
+  # 3. Timecop.freeze(date_inst)
+  # 4. Timecop.freeze(offset_in_seconds)
+  # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
+  #
+  # 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
+  # calls to Timecop.travel and have each block maintain it's concept of "now."
+  #
+  # * Note: Timecop.freeze will actually freeze time.  This can cause unanticipated problems if
+  #   benchmark or other timing calls are executed, which implicitly expect Time to actually move
+  #   forward.
+  #
+  # * Rails Users: Be especially careful when setting this in your development environment in a
+  #   rails project.  Generators will load your environment, including the migration generator,
+  #   which will lead to files being generated with the timestamp set by the Timecop.freeze call
+  #   in your dev environment
+  #
+  # Returns the frozen time.
+  def self.freeze(*args, &block)
+    instance().send(:travel, :freeze, *args, &block)
+    Time.now
+  end
+
+  # Allows you to run a block of code and "fake" a time throughout the execution of that block.
+  # See Timecop#freeze for a sample of how to use (same exact usage syntax)
+  #
+  # * Note: Timecop.travel will not freeze time (as opposed to Timecop.freeze).  This is a particularly
+  #   good candidate for use in environment files in rails projects.
+  #
+  # Returns the 'new' current Time.
+  def self.travel(*args, &block)
+    instance().send(:travel, :move, *args, &block)
+    Time.now
+  end
+
+  # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists). If freeze_all or rebase_all
+  # was never called in the first place, this method will have no effect.
+  #
+  # Returns Time.now, which is now the real current time.
+  def self.return
+    instance().send(:unmock!)
+    Time.now
+  end
+
+  protected
+
+  def initialize #:nodoc:
+    @_stack = []
+    Time.clear_mock_cache
+  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)
+
+    # perform our action
+    if mock_type == :freeze
+      freeze_all(year, month, day, hour, minute, second)
+    else
+      move_all(year, month, day, hour, minute, second)
+    end
+    # store this time traveling on our stack...
+    @_stack << StackItem.new(mock_type, year, month, day, hour, minute, second)
+
+    if block_given?
+      begin
+        yield
+      ensure
+        # pull it off the stack...
+        stack_item = @_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
+          if new_top.mock_type == :freeze
+            freeze_all(new_top.year, new_top.month, new_top.day, new_top.hour, new_top.minute, new_top.second)
+          else
+            move_all(new_top.year, new_top.month, new_top.day, new_top.hour, new_top.minute, new_top.second)
+          end
+        end
+      end
+    end
+  end
+
+  def unmock! #:nodoc:
+    @_stack = []
+    Time.unmock!
+  end
+
+  private
+
+    # Re-bases Time.now, Date.today and DateTime.now (if it exists) to use the time passed in.
+    # When using this method directly, it is up to the developer to call unset_all to return us
+    # to sanity.
+    #
+    # * If being consumed in a rails app, Time.zone.local will be used to instantiate the time.
+    #   Otherwise, Time.local will be used.
+    def freeze_all(year, month, day, hour=0, minute=0, second=0)
+      if Time.respond_to?(:zone) && !Time.zone.nil?
+        # ActiveSupport loaded
+        time = Time.zone.local(year, month, day, hour, minute, second)
+      else
+        # ActiveSupport not loaded
+        time = Time.local(year, month, day, hour, minute, second)
+      end
+
+      Time.freeze_time(time)
+    end
+
+    # Re-bases Time.now, Date.today and DateTime.now to use the time passed in and to continue moving time
+    # forward.  When using this method directly, it is up to the developer to call return to return us to
+    # sanity.
+    #
+    # * If being consumed in a rails app, Time.zone.local will be used to instantiate the time.
+    #   Otherwise, Time.local will be used.
+    def move_all(year, month, day, hour=0, minute=0, second=0)
+      if Time.respond_to?(:zone) && !Time.zone.nil?
+        # ActiveSupport loaded
+        time = Time.zone.local(year, month, day, hour, minute, second)
+      else
+        # ActiveSupport not loaded
+        time = Time.local(year, month, day, hour, minute, second)
+      end
+
+      Time.move_time(time)
+    end
+
+    def parse_travel_args(*args)
+      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

@@ -0,0 +1,10 @@
+#!/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_timecop_without_date...\033[0m"
+ruby test_timecop_without_date.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,2 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')

data/test/test_timecop.rb

@@ -0,0 +1,228 @@
+require 'date'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TestTimecop < Test::Unit::TestCase
+
+  def setup
+
+  end
+
+  # just in case...let's really make sure that Timecop is disabled between tests...
+  def teardown
+    Timecop.return
+  end
+
+  def test_freeze_changes_and_resets_time
+    # depending on how we're invoked (individually or via the rake test suite)
+    assert !Time.respond_to?(:zone) || Time.zone.nil?
+
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    assert_not_equal t, Time.now
+    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
+      assert_equal t, Time.now
+    end
+    assert_not_equal t, Time.now
+  end
+
+  def test_freeze_then_return_unsets_mock_time
+    Timecop.freeze(1)
+    Timecop.return
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_travel_then_return_unsets_mock_time
+    Timecop.travel(1)
+    Timecop.return
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_freeze_with_block_unsets_mock_time
+    assert_nil Time.send(:mock_time), "test is invalid"
+    Timecop.freeze(1) do; end
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_travel_with_block_unsets_mock_time
+    assert_nil Time.send(:mock_time), "test is invalid"
+    Timecop.travel(1) do; end
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_recursive_freeze
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
+      assert_equal t, Time.now
+      t2 = Time.local(2008, 9, 9, 9, 9, 9)
+      Timecop.freeze(2008, 9, 9, 9, 9, 9) do
+        assert_equal t2, Time.now
+      end
+      assert_equal t, Time.now
+    end
+    assert_not_equal t, Time.now
+  end
+
+  def test_freeze_with_time_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_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 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
+    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_date_instance_works_as_expected
+    d = Date.new(2008, 10, 10)
+    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
+    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
+  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_equal Date.new(2008, 10, 10), Date.today
+      Timecop.freeze(10) do
+        assert_equal t + 10, Time.now
+        assert_equal Time.local(2008, 10, 10, 10, 10, 20), Time.now
+        assert_equal Date.new(2008, 10, 10), Date.today
+      end
+    end
+    assert_not_equal t, Time.now
+    assert_not_equal DateTime.new(2008, 10, 10, 10, 10, 10), DateTime.now
+    assert_not_equal Date.new(2008, 10, 10), Date.today
+  end
+
+  def test_exception_thrown_in_freeze_block_properly_resets_time
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    begin
+      Timecop.freeze(t) do
+        assert_equal t, Time.now
+        raise "blah exception"
+      end
+    rescue
+      assert_not_equal t, Time.now
+      assert_nil Time.send(:mock_time)
+    end
+  end
+
+  def test_freeze_freezes_time
+    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."
+      new_t, new_d, new_dt = Time.now, Date.today, DateTime.now
+      assert_equal t, new_t, "Failed to freeze time." # 2 seconds
+      #sleep(10)
+      assert_equal new_t, Time.now
+      assert_equal new_d, Date.today
+      assert_equal new_dt, DateTime.now
+    end
+  end
+
+  def test_travel_keeps_time_moving
+    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
+    end
+  end
+
+  def test_recursive_rebasing_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.")
+      end
+      assert((t - Time.now).abs < 2000, "Failed to restore previously-traveled time.")
+    end
+  end
+
+  def test_recursive_travel_then_freeze
+    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.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.")
+    end
+  end
+
+  def test_recursive_freeze_then_travel
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.freeze(t) do
+      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.")
+      end
+      assert_equal t, Time.now
+    end
+  end
+
+  def test_return_values_are_Time_instances
+    assert Timecop.freeze.is_a?(Time)
+    assert Timecop.travel.is_a?(Time)
+    assert Timecop.return.is_a?(Time)
+  end
+
+  def test_travel_time_returns_passed_value
+    t_future = Time.local(2030, 10, 10, 10, 10, 10)
+    t_travel = Timecop.travel t_future
+    assert times_effectively_equal(t_future, t_travel)
+  end
+
+  def test_freeze_time_returns_passed_value
+    t_future = Time.local(2030, 10, 10, 10, 10, 10)
+    t_frozen = Timecop.freeze t_future
+    assert times_effectively_equal(t_future, t_frozen)
+  end
+
+  def test_return_time_returns_actual_time
+    t_real = Time.now
+    Timecop.freeze Time.local(2030, 10, 10, 10, 10, 10)
+    t_return = Timecop.return
+    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_internals.rb

@@ -0,0 +1,67 @@
+require 'date'
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+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

data/test/test_timecop_without_date.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TestTimecopWithouDate < Test::Unit::TestCase
+
+  def setup
+    assert !Object.const_defined?(:Date)
+    assert !Object.const_defined?(:DateTime)
+  end
+
+  # just in case...let's really make sure that Timecop is disabled between tests...
+  def teardown
+    Timecop.return
+  end
+
+  def test_freeze_changes_and_resets_time
+    # depending on how we're invoked (individually or via the rake test suite)
+    assert !Time.respond_to?(:zone) || Time.zone.nil?
+
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    assert_not_equal t, Time.now
+    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
+      assert_equal t, Time.now
+    end
+    assert_not_equal t, Time.now
+  end
+
+  def test_recursive_freeze
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
+      assert_equal t, Time.now
+      t2 = Time.local(2008, 9, 9, 9, 9, 9)
+      Timecop.freeze(2008, 9, 9, 9, 9, 9) do
+        assert_equal t2, Time.now
+      end
+      assert_equal t, Time.now
+    end
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_exception_thrown_in_freeze_block_properly_resets_time
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    begin
+      Timecop.freeze(t) do
+        assert_equal t, Time.now
+        raise "blah exception"
+      end
+    rescue
+      assert_not_equal t, Time.now
+      assert_nil Time.send(:mock_time)
+    end
+  end
+
+  def test_freeze_freezes_time
+    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."
+      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
+
+  def test_travel_keeps_time_moving
+    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
+    end
+  end
+
+  def test_recursive_rebasing_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.")
+      end
+      assert((t - Time.now).abs < 2000, "Failed to restore previously-traveled time.")
+    end
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_recursive_travel_then_freeze
+    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.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.")
+    end
+    assert_nil Time.send(:mock_time)
+  end
+
+  def test_recursive_freeze_then_travel
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.freeze(t) do
+      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.")
+      end
+      assert_equal t, Time.now
+    end
+    assert_nil Time.send(:mock_time)
+  end
+
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: liangzan-timecop
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+platform: ruby
+authors: 
+- John Trupiano
+- Wong Liang Zan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-23 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+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. This fork uses cache files. Different processes can use time cop. It is meant to be used with Culerity.
+email: zan@liangzan.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- History.txt
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/timecop.rb
+- lib/timecop/stack_item.rb
+- lib/timecop/time_extensions.rb
+- lib/timecop/timecop.rb
+- test/run_tests.sh
+- test/test_helper.rb
+- test/test_timecop.rb
+- test/test_timecop_internals.rb
+- test/test_timecop_without_date.rb
+has_rdoc: false
+homepage: http://github.com/jtrupiano/timecop
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: johntrupiano
+rubygems_version: 1.3.5
+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. This fork uses cache files. Different processes can use time cop. It is meant to be used with Culerity.
+test_files: 
+- test/test_timecop_internals.rb
+- test/test_timecop.rb
+- test/test_timecop_without_date.rb
+- test/test_helper.rb