timecop 0.0.99

data/History.txt

@@ -0,0 +1,48 @@
+=== 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/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/timecop.rb
+lib/timecop/stack_item.rb
+lib/timecop/time_extensions.rb
+lib/timecop/timecop.rb
+lib/timecop/version.rb
+test/run_tests.sh
+test/test_timecop.rb
+test/test_timecop_internals.rb
+test/test_timecop_without_date.rb
+timecop.gemspec

data/README.textile

@@ -0,0 +1,68 @@
+h1. timecop
+
+* http://github.com/jtrupiano/timecop
+
+h2. DESCRIPTION
+
+A gem providing simple ways to mock Time.now, Date.today, and DateTime.now.  It provides "time travel" and "time freezing" capabilities, making it dead simple to test time-dependent code.
+
+h2. FEATURES
+
+* Temporarily (or permanently if you prefer) change the concept of Time.now, DateTime.now, and Date.today
+* 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 it's interpretation of now.
+
+h2. SHORTCOMINGS
+
+* Only fully tested on the 1.8.6 Ruby implementations.  1.8.7 and 1.9.1 should be tested, as well as other flavors (jruby, etc.)
+
+h2. SYNOPSIS
+
+Run a time-sensitive test
+
+<pre>
+<code>
+  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
+</code>
+</pre>
+
+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
+
+<pre>
+<code>
+  config.after_initialize do
+    # Set Time.now to September 1, 2008 10:05:00 AM
+    t = Time.local(2008, 9, 1, 10, 5, 0)
+    Timecop.travel(t)
+  end
+</code>
+</pre>
+
+h2. REQUIREMENTS
+
+* None
+
+h2. INSTALL
+
+* sudo gem install timecop (latest stable version from rubyforge)
+* sudo gem install jtrupiano-timecop (HEAD of the repo from github)
+
+h2. REFERENCES
+
+* "0.1.0 release":http://blog.smartlogicsolutions.com/2008/11/19/timecop-freeze-time-in-ruby-for-better-testing/
+* "0.2.0 release":http://blog.smartlogicsolutions.com/2008/12/24/timecop-2-released-freeze-and-rebase-time-ruby/
+

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+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 simple ways to temporarily override Time.now, Date.today, and DateTime.now.  It provides "time travel" capabilities, making it dead simple to test time-dependent code.)
+    s.summary = s.description # More details later??
+    s.email = "jtrupiano@gmail.com"
+    s.homepage = "http://github.com/jtrupiano/timecop"
+    s.authors = ["John Trupiano"]
+    s.files =  FileList["[A-Z]*", "{bin,lib,test}/**/*"]
+    #s.add_dependency 'schacon-git'
+  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
+
+# Override the test task and instruct them how to actually run the tests.
+Rake.application.send(:eval, "@tasks.delete('test')")
+desc "Does not execute tests.  Manually run shell script ./run_tests.sh to execute tests."
+task :test do
+  puts <<-MSG
+    In order to run the test suite, run: cd test && ./run_tests.sh
+    The tests need to be run with different libraries loaded, which rules out using Rake
+    to automate them.
+  MSG
+end

data/VERSION.yml

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

data/lib/timecop.rb

@@ -0,0 +1,3 @@
+# place gem dependencies here...
+#require 'timecop/timecop'
+require File.join(File.dirname(__FILE__), 'timecop', 'timecop')

data/lib/timecop/stack_item.rb

@@ -0,0 +1,11 @@
+
+# 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
+  
+  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
+

data/lib/timecop/time_extensions.rb

@@ -0,0 +1,96 @@
+# 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
+  class << self
+    # Time we might be behaving as
+    #attr_reader :mock_time
+    
+    @@mock_offset = nil
+    @@mock_time = nil
+    
+    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)
+    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
+    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
+    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,198 @@
+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:
+  #
+  # <code>
+  #   joe = User.find(1)
+  #   joe.purchase_home()
+  #   assert !joe.mortgage_due?
+  #   Timecop.freeze(2008, 10, 5) do
+  #     assert joe.mortgage_due?
+  #   end
+  # </code>
+  #
+  # 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(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.  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
+  def self.freeze(*args, &block)
+    instance().send(:travel, :freeze, *args, &block)
+  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.  
+  def self.travel(*args, &block)
+    instance().send(:travel, :move, *args, &block)
+  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.
+  def self.return
+    instance().send(:unmock!)
+  end
+
+  # [Deprecated]: See Timecop#return instead.
+  def self.unset_all
+    $stderr.puts "Timecop#unset_all is deprecated.  Please use Timecop#return instead."
+    $stderr.flush
+    self.return
+  end
+  
+  protected
+  
+    def initialize
+      @_stack = []
+    end
+    
+    def travel(mock_type, *args, &block)
+      # 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!
+      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
+
+#def with_dates(*dates, &block)
+#  dates.flatten.each do |date|
+#    begin
+#      DateTime.forced_now = case date
+#        when String: DateTime.parse(date)
+#        when Time: DateTime.parse(date.to_s)
+#        else
+#          date
+#      end
+#      Date.forced_today = Date.new(DateTime.forced_now.year,
+#DateTime.forced_now.month, DateTime.forced_now.day)
+#      yield
+#    rescue Exception => e
+#      raise e
+#    ensure
+#      DateTime.forced_now = nil
+#      Date.forced_today = nil
+#    end
+#  end
+#end 
+

data/lib/timecop/version.rb

@@ -0,0 +1,20 @@
+module Timecop
+  module Version #:nodoc:
+    # A method for comparing versions of required modules. It expects two
+    # arrays of integers as parameters, the first being the minimum version
+    # required, and the second being the actual version available. It returns
+    # true if the actual version is at least equal to the required version.
+    def self.check(required, actual) #:nodoc:
+      required = required.map { |v| "%06d" % v }.join(".")
+      actual   = actual.map { |v| "%06d" % v }.join(".")
+      return actual >= required
+    end
+
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join(".")
+  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_timecop.rb

@@ -0,0 +1,175 @@
+
+require 'date'
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+
+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_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
+    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

data/test/test_timecop_internals.rb

@@ -0,0 +1,69 @@
+
+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

data/test/test_timecop_without_date.rb

@@ -0,0 +1,120 @@
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+
+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,70 @@
+--- !ruby/object:Gem::Specification 
+name: timecop
+version: !ruby/object:Gem::Version 
+  version: 0.0.99
+platform: ruby
+authors: 
+- John Trupiano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-07 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A gem providing simple ways to temporarily override Time.now, Date.today, and DateTime.now.  It provides "time travel" capabilities, making it dead simple to test time-dependent code.
+email: jtrupiano@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+- LICENSE
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- Rakefile
+- README.textile
+- VERSION.yml
+- lib/timecop
+- lib/timecop/stack_item.rb
+- lib/timecop/time_extensions.rb
+- lib/timecop/timecop.rb
+- lib/timecop/version.rb
+- lib/timecop.rb
+- test/run_tests.sh
+- test/test_timecop.rb
+- test/test_timecop_internals.rb
+- test/test_timecop_without_date.rb
+has_rdoc: true
+homepage: http://github.com/jtrupiano/timecop
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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.1
+signing_key: 
+specification_version: 2
+summary: A gem providing simple ways to temporarily override Time.now, Date.today, and DateTime.now.  It provides "time travel" capabilities, making it dead simple to test time-dependent code.
+test_files: []
+