timecop 0.6.1 → 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bfc685225a22109f897b68e3174608a4b6a16def
+  data.tar.gz: 66aee6ccc9dfd424502c3f3f149c175af3fa3fbc
+SHA512:
+  metadata.gz: ac084a1428c7b528faa70aa321b1cb9db1f9f3f8eb45e4a94777f15b915662fc60ba9208091837903348348a1c902c109649aa7a471819cbec7ea1e0d8c1a377
+  data.tar.gz: 14082a5cba36b7f5238455d884025c5f9ce01ca0b81073f9b9860220286d13db10cce76b3da38465fb585976fd29782a1e0d81913d699814e4505790446e03b7

data/README.markdown

@@ -2,16 +2,13 @@
 
 [![Build Status](https://secure.travis-ci.org/travisjeffery/timecop.png)](http://travis-ci.org/travisjeffery/timecop)
 
-- Source[http://github.com/travisjeffery/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
+`gem install timecop`
 
 ## FEATURES
 
@@ -49,12 +46,13 @@ describe "some set of tests to mock" do
   before do
     Timecop.freeze(Time.local(1990))
   end
-  
+
   after do
     Timecop.return
   end
 
-  it "should do blah blah blah" {}
+  it "should do blah blah blah" do
+  end
 end
 ```
 
@@ -62,7 +60,7 @@ 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
 
 ```ruby
@@ -111,19 +109,29 @@ Time.now
 # => 2012-09-21 06:22:59 -0500
 ```
 
-See #42 for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
+See [#42](https://github.com/travisjeffery/timecop/pull/42) for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
 
-## REFERENCES
+### Timecop.safe_mode
 
-* {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/]
+Safe mode forces you to use Timecop with the block syntax since it always puts time back the way it was. If you are running in safe mode and use Timecop without the block syntax `Timecop::SafeModeException` will be raised to tell the user they are not being safe.
+
+``` ruby
+# turn on safe mode
+Timecop.safe_mode = true
+
+# check if you are in safe mode
+Timecop.safe_mode?
+# => true
+
+# using method without block
+Timecop.freeze
+# => Timecop::SafeModeException: Safe mode is enabled, only calls passing a block are allowed.
+```
 
 ## Contribute
 
 timecop is maintained by [travisjeffery](http://github.com/travisjeffery), and
-was created by [jtrupiano](https://github.com/jtrupiano). 
+was created by [jtrupiano](https://github.com/jtrupiano).
 
 Here's the most direct way to get your work merged into the project.
 

data/Rakefile

@@ -3,8 +3,6 @@ require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rdoc/task'
 
-$LOAD_PATH.unshift("lib")
-
 Rake::RDocTask.new do |rdoc|
   if File.exist?('VERSION')
     version = File.read('VERSION')
@@ -20,8 +18,16 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :test do 
-  system "cd test && ./run_tests.sh"
+task :test do
+  failed = Dir["test/*_test.rb"].map do |test|
+    command = "ruby #{test}"
+    puts
+    puts command
+    command unless system(command)
+  end.compact
+  if failed.any?
+    abort "#{failed.count} Tests failed\n#{failed.join("\n")}"
+  end
 end
 
 desc 'Default: run tests'

data/lib/timecop/time_extensions.rb

@@ -1,3 +1,5 @@
+require 'time'
+require 'date'
 
 class Time #:nodoc:
   class << self
@@ -5,77 +7,109 @@ class Time #:nodoc:
       mocked_time_stack_item = Timecop.top_stack_item
       mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.time(self)
     end
-    
+
     alias_method :now_without_mock_time, :now
 
     def now_with_mock_time
       mock_time || now_without_mock_time
     end
-    
+
     alias_method :now, :now_with_mock_time
 
     alias_method :new_without_mock_time, :new
 
     def new_with_mock_time(*args)
-      begin
-        raise ArgumentError.new if args.size <= 0
-        new_without_mock_time(*args)
-      rescue ArgumentError
-        now
-      end
+      args.size <= 0 ? now : new_without_mock_time(*args)
     end
 
     alias_method :new, :new_with_mock_time
   end
-end 
-
-if Object.const_defined?(:Date) && Date.respond_to?(:today)
-  class Date #:nodoc:
-    class << self
-      def mock_date
-        mocked_time_stack_item = Timecop.top_stack_item
-        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date(self)
+end
+
+class Date #:nodoc:
+  WEEKDAYS = {
+    "sunday"    => 0,
+    "monday"    => 1,
+    "tuesday"   => 2,
+    "wednesday" => 3,
+    "thursday"  => 4,
+    "friday"    => 5,
+    "saturday"  => 6
+  }
+
+  class << self
+    def mock_date
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date(self)
+    end
+
+    alias_method :today_without_mock_date, :today
+
+    def today_with_mock_date
+      mock_date || today_without_mock_date
+    end
+
+    alias_method :today, :today_with_mock_date
+
+    alias_method :strptime_without_mock_date, :strptime
+
+    def strptime_with_mock_date(str = '-4712-01-01', fmt = '%F', start = Date::ITALY)
+      unless start == Date::ITALY
+        raise ArgumentError, "Timecop's #{self}::#{__method__} only " +
+          "supports Date::ITALY for the start argument."
       end
-      
-      alias_method :today_without_mock_date, :today
-    
-      def today_with_mock_date
-        mock_date || today_without_mock_date
+
+      Time.strptime(str, fmt).to_date
+    end
+
+    alias_method :strptime, :strptime_with_mock_date
+
+    def parse_with_mock_date(*args)
+      str = args.first
+      if str && WEEKDAYS.keys.include?(str.downcase)
+        offset = WEEKDAYS[str.downcase] - Date.today.wday
+
+        Date.today + offset
+      else
+        parse_without_mock_date(*args)
       end
-    
-      alias_method :today, :today_with_mock_date
     end
+
+    alias_method :parse_without_mock_date, :parse
+    alias_method :parse, :parse_with_mock_date
+
   end
 end
 
-if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
-  class DateTime #:nodoc:
-    class << self
-      def mock_time
-        mocked_time_stack_item = Timecop.top_stack_item
-        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
-      end
-      
-      def now_without_mock_time
-        Time.now_without_mock_time.to_datetime
-      end
-      
-      def now_with_mock_time
-        mock_time || now_without_mock_time
-      end
+class DateTime #:nodoc:
+  class << self
+    def mock_time
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
+    end
 
-      alias_method :now, :now_with_mock_time
+    def now_with_mock_time
+      mock_time || now_without_mock_time
     end
-  end
 
-  # for ruby1.8
-  unless Time::public_instance_methods.include? :to_datetime
-    class DateTime
-      class << self
-        def now_without_mock_time
-          Time.now_without_mock_time.send(:to_datetime)
-        end
+    alias_method :now_without_mock_time, :now
+
+    alias_method :now, :now_with_mock_time
+
+    def parse_with_mock_date(*args)
+      str = args.first
+      if str && Date::WEEKDAYS.keys.include?(str.downcase)
+        offset = Date::WEEKDAYS[str.downcase] - DateTime.now.wday
+
+        parsed_weekday =(DateTime.now + offset)
+
+        DateTime.new(parsed_weekday.year, parsed_weekday.month, parsed_weekday.day, 0, 0, 0, 0)
+      else
+        parse_without_mock_date(*args)
       end
     end
+
+    alias_method :parse_without_mock_date, :parse
+    alias_method :parse, :parse_with_mock_date
   end
 end

data/lib/timecop/time_stack_item.rb

@@ -6,12 +6,12 @@ class Timecop
 
       def initialize(mock_type, *args)
         raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel, :scale].include?(mock_type)
+        @travel_offset  = @scaling_factor = nil
         @scaling_factor = args.shift if mock_type == :scale
         @mock_type      = mock_type
         @time           = parse_time(*args)
         @time_was       = Time.now_without_mock_time
         @travel_offset  = compute_travel_offset
-        @dst_adjustment = compute_dst_adjustment(@time)
       end
 
       def year
@@ -50,21 +50,19 @@ class Timecop
         @scaling_factor
       end
 
-      def time(klass = time_klass) #:nodoc:
-        begin
-          actual_time = klass.at(@time)
-          calculated_time = klass.at(@time.to_f)
-          time = times_are_equal_within_epsilon(actual_time, calculated_time, 1) ? actual_time : calculated_time
-        rescue
-          time = klass.at(@time.to_f)
+      def time(time_klass = Time) #:nodoc:
+        if @time.respond_to?(:in_time_zone)
+          time = time_klass.at(@time.dup.utc.to_r)
+        else
+          time = time_klass.at(@time)
         end
 
         if travel_offset.nil?
           time
         elsif scaling_factor.nil?
-          klass.at(Time.now_without_mock_time + travel_offset)
+          time_klass.at((Time.now_without_mock_time + travel_offset).to_f)
         else
-          klass.at(scaled_time)
+          time_klass.at(scaled_time)
         end
       end
 
@@ -77,21 +75,14 @@ class Timecop
       end
 
       def datetime(datetime_klass = DateTime)
-        our_offset = utc_offset + dst_adjustment
-
         if Float.method_defined?(:to_r)
           fractions_of_a_second = time.to_f % 1
-          datetime_klass.new(year, month, day, hour, min, sec + fractions_of_a_second, utc_offset_to_rational(our_offset))
+          datetime_klass.new(year, month, day, hour, min, (fractions_of_a_second + sec), utc_offset_to_rational(utc_offset))
         else
-          our_offset = utc_offset + dst_adjustment
-          datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(our_offset))
+          datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(utc_offset))
         end
       end
 
-      def dst_adjustment
-        @dst_adjustment
-      end
-
       private
 
       def rational_to_utc_offset(rational)
@@ -105,23 +96,17 @@ class Timecop
       def parse_time(*args)
         arg = args.shift
         if arg.is_a?(Time)
-          if Timecop.active_support != false && arg.respond_to?(:in_time_zone)
-            arg.in_time_zone
-          else
-            arg.getlocal
-          end
+          arg
         elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
-          expected_time = time_klass.local(arg.year, arg.month, arg.day, arg.hour, arg.min, arg.sec)
-          expected_time += expected_time.utc_offset - rational_to_utc_offset(arg.offset)
-          expected_time + compute_dst_adjustment(expected_time)
+          time_klass.at(arg.to_time.to_f).getlocal
         elsif Object.const_defined?(:Date) && arg.is_a?(Date)
           time_klass.local(arg.year, arg.month, arg.day, 0, 0, 0)
-        elsif args.empty? && arg.kind_of?(Integer)
+        elsif args.empty? && (arg.kind_of?(Integer) || arg.kind_of?(Float))
           Time.now + arg
         elsif arg.nil?
           Time.now
         else
-          if arg.is_a?(String) && Timecop.active_support != false && Time.respond_to?(:parse)
+          if arg.is_a?(String) && Time.respond_to?(:parse)
             Time.parse(arg)
           else
             # we'll just assume it's a list of y/m/d/h/m/s
@@ -136,12 +121,6 @@ class Timecop
         end
       end
 
-      def compute_dst_adjustment(time)
-        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
@@ -155,4 +134,4 @@ class Timecop
         Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
       end
     end
-  end
+end

data/lib/timecop/timecop.rb

@@ -14,8 +14,6 @@ class Timecop
   include Singleton
 
   class << self
-    attr_accessor :active_support
-
     # 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:
@@ -33,6 +31,7 @@ class Timecop
     # 3. Timecop.freeze(date_inst)
     # 4. Timecop.freeze(offset_in_seconds)
     # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
+    # 6. Timecop.freeze() # Defaults to Time.now
     #
     # When a block is also passed, Time.now, DateTime.now and Date.today are all reset to their
     # previous values after the block has finished executing.  This allows us to nest multiple
@@ -104,6 +103,19 @@ class Timecop
       instance.instance_variable_get(:@_stack).last
     end
 
+    def safe_mode=(safe)
+      @safe_mode = safe
+    end
+
+    def safe_mode?
+      @safe_mode ||= false
+    end
+
+    # Returns whether or not Timecop is currently frozen/travelled
+    def frozen?
+      !instance.instance_variable_get(:@_stack).empty?
+    end
+
     private
     def send_travel(mock_type, *args, &block)
       val = instance.send(:travel, mock_type, *args, &block)
@@ -123,15 +135,18 @@ class Timecop
   end
 
   def travel(mock_type, *args, &block) #:nodoc:
+    raise SafeModeException if Timecop.safe_mode? && !block_given?
+
     stack_item = TimeStackItem.new(mock_type, *args)
 
+    stack_backup = @_stack.dup
     @_stack << stack_item
 
     if block_given?
       begin
         yield stack_item.time
       ensure
-        @_stack.pop
+        @_stack.replace stack_backup
       end
     end
   end
@@ -141,6 +156,7 @@ class Timecop
     current_baseline = @baseline
     unmock!
     yield
+  ensure
     @_stack = current_stack
     @baseline = current_baseline
   end
@@ -157,4 +173,10 @@ class Timecop
       unmock!
     end
   end
+
+  class SafeModeException < StandardError
+    def initialize
+      super "Safe mode is enabled, only calls passing a block are allowed."
+    end
+  end
 end

data/lib/timecop/version.rb

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

data/test/test_helper.rb

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

data/test/time_stack_item_test.rb

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

data/test/timecop_test.rb

@@ -1,23 +1,28 @@
-require 'date'
-require File.join(File.dirname(__FILE__), "test_helper")
-require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+require_relative "test_helper"
+require 'timecop'
 
-class TestTimecop < Test::Unit::TestCase
+class TestTimecop < Minitest::Test
   def teardown
     Timecop.return
   end
 
   def test_freeze_changes_and_resets_time
-    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
+    outer_freeze_time = Time.local(2001, 01, 01)
+    inner_freeze_block = Time.local(2002, 02, 02)
+    inner_freeze_one = Time.local(2003, 03, 03)
+    inner_freeze_two = Time.local(2004, 04, 04)
+
+    Timecop.freeze(outer_freeze_time) do
+      assert_times_effectively_equal outer_freeze_time, Time.now
+      Timecop.freeze(inner_freeze_block) do
+        assert_times_effectively_equal inner_freeze_block, Time.now
+        Timecop.freeze(inner_freeze_one)
+        assert_times_effectively_equal inner_freeze_one, Time.now
+        Timecop.freeze(inner_freeze_two)
+        assert_times_effectively_equal inner_freeze_two, Time.now
+      end
+      assert_times_effectively_equal outer_freeze_time, Time.now
     end
-
-    assert_not_equal t, Time.now
   end
 
   def test_freeze_yields_mocked_time
@@ -25,7 +30,7 @@ class TestTimecop < Test::Unit::TestCase
       assert_equal frozen_time, Time.now
     end
   end
-  
+
   def test_freeze_then_return_unsets_mock_time
     Timecop.freeze(1)
     Timecop.return
@@ -53,8 +58,11 @@ class TestTimecop < Test::Unit::TestCase
   def test_travel_does_not_reduce_precision_of_datetime
     # requires to_r on Float (>= 1.9)
     if Float.method_defined?(:to_r)
-      Timecop.travel(1)
-      assert_not_equal DateTime.now, DateTime.now
+      Timecop.travel(Time.new(2014, 1, 1, 0, 0, 0))
+      assert DateTime.now != DateTime.now
+
+      Timecop.travel(Time.new(2014, 1, 1, 0, 0, 59))
+      assert DateTime.now != DateTime.now
     end
   end
 
@@ -107,7 +115,7 @@ class TestTimecop < Test::Unit::TestCase
       end
       assert_equal t, Time.now
     end
-    assert_not_equal t, Time.now
+    assert t != Time.now
   end
 
   def test_freeze_with_time_instance_works_as_expected
@@ -118,9 +126,9 @@ class TestTimecop < Test::Unit::TestCase
       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, local_offset), DateTime.now
-    assert_not_equal Date.new(2008, 10, 10), Date.today
+    assert t != Time.now
+    assert DateTime.new(2008, 10, 10, 10, 10, 10, local_offset) != DateTime.now
+    assert Date.new(2008, 10, 10) != Date.today
   end
 
   def test_freeze_with_datetime_on_specific_timezone_during_dst
@@ -179,9 +187,9 @@ class TestTimecop < Test::Unit::TestCase
       assert_equal Time.local(2008, 10, 10, 0, 0, 0), Time.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, local_offset), DateTime.now
+    assert d != Date.today
+    assert Time.local(2008, 10, 10, 0, 0, 0) != Time.now
+    assert DateTime.new(2008, 10, 10, 0, 0, 0, local_offset) != DateTime.now
   end
 
   def test_freeze_with_integer_instance_works_as_expected
@@ -196,9 +204,9 @@ class TestTimecop < Test::Unit::TestCase
         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
+    assert t != Time.now
+    assert DateTime.new(2008, 10, 10, 10, 10, 10) != DateTime.now
+    assert Date.new(2008, 10, 10) != Date.today
   end
 
   def test_exception_thrown_in_freeze_block_properly_resets_time
@@ -209,11 +217,19 @@ class TestTimecop < Test::Unit::TestCase
         raise "blah exception"
       end
     rescue
-      assert_not_equal t, Time.now
+      assert t != Time.now
       assert_nil Time.send(:mock_time)
     end
   end
 
+  def test_exception_thrown_in_return_block_restores_previous_time
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.freeze(t) do
+      Timecop.return { raise 'foobar' } rescue nil
+      assert_equal t, Time.now
+    end
+  end
+
   def test_freeze_freezes_time
     t = Time.local(2008, 10, 10, 10, 10, 10)
     now = Time.now
@@ -243,6 +259,11 @@ class TestTimecop < Test::Unit::TestCase
     each_timezone do
       t = DateTime.parse("2009-10-11 00:38:00 +0200")
       Timecop.freeze(t) do
+        if ENV['TZ'] == 'UTC'
+          assert_equal(local_offset, 0, "Local offset not be zero for #{ENV['TZ']}")
+        else
+          assert(local_offset, 0 != "Local offset should not be zero for #{ENV['TZ']}")
+        end
         assert_equal local_offset, DateTime.now.offset, "Failed for timezone: #{ENV['TZ']}"
       end
     end
@@ -273,6 +294,19 @@ class TestTimecop < Test::Unit::TestCase
     end
   end
 
+  def test_freeze_without_arguments_instance_works_as_expected
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.freeze(t) do
+      assert_equal t, Time.now
+      Timecop.freeze do
+        assert_equal t, Time.now
+        assert_equal Time.local(2008, 10, 10, 10, 10, 10), Time.now
+        assert_equal Date.new(2008, 10, 10), Date.today
+      end
+    end
+    assert t != Time.now
+  end
+
   def test_destructive_methods_on_frozen_time
     # Use any time zone other than UTC.
     ENV['TZ'] = 'EST'
@@ -303,13 +337,13 @@ class TestTimecop < Test::Unit::TestCase
   end
 
   def test_recursive_travel_yields_correct_time
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do 
+    Timecop.travel(2008, 10, 10, 10, 10, 10) do
       Timecop.travel(2008, 9, 9, 9, 9, 9) do |inner_freeze|
         assert_times_effectively_equal inner_freeze, Time.now, 1, "Failed to yield current time back to block"
       end
     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
@@ -431,8 +465,84 @@ class TestTimecop < Test::Unit::TestCase
   end
 
   def test_not_callable_send_travel
-    assert_raise NoMethodError do
+    assert_raises NoMethodError do
       Timecop.send_travel(:travel, Time.now - 100)
     end
   end
+
+  def test_datetime_to_time_for_dst_to_non_dst
+    # Start at a time subject to DST
+    Timecop.travel(2009, 4, 1, 0, 0, 0, -4*60*60) do
+
+      # Then freeze, via DateTime, at a time not subject to DST
+      t = DateTime.new(2009,01,01,0,0,0, "-0500")
+      Timecop.freeze(t) do
+
+        # Check the current time via DateTime.now--should be what we asked for
+        assert_date_times_equal t, DateTime.now
+
+        # Then check the current time via Time.now (not DateTime.now)
+        assert_times_effectively_equal Time.new(2009, 1, 1, 0, 0, 0, -5*60*60), Time.now
+      end
+    end
+  end
+
+  def test_raises_when_safe_mode_and_no_block
+    with_safe_mode do
+      assert_raises Timecop::SafeModeException do
+        Timecop.freeze
+      end
+    end
+  end
+
+  def test_no_raise_when_safe_mode_and_block_used
+    with_safe_mode do
+      Timecop.freeze {}
+    end
+  end
+
+  def test_no_raise_when_not_safe_mode_and_no_block
+    with_safe_mode(false) do
+      Timecop.freeze
+    end
+  end
+
+  def test_date_strptime_without_year
+    Timecop.freeze(Time.new(1984,2,28)) do
+      assert_equal Date.strptime('04-14', '%m-%d'), Date.new(1984, 4, 14)
+    end
+  end
+
+  def test_date_strptime_without_specifying_format
+    Timecop.freeze(Time.new(1984,2,28)) do
+      assert_equal Date.strptime('1999-04-14'), Date.new(1999, 4, 14)
+    end
+  end
+
+  def test_frozen_after_freeze
+    Timecop.freeze
+    assert Timecop.frozen?
+  end
+
+  def test_frozen_inside_freeze
+    Timecop.freeze do
+      assert Timecop.frozen?
+    end
+  end
+
+  def test_not_frozen_after_return
+    Timecop.freeze
+    Timecop.return
+    assert !Timecop.frozen?
+  end
+
+  private
+
+  def with_safe_mode(enabled=true)
+    mode = Timecop.safe_mode?
+    Timecop.safe_mode = enabled
+    yield
+  ensure
+    Timecop.safe_mode = mode
+  end
 end

data/test/timecop_without_date_but_with_time_test.rb

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

data/test/timecop_without_date_test.rb

@@ -1,34 +1,33 @@
+require_relative "test_helper"
+require 'timecop'
 
-require File.join(File.dirname(__FILE__), "test_helper")
-require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+class TestTimecopWithoutDate < Minitest::Test
 
-class TestTimecopWithoutDate < Test::Unit::TestCase
-  
   def setup
     Object.send(:remove_const, :Date) if Object.const_defined?(:Date)
     Object.send(:remove_const, :DateTime) if 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
+    assert t != Time.now
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert_equal t, Time.now
     end
-    assert_not_equal t, Time.now
+    assert 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 
+    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
@@ -38,7 +37,7 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
     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
@@ -47,11 +46,11 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
         raise "blah exception"
       end
     rescue
-      assert_not_equal t, Time.now
+      assert 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
@@ -63,7 +62,7 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
       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
@@ -74,10 +73,10 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
       assert_times_effectively_not_equal new_now, Time.now, 0.25, "Looks like time is not moving"
     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 
+    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
@@ -88,10 +87,10 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
     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 
+    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
@@ -101,10 +100,10 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
     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 
+    Timecop.freeze(t) do
       assert_equal t, Time.now
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(t2) do
@@ -113,7 +112,7 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
       end
       assert_equal t, Time.now
     end
-    assert_nil Time.send(:mock_time)    
+    assert_nil Time.send(:mock_time)
   end
 
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.6.1
-  prerelease: 
+  version: 0.8.1
 platform: ruby
 authors:
 - Travis Jeffery
@@ -10,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2016-04-01 00:00:00.000000000 Z
 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
@@ -28,37 +27,35 @@ files:
 - lib/timecop.rb
 - lib/timecop/time_extensions.rb
 - lib/timecop/time_stack_item.rb
-- lib/timecop/version.rb
 - lib/timecop/timecop.rb
-- test/run_tests.sh
+- lib/timecop/version.rb
 - test/test_helper.rb
 - test/time_stack_item_test.rb
 - test/timecop_test.rb
-- test/timecop_without_date_test.rb
 - test/timecop_without_date_but_with_time_test.rb
+- test/timecop_without_date_test.rb
 homepage: https://github.com/travisjeffery/timecop
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: timecop
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 3
 summary: A gem providing "time travel" and "time freezing" capabilities, making it
@@ -70,3 +67,4 @@ test_files:
 - test/timecop_test.rb
 - test/timecop_without_date_test.rb
 - test/timecop_without_date_but_with_time_test.rb
+has_rdoc: 

data/test/run_tests.sh

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-for f in *_test.rb; do
-  ${RUBY:-ruby} -I../lib:. $f 
-done
-