timecop 0.5.2 → 0.9.5

data/test/timecop_test.rb

@@ -1,28 +1,28 @@
-require 'date'
-require 'test_helper'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
+require_relative "test_helper"
+require 'timecop'
 
-class TestTimecop < Test::Unit::TestCase
-
-  def setup
-
-  end
-
-  # just in case...let's really make sure that Timecop is disabled between tests...
+class TestTimecop < Minitest::Test
   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
+    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
@@ -30,13 +30,19 @@ 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
     assert_nil Time.send(:mock_time)
   end
 
+  def test_freeze_then_unfreeze_unsets_mock_time
+    Timecop.freeze(1)
+    Timecop.unfreeze
+    assert_nil Time.send(:mock_time)
+  end
+
   def test_travel_then_return_unsets_mock_time
     Timecop.travel(1)
     Timecop.return
@@ -58,8 +64,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
 
@@ -68,6 +77,7 @@ class TestTimecop < Test::Unit::TestCase
     custom_timeklass = Class.new(Time) do
       def custom_format_method() strftime('%F') end
     end
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert custom_timeklass.now.is_a? custom_timeklass
       assert Time.now.eql? custom_timeklass.now
@@ -80,6 +90,7 @@ class TestTimecop < Test::Unit::TestCase
     custom_dateklass = Class.new(Date) do
       def custom_format_method() strftime('%F') end
     end
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert custom_dateklass.today.is_a? custom_dateklass
       assert Date.today.eql? custom_dateklass.today
@@ -92,6 +103,7 @@ class TestTimecop < Test::Unit::TestCase
     custom_datetimeklass = Class.new(DateTime) do
       def custom_format_method() strftime('%F') end
     end
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert custom_datetimeklass.now.is_a? custom_datetimeklass
       assert DateTime.now.eql? custom_datetimeklass.now
@@ -109,7 +121,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
@@ -119,9 +131,10 @@ class TestTimecop < Test::Unit::TestCase
       assert_date_times_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
       assert_equal Date.new(2008, 10, 10), Date.today
     end
-    assert_not_equal t, Time.now
-    assert_not_equal DateTime.new(2008, 10, 10, 10, 10, 10, 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
@@ -133,7 +146,6 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.freeze(t) do
         assert_date_times_equal t, DateTime.now
       end
-      # Undo the original freeze
       Timecop.return
     end
   end
@@ -181,9 +193,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
@@ -198,9 +210,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
@@ -211,11 +223,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
@@ -237,7 +257,7 @@ class TestTimecop < Test::Unit::TestCase
       new_now = Time.now
       assert_times_effectively_equal(new_now, t, 1, "Looks like we failed to actually travel time")
       sleep(0.25)
-      assert_times_effectively_not_equal new_now, Time.now, 0.25, "Looks like time is not moving"
+      assert_times_effectively_not_equal new_now, Time.now, 0.24, "Looks like time is not moving"
     end
   end
 
@@ -245,12 +265,17 @@ 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
   end
 
-  def test_lensing_keeps_time_moving_at_an_accelerated_rate
+  def test_scaling_keeps_time_moving_at_an_accelerated_rate
     t = Time.local(2008, 10, 10, 10, 10, 10)
     Timecop.scale(4, t) do
       start = Time.now
@@ -260,6 +285,22 @@ class TestTimecop < Test::Unit::TestCase
     end
   end
 
+  def test_scaling_returns_now_if_no_block_given
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    assert_times_effectively_equal t, Timecop.scale(4, t)
+  end
+  
+  def test_scaling_returns_now_if_nil_supplied
+    assert_times_effectively_equal Time.now, Timecop.scale(nil)
+  end
+
+  def test_scaling_raises_when_empty_string_supplied
+    err = assert_raises(TypeError) do
+      Timecop.scale("")
+    end
+    assert_match /String can't be coerced into Float/, err.message
+  end
+
   def test_freeze_with_utc_time
     each_timezone do
       t = Time.utc(2008, 10, 10, 10, 10, 10)
@@ -270,6 +311,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'
@@ -300,13 +354,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
@@ -334,9 +388,26 @@ class TestTimecop < Test::Unit::TestCase
     assert_nil Time.send(:mock_time)
   end
 
-  def test_travel_time_returns_nil
+  def test_travel_time_returns_now_if_no_block_given
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    assert_nil Timecop.travel(t_future)
+    assert_times_effectively_equal t_future, Timecop.travel(t_future)
+  end
+
+  def test_return_temporarily_returns_to_current_time_in_given_block
+    time_after_travel = Time.local(1990, 7, 16)
+    now = Time.now
+
+    Timecop.travel(time_after_travel)
+
+    assert_times_effectively_equal(time_after_travel, Time.now)
+    Timecop.return do
+      assert_times_effectively_equal(now, Time.now)
+    end
+    assert_times_effectively_equal(time_after_travel, Time.now)
+  end
+  
+  def test_travel_returns_now_if_nil_supplied
+    assert_times_effectively_equal Time.now, Timecop.travel(nil)
   end
 
   def test_travel_time_with_block_returns_the_value_of_the_block
@@ -346,10 +417,17 @@ class TestTimecop < Test::Unit::TestCase
 
     assert_equal expected, actual
   end
+  
+  def test_travel_raises_when_empty_string_supplied
+    err = assert_raises(ArgumentError) do
+      Timecop.travel("")
+    end
+    assert_match /no time information in \"\"/, err.message
+  end
 
-  def test_freeze_time_returns_nil
+  def test_freeze_time_returns_now_if_no_block_given
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    assert_nil Timecop.freeze(t_future)
+    assert_times_effectively_equal t_future, Timecop.freeze(t_future)
   end
 
   def test_freeze_time_with_block_returns_the_value_of_the_block
@@ -372,6 +450,17 @@ class TestTimecop < Test::Unit::TestCase
       end
     end
   end
+  
+   def test_freeze_returns_now_if_nil_supplied
+    assert_times_effectively_equal Time.now, Timecop.freeze(nil)
+  end
+
+  def test_freeze_raises_when_empty_string_supplied
+    err = assert_raises(ArgumentError) do
+      Timecop.freeze("")
+    end
+     assert_match /no time information in \"\"/, err.message
+  end
 
   def test_freeze_with_new_date
     date = Date.new(2012, 6, 9)
@@ -413,4 +502,121 @@ class TestTimecop < Test::Unit::TestCase
     assert_equal date, Time.now
     assert_equal date, Time.new
   end
+
+  def test_not_callable_send_travel
+    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_raises_when_safe_mode_and_no_block_though_previously_block_given
+    Timecop.freeze do
+      Timecop.freeze
+    end
+
+    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_no_raise_when_safe_mode_and_no_block_and_in_block_context
+    with_safe_mode do
+      Timecop.freeze do
+        Timecop.freeze
+      end
+    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
+
+  def test_thread_safe_timecop_in_parallel
+    Timecop.thread_safe = true
+    date = Time.local(2011, 01, 02)
+    thread = Thread.new do
+      Timecop.freeze(date) do
+        sleep 1 #give main thread time to run
+        assert_equal date, Time.now
+      end
+    end
+
+    sleep 0.25
+    assert Time.now != date
+    thread.join
+  ensure
+    Timecop.thread_safe = false
+  end
+
+  def test_thread_safe_timecop_returns_after_block
+    Timecop.thread_safe = true
+    date = Time.local(2017, 10, 8)
+
+    Timecop.freeze(date) { }
+    assert Time.now != date
+  ensure
+    Timecop.thread_safe = false
+  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 '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
@@ -71,13 +70,13 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
       new_now = Time.now
       assert_times_effectively_equal new_now, t, 1, "Looks like we failed to actually travel time" # 0.1 seconds
       sleep(0.25)
-      assert_times_effectively_not_equal new_now, Time.now, 0.25, "Looks like time is not moving"
+      assert_times_effectively_not_equal new_now, Time.now, 0.24, "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,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.5.2
-  prerelease: 
+  version: 0.9.5
 platform: ruby
 authors:
 - Travis Jeffery
 - John Trupiano
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-09-20 00:00:00.000000000 Z
+date: 2022-03-07 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
@@ -22,47 +21,41 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files:
-- History.rdoc
 - LICENSE
 - README.markdown
 - Rakefile
 - 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
-homepage: http://github.com/jtrupiano/timecop
-licenses: []
-post_install_message: 
+- 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'
-      segments:
-      - 0
-      hash: -1525074573276164628
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: johntrupiano
-rubygems_version: 1.8.10
-signing_key: 
+rubygems_version: 3.2.22
+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,