File denose.patch of Package python-freezegun

Overview Repositories Revisions Requests Users Attributes Meta

File denose.patch of Package python-freezegun (Revision ce1d36cb6ba439936e734acddf969fd5)

Currently displaying revision ce1d36cb6ba439936e734acddf969fd5 , Show latest

--- a/tests/utils.py
+++ b/tests/utils.py
@@ -1,6 +1,6 @@
 from functools import wraps
 
-from nose.plugins import skip
+from unittest import SkipTest
 
 from freezegun.api import FakeDate, FakeDatetime, _is_cpython
 
@@ -17,6 +17,6 @@ def cpython_only(func):
     @wraps(func)
     def wrapper(*args):
         if not _is_cpython:
-            raise skip.SkipTest("Requires CPython")
+            raise SkipTest("Requires CPython")
         return func(*args)
     return wrapper
--- a/setup.py
+++ b/setup.py
@@ -4,7 +4,7 @@ import sys
 from setuptools import setup
 
 requires = ['six']
-tests_require = ['mock', 'nose']
+tests_require = ['mock']
 
 if sys.version_info.major == 2:
     requires += ['python-dateutil>=1.0, != 2.0']
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -2,7 +2,7 @@ try:
     import mock
 except ImportError:
     import unittest.mock as mock
-from nose.plugins import skip
+from unittest import SkipTest
 
 from freezegun import api
 from tests import utils
@@ -23,7 +23,7 @@ def test_should_not_skip_cpython():
     function_mock = mock.MagicMock(__name__='function')
     try:
         utils.cpython_only(function_mock)()
-    except skip.SkipTest:
+    except SkipTest:
         raise AssertionError("Test was skipped in CPython")
     assert function_mock.called
 
@@ -35,7 +35,7 @@ def test_should_skip_non_cpython():
     function_mock = mock.MagicMock(__name__='function', skipped=False)
     try:
         utils.cpython_only(function_mock)()
-    except skip.SkipTest:
+    except SkipTest:
         function_mock.skipped = True
     assert not function_mock.called
     assert function_mock.skipped
--- a/tests/test_asyncio.py
+++ b/tests/test_asyncio.py
@@ -1,7 +1,7 @@
 import datetime
 from textwrap import dedent
 
-from nose.plugins import skip
+from unittest import SkipTest
 
 from freezegun import freeze_time
 
@@ -13,7 +13,7 @@ except ImportError:
 
 def test_time_freeze_coroutine():
     if not asyncio:
-        raise skip.SkipTest('asyncio required')
+        raise SkipTest('asyncio required')
     @asyncio.coroutine
     @freeze_time('1970-01-01')
     def frozen_coroutine():
@@ -26,7 +26,7 @@ def test_time_freeze_async_def():
     try:
         exec('async def foo(): pass')
     except SyntaxError:
-        raise skip.SkipTest('async def not supported')
+        raise SkipTest('async def not supported')
     else:
         exec(dedent('''
         @freeze_time('1970-01-01')
--- a/tests/test_uuid.py
+++ b/tests/test_uuid.py
@@ -1,46 +1,46 @@
 from __future__ import print_function, absolute_import, unicode_literals
 import datetime
 import uuid
-
-from nose.tools import assert_equal
+import unittest
 
 from freezegun import freeze_time
 
 
-def time_from_uuid(value):
-    """
-    Converts an UUID(1) to it's datetime value
-    """
-    uvalue = value if isinstance(value, uuid.UUID) else uuid.UUID(value)
-    assert uvalue.version == 1
-    return (datetime.datetime(1582, 10, 15) +
-            datetime.timedelta(microseconds=uvalue.time // 10))
-
-
-def test_uuid1_future():
-    """
-    Test that we can go back in time after setting a future date.
-    Normally UUID1 would disallow this, since it keeps track of
-    the _last_timestamp, but we override that now.
-    """
-    future_target = datetime.datetime(2056, 2, 6, 14, 3, 21)
-    with freeze_time(future_target):
-        assert_equal(time_from_uuid(uuid.uuid1()), future_target)
-
-    past_target = datetime.datetime(1978, 7, 6, 23, 6, 31)
-    with freeze_time(past_target):
-        assert_equal(time_from_uuid(uuid.uuid1()), past_target)
-
-
-def test_uuid1_past():
-    """
-    Test that we can go forward in time after setting some time in the past.
-    This is simply the opposite of test_uuid1_future()
-    """
-    past_target = datetime.datetime(1978, 7, 6, 23, 6, 31)
-    with freeze_time(past_target):
-        assert_equal(time_from_uuid(uuid.uuid1()), past_target)
-
-    future_target = datetime.datetime(2056, 2, 6, 14, 3, 21)
-    with freeze_time(future_target):
-        assert_equal(time_from_uuid(uuid.uuid1()), future_target)
+class TestUUID(unittest.TestCase):
+    def time_from_uuid(self, value):
+        """
+        Converts an UUID(1) to it's datetime value
+        """
+        uvalue = value if isinstance(value, uuid.UUID) else uuid.UUID(value)
+        assert uvalue.version == 1
+        return (datetime.datetime(1582, 10, 15) +
+                datetime.timedelta(microseconds=uvalue.time // 10))
+
+
+    def test_uuid1_future(self):
+        """
+        Test that we can go back in time after setting a future date.
+        Normally UUID1 would disallow this, since it keeps track of
+        the _last_timestamp, but we override that now.
+        """
+        future_target = datetime.datetime(2056, 2, 6, 14, 3, 21)
+        with freeze_time(future_target):
+            self.assertEqual(self.time_from_uuid(uuid.uuid1()), future_target)
+
+        past_target = datetime.datetime(1978, 7, 6, 23, 6, 31)
+        with freeze_time(past_target):
+            self.assertEqual(self.time_from_uuid(uuid.uuid1()), past_target)
+
+
+    def test_uuid1_past(self):
+        """
+        Test that we can go forward in time after setting some time in the past.
+        This is simply the opposite of test_uuid1_future()
+        """
+        past_target = datetime.datetime(1978, 7, 6, 23, 6, 31)
+        with freeze_time(past_target):
+            self.assertEqual(self.time_from_uuid(uuid.uuid1()), past_target)
+
+        future_target = datetime.datetime(2056, 2, 6, 14, 3, 21)
+        with freeze_time(future_target):
+            self.assertEqual(self.time_from_uuid(uuid.uuid1()), future_target)
--- a/tests/test_datetimes.py
+++ b/tests/test_datetimes.py
@@ -4,8 +4,6 @@ import unittest
 import locale
 import sys
 
-from nose.plugins import skip
-from nose.tools import assert_raises
 from tests import utils
 
 from freezegun import freeze_time
@@ -33,7 +31,7 @@ class temp_locale(object):
             except locale.Error:
                 pass
         msg = 'could not set locale to any of: %s' % ', '.join(self.targets)
-        raise skip.SkipTest(msg)
+        raise unittest.SkipTest(msg)
 
     def __exit__(self, *args):
         locale.setlocale(locale.LC_ALL, self.old)
@@ -42,184 +40,7 @@ class temp_locale(object):
 # which can cause trouble when parsed with dateutil.
 _dd_mm_yyyy_locales = ['da_DK.UTF-8', 'de_DE.UTF-8', 'fr_FR.UTF-8']
 
-
-def test_simple_api():
-    # time to freeze is always provided in UTC
-    freezer = freeze_time("2012-01-14")
-    # expected timestamp must be a timestamp, corresponding to 2012-01-14 UTC
-    local_time = datetime.datetime(2012, 1, 14)
-    utc_time = local_time - datetime.timedelta(seconds=time.timezone)
-    expected_timestamp = time.mktime(utc_time.timetuple())
-
-    freezer.start()
-    assert time.time() == expected_timestamp
-    assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)
-    assert datetime.datetime.utcnow() == datetime.datetime(2012, 1, 14)
-    assert datetime.date.today() == datetime.date(2012, 1, 14)
-    assert datetime.datetime.now().today() == datetime.datetime(2012, 1, 14)
-    freezer.stop()
-    assert time.time() != expected_timestamp
-    assert datetime.datetime.now() != datetime.datetime(2012, 1, 14)
-    assert datetime.datetime.utcnow() != datetime.datetime(2012, 1, 14)
-    freezer = freeze_time("2012-01-10 13:52:01")
-    freezer.start()
-    assert datetime.datetime.now() == datetime.datetime(2012, 1, 10, 13, 52, 1)
-    freezer.stop()
-
-
-def test_tz_offset():
-    freezer = freeze_time("2012-01-14 03:21:34", tz_offset=-4)
-    # expected timestamp must be a timestamp,
-    # corresponding to 2012-01-14 03:21:34 UTC
-    # and it doesn't depend on tz_offset
-    local_time = datetime.datetime(2012, 1, 14, 3, 21, 34)
-    utc_time = local_time - datetime.timedelta(seconds=time.timezone)
-    expected_timestamp = time.mktime(utc_time.timetuple())
-
-    freezer.start()
-    assert datetime.datetime.now() == datetime.datetime(2012, 1, 13, 23, 21, 34)
-    assert datetime.datetime.utcnow() == datetime.datetime(2012, 1, 14, 3, 21, 34)
-    assert time.time() == expected_timestamp
-    freezer.stop()
-
-
-def test_timedelta_tz_offset():
-    freezer = freeze_time("2012-01-14 03:21:34",
-                          tz_offset=-datetime.timedelta(hours=3, minutes=30))
-    freezer.start()
-    assert datetime.datetime.now() == datetime.datetime(2012, 1, 13, 23, 51, 34)
-    assert datetime.datetime.utcnow() == datetime.datetime(2012, 1, 14, 3, 21, 34)
-    freezer.stop()
-
-
-def test_tz_offset_with_today():
-    freezer = freeze_time("2012-01-14", tz_offset=-4)
-    freezer.start()
-    assert datetime.date.today() == datetime.date(2012, 1, 13)
-    freezer.stop()
-    assert datetime.date.today() != datetime.date(2012, 1, 13)
-
-
-def test_zero_tz_offset_with_time():
-    # we expect the system to behave like a system with UTC timezone
-    # at the beginning of the Epoch
-    freezer = freeze_time('1970-01-01')
-    freezer.start()
-    assert datetime.date.today() == datetime.date(1970, 1, 1)
-    assert datetime.datetime.now() == datetime.datetime(1970, 1, 1)
-    assert datetime.datetime.utcnow() == datetime.datetime(1970, 1, 1)
-    assert time.time() == 0.0
-    freezer.stop()
-
-
-def test_tz_offset_with_time():
-    # we expect the system to behave like a system with UTC-4 timezone
-    # at the beginning of the Epoch (wall clock should be 4 hrs late)
-    freezer = freeze_time('1970-01-01', tz_offset=-4)
-    freezer.start()
-    assert datetime.date.today() == datetime.date(1969, 12, 31)
-    assert datetime.datetime.now() == datetime.datetime(1969, 12, 31, 20)
-    assert datetime.datetime.utcnow() == datetime.datetime(1970, 1, 1)
-    assert time.time() == 0.0
-    freezer.stop()
-
-
-def test_time_with_microseconds():
-    freezer = freeze_time(datetime.datetime(1970, 1, 1, 0, 0, 1, 123456))
-    freezer.start()
-    assert time.time() == 1.123456
-    freezer.stop()
-
-
-def test_time_with_dst():
-    freezer = freeze_time(datetime.datetime(1970, 6, 1, 0, 0, 1, 123456))
-    freezer.start()
-    assert time.time() == 13046401.123456
-    freezer.stop()
-
-
-def test_manual_increment():
-    initial_datetime = datetime.datetime(year=1, month=7, day=12,
-                                        hour=15, minute=6, second=3)
-    with freeze_time(initial_datetime) as frozen_datetime:
-        assert frozen_datetime() == initial_datetime
-
-        frozen_datetime.tick()
-        initial_datetime += datetime.timedelta(seconds=1)
-        assert frozen_datetime() == initial_datetime
-
-        frozen_datetime.tick(delta=datetime.timedelta(seconds=10))
-        initial_datetime += datetime.timedelta(seconds=10)
-        assert frozen_datetime() == initial_datetime
-
-
-def test_manual_increment_seconds():
-    initial_datetime = datetime.datetime(year=1, month=7, day=12,
-                                         hour=15, minute=6, second=3)
-    with freeze_time(initial_datetime) as frozen_datetime:
-        assert frozen_datetime() == initial_datetime
-
-        frozen_datetime.tick()
-        initial_datetime += datetime.timedelta(seconds=1)
-        assert frozen_datetime() == initial_datetime
-
-        frozen_datetime.tick(10)
-        initial_datetime += datetime.timedelta(seconds=10)
-        assert frozen_datetime() == initial_datetime
-
-
-def test_move_to():
-    initial_datetime = datetime.datetime(year=1, month=7, day=12,
-                                        hour=15, minute=6, second=3)
-
-    other_datetime = datetime.datetime(year=2, month=8, day=13,
-                                        hour=14, minute=5, second=0)
-    with freeze_time(initial_datetime) as frozen_datetime:
-        assert frozen_datetime() == initial_datetime
-
-        frozen_datetime.move_to(other_datetime)
-        assert frozen_datetime() == other_datetime
-
-        frozen_datetime.move_to(initial_datetime)
-        assert frozen_datetime() == initial_datetime
-
-
-def test_bad_time_argument():
-    try:
-        freeze_time("2012-13-14", tz_offset=-4)
-    except ValueError:
-        pass
-    else:
-        assert False, "Bad values should raise a ValueError"
-
-
-def test_time_gmtime():
-    with freeze_time('2012-01-14 03:21:34'):
-        time_struct = time.gmtime()
-        assert time_struct.tm_year == 2012
-        assert time_struct.tm_mon == 1
-        assert time_struct.tm_mday == 14
-        assert time_struct.tm_hour == 3
-        assert time_struct.tm_min == 21
-        assert time_struct.tm_sec == 34
-        assert time_struct.tm_wday == 5
-        assert time_struct.tm_yday == 14
-        assert time_struct.tm_isdst == -1
-
-
-def test_time_clock():
-    with freeze_time('2012-01-14 03:21:34'):
-        assert time.clock() == 0
-
-        with freeze_time('2012-01-14 03:21:35'):
-            assert time.clock() == 1
-
-        with freeze_time('2012-01-14 03:21:36'):
-            assert time.clock() == 2
-
-
 class modify_timezone(object):
-
     def __init__(self, new_timezone):
         self.new_timezone = new_timezone
         self.original_timezone = time.timezone
@@ -231,137 +52,305 @@ class modify_timezone(object):
         time.timezone = self.original_timezone
 
 
-def test_time_localtime():
-    with modify_timezone(-3600):  # Set this for UTC-1
+class TestDateTimes(unittest.TestCase):
+    def test_simple_api(self):
+        # time to freeze is always provided in UTC
+        freezer = freeze_time("2012-01-14")
+        # expected timestamp must be a timestamp, corresponding to 2012-01-14 UTC
+        local_time = datetime.datetime(2012, 1, 14)
+        utc_time = local_time - datetime.timedelta(seconds=time.timezone)
+        expected_timestamp = time.mktime(utc_time.timetuple())
+
+        freezer.start()
+        self.assertEqual(time.time(), expected_timestamp)
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
+        self.assertEqual(datetime.datetime.utcnow(), datetime.datetime(2012, 1, 14))
+        self.assertEqual(datetime.date.today(), datetime.date(2012, 1, 14))
+        self.assertEqual(datetime.datetime.now().today(), datetime.datetime(2012, 1, 14))
+        freezer.stop()
+        self.assertNotEqual(time.time(), expected_timestamp)
+        self.assertNotEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
+        self.assertNotEqual(datetime.datetime.utcnow(), datetime.datetime(2012, 1, 14))
+        freezer = freeze_time("2012-01-10 13:52:01")
+        freezer.start()
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 10, 13, 52, 1))
+        freezer.stop()
+
+
+    def test_tz_offset(self):
+        freezer = freeze_time("2012-01-14 03:21:34", tz_offset=-4)
+        # expected timestamp must be a timestamp,
+        # corresponding to 2012-01-14 03:21:34 UTC
+        # and it doesn't depend on tz_offset
+        local_time = datetime.datetime(2012, 1, 14, 3, 21, 34)
+        utc_time = local_time - datetime.timedelta(seconds=time.timezone)
+        expected_timestamp = time.mktime(utc_time.timetuple())
+
+        freezer.start()
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 13, 23, 21, 34))
+        self.assertEqual(datetime.datetime.utcnow(), datetime.datetime(2012, 1, 14, 3, 21, 34))
+        self.assertEqual(time.time(), expected_timestamp)
+        freezer.stop()
+
+
+    def test_timedelta_tz_offset(self):
+        freezer = freeze_time("2012-01-14 03:21:34",
+                              tz_offset=-datetime.timedelta(hours=3, minutes=30))
+        freezer.start()
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 13, 23, 51, 34))
+        self.assertEqual(datetime.datetime.utcnow(), datetime.datetime(2012, 1, 14, 3, 21, 34))
+        freezer.stop()
+
+
+    def test_tz_offset_with_today(self):
+        freezer = freeze_time("2012-01-14", tz_offset=-4)
+        freezer.start()
+        self.assertEqual(datetime.date.today(), datetime.date(2012, 1, 13))
+        freezer.stop()
+        self.assertNotEqual(datetime.date.today(), datetime.date(2012, 1, 13))
+
+
+    def test_zero_tz_offset_with_time(self):
+        # we expect the system to behave like a system with UTC timezone
+        # at the beginning of the Epoch
+        freezer = freeze_time('1970-01-01')
+        freezer.start()
+        self.assertEqual(datetime.date.today(), datetime.date(1970, 1, 1))
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(1970, 1, 1))
+        self.assertEqual(datetime.datetime.utcnow(), datetime.datetime(1970, 1, 1))
+        self.assertEqual(time.time(), 0.0)
+        freezer.stop()
+
+
+    def test_tz_offset_with_time(self):
+        # we expect the system to behave like a system with UTC-4 timezone
+        # at the beginning of the Epoch (wall clock should be 4 hrs late)
+        freezer = freeze_time('1970-01-01', tz_offset=-4)
+        freezer.start()
+        self.assertEqual(datetime.date.today(), datetime.date(1969, 12, 31))
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(1969, 12, 31, 20))
+        self.assertEqual(datetime.datetime.utcnow(), datetime.datetime(1970, 1, 1))
+        self.assertEqual(time.time(), 0.0)
+        freezer.stop()
+
+
+    def test_time_with_microseconds(self):
+        freezer = freeze_time(datetime.datetime(1970, 1, 1, 0, 0, 1, 123456))
+        freezer.start()
+        self.assertEqual(time.time(), 1.123456)
+        freezer.stop()
+
+
+    def test_time_with_dst(self):
+        freezer = freeze_time(datetime.datetime(1970, 6, 1, 0, 0, 1, 123456))
+        freezer.start()
+        self.assertEqual(time.time(), 13046401.123456)
+        freezer.stop()
+
+
+    def test_manual_increment(self):
+        initial_datetime = datetime.datetime(year=1, month=7, day=12,
+                                            hour=15, minute=6, second=3)
+        with freeze_time(initial_datetime) as frozen_datetime:
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+            frozen_datetime.tick()
+            initial_datetime += datetime.timedelta(seconds=1)
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+            frozen_datetime.tick(delta=datetime.timedelta(seconds=10))
+            initial_datetime += datetime.timedelta(seconds=10)
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+
+    def test_manual_increment_seconds(self):
+        initial_datetime = datetime.datetime(year=1, month=7, day=12,
+                                             hour=15, minute=6, second=3)
+        with freeze_time(initial_datetime) as frozen_datetime:
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+            frozen_datetime.tick()
+            initial_datetime += datetime.timedelta(seconds=1)
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+            frozen_datetime.tick(10)
+            initial_datetime += datetime.timedelta(seconds=10)
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+
+    def test_move_to(self):
+        initial_datetime = datetime.datetime(year=1, month=7, day=12,
+                                            hour=15, minute=6, second=3)
+
+        other_datetime = datetime.datetime(year=2, month=8, day=13,
+                                            hour=14, minute=5, second=0)
+        with freeze_time(initial_datetime) as frozen_datetime:
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+            frozen_datetime.move_to(other_datetime)
+            self.assertEqual(frozen_datetime(), other_datetime)
+
+            frozen_datetime.move_to(initial_datetime)
+            self.assertEqual(frozen_datetime(), initial_datetime)
+
+
+    def test_bad_time_argument(self):
+        with self.assertRaises(ValueError):
+            freeze_time("2012-13-14", tz_offset=-4)
+
+    def test_time_gmtime(self):
         with freeze_time('2012-01-14 03:21:34'):
-            time_struct = time.localtime()
-            assert time_struct.tm_year == 2012
-            assert time_struct.tm_mon == 1
-            assert time_struct.tm_mday == 14
-            assert time_struct.tm_hour == 4  # offset of 1 hour due to time zone
-            assert time_struct.tm_min == 21
-            assert time_struct.tm_sec == 34
-            assert time_struct.tm_wday == 5
-            assert time_struct.tm_yday == 14
-            assert time_struct.tm_isdst == -1
-    assert time.localtime().tm_year != 2012
-
-
-def test_strftime():
-    with modify_timezone(0):
-        with freeze_time('1970-01-01'):
-            assert time.strftime("%Y") == "1970"
-
-
-def test_date_object():
-    frozen_date = datetime.date(year=2012, month=11, day=10)
-    date_freezer = freeze_time(frozen_date)
-    regular_freezer = freeze_time('2012-11-10')
-    assert date_freezer.time_to_freeze == regular_freezer.time_to_freeze
-
-
-def test_old_date_object():
-    frozen_date = datetime.date(year=1, month=1, day=1)
-    with freeze_time(frozen_date):
-        assert datetime.date.today() == frozen_date
-
-
-def test_date_with_locale():
-    with temp_locale(*_dd_mm_yyyy_locales):
-        frozen_date = datetime.date(year=2012, month=1, day=2)
+            time_struct = time.gmtime()
+            self.assertEqual(time_struct.tm_year, 2012)
+            self.assertEqual(time_struct.tm_mon, 1)
+            self.assertEqual(time_struct.tm_mday, 14)
+            self.assertEqual(time_struct.tm_hour, 3)
+            self.assertEqual(time_struct.tm_min, 21)
+            self.assertEqual(time_struct.tm_sec, 34)
+            self.assertEqual(time_struct.tm_wday, 5)
+            self.assertEqual(time_struct.tm_yday, 14)
+            self.assertEqual(time_struct.tm_isdst, -1)
+
+
+    def test_time_clock(self):
+        with freeze_time('2012-01-14 03:21:34'):
+            self.assertEqual(time.clock(), 0)
+
+            with freeze_time('2012-01-14 03:21:35'):
+                self.assertEqual(time.clock(), 1)
+
+            with freeze_time('2012-01-14 03:21:36'):
+                self.assertEqual(time.clock(), 2)
+
+
+
+    def test_time_localtime(self):
+        with modify_timezone(-3600):  # Set this for UTC-1
+            with freeze_time('2012-01-14 03:21:34'):
+                time_struct = time.localtime()
+                self.assertEqual(time_struct.tm_year, 2012)
+                self.assertEqual(time_struct.tm_mon, 1)
+                self.assertEqual(time_struct.tm_mday, 14)
+                # offset of 1 hour due to time zone
+                self.assertEqual(time_struct.tm_hour, 4)
+                self.assertEqual(time_struct.tm_min, 21)
+                self.assertEqual(time_struct.tm_sec, 34)
+                self.assertEqual(time_struct.tm_wday, 5)
+                self.assertEqual(time_struct.tm_yday, 14)
+                self.assertEqual(time_struct.tm_isdst, -1)
+        self.assertNotEqual(time.localtime().tm_year, 2012)
+
+
+    def test_strftime(self):
+        with modify_timezone(0):
+            with freeze_time('1970-01-01'):
+                self.assertEqual(time.strftime("%Y"), "1970")
+
+
+    def test_date_object(self):
+        frozen_date = datetime.date(year=2012, month=11, day=10)
         date_freezer = freeze_time(frozen_date)
-        assert date_freezer.time_to_freeze.date() == frozen_date
+        regular_freezer = freeze_time('2012-11-10')
+        self.assertEqual(date_freezer.time_to_freeze, regular_freezer.time_to_freeze)
 
 
-def test_invalid_type():
-    try:
-        freeze_time(int(4))
-    except TypeError:
-        pass
-    else:
-        assert False, "Bad types should raise a TypeError"
+    def test_old_date_object(self):
+        frozen_date = datetime.date(year=1, month=1, day=1)
+        with freeze_time(frozen_date):
+            self.assertEqual(datetime.date.today(), frozen_date)
 
 
-def test_datetime_object():
-    frozen_datetime = datetime.datetime(year=2012, month=11, day=10,
-                                        hour=4, minute=15, second=30)
-    datetime_freezer = freeze_time(frozen_datetime)
-    regular_freezer = freeze_time('2012-11-10 04:15:30')
-    assert datetime_freezer.time_to_freeze == regular_freezer.time_to_freeze
+    def test_date_with_locale(self):
+        with temp_locale(*_dd_mm_yyyy_locales):
+            frozen_date = datetime.date(year=2012, month=1, day=2)
+            date_freezer = freeze_time(frozen_date)
+            self.assertEqual(date_freezer.time_to_freeze.date(), frozen_date)
 
 
-def test_function_object():
-    frozen_datetime = datetime.datetime(year=2012, month=11, day=10,
-                                        hour=4, minute=15, second=30)
-    def function(): return frozen_datetime
+    def test_invalid_type(self):
+        with self.assertRaises(TypeError):
+            freeze_time(int(4))
 
-    with freeze_time(function):
-        assert frozen_datetime == datetime.datetime.now()
+    def test_datetime_object(self):
+        frozen_datetime = datetime.datetime(year=2012, month=11, day=10,
+                                            hour=4, minute=15, second=30)
+        datetime_freezer = freeze_time(frozen_datetime)
+        regular_freezer = freeze_time('2012-11-10 04:15:30')
+        self.assertEqual(datetime_freezer.time_to_freeze, regular_freezer.time_to_freeze)
 
 
-def test_lambda_object():
-    frozen_datetime = datetime.datetime(year=2012, month=11, day=10,
-                                        hour=4, minute=15, second=30)
-    with freeze_time(lambda: frozen_datetime):
-        assert frozen_datetime == datetime.datetime.now()
+    def test_function_object(self):
+        frozen_datetime = datetime.datetime(year=2012, month=11, day=10,
+                                            hour=4, minute=15, second=30)
+        def function(): return frozen_datetime
 
+        with freeze_time(function):
+            self.assertEqual(frozen_datetime, datetime.datetime.now())
 
-def test_generator_object():
-    frozen_datetimes = (datetime.datetime(year=y, month=1, day=1)
-        for y in range(2010, 2012))
 
-    with freeze_time(frozen_datetimes):
-        assert datetime.datetime(2010, 1, 1) == datetime.datetime.now()
+    def test_lambda_object(self):
+        frozen_datetime = datetime.datetime(year=2012, month=11, day=10,
+                                            hour=4, minute=15, second=30)
+        with freeze_time(lambda: frozen_datetime):
+            self.assertEqual(frozen_datetime, datetime.datetime.now())
 
-    with freeze_time(frozen_datetimes):
-        assert datetime.datetime(2011, 1, 1) == datetime.datetime.now()
 
-    assert_raises(StopIteration, freeze_time, frozen_datetimes)
+    def test_generator_object(self):
+        frozen_datetimes = (datetime.datetime(year=y, month=1, day=1)
+            for y in range(2010, 2012))
 
+        with freeze_time(frozen_datetimes):
+            self.assertEqual(datetime.datetime(2010, 1, 1), datetime.datetime.now())
 
-def test_maya_datetimes():
-    if not maya:
-        raise skip.SkipTest("maya is optional since it's not supported for "
-                            "enough python versions")
+        with freeze_time(frozen_datetimes):
+            self.assertEqual(datetime.datetime(2011, 1, 1), datetime.datetime.now())
 
-    with freeze_time(maya.when("October 2nd, 1997")):
-        assert datetime.datetime.now() == datetime.datetime(
-            year=1997,
-            month=10,
-            day=2
-        )
+        with self.assertRaises(StopIteration):
+            freeze_time(frozen_datetimes)
 
 
-def test_old_datetime_object():
-    frozen_datetime = datetime.datetime(year=1, month=7, day=12,
-                                        hour=15, minute=6, second=3)
-    with freeze_time(frozen_datetime):
-        assert datetime.datetime.now() == frozen_datetime
+    def test_maya_datetimes(self):
+        if not maya:
+            raise unittest.SkipTest("maya is optional since it's not supported for "
+                                "enough python versions")
 
+        with freeze_time(maya.when("October 2nd, 1997")):
+            self.assertEqual(datetime.datetime.now(), datetime.datetime(
+                year=1997,
+                month=10,
+                day=2
+            ))
 
-def test_datetime_with_locale():
-    with temp_locale(*_dd_mm_yyyy_locales):
-        frozen_datetime = datetime.datetime(year=2012, month=1, day=2)
-        date_freezer = freeze_time(frozen_datetime)
-        assert date_freezer.time_to_freeze == frozen_datetime
 
+    def test_old_datetime_object(self):
+        frozen_datetime = datetime.datetime(year=1, month=7, day=12,
+                                            hour=15, minute=6, second=3)
+        with freeze_time(frozen_datetime):
+            self.assertEqual(datetime.datetime.now(), frozen_datetime)
 
-@freeze_time("2012-01-14")
-def test_decorator():
-    assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)
 
+    def test_datetime_with_locale(self):
+        with temp_locale(*_dd_mm_yyyy_locales):
+            frozen_datetime = datetime.datetime(year=2012, month=1, day=2)
+            date_freezer = freeze_time(frozen_datetime)
+            self.assertEqual(date_freezer.time_to_freeze, frozen_datetime)
 
-def test_decorator_wrapped_attribute():
-    def to_decorate():
-        pass
 
-    wrapped = freeze_time("2014-01-14")(to_decorate)
+    @freeze_time("2012-01-14")
+    def test_decorator(self):
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
+
 
-    assert wrapped.__wrapped__ is to_decorate
+    def test_decorator_wrapped_attribute(self):
+        def to_decorate(self):
+            pass
 
+        wrapped = freeze_time("2014-01-14")(to_decorate)
+
+        self.assertIs(wrapped.__wrapped__, to_decorate)
 
-class Callable(object):
 
+class Callable(object):
     def __call__(self, *args, **kws):
         return (args, kws)
 
@@ -370,13 +359,13 @@ class Callable(object):
 class Tester(object):
 
     def test_the_class(self):
-        assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
 
     def test_still_the_same(self):
-        assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
 
     def test_class_name_preserved_by_decorator(self):
-        assert self.__class__.__name__ == "Tester"
+        self.assertEqual(self.__class__.__name__, "Tester")
 
     class NotATestClass(object):
 
@@ -386,97 +375,99 @@ class Tester(object):
     @freeze_time('2001-01-01')
     def test_class_decorator_ignores_nested_class(self):
         not_a_test = self.NotATestClass()
-        assert not_a_test.perform_operation() == datetime.date(2001, 1, 1)
+        self.assertEqual(not_a_test.perform_operation(), datetime.date(2001, 1, 1))
 
     a_mock = Callable()
 
     def test_class_decorator_skips_callable_object_py2(self):
         if sys.version_info[0] != 2:
-            raise skip.SkipTest("test target is Python2")
-        assert self.a_mock.__class__ == Callable
+            raise unittest.SkipTest("test target is Python2")
+        self.assertEqual(self.a_mock.__class__, Callable)
 
     def test_class_decorator_wraps_callable_object_py3(self):
         if sys.version_info[0] != 3:
-            raise skip.SkipTest("test target is Python3")
-        assert self.a_mock.__wrapped__.__class__ == Callable
+            raise unittest.SkipTest("test target is Python3")
+        self.assertEqual(self.a_mock.__wrapped__.__class__, Callable)
 
     @staticmethod
-    def helper():
+    def helper(self):
         return datetime.date.today()
 
     def test_class_decorator_respects_staticmethod(self):
-        assert self.helper() == datetime.date(2012, 1, 14)
+        self.assertEqual(self.helper(), datetime.date(2012, 1, 14))
 
 
-@freeze_time("Jan 14th, 2012")
-def test_nice_datetime():
-    assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)
+    @freeze_time("Jan 14th, 2012")
+    def test_nice_datetime(self):
+        self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
 
 
-@freeze_time("2012-01-14")
-def test_datetime_date_method():
-    now = datetime.datetime.now()
-    assert now.date() == FakeDate(2012, 1, 14)
-
-
-def test_context_manager():
-    with freeze_time("2012-01-14"):
-        assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)
-    assert datetime.datetime.now() != datetime.datetime(2012, 1, 14)
-
-
-def test_nested_context_manager():
-    with freeze_time("2012-01-14"):
-        with freeze_time("2012-12-25"):
-            _assert_datetime_date_and_time_are_all_equal(datetime.datetime(2012, 12, 25))
-        _assert_datetime_date_and_time_are_all_equal(datetime.datetime(2012, 1, 14))
-    assert datetime.datetime.now() > datetime.datetime(2013, 1, 1)
-
-
-def _assert_datetime_date_and_time_are_all_equal(expected_datetime):
-    assert datetime.datetime.now() == expected_datetime
-    assert datetime.date.today() == expected_datetime.date()
-    datetime_from_time = datetime.datetime.fromtimestamp(time.time())
-    timezone_adjusted_datetime = datetime_from_time + datetime.timedelta(seconds=time.timezone)
-    assert timezone_adjusted_datetime == expected_datetime
-
-
-def test_nested_context_manager_with_tz_offsets():
-    with freeze_time("2012-01-14 23:00:00", tz_offset=2):
-        with freeze_time("2012-12-25 19:00:00", tz_offset=6):
-            assert datetime.datetime.now() == datetime.datetime(2012, 12, 26, 1)
-            assert datetime.date.today() == datetime.date(2012, 12, 26)
-            # no assertion for time.time() since it's not affected by tz_offset
-        assert datetime.datetime.now() == datetime.datetime(2012, 1, 15, 1)
-        assert datetime.date.today() == datetime.date(2012, 1, 15)
-    assert datetime.datetime.now() > datetime.datetime(2013, 1, 1)
-
-
-@freeze_time("Jan 14th, 2012")
-def test_isinstance_with_active():
-    now = datetime.datetime.now()
-    assert utils.is_fake_datetime(now)
-    assert utils.is_fake_date(now.date())
-
-    today = datetime.date.today()
-    assert utils.is_fake_date(today)
-
-
-def test_isinstance_without_active():
-    now = datetime.datetime.now()
-    assert isinstance(now, datetime.datetime)
-    assert isinstance(now, datetime.date)
-    assert isinstance(now.date(), datetime.date)
+    @freeze_time("2012-01-14")
+    def test_datetime_date_method(self):
+        now = datetime.datetime.now()
+        self.assertEqual(now.date(), FakeDate(2012, 1, 14))
+
+
+    def test_context_manager(self):
+        with freeze_time("2012-01-14"):
+            self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
+        self.assertNotEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 14))
+
 
-    today = datetime.date.today()
-    assert isinstance(today, datetime.date)
+    def test_nested_context_manager(self):
+        with freeze_time("2012-01-14"):
+            with freeze_time("2012-12-25"):
+                _assert_datetime_date_and_time_are_all_equal(datetime.datetime(2012, 12, 25))
+            _assert_datetime_date_and_time_are_all_equal(datetime.datetime(2012, 1, 14))
+        self.assertGreater(datetime.datetime.now(), datetime.datetime(2013, 1, 1))
+
+
+    def _assert_datetime_date_and_time_are_all_equal(self, expected_datetime):
+        self.assertEqual(datetime.datetime.now(), expected_datetime)
+        self.assertEqual(datetime.date.today(), expected_datetime.date())
+        datetime_from_time = datetime.datetime.fromtimestamp(time.time())
+        timezone_adjusted_datetime = datetime_from_time + datetime.timedelta(seconds=time.timezone)
+        self.assertEqual(timezone_adjusted_datetime, expected_datetime)
+
+
+    def test_nested_context_manager_with_tz_offsets(self):
+        with freeze_time("2012-01-14 23:00:00", tz_offset=2):
+            with freeze_time("2012-12-25 19:00:00", tz_offset=6):
+                self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 12, 26, 1))
+                self.assertEqual(datetime.date.today(), datetime.date(2012, 12, 26))
+                # no assertion for time.time() since it's not affected by tz_offset
+            self.assertEqual(datetime.datetime.now(), datetime.datetime(2012, 1, 15, 1))
+            self.assertEqual(datetime.date.today(), datetime.date(2012, 1, 15))
+        self.assertGreater(datetime.datetime.now(), datetime.datetime(2013, 1, 1))
+
+
+    @freeze_time("Jan 14th, 2012")
+    def test_isinstance_with_active(self):
+        now = datetime.datetime.now()
+        self.assertTrue(utils.is_fake_datetime(now))
+        self.assertTrue(utils.is_fake_date(now.date()))
+
+        today = datetime.date.today()
+        self.assertTrue(utils.is_fake_date(today))
+
+
+    def test_isinstance_without_active(self):
+        now = datetime.datetime.now()
+        self.assertTrue(isinstance(now, datetime.datetime))
+        self.assertTrue(isinstance(now, datetime.date))
+        self.assertTrue(isinstance(now.date(), datetime.date))
+
+        today = datetime.date.today()
+        self.assertTrue(isinstance(today, datetime.date))
 
 
 @freeze_time('2013-04-09')
 class TestUnitTestClassDecorator(unittest.TestCase):
-
     @classmethod
     def setUpClass(cls):
+        # Not sure whether this make any sense whatsoever, but
+        # I don't want to make waves, so I keep it here. Of
+        # course, self.assert* methods are not available.
         assert datetime.date(2013, 4, 9) == datetime.date.today()
 
     def setUp(self):
@@ -487,6 +478,7 @@ class TestUnitTestClassDecorator(unittes
 
     @classmethod
     def tearDownClass(cls):
+        # see above
         assert datetime.date(2013, 4, 9) == datetime.date.today()
 
     def test_class_decorator_works_on_unittest(self):
@@ -550,7 +542,7 @@ class TestOldStyleClasses:
             def method(self):
                 return datetime.date.today()
 
-        assert OldStyleClass().method() == datetime.date(2013, 4, 9)
+        self.assertEqual(OldStyleClass().method(), datetime.date(2013, 4, 9))
 
     def test_inherited_method(self):
         class OldStyleBaseClass:
@@ -561,84 +553,84 @@ class TestOldStyleClasses:
         class OldStyleClass(OldStyleBaseClass):
             pass
 
-        assert OldStyleClass().inherited_method() == datetime.date(2013, 4, 9)
+        self.assertEqual(OldStyleClass().inherited_method(), datetime.date(2013, 4, 9))
 
 
-def test_min_and_max():
-    freezer = freeze_time("2012-01-14")
-    real_datetime = datetime.datetime
-    real_date = datetime.date
-
-    freezer.start()
-    assert datetime.datetime.min.__class__ == FakeDatetime
-    assert datetime.datetime.max.__class__ == FakeDatetime
-    assert datetime.date.min.__class__ == FakeDate
-    assert datetime.date.max.__class__ == FakeDate
-    assert datetime.datetime.min.__class__ != real_datetime
-    assert datetime.datetime.max.__class__ != real_datetime
-    assert datetime.date.min.__class__ != real_date
-    assert datetime.date.max.__class__ != real_date
-
-    freezer.stop()
-    assert datetime.datetime.min.__class__ == datetime.datetime
-    assert datetime.datetime.max.__class__ == datetime.datetime
-    assert datetime.date.min.__class__ == datetime.date
-    assert datetime.date.max.__class__ == datetime.date
-    assert datetime.datetime.min.__class__ != FakeDatetime
-    assert datetime.datetime.max.__class__ != FakeDatetime
-    assert datetime.date.min.__class__ != FakeDate
-    assert datetime.date.max.__class__ != FakeDate
-
-
-@freeze_time("2014-07-30T01:00:00Z")
-def test_freeze_with_timezone_aware_datetime_in_utc():
-    """
-    utcnow() should always return a timezone naive datetime
-    """
-    utc_now = datetime.datetime.utcnow()
-    assert utc_now.tzinfo is None
-
-
-@freeze_time("1970-01-01T00:00:00-04:00")
-def test_freeze_with_timezone_aware_datetime_in_non_utc():
-    """
-    we expect the system to behave like a system with UTC-4 timezone
-    at the beginning of the Epoch (wall clock should be 4 hrs late)
-    """
-    utc_now = datetime.datetime.utcnow()
-    assert utc_now.tzinfo is None
-    assert utc_now == datetime.datetime(1970, 1, 1, 4)
-
-
-@freeze_time('2015-01-01')
-def test_time_with_nested():
-    from time import time
-    first = 1420070400.0
-    second = 1420070760.0
-
-    assert time() == first
-    with freeze_time('2015-01-01T00:06:00'):
-        assert time() == second
-
-
-def test_should_use_real_time():
-    frozen = datetime.datetime(2015, 3, 5)
-    expected_frozen = 1425513600.0
-    # TODO: local time seems to leak the local timezone, so this test fails in CI
-    # expected_frozen_local = (2015, 3, 5, 1, 0, 0, 3, 64, -1)
-    expected_frozen_gmt = (2015, 3, 5, 0, 0, 0, 3, 64, -1)
-    expected_clock = 0
-
-    BaseFakeTime.call_stack_inspection_limit = 100  # just to increase coverage
-
-    with freeze_time(frozen):
-        assert time.time() == expected_frozen
-        # assert time.localtime() == expected_frozen_local
-        assert time.gmtime() == expected_frozen_gmt
-        assert time.clock() == expected_clock
-
-    with freeze_time(frozen, ignore=['_pytest', 'nose']):
-        assert time.time() != expected_frozen
-        # assert time.localtime() != expected_frozen_local
-        assert time.gmtime() != expected_frozen_gmt
-        assert time.clock() != expected_clock
+    def test_min_and_max(self):
+        freezer = freeze_time("2012-01-14")
+        real_datetime = datetime.datetime
+        real_date = datetime.date
+
+        freezer.start()
+        self.assertEqual(datetime.datetime.min.__class__, FakeDatetime)
+        self.assertEqual(datetime.datetime.max.__class__, FakeDatetime)
+        self.assertEqual(datetime.date.min.__class__, FakeDate)
+        self.assertEqual(datetime.date.max.__class__, FakeDate)
+        self.assertNotEqual(datetime.datetime.min.__class__, real_datetime)
+        self.assertNotEqual(datetime.datetime.max.__class__, real_datetime)
+        self.assertNotEqual(datetime.date.min.__class__, real_date)
+        self.assertNotEqual(datetime.date.max.__class__, real_date)
+
+        freezer.stop()
+        self.assertEqual(datetime.datetime.min.__class__, datetime.datetime)
+        self.assertEqual(datetime.datetime.max.__class__, datetime.datetime)
+        self.assertEqual(datetime.date.min.__class__, datetime.date)
+        self.assertEqual(datetime.date.max.__class__, datetime.date)
+        self.assertNotEqual(datetime.datetime.min.__class__, FakeDatetime)
+        self.assertNotEqual(datetime.datetime.max.__class__, FakeDatetime)
+        self.assertNotEqual(datetime.date.min.__class__, FakeDate)
+        self.assertNotEqual(datetime.date.max.__class__, FakeDate)
+
+
+    @freeze_time("2014-07-30T01:00:00Z")
+    def test_freeze_with_timezone_aware_datetime_in_utc(self):
+        """
+        utcnow() should always return a timezone naive datetime
+        """
+        utc_now = datetime.datetime.utcnow()
+        self.assertIsNone(utc_now.tzinfo)
+
+
+    @freeze_time("1970-01-01T00:00:00-04:00")
+    def test_freeze_with_timezone_aware_datetime_in_non_utc(self):
+        """
+        we expect the system to behave like a system with UTC-4 timezone
+        at the beginning of the Epoch (wall clock should be 4 hrs late)
+        """
+        utc_now = datetime.datetime.utcnow()
+        self.assertIsNone(utc_now.tzinfo)
+        self.assertEqual(utc_now, datetime.datetime(1970, 1, 1, 4))
+
+
+    @freeze_time('2015-01-01')
+    def test_time_with_nested(self):
+        from time import time
+        first = 1420070400.0
+        second = 1420070760.0
+
+        self.assertEqual(time(), first)
+        with freeze_time('2015-01-01T00:06:00'):
+            self.assertEqual(time(), second)
+
+
+    def test_should_use_real_time(self):
+        frozen = datetime.datetime(2015, 3, 5)
+        expected_frozen = 1425513600.0
+        # TODO: local time seems to leak the local timezone, so this test fails in CI
+        # expected_frozen_local = (2015, 3, 5, 1, 0, 0, 3, 64, -1)
+        expected_frozen_gmt = (2015, 3, 5, 0, 0, 0, 3, 64, -1)
+        expected_clock = 0
+
+        BaseFakeTime.call_stack_inspection_limit = 100  # just to increase coverage
+
+        with freeze_time(frozen):
+            self.assertEqual(time.time(), expected_frozen)
+            # self.assertEqual(time.localtime(), expected_frozen_local)
+            self.assertEqual(time.gmtime(), expected_frozen_gmt)
+            self.assertEqual(time.clock(), expected_clock)
+
+        with freeze_time(frozen, ignore=['_pytest', 'nose']):
+            self.assertNotEqual(time.time(), expected_frozen)
+            # self.assertNotEqual(time.localtime(), expected_frozen_local)
+            self.assertNotEqual(time.gmtime(), expected_frozen_gmt)
+            self.assertNotEqual(time.clock(), expected_clock)

Places

File denose.patch of Package python-freezegun (Revision ce1d36cb6ba439936e734acddf969fd5)

Places