--- 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)