rpm/python-freezegun
SHA256
1
0
Fork 0
forked from pool/python-freezegun
Code Pull Requests Activity
python-freezegun/denose.patch
Matej Cepl 5f7003500d - Update to 0.3.11: 
* Performance improvements
    * Fix nesting time.time
    * Add nanosecond property
- Remove nose dependency by adding denose.patch

- Remove superfluous devel dependency for noarch package

OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-freezegun?expand=0&rev=17
2019-01-10 14:59:27 +00:00

1151 lines
44 KiB
Diff
Raw Blame History

--- 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)
View Git Blame Copy Permalink