diff --git a/_u_p37_tests.patch b/_u_p37_tests.patch deleted file mode 100644 index a8dc084..0000000 --- a/_u_p37_tests.patch +++ /dev/null @@ -1,55 +0,0 @@ -From 4fdad69659f15a9e62cf4f6c15c9f319276cf9b0 Mon Sep 17 00:00:00 2001 -From: Jonas Obrist -Date: Tue, 6 Mar 2018 12:21:38 +0900 -Subject: [PATCH] add support for Python 3.7 uuid module changes - -Python 3.7 removed uuid._uuid_generate_time. It now has -uuid._load_system_functions and uuid._generate_time_safe. -_generate_time_safe is set by calling _load_system_functions (subsequent -calls to that function are no-op). This change detects the missing -uuid._uuid_generate_time attribute and uses the new attribute/function -if they're missing. ---- - freezegun/api.py | 14 +++++++++++--- - 1 file changed, 11 insertions(+), 3 deletions(-) - -diff --git a/freezegun/api.py b/freezegun/api.py -index eb09932..a88a392 100644 ---- a/freezegun/api.py -+++ b/freezegun/api.py -@@ -27,8 +27,14 @@ - - try: - real_uuid_generate_time = uuid._uuid_generate_time --except (AttributeError, ImportError): -+ uuid_generate_time_attr = '_uuid_generate_time' -+except AttributeError: -+ uuid._load_system_functions() -+ real_uuid_generate_time = uuid._generate_time_safe -+ uuid_generate_time_attr = '_generate_time_safe' -+except ImportError: - real_uuid_generate_time = None -+ uuid_generate_time_attr = None - - try: - real_uuid_create = uuid._UuidCreate -@@ -482,7 +488,8 @@ def start(self): - time.localtime = fake_localtime - time.gmtime = fake_gmtime - time.strftime = fake_strftime -- uuid._uuid_generate_time = None -+ if uuid_generate_time_attr: -+ setattr(uuid, uuid_generate_time_attr, None) - uuid._UuidCreate = None - uuid._last_timestamp = None - -@@ -573,7 +580,8 @@ def stop(self): - time.localtime = time.localtime.previous_localtime_function - time.strftime = time.strftime.previous_strftime_function - -- uuid._uuid_generate_time = real_uuid_generate_time -+ if uuid_generate_time_attr: -+ setattr(uuid, uuid_generate_time_attr, real_uuid_generate_time) - uuid._UuidCreate = real_uuid_create - uuid._last_timestamp = None - diff --git a/denose.patch b/denose.patch new file mode 100644 index 0000000..dc81328 --- /dev/null +++ b/denose.patch @@ -0,0 +1,1150 @@ +--- 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) diff --git a/freezegun-0.3.10.tar.gz b/freezegun-0.3.10.tar.gz deleted file mode 100644 index 7692030..0000000 --- a/freezegun-0.3.10.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:703caac155dcaad61f78de4cb0666dca778d854dfb90b3699930adee0559a622 -size 20398 diff --git a/freezegun-0.3.11.tar.gz b/freezegun-0.3.11.tar.gz new file mode 100644 index 0000000..ee518d9 --- /dev/null +++ b/freezegun-0.3.11.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e839b43bfbe8158b4d62bb97e6313d39f3586daf48e1314fb1083d2ef17700da +size 23382 diff --git a/python-freezegun.changes b/python-freezegun.changes index 4c8de10..8808673 100644 --- a/python-freezegun.changes +++ b/python-freezegun.changes @@ -1,3 +1,17 @@ +------------------------------------------------------------------- +Thu Jan 10 14:29:14 CET 2019 - mcepl@suse.com + +- Update to 0.3.11: + * Performance improvements + * Fix nesting time.time + * Add nanosecond property +- Remove nose dependency by adding denose.patch + +------------------------------------------------------------------- +Tue Dec 4 12:48:13 UTC 2018 - Matej Cepl + +- Remove superfluous devel dependency for noarch package + ------------------------------------------------------------------- Tue Sep 4 16:32:05 UTC 2018 - Matěj Cepl diff --git a/python-freezegun.spec b/python-freezegun.spec index 2e0deba..13f7c4e 100644 --- a/python-freezegun.spec +++ b/python-freezegun.spec @@ -1,7 +1,7 @@ # # spec file for package python-freezegun # -# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -12,24 +12,23 @@ # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. -# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# Please submit bugfixes or comments via https://bugs.opensuse.org/ # %{?!python_module:%define python_module() python-%{**} python3-%{**}} -%bcond_without tests Name: python-freezegun -Version: 0.3.10 +Version: 0.3.11 Release: 0 Summary: Mock time date for Python License: Apache-2.0 Group: Development/Languages/Python URL: https://github.com/spulec/freezegun Source: https://files.pythonhosted.org/packages/source/f/freezegun/freezegun-%{version}.tar.gz -Patch0: _u_p37_tests.patch -# https://github.com/spulec/freezegun/issues/259 -Patch1: remove_dependency_on_mock.patch -BuildRequires: %{python_module devel} +# gh#spulec/freezegun#259 +Patch0: remove_dependency_on_mock.patch +# gh#spulec/freezegun#280 Removal of nose dependency +Patch1: denose.patch BuildRequires: %{python_module python-dateutil > 2.0} BuildRequires: %{python_module setuptools} BuildRequires: %{python_module six} @@ -38,10 +37,7 @@ BuildRequires: python-rpm-macros Requires: python-python-dateutil > 2.0 Requires: python-six BuildArch: noarch -%if %{with tests} -BuildRequires: %{python_module nose} BuildRequires: python2-mock -%endif %python_subpackages %description @@ -59,10 +55,8 @@ time by mocking the datetime module. %python_install %python_expand %fdupes %{buildroot}%{$python_sitelib} -%if %{with tests} %check -%python_expand nosetests-%{$python_bin_suffix} -%endif +%python_exec -munittest discover -v %files %{python_files} %license LICENSE