2018-04-03 13:33:05 +00:00
|
|
|
import datetime as pdt
|
2018-11-11 11:25:53 +00:00
|
|
|
import sys
|
2019-04-23 11:18:42 +00:00
|
|
|
import platform
|
2018-04-03 13:33:05 +00:00
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
import pytest
|
|
|
|
import rustapi_module.datetime as rdt
|
2019-07-15 05:49:31 +00:00
|
|
|
from hypothesis import given, example
|
2018-08-08 18:41:39 +00:00
|
|
|
from hypothesis import strategies as st
|
2018-04-08 19:30:29 +00:00
|
|
|
from hypothesis.strategies import dates, datetimes
|
2018-04-08 17:21:28 +00:00
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
|
2018-04-08 16:46:12 +00:00
|
|
|
# Constants
|
2018-08-09 20:24:40 +00:00
|
|
|
def _get_utc():
|
2018-11-11 11:25:53 +00:00
|
|
|
timezone = getattr(pdt, "timezone", None)
|
2018-08-09 20:24:40 +00:00
|
|
|
if timezone:
|
|
|
|
return timezone.utc
|
|
|
|
else:
|
2018-11-11 11:25:53 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
class UTC(pdt.tzinfo):
|
|
|
|
def utcoffset(self, dt):
|
|
|
|
return pdt.timedelta(0)
|
2018-04-08 14:28:20 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
def dst(self, dt):
|
|
|
|
return pdt.timedelta(0)
|
2018-04-09 12:00:36 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
def tzname(self, dt):
|
|
|
|
return "UTC"
|
2018-04-03 13:33:05 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
return UTC()
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
UTC = _get_utc()
|
2018-04-08 17:21:28 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
MAX_SECONDS = int(pdt.timedelta.max.total_seconds())
|
|
|
|
MIN_SECONDS = int(pdt.timedelta.min.total_seconds())
|
2018-04-08 17:21:28 +00:00
|
|
|
|
2019-07-15 06:13:03 +00:00
|
|
|
MAX_DAYS = pdt.timedelta.max // pdt.timedelta(days=1)
|
|
|
|
MIN_DAYS = pdt.timedelta.min // pdt.timedelta(days=1)
|
2018-08-09 18:17:34 +00:00
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
MAX_MICROSECONDS = int(pdt.timedelta.max.total_seconds() * 1e6)
|
|
|
|
MIN_MICROSECONDS = int(pdt.timedelta.min.total_seconds() * 1e6)
|
2018-08-09 18:17:34 +00:00
|
|
|
|
2019-10-21 14:50:43 +00:00
|
|
|
IS_X86 = platform.architecture()[0] == "32bit"
|
|
|
|
IS_WINDOWS = sys.platform == "win32"
|
|
|
|
if IS_WINDOWS:
|
|
|
|
MIN_DATETIME = pdt.datetime(1970, 1, 2, 0, 0)
|
|
|
|
if IS_X86:
|
|
|
|
MAX_DATETIME = pdt.datetime(3001, 1, 19, 4, 59, 59)
|
|
|
|
else:
|
|
|
|
MAX_DATETIME = pdt.datetime(3001, 1, 19, 7, 59, 59)
|
|
|
|
else:
|
|
|
|
if IS_X86:
|
|
|
|
# TS ±2147483648 (2**31)
|
|
|
|
MIN_DATETIME = pdt.datetime(1901, 12, 13, 20, 45, 52)
|
|
|
|
MAX_DATETIME = pdt.datetime(2038, 1, 19, 3, 14, 8)
|
|
|
|
else:
|
|
|
|
MIN_DATETIME = pdt.datetime(1, 1, 2, 0, 0)
|
|
|
|
MAX_DATETIME = pdt.datetime(9999, 12, 31, 18, 59, 59)
|
2019-04-23 11:18:42 +00:00
|
|
|
|
|
|
|
PYPY = platform.python_implementation() == "PyPy"
|
2018-11-11 11:25:53 +00:00
|
|
|
HAS_FOLD = getattr(pdt.datetime, "fold", False)
|
2018-08-09 18:17:34 +00:00
|
|
|
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
xfail_date_bounds = pytest.mark.xfail(
|
|
|
|
sys.version_info < (3, 6),
|
|
|
|
reason="Date bounds were not checked in the C constructor prior to version 3.6",
|
|
|
|
)
|
|
|
|
|
2018-08-09 18:17:34 +00:00
|
|
|
|
2018-04-08 17:21:28 +00:00
|
|
|
# Tests
|
2018-04-03 13:33:05 +00:00
|
|
|
def test_date():
|
|
|
|
assert rdt.make_date(2017, 9, 1) == pdt.date(2017, 9, 1)
|
|
|
|
|
|
|
|
|
2018-08-09 00:27:24 +00:00
|
|
|
@given(d=st.dates())
|
|
|
|
def test_date_accessors(d):
|
|
|
|
act = rdt.get_date_tuple(d)
|
|
|
|
exp = (d.year, d.month, d.day)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
@xfail_date_bounds
|
2018-04-06 17:39:45 +00:00
|
|
|
def test_invalid_date_fails():
|
2018-04-03 13:33:05 +00:00
|
|
|
with pytest.raises(ValueError):
|
|
|
|
rdt.make_date(2017, 2, 30)
|
2018-04-06 17:39:45 +00:00
|
|
|
|
|
|
|
|
2019-10-19 15:56:39 +00:00
|
|
|
@given(d=st.dates(MIN_DATETIME.date(), MAX_DATETIME.date()))
|
2018-04-08 17:21:28 +00:00
|
|
|
def test_date_from_timestamp(d):
|
2019-04-23 11:18:42 +00:00
|
|
|
if PYPY and d < pdt.date(1900, 1, 1):
|
2019-07-15 06:13:03 +00:00
|
|
|
pytest.xfail("pdt.datetime.timestamp will raise on PyPy with dates before 1900")
|
2019-04-23 11:18:42 +00:00
|
|
|
|
2019-07-15 06:13:03 +00:00
|
|
|
ts = pdt.datetime.timestamp(pdt.datetime.combine(d, pdt.time(0)))
|
2018-04-08 19:30:29 +00:00
|
|
|
assert rdt.date_from_timestamp(int(ts)) == pdt.date.fromtimestamp(ts)
|
2018-04-08 17:21:28 +00:00
|
|
|
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args, kwargs",
|
|
|
|
[
|
|
|
|
((0, 0, 0, 0, None), {}),
|
|
|
|
((1, 12, 14, 124731), {}),
|
|
|
|
((1, 12, 14, 124731), {"tzinfo": UTC}),
|
|
|
|
],
|
|
|
|
)
|
2018-04-08 14:28:20 +00:00
|
|
|
def test_time(args, kwargs):
|
|
|
|
act = rdt.make_time(*args, **kwargs)
|
|
|
|
exp = pdt.time(*args, **kwargs)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
assert act.tzinfo is exp.tzinfo
|
|
|
|
|
|
|
|
|
2018-08-09 15:25:33 +00:00
|
|
|
@given(t=st.times())
|
|
|
|
def test_time(t):
|
|
|
|
act = rdt.get_time_tuple(t)
|
|
|
|
exp = (t.hour, t.minute, t.second, t.microsecond)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.skipif(not HAS_FOLD, reason="Feature not available before 3.6")
|
|
|
|
@given(t=st.times())
|
|
|
|
def test_time_fold(t):
|
|
|
|
t_nofold = t.replace(fold=0)
|
|
|
|
t_fold = t.replace(fold=1)
|
|
|
|
|
|
|
|
for t in (t_nofold, t_fold):
|
|
|
|
act = rdt.get_time_tuple_fold(t)
|
|
|
|
exp = (t.hour, t.minute, t.second, t.microsecond, t.fold)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
|
|
|
|
2018-04-09 12:00:36 +00:00
|
|
|
@pytest.mark.skipif(not HAS_FOLD, reason="Feature not available before 3.6")
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize("fold", [False, True])
|
2018-04-09 12:00:36 +00:00
|
|
|
def test_time_fold(fold):
|
|
|
|
t = rdt.time_with_fold(0, 0, 0, 0, None, fold)
|
|
|
|
assert t.fold == fold
|
|
|
|
|
|
|
|
|
2018-04-08 14:28:20 +00:00
|
|
|
@pytest.mark.xfail
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args", [(-1, 0, 0, 0), (0, -1, 0, 0), (0, 0, -1, 0), (0, 0, 0, -1)]
|
|
|
|
)
|
2018-04-08 14:28:20 +00:00
|
|
|
def test_invalid_time_fails_xfail(args):
|
|
|
|
with pytest.raises(ValueError):
|
|
|
|
rdt.make_time(*args)
|
|
|
|
|
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
@xfail_date_bounds
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args",
|
|
|
|
[
|
|
|
|
(24, 0, 0, 0),
|
|
|
|
(25, 0, 0, 0),
|
|
|
|
(0, 60, 0, 0),
|
|
|
|
(0, 61, 0, 0),
|
|
|
|
(0, 0, 60, 0),
|
|
|
|
(0, 0, 61, 0),
|
|
|
|
(0, 0, 0, 1000000),
|
|
|
|
],
|
|
|
|
)
|
2018-04-08 14:28:20 +00:00
|
|
|
def test_invalid_time_fails(args):
|
|
|
|
with pytest.raises(ValueError):
|
|
|
|
rdt.make_time(*args)
|
|
|
|
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args",
|
|
|
|
[
|
|
|
|
("0", 0, 0, 0),
|
|
|
|
(0, "0", 0, 0),
|
|
|
|
(0, 0, "0", 0),
|
|
|
|
(0, 0, 0, "0"),
|
|
|
|
(0, 0, 0, 0, "UTC"),
|
|
|
|
],
|
|
|
|
)
|
2018-04-08 14:28:20 +00:00
|
|
|
def test_time_typeerror(args):
|
|
|
|
with pytest.raises(TypeError):
|
|
|
|
rdt.make_time(*args)
|
|
|
|
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args, kwargs",
|
|
|
|
[((2017, 9, 1, 12, 45, 30, 0), {}), ((2017, 9, 1, 12, 45, 30, 0), {"tzinfo": UTC})],
|
|
|
|
)
|
2018-04-06 17:39:45 +00:00
|
|
|
def test_datetime(args, kwargs):
|
|
|
|
act = rdt.make_datetime(*args, **kwargs)
|
|
|
|
exp = pdt.datetime(*args, **kwargs)
|
|
|
|
|
|
|
|
assert act == exp
|
2018-04-08 14:28:20 +00:00
|
|
|
assert act.tzinfo is exp.tzinfo
|
2018-04-06 17:39:45 +00:00
|
|
|
|
|
|
|
|
2018-08-09 14:50:46 +00:00
|
|
|
@given(dt=st.datetimes())
|
|
|
|
def test_datetime_tuple(dt):
|
|
|
|
act = rdt.get_datetime_tuple(dt)
|
2018-11-11 11:25:53 +00:00
|
|
|
exp = dt.timetuple()[0:6] + (dt.microsecond,)
|
2018-08-09 14:50:46 +00:00
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.skipif(not HAS_FOLD, reason="Feature not available before 3.6")
|
|
|
|
@given(dt=st.datetimes())
|
|
|
|
def test_datetime_tuple_fold(dt):
|
2018-08-09 15:25:33 +00:00
|
|
|
dt_fold = dt.replace(fold=1)
|
|
|
|
dt_nofold = dt.replace(fold=0)
|
2018-08-09 14:50:46 +00:00
|
|
|
|
|
|
|
for dt in (dt_fold, dt_nofold):
|
|
|
|
act = rdt.get_datetime_tuple_fold(dt)
|
|
|
|
exp = dt.timetuple()[0:6] + (dt.microsecond, dt.fold)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
2018-08-09 20:24:40 +00:00
|
|
|
|
|
|
|
@xfail_date_bounds
|
2018-04-06 17:39:45 +00:00
|
|
|
def test_invalid_datetime_fails():
|
|
|
|
with pytest.raises(ValueError):
|
|
|
|
rdt.make_datetime(2011, 1, 42, 0, 0, 0, 0)
|
|
|
|
|
|
|
|
|
|
|
|
def test_datetime_typeerror():
|
|
|
|
with pytest.raises(TypeError):
|
2018-11-11 11:25:53 +00:00
|
|
|
rdt.make_datetime("2011", 1, 1, 0, 0, 0, 0)
|
2018-04-08 16:46:12 +00:00
|
|
|
|
|
|
|
|
2019-10-19 15:56:39 +00:00
|
|
|
@given(dt=st.datetimes(MIN_DATETIME, MAX_DATETIME))
|
2019-07-15 05:49:31 +00:00
|
|
|
@example(dt=pdt.datetime(1970, 1, 2, 0, 0))
|
2018-04-08 19:30:29 +00:00
|
|
|
def test_datetime_from_timestamp(dt):
|
2019-04-23 11:18:42 +00:00
|
|
|
if PYPY and dt < pdt.datetime(1900, 1, 1):
|
2019-07-15 06:13:03 +00:00
|
|
|
pytest.xfail("pdt.datetime.timestamp will raise on PyPy with dates before 1900")
|
2019-04-23 11:18:42 +00:00
|
|
|
|
2019-07-15 06:13:03 +00:00
|
|
|
ts = pdt.datetime.timestamp(dt)
|
2018-04-08 19:30:29 +00:00
|
|
|
assert rdt.datetime_from_timestamp(ts) == pdt.datetime.fromtimestamp(ts)
|
|
|
|
|
|
|
|
|
|
|
|
def test_datetime_from_timestamp_tzinfo():
|
|
|
|
d1 = rdt.datetime_from_timestamp(0, tz=UTC)
|
|
|
|
d2 = rdt.datetime_from_timestamp(0, tz=UTC)
|
|
|
|
|
|
|
|
assert d1 == d2
|
|
|
|
assert d1.tzinfo is d2.tzinfo
|
|
|
|
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args",
|
|
|
|
[
|
|
|
|
(0, 0, 0),
|
|
|
|
(1, 0, 0),
|
|
|
|
(-1, 0, 0),
|
|
|
|
(0, 1, 0),
|
|
|
|
(0, -1, 0),
|
|
|
|
(1, -1, 0),
|
|
|
|
(-1, 1, 0),
|
|
|
|
(0, 0, 123456),
|
|
|
|
(0, 0, -123456),
|
|
|
|
],
|
|
|
|
)
|
2018-04-08 16:46:12 +00:00
|
|
|
def test_delta(args):
|
|
|
|
act = pdt.timedelta(*args)
|
|
|
|
exp = rdt.make_delta(*args)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
|
|
|
|
2018-08-08 18:41:39 +00:00
|
|
|
@given(td=st.timedeltas())
|
|
|
|
def test_delta_accessors(td):
|
|
|
|
act = rdt.get_delta_tuple(td)
|
|
|
|
exp = (td.days, td.seconds, td.microseconds)
|
|
|
|
|
|
|
|
assert act == exp
|
|
|
|
|
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"args,err_type",
|
|
|
|
[
|
|
|
|
((MAX_DAYS + 1, 0, 0), OverflowError),
|
|
|
|
((MIN_DAYS - 1, 0, 0), OverflowError),
|
|
|
|
((0, MAX_SECONDS + 1, 0), OverflowError),
|
|
|
|
((0, MIN_SECONDS - 1, 0), OverflowError),
|
|
|
|
((0, 0, MAX_MICROSECONDS + 1), OverflowError),
|
|
|
|
((0, 0, MIN_MICROSECONDS - 1), OverflowError),
|
|
|
|
(("0", 0, 0), TypeError),
|
|
|
|
((0, "0", 0), TypeError),
|
|
|
|
((0, 0, "0"), TypeError),
|
|
|
|
],
|
|
|
|
)
|
2018-04-08 16:46:12 +00:00
|
|
|
def test_delta_err(args, err_type):
|
|
|
|
with pytest.raises(err_type):
|
|
|
|
rdt.make_delta(*args)
|
2018-08-09 18:17:34 +00:00
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
|
2018-09-17 17:46:50 +00:00
|
|
|
def test_issue_219():
|
|
|
|
rdt.issue_219()
|
2018-09-27 22:02:29 +00:00
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
|
2018-09-27 22:02:29 +00:00
|
|
|
def test_tz_class():
|
|
|
|
tzi = rdt.TzClass()
|
|
|
|
|
|
|
|
dt = pdt.datetime(2018, 1, 1, tzinfo=tzi)
|
|
|
|
|
|
|
|
assert dt.tzname() == "+01:00"
|
|
|
|
assert dt.utcoffset() == pdt.timedelta(hours=1)
|
|
|
|
assert dt.dst() is None
|
2018-09-28 15:13:53 +00:00
|
|
|
|
2018-11-11 11:25:53 +00:00
|
|
|
|
2018-09-28 15:13:53 +00:00
|
|
|
def test_tz_class_introspection():
|
|
|
|
tzi = rdt.TzClass()
|
|
|
|
|
|
|
|
assert tzi.__class__ == rdt.TzClass
|
2019-02-01 15:31:18 +00:00
|
|
|
assert repr(tzi).startswith("<TzClass object at")
|